void MGLAPI XWIN8_realizePalette(MGLDC *dc,palette_t *pal,int num,int index,int waitVRT)
/****************************************************************************
*
* Function: XWIN8_realizePalette
* Parameters: dc - Device context
* pal - Palette of values to program
* num - Number of entries to program
* index - Index to start programming at
*
* Description: Program the X11 colormap. First we need to translate the
* values from the MGL internal format into the 16 bit RGB
* format used by X11.
*
****************************************************************************/
{
int i;
XColor *cols = MGL_malloc(sizeof(XColor) * num);
xwindc_vars *v = &dc->wm.xwindc;
for(i=0; i<num; i++){
cols[i].flags = DoRed | DoGreen | DoBlue;
cols[i].pixel = i+index;
cols[i].red = pal[i].red << 8;
cols[i].green = pal[i].green << 8;
cols[i].blue = pal[i].blue << 8;
}
XStoreColors(v->dpy, v->hpal, cols, num);
XFlush(v->dpy);
MGL_free(cols);
}
static void SetColormap(CanvasExtension *CE) {
/* Calculate colormap entries. */
for (int i=0; i<Shades; i++) {
int (*Scaler)(int,int);
if (CE->GammaCorrect)
Scaler=&GammaCorrected;
else
Scaler=&LinearScale;
if (CE->Mask==ALL_COLORS) {
CE->Colors[i].red=(*Scaler)(i%Reds,Reds)<<8;
CE->Colors[i].green=(*Scaler)((i/Reds)%Greens,Greens)<<8;
CE->Colors[i].blue=(*Scaler)(i/(Reds*Greens),Blues)<<8;
} else if (CE->Mask==ONLY_RED) {
CE->Colors[i].red=(*Scaler)(i,Shades)<<8;
CE->Colors[i].green=CE->Colors[i].blue=0;
} else if (CE->Mask==ONLY_GREEN) {
CE->Colors[i].green=(*Scaler)(i,Shades)<<8;
CE->Colors[i].red=CE->Colors[i].blue=0;
} else if (CE->Mask==ONLY_BLUE) {
CE->Colors[i].blue=(*Scaler)(i,Shades)<<8;
CE->Colors[i].red=CE->Colors[i].green=0;
}
}
/* Update server. */
XStoreColors(Disp,CE->CMap,CE->Colors,Shades);
}
/* _xdga2_set_palette_range:
* Sets palette entries.
*/
static void _xdga2_set_palette_range(AL_CONST PALETTE p, int from, int to, int vsync)
{
int i;
static XColor color[256];
XLOCK();
if (vsync) {
XSync(_xwin.display, False);
}
if (dga_device->mode.depth == 8) {
for (i = from; i <= to; i++) {
color[i].flags = DoRed | DoGreen | DoBlue;
color[i].pixel = i;
color[i].red = ((p[i].r & 0x3F) * 65535L) / 0x3F;
color[i].green = ((p[i].g & 0x3F) * 65535L) / 0x3F;
color[i].blue = ((p[i].b & 0x3F) * 65535L) / 0x3F;
}
XStoreColors(_xwin.display, _dga_cmap, color + from, to - from + 1);
XSync(_xwin.display, False);
}
XUNLOCK();
}
///////////////////////////////////////////////////////////
// Palette stuff.
//
static void I_UploadNewPalette(int pal)
{
// This is used to replace the current 256 colour cmap with a new one
// Used by 256 colour PseudoColor modes
// Array of XColor structs used for setting the 256-colour palette
static XColor* colours;
static int cachedgamma;
static size_t num_pals;
if ((colours == NULL) || (cachedgamma != usegamma)) {
int lump = W_GetNumForName("PLAYPAL");
const byte *palette = W_CacheLumpNum(lump);
register const byte *const gtable = gammatable[cachedgamma = usegamma];
register int i;
num_pals = W_LumpLength(lump) / (3*256);
num_pals *= 256;
if (!colours) {
// First call - allocate and prepare colour array
colours = malloc(sizeof(*colours)*num_pals);
for (i=0 ; i<num_pals ; i++) {
colours[i].pixel = i & 0xff;
colours[i].flags = DoRed|DoGreen|DoBlue;
}
}
// set the X colormap entries
for (i=0 ; i<num_pals ; i++) {
register int c;
c = gtable[palette[0]];
colours[i].red = (c<<8) + c;
c = gtable[palette[1]];
colours[i].green = (c<<8) + c;
c = gtable[palette[2]];
colours[i].blue = (c<<8) + c;
palette += 3;
}
W_UnlockLumpNum(lump);
num_pals/=256;
}
#ifdef RANGECHECK
if (pal >= num_pals)
I_Error("I_UploadNewPalette: Palette number out of range (%d>=%d)",
pal, num_pals);
#endif
// store the colors to the current colormap
XStoreColors(X_display, X_cmap, colours + 256*pal, 256);
#ifdef HAVE_LIBXXF86DGA
/* install DGA colormap */
if(doDga)
XF86DGAInstallColormap(X_display, X_screen, X_cmap);
#endif
}
static void
initialize_transparency_colormap (Display *dpy, Colormap cmap,
int nplanes,
unsigned long base_pixel,
unsigned long *plane_masks,
XColor *colors,
Bool additive_p , ModeInfo* mi )
{
int i;
int total_colors = i_exp (2, nplanes);
XColor *all_colors = (XColor *) calloc (total_colors, sizeof (XColor));
for (i = 0; i < nplanes; i++)
colors[i].pixel = base_pixel | plane_masks [i];
permute_colors (colors, all_colors, nplanes, plane_masks, additive_p);
/* clone the default background of the window into our "base" pixel */
all_colors [total_colors - 1].pixel = MI_BLACK_PIXEL( mi );
XQueryColor (dpy, cmap, &all_colors [total_colors - 1]);
all_colors [total_colors - 1].pixel = base_pixel;
for (i = 0; i < total_colors; i++)
all_colors[i].flags = DoRed|DoGreen|DoBlue;
XStoreColors (dpy, cmap, all_colors, total_colors);
XFree ((XPointer) all_colors);
}
void
rotate_colors(Display * dpy, Colormap cmap,
XColor * colors, int ncolors, int distance)
{
int i;
XColor *colors2 = (XColor *) malloc(sizeof (XColor) * ncolors);
if (ncolors < 2)
return;
distance = distance % ncolors;
for (i = 0; i < ncolors; i++) {
int j = i - distance;
if (j >= ncolors)
j -= ncolors;
if (j < 0)
j += ncolors;
colors2[i] = colors[j];
colors2[i].pixel = colors[i].pixel;
}
XStoreColors(dpy, cmap, colors2, ncolors);
XFlush(dpy);
(void) memcpy((char *) colors, colors2, sizeof (*colors) * ncolors);
free(colors2);
}
void redocolors() {
int i;
for (i = 0; i < COLORS; i++) { /* Set up the colors gradient */
// myRGB r=myRGB(thru,thru,thru);
// myRGB r=( thru < 1 ? myRGB(0.0,thru*5.0,0.0)
// : myRGB(thru*2.0-1.0,1.0,thru*2.0-1.0)
// );
float thru=4.0*(float)((frameno*palspeed+i/2)%colors)/(float)COLORS;
myRGB r;
if (thru<1.0)
r=myRGB(0.0,thru,0.0);
else if (thru<2.0)
r=myRGB(thru-1.0,1.0,thru-1.0);
else if (thru<3.0)
r=myRGB(1.0-(thru-2.0),1.0-(thru-2.0),1.0);
else
r=myRGB(0.0,0.0,1.0-(thru-3.0));
#ifdef X11GFX
xrgb[i].red = 65535 * r.r/255; // (1.0 - 1.0 * i / COLORS);
xrgb[i].green = 65535 * r.g/255;
xrgb[i].blue = 65535 * r.b/255;
xrgb[i].flags = DoRed | DoGreen | DoBlue;
xrgb[i].pixel=i;
#endif
#ifdef ALLEGRO
RGB algrgb;
algrgb.r=r.r/4;
algrgb.g=r.g/4;
algrgb.b=r.b/4;
set_color(i,&algrgb);
#endif
}
#ifdef X11GFX
if (stylee == styleeTrueColor) {
// XInstallColormap (d, colormap);
for (int i=0;i<colors;i++) {
if ( XAllocColor(d,colormap,&xrgb[i]) == 0 )
printf("Error allocating %i\n",i);
// works for true-color
}
} else {
XAllocColorCells(d,colormap,1,0,0,color,colors);
// for (int i=0;i<colors;i++) {
// xrgb[i].pixel=color[i];
// }
XStoreColors(d,colormap,xrgb,COLORS);
XSetWindowColormap(d,win,colormap);
// fputs("Couldn't allocate enough colors cells.\n",
// stderr), exit(1);
}
#endif
}
static void
changeColor (struct state *st, double r, double g, double b)
{
int n,n1;
n1=0;
for(n=30;n<64;n+=3)
{
st->colors[n1].red =1023+ n*(int)(1024.*r);
st->colors[n1].blue =1023+ n*(int)(1024.*b);
st->colors[n1].green =1023+ n*(int)(1024.*g);
n1++;
}
XStoreColors (st->dpy, st->cmap, st->colors, 12);
}
void S9xSetPalette ()
{
int Brightness;
if (ourvideo.bitdepth != 8)
return;
Brightness = IPPU.MaxBrightness *138;
for (int i = 0; i < 256; i++) {
colors[i].red = ((PPU.CGDATA[i] >> 0) & 0x1F) * Brightness;
colors[i].green = ((PPU.CGDATA[i] >> 5) & 0x1F) * Brightness;
colors[i].blue = ((PPU.CGDATA[i] >> 10) & 0x1F) * Brightness;
}
XStoreColors (ourdisp, cmap, colors, 256);
XF86DGAInstallColormap (ourdisp, ourscreen, cmap);
}
void
WindowDevice::WINOPEN(const char *_title, int _xLoc, int _yLoc, int _width, int _height)
{
// set the WindowDevices title, height, wdth, xLoc and yLoc
strcpy(title, _title);
height = _height;
width = _width;
xLoc = _xLoc;
yLoc = _yLoc;
#ifdef _UNIX
if (winOpen == 0) { // we must close the old window
XFreeGC(theDisplay, theGC);
XDestroyWindow(theDisplay, theWindow);
}
// define the position and size of the window - only hints
hints.x = _xLoc;
hints.y = _yLoc;
hints.width = _width;
hints.height = _height;
hints.flags = PPosition | PSize;
// set the defualt foreground and background colors
XVisualInfo visual;
visual.visual = 0;
int depth = DefaultDepth(theDisplay, theScreen);
if (background == 0) {
if (XMatchVisualInfo(theDisplay, theScreen, depth, PseudoColor, &visual) == 0) {
foreground = BlackPixel(theDisplay, theScreen);
background = WhitePixel(theDisplay, theScreen);
} else {
foreground = 0;
background = 255;
}
}
// now open a window
theWindow = XCreateSimpleWindow(theDisplay,RootWindow(theDisplay,0),
hints.x, hints.y,
hints.width,hints.height,4,
foreground, background);
if (theWindow == 0) {
opserr << "WindowDevice::WINOPEN() - could not open a window\n";
exit(-1);
}
XSetStandardProperties(theDisplay, theWindow, title, title, None, 0, 0, &hints);
// create a graphical context
theGC = XCreateGC(theDisplay, theWindow, 0, 0);
// if we were unable to get space for our colors
// we must create and use our own colormap
if (colorFlag == 3 ) {
// create the colormap if the 1st window
if (numWindowDevice == 1) {
int fail = false;
// XMatchVisualInfo(theDisplay, theScreen, depth, PseudoColor, &visual);
if (XMatchVisualInfo(theDisplay, theScreen, depth, PseudoColor, &visual) == 0) {
opserr << "WindowDevice::initX11() - could not get a visual for PseudoColor\n";
opserr << "Colors diplayed will be all over the place\n";
cmap = DefaultColormap(theDisplay, theScreen);
fail = true;
} else {
opserr << "WindowDevice::WINOPEN have created our own colormap, \n";
opserr << "windows may change color as move mouse from one window to\n";
opserr << "another - depends on your video card to use another colormap\n\n";
cmap = XCreateColormap(theDisplay,theWindow,
visual.visual, AllocAll);
}
/*
cmap = XCreateColormap(theDisplay,theWindow,
DefaultVisual(theDisplay,0),AllocAll);
*/
if (cmap == 0) {
opserr << "WindowDevice::initX11() - could not get a new color table\n";
exit(-1);
}
// we are going to try to allocate 256 new colors -- need 8 planes for this
depth = DefaultDepth(theDisplay, theScreen);
if (depth < 8) {
opserr << "WindowDevice::initX11() - needed at least 8 planes\n";
exit(-1);
}
if (fail == false) {
int cnt = 0;
for (int red = 0; red < 8; red++) {
for (int green = 0; green < 8; green++) {
for (int blue = 0; blue < 4; blue++) {
pixels[32*red + 4*green + blue] = cnt;
colors[cnt].pixel = pixels[32*red + 4*green + blue];
colors[cnt].red = (65536/7)*red;
colors[cnt].green = (65536/7)*green;
colors[cnt].blue = (65536/3)*blue;
colors[cnt].flags = DoRed | DoGreen | DoBlue;
cnt++;
}
}
}
background = 0; //pixels[0];
foreground = 255; // pixels[255];
XStoreColors(theDisplay, cmap, colors, cnt);
}
}
// now set the windows to use the colormap
XSetWindowColormap(theDisplay, theWindow, cmap);
}
XSetBackground(theDisplay, theGC, background);
XSetForeground(theDisplay, theGC, foreground);
XMapWindow(theDisplay,theWindow);
XClearWindow(theDisplay, theWindow);
XFlush(theDisplay);
#else
// auxInitDisplayMode(AUX_SINGLE | AUX_RGBA);
// auxInitPosition(100,100,_width,_height);
// auxInitWindow("G3");
if (winOpen == 0)
oglDestroyWindow(title,theWND, theHRC, theHDC);
theWND = oglCreateWindow(title, xLoc, yLoc, width, height, &theHRC, &theHDC);
if (theWND == NULL)
exit(1);
winOpen = 0;
wglMakeCurrent(theHDC, theHRC);
glClearColor(1.0f,1.0f,1.0f,1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, (GLsizei)width, (GLsizei)height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// gluOrtho2D(0.0, (GLdouble)width, 0.0, (GLdouble)height);
glFlush();
#endif
winOpen = 0;
}
void
do_setcustompalette (XColor * inpal)
{
int i, n, me = 0, flag[256], vid;
int depth;
long unsigned int plane_masks[3];
XColor pal[256];
int writeable_p;
display.cmap = XDefaultColormap (display.dpy, display.screen);
depth = DefaultDepth (display.dpy, display.screen);
/* Decide, if the colormap is writable */
{
Visual *visual = DefaultVisual (display.dpy, display.screen);
#if defined(__cplusplus) || defined(c_plusplus)
int visual_class = visual->c_class;
#else
int visual_class = visual->class;
#endif
writeable_p = (visual_class == PseudoColor || visual_class == GrayScale);
}
if (writeable_p)
{
if (XAllocColorCells (display.dpy, display.cmap, 0
,plane_masks, 0, colour_table, 256) == 0)
{
me = (*DefaultVisual (display.dpy, display.screen)).map_entries;
vid = (*DefaultVisual (display.dpy, display.screen)).visualid;
display.cmap = XCreateColormap (display.dpy, display.win
,DefaultVisual (display.dpy, display.screen)
/* ,PseudoColor */
,AllocNone);
if (me == 256 && depth != 24)
{
if (XAllocColorCells (display.dpy, display.cmap, 0
,plane_masks, 0, colour_table, 256) != 0) {
/* printf ("Allocated 256 cells\n"); */
}
else {
printf ("Couldn't allocate 256 cells\n");
}
}
else
for (i = 0; i < 256; i++)
colour_table[i] = i;
}
if (!display.cmap)
HandleError ("No default colour map", FATAL);
}
for (i = 0; i < 256; i++)
flag[i] = 0;
for (n = 0; n < 256; n++)
{
pal[n].red = inpal[n].red << 10;
pal[n].green = inpal[n].green << 10;
pal[n].blue = inpal[n].blue << 10;
pal[n].flags = DoRed | DoGreen | DoBlue;
if (writeable_p)
pal[n].pixel = colour_table[n];
else
{
if (XAllocColor (display.dpy
,display.cmap, &(pal[n])) == 0)
HandleError ("alloc colour failed"
,FATAL);
colour_table[n] = pal[n].pixel;
XSetForeground (display.dpy
,display.pixcolour_gc[n]
,colour_table[n]);
}
flag[n] = 1;
}
if (writeable_p)
{
XStoreColors (display.dpy, display.cmap, pal, 256);
XFlush (display.dpy);
}
XSetWindowColormap (display.dpy, display.win, display.cmap);
}
void
make_random_colormap(ModeInfo * mi, Colormap cmap,
XColor * colors, int *ncolorsP,
Bool bright_p,
Bool allocate_p,
Bool * writable_pP)
{
Bool wanted_writable = (allocate_p && writable_pP && *writable_pP);
int ncolors = *ncolorsP;
int i;
if (*ncolorsP <= 0)
return;
/* If this visual doesn't support writable cells, don't bother trying. */
if (wanted_writable && !has_writable_cells(mi))
*writable_pP = False;
for (i = 0; i < ncolors; i++) {
colors[i].flags = DoRed | DoGreen | DoBlue;
if (bright_p) {
int H = (int) LRAND() % 360; /* range 0-360 */
double S = ((double) (LRAND() % 70) + 30) / 100.0; /* range 30%-100% */
double V = ((double) (LRAND() % 34) + 66) / 100.0; /* range 66%-100% */
hsv_to_rgb(H, S, V,
&colors[i].red, &colors[i].green, &colors[i].blue);
} else {
colors[i].red = (unsigned short) (LRAND() % 0xFFFF);
colors[i].green = (unsigned short) (LRAND() % 0xFFFF);
colors[i].blue = (unsigned short) (LRAND() % 0xFFFF);
}
}
if (!allocate_p)
return;
RETRY_NON_WRITABLE:
if (writable_pP && *writable_pP) {
unsigned long *pixels = (unsigned long *)
malloc(sizeof (unsigned long) * (ncolors + 1));
allocate_writable_colors(MI_DISPLAY(mi), cmap, pixels, &ncolors);
if (ncolors > 0)
for (i = 0; i < ncolors; i++)
colors[i].pixel = pixels[i];
free(pixels);
if (ncolors > 0)
XStoreColors(MI_DISPLAY(mi), cmap, colors, ncolors);
} else {
for (i = 0; i < ncolors; i++) {
XColor color;
color = colors[i];
if (!XAllocColor(MI_DISPLAY(mi), cmap, &color))
break;
colors[i].pixel = color.pixel;
}
ncolors = i;
}
/* If we tried for writable cells and got none, try for non-writable. */
if (allocate_p && ncolors == 0 && writable_pP && *writable_pP) {
ncolors = *ncolorsP;
*writable_pP = False;
goto RETRY_NON_WRITABLE;
}
if (MI_IS_VERBOSE(mi) || MI_IS_DEBUG(mi))
complain(*ncolorsP, ncolors, wanted_writable,
wanted_writable && *writable_pP);
*ncolorsP = ncolors;
}
void Window2d::setup_window()
{
int status;
unsigned long plane_masks[8];
XSetWindowAttributes attrib;
static char default_font[] = "8x13";
psize = 1;
/* Open a connection to the display. */
/* if ((display = XOpenDisplay (NULL)) == NULL) {
printf ("Couldn't open display:\n");
printf ("Make sure X11 is running and DISPLAY is set correctly\n");
exit (-1);
}
screen = XDefaultScreen (display);
*/
num_colors = 30;
/*
XSetErrorHandler (my_error_handler);
*/
/* set up foreground, background colors (to Xdefaults, if any) */
// if (XDisplayCells (display, screen) > 2) /* this is a color display */
// defColormap = XDefaultColormap (display, screen);
// foregrnd = XWhitePixel (display, screen);
// backgrnd = XBlackPixel (display, screen);
/* set up default depth, visual params */
// defDepth = XDefaultDepth (display, screen);
// defVisual = XDefaultVisual (display, screen);
/* set up fonts */
// RegFont = XLoadQueryFont (display, "8x13");
// SmallFont = XLoadQueryFont (display, "6x10");
// BigFont = XLoadQueryFont (display, "9x15");
if (RegFont == NULL || SmallFont == NULL || BigFont == NULL) {
printf ("Couldn't find all fonts.\n");
}
/* create root cursor (left arrow) */
//root_cursor = XCreateFontCursor (display, 68);
/* create root window */
attrib.background_pixel = backgrnd;
attrib.border_pixel = foregrnd;
attrib.override_redirect = False;
/*
attrib.override_redirect = True;
*/
attrib.event_mask = ButtonPressMask | ButtonReleaseMask | ExposureMask |
StructureNotifyMask;
attrib.cursor = root_cursor;
// root = XCreateWindow (display, RootWindow(display, screen),
// xorg, yorg,
// xsize, ysize, 1, defDepth, InputOutput,
// defVisual, CWBackPixel|CWBorderPixel|CWOverrideRedirect|
// CWEventMask|CWCursor, &attrib);
// XChangeProperty (display, root, XA_WM_NAME, XA_STRING, 8, PropModeReplace,
// (unsigned char *) "Icon", 5);
/* set up some graphics contexts */
gcvalues.foreground = foregrnd;
gcvalues.background = backgrnd;
gcvalues.line_width = 1;
gcvalues.font = RegFont->fid;
// gc_reg_font = XCreateGC (display, root,
// GCForeground|GCBackground|GCLineWidth|GCFont,
// &gcvalues);
gcvalues.font = SmallFont->fid;
//gc_small_font = XCreateGC (display, root,
// GCForeground|GCBackground|GCLineWidth|GCFont,
// &gcvalues);
gcvalues.font = BigFont->fid;
// gc_big_font = XCreateGC (display, root,
// GCForeground|GCBackground|GCLineWidth|GCFont,
// &gcvalues);
/* set up drawing parameters */
//status = XAllocColorCells (display, defColormap,
// 0, plane_masks, 0, pixels, num_colors);
if (status == 0) {
printf ("bad status from XAllocColorCells\n");
return;
}
gray_ramp();
#if 0
/* create grey ramp */
for (int i = 0; i < num_colors; i++) {
t = 65535 * i / (num_colors - 1.0);
colors[i].red = (unsigned short) t;
colors[i].green = (unsigned short) t;
colors[i].blue = (unsigned short) t;
colors[i].pixel = pixels[i];
colors[i].flags = DoRed | DoGreen | DoBlue;
}
XStoreColors (display, defColormap, colors, num_colors);
#endif
gcvalues.foreground = foregrnd;
gcvalues.background = backgrnd;
// gc = XCreateGC (display, root, GCForeground|GCBackground, &gcvalues);
/* set all callbacks to NULL */
press1 = NULL;
press2 = NULL;
press3 = NULL;
release1 = NULL;
release2 = NULL;
release3 = NULL;
escape_callback = NULL;
redraw_callback = NULL;
/* save a pointer to this window */
window_list[num_windows++] = this;
}
XilLookup XILWindowAssistor::create_cmap(
Colormap *cmap, int type, XilIndexList *ilist,
XilLookup yuvtorgb, XilLookup colorcube
) {
unsigned long tmp_colors[256], pixels[256], mask;
XColor cdefs[256];
int top_colors = 2; /* colormap indices 255 and 254 */
int i, t;
Xil_unsigned8 *data;
XilLookup lut;
int cmapsize;
Display *display = Tk_Display(window_->tkwin());
Window window = Tk_WindowId(window_->tkwin());
int screen = Tk_ScreenNumber(window_->tkwin());
//fprintf(stderr,"XILWindowAssistor::"__FUNCTION__"\n");
/* Get colormap size */
switch(type)
{
case FT_JPEG:
case FT_H261:
cmapsize = xil_lookup_get_num_entries(yuvtorgb);
break;
case FT_CELLB:
default: /* hmm */
xil_cis_get_attribute(cis_,"DECOMPRESSOR_MAX_CMAP_SIZE", (void**)&cmapsize);
break;
}
/* Create an X colormap for the cis.*/
*cmap = XCreateColormap(display, window, DefaultVisual(display,screen), AllocNone);
/* Allocate X Colormap cells
*
* If we do not need the entire colormap, allocate `cmapsize'
* entries just below the top of the colormap. Here's how:
* Temporarily allocate some entries at the front of the cmap.
* Don't allocate the top_colors (the top two color indices
* are often used by other applications).
* Allocate the needed entries in the next cmap section
* Free the temporary entries.
* This allows the X-Window manager to use them and reduces the
* chances of of your window colormap flashing.
*/
if (cmapsize < 256-top_colors) {
if (!XAllocColorCells(display, *cmap, 0, &mask, 0,
tmp_colors, 256 - cmapsize - top_colors)) {
fprintf(stderr, " XAllocColorCells for cmap_create failed(1)\n");
}
}
if (!XAllocColorCells(display, *cmap, 0, &mask, 0, pixels, cmapsize)) {
fprintf(stderr, " XAllocColorCells for cmap_create failed(2)\n");
}
/* The remaining code assumes that the values returned in pixels[0] through
* pixels[cmapsize-1] are a contiguous range.
*/
/* Free the unused colors in the front */
if (cmapsize < 256-top_colors)
XFreeColors(display, *cmap, tmp_colors, 256 - cmapsize - top_colors, 0);
#if 0
if (type == CELLB) {
/* Initialize the XilIndexList to use when setting the RDWR_INDICES
* attribute. In this example, we make all of the indices writable.
*/
if ( (ilist->pixels = (Xil_unsigned32 *)
malloc(sizeof(Xil_unsigned32) * cmapsize) ) == NULL ) {
fprintf(stderr, " out of memory for ilist->pixels create\n");
}
ilist->ncolors = cmapsize;
/* Copy the color cells returned by XAllocColorCells into the ilist */
for (i = 0; i < cmapsize; i++)
ilist->pixels[i] = (Xil_unsigned32) pixels[i];
}
#else
UNUSED(ilist);
#endif
/* Allocate memory to hold colormap data. */
if ( (data = (Xil_unsigned8 *)
malloc(sizeof(Xil_unsigned8) * cmapsize * 3) ) == NULL ) {
fprintf(stderr, "xilcis_color: out of memory for cmap data create\n");
}
/* Get the entries for the colormap. The method depends on the compression
* type. For CELL, get the entries in the current default colormap.
* For JPEG, get the entries from the standard lookup table
* yuv_to_rgb.
*/
switch(type_) {
#if 0
/* case FT_CELLB:*/
/* Get the current values in the colormap */
for (i = 0; i < cmapsize; i++)
cdefs[i].pixel = i + pixels[0];
XQueryColors(display, DefaultColormap(display, screen), cdefs,
cmapsize);
/* Convert the values read from the colormap to an array that can
* be read by xil_lookup_create. Note that the colormap values are
* are stored in the XilLookup in BGR order.
*/
for (i = 0, j = 0; i < cmapsize; i++, j += 3) {
data[j] = cdefs[i].blue >> 8;
data[j + 1] = cdefs[i].green >> 8;
data[j + 2] = cdefs[i].red >> 8;
}
lut = xil_lookup_create(xil_, XIL_BYTE, XIL_BYTE, 3, cmapsize,
(int)pixels[0], data);
break;
#endif
case FT_JPEG:
case FT_H261:
case FT_CELLB:
xil_lookup_get_values(yuvtorgb, xil_lookup_get_offset(yuvtorgb),
cmapsize, data);
xil_lookup_set_offset(colorcube, (unsigned int)pixels[0]);
for (i = 0, t = 0; i < cmapsize; i++, t += 3) {
cdefs[i].pixel = pixels[i];
cdefs[i].flags = DoRed | DoGreen | DoBlue;
cdefs[i].blue = data[t] << 8;
cdefs[i].green = data[t+1] << 8;
cdefs[i].red = data[t+2] << 8;
}
XStoreColors(display, *cmap, cdefs, cmapsize);
lut = yuvtorgb;
break;
}
Tk_SetWindowColormap(window_->tkwin(),*cmap);
free(data);
return(lut);
}
//////////////////////////////////////////////////////////////////////
// Main
//////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
int i;
fprintf(stderr, "\n%s v%s (Build %s)\n\n", bench_name, __VERSION, __BUILD);
if(argc>1) for(i=1; i<argc; i++)
{
if(!stricmp(argv[i], "-checkdb"))
{
checkdb=1;
fprintf(stderr, "Checking double buffering. Watch for flashing to indicate that it is\n");
fprintf(stderr, "not enabled. Performance will be sub-optimal.\n");
}
if(!stricmp(argv[i], "-noshm"))
{
doshm=0;
}
if(!stricmp(argv[i], "-verbose"))
{
fbx_printwarnings(stderr);
}
}
try {
#ifdef FBXWIN32
WNDCLASSEX wndclass; MSG msg;
wndclass.cbSize = sizeof(WNDCLASSEX);
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = GetModuleHandle(NULL);
wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = bench_name;
wndclass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
tryw32(RegisterClassEx(&wndclass));
width=GetSystemMetrics(SM_CXSCREEN);
height=GetSystemMetrics(SM_CYSCREEN);
#else
if(!XInitThreads()) {fprintf(stderr, "ERROR: Could not initialize Xlib thread safety\n"); exit(1);}
XSetErrorHandler(xhandler);
if(!(wh.dpy=XOpenDisplay(0))) {fprintf(stderr, "Could not open display %s\n", XDisplayName(0)); exit(1);}
width=DisplayWidth(wh.dpy, DefaultScreen(wh.dpy));
height=DisplayHeight(wh.dpy, DefaultScreen(wh.dpy));
#endif
if(width<MIN_SCREEN_WIDTH && height<MIN_SCREEN_HEIGHT)
{
fprintf(stderr, "ERROR: Please switch to a screen resolution of at least %d x %d.\n", MIN_SCREEN_WIDTH, MIN_SCREEN_HEIGHT);
exit(1);
}
width=WIDTH;
height=HEIGHT;
#ifdef FBXWIN32
int bw=GetSystemMetrics(SM_CXFIXEDFRAME)*2;
int bh=GetSystemMetrics(SM_CYFIXEDFRAME)*2+GetSystemMetrics(SM_CYCAPTION);
tryw32(wh=CreateWindowEx(0, bench_name, bench_name, WS_OVERLAPPED |
WS_SYSMENU | WS_CAPTION | WS_VISIBLE, 0, 0, width+bw, height+bh, NULL,
NULL, GetModuleHandle(NULL), NULL));
UpdateWindow(wh);
BOOL ret;
while(1)
{
if((ret=GetMessage(&msg, NULL, 0, 0))==-1) _throww32();
else if(ret==0) break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return (int)msg.wParam;
#else
XVisualInfo vtemp, *v=NULL; int n=0;
XSetWindowAttributes swa;
Window root=DefaultRootWindow(wh.dpy);
vtemp.depth=24; vtemp.c_class=TrueColor;
if((v=XGetVisualInfo(wh.dpy, VisualDepthMask|VisualClassMask, &vtemp, &n))!=NULL && n!=0)
{
swa.colormap=XCreateColormap(wh.dpy, root, v->visual, AllocNone);
swa.border_pixel=0;
swa.event_mask=0;
errifnot(wh.win=XCreateWindow(wh.dpy, root, 0, 0, width, height, 0,
v->depth, InputOutput, v->visual, CWBorderPixel|CWColormap|CWEventMask,
&swa));
errifnot(XMapRaised(wh.dpy, wh.win));
XSync(wh.dpy, False);
display();
XDestroyWindow(wh.dpy, wh.win);
XFree(v); v=NULL;
}
else fprintf(stderr, "No RGB visuals available. Skipping those tests.\n\n");
vtemp.depth=8; vtemp.c_class=PseudoColor;
if((v=XGetVisualInfo(wh.dpy, VisualDepthMask|VisualClassMask, &vtemp, &n))!=NULL && n!=0)
{
swa.colormap=XCreateColormap(wh.dpy, root, v->visual, AllocAll);
swa.border_pixel=0;
swa.event_mask=0;
XColor xc[32]; int i;
errifnot(v->colormap_size==256);
for(i=0; i<32; i++)
{
xc[i].red=(i<16? i*16:255)<<8;
xc[i].green=(i<16? i*16:255-(i-16)*16)<<8;
xc[i].blue=(i<16? 255:255-(i-16)*16)<<8;
xc[i].flags = DoRed | DoGreen | DoBlue;
xc[i].pixel=i;
}
XStoreColors(wh.dpy, swa.colormap, xc, 32);
errifnot(wh.win=XCreateWindow(wh.dpy, root, 0, 0, width, height, 0,
v->depth, InputOutput, v->visual, CWBorderPixel|CWColormap|CWEventMask,
&swa));
errifnot(XMapRaised(wh.dpy, wh.win));
XSync(wh.dpy, False);
display();
XDestroyWindow(wh.dpy, wh.win);
XFreeColormap(wh.dpy, swa.colormap);
XFree(v); v=NULL;
}
else fprintf(stderr, "No Pseudocolor visuals available. Skipping those tests.\n\n");
return 0;
#endif
} catch(rrerror &e) {fprintf(stderr, "%s\n", e.getMessage());}
}
static BOOL CreateDeviceColormap(Display *display, int screen,
int minplanes, int maxplanes)
{
int i, j;
unsigned long *pixels, planes[32];
/* pass 1: allocate colors from default colormap
* pass 2: create colormap & allocate colors from new colormap
*/
DeviceColormapSize = (XDefaultVisual(display, screen))->map_entries;
for (i = 0; i < 2; i++)
{
/* pass 1: get default colormap
* pass 2: create custom colormap
*/
if (i == 0)
{
DeviceColormap = XDefaultColormap(display, screen);
}
else
{
DeviceColormap = XCreateColormap(display,
XRootWindow(display, screen),
XDefaultVisual(display, screen),
AllocNone);
}
/* pass 1: save default colormap colors for pass 2
* pass 2: initialize with default colormap colors to minimize
* techni-color(tm) effect
*/
if (i == 0)
{
DeviceColormapValues = (XColor *)
WinMalloc(DeviceColormapSize * sizeof(XColor));
for (j = 0; j < DeviceColormapSize; j++)
{
DeviceColormapValues[j].pixel = j;
}
XQueryColors(display, DeviceColormap,
DeviceColormapValues,
DeviceColormapSize);
}
else
{
pixels = (unsigned long *) WinMalloc(DeviceColormapSize *
sizeof(unsigned long));
XAllocColorCells(display, DeviceColormap, True,
planes, 0, pixels, DeviceColormapSize);
XStoreColors(display, DeviceColormap,
DeviceColormapValues,
DeviceColormapSize);
XFreeColors(display, DeviceColormap, pixels,
DeviceColormapSize, 0L);
}
/* allocate as many color planes as possible */
if ((minplanes < 1) || (maxplanes < 1))
break;
for (j = maxplanes; j >= minplanes; j--)
{
if (!XAllocColorCells(display, DeviceColormap, True,
pixel_masks, j, &pixel0, 1))
{
continue;
}
pixel_numplanes = j;
pixel_mask0 = ~0;
for (pixel_mask = 0, j = 0; j < pixel_numplanes; j++)
{
pixel_mask |= pixel_masks[j];
pixel_mask0 = min(pixel_mask0, pixel_masks[j]);
}
break;
}
if (j >= minplanes)
break;
}
if (i == 2)
{
ERRSTR((LF_WARNING,
"%s: Unable to alloc %d to %d planes.\n",
"CreateDeviceColormap",
minplanes, maxplanes));
return (FALSE);
}
/* success */
return (TRUE);
}
void backmen_butm(Widget iw_temp, XtPointer data,
XtPointer call_data)
{
int nindex, ival, iflags, indx;
float fval,ft;
int ngo_com, nend_com;
/* Get new ngo & nend */
XmScaleGetValue(iw_ngob, &ngo_com);
XmScaleGetValue(iw_nendb, &nend_com);
if (nend_com < ngo_com)
{ spout("*** Upper value must be > lower value"); return;}
else if (ngo_com < imagego)
{ spout("*** Lower value outside of image ramp"); return;}
else if (nend_com > imageend)
{ spout("*** Upper value outside of image ramp"); return;}
// Use ngo to signal ramp info
ngo = ngo_com;
nend = nend_com;
#ifdef WEB_TRUE
// WEB_TRUE ------------------------------------------- WEB_TRUE
// Uses virtual cmap
newvmap(ngo,nend,vmap);
neednewmap = TRUE;
// Applies virtual cmap
expos_cb(NULL,NULL,NULL);
#else
// WEB_24 --------------------------------------------- WEB_24
/* Set the colors in the image portion of the colormap, only */
iflags = DoRed | DoGreen | DoBlue;
indx = 0;
ft = 65535.0 / ((float) (nend - ngo));
for (nindex = mapgo; nindex <= imageend; nindex++)
{
colort[indx].pixel = ispicol[nindex];
colort[indx].flags = iflags;
if (nindex <= ngo)
{ ival = 0; } /* Set this color to black */
else if (nindex < nend)
{
/* Interpolate shade */
fval = (float)(nindex - ngo) * ft;
ival = fval;
}
else
{ ival = 65535; } /* Set this color to white */
colort[indx].red = ival;
colort[indx].green = ival;
colort[indx++].blue = ival;
}
/* Put the colors in the desired colormap */
XStoreColors(idispl, map, colort, indx);
// BOTH --------------------------------------------- BOTH
#endif
XFlush(idispl);
return;
}
void init_3DView_cmap(
Widget w)
{
Display *dpy = XtDisplay( w );
Colormap cmap;
unsigned long plane_masks[1], free_pixels[256];
unsigned int n_free_pixels;
unsigned long min_required_val, max_required_val;
XColor colorcells[256];
int i, j;
/* allocate the colours we need */
n_free_pixels = 0;
min_required_val = 64;
max_required_val = 255;
cmap = globals.cmap;
for(i=0; i < 256; i++){
if( XAllocColorCells(dpy, cmap, False, plane_masks,
0, &(free_pixels[n_free_pixels]), 1) == 0 )
continue;
/* check if required */
if(free_pixels[n_free_pixels] >= min_required_val &&
free_pixels[n_free_pixels] <= max_required_val){
continue;
} else {
n_free_pixels++;
}
}
/* free unwanted colorcells */
XFreeColors(dpy, cmap, free_pixels, n_free_pixels, 0);
/* set 64-127 to greys */
for(i=0, j=64; j < 128; i++, j++){
colorcells[i].red = (j - 64) * 4 * 256;
colorcells[i].green = (j - 64) * 4 * 256;
colorcells[i].blue = (j - 64) * 4 * 256;
colorcells[i].pixel = j;
colorcells[i].flags = DoRed | DoGreen | DoBlue;
}
/* set a load of colors for the remaining values
so that the drawn polylines are visible */
for(; j < 255; i++, j++){
colorcells[i].red = ((j%3)?0:255) * 256;
colorcells[i].green = (((j+1)%3)?0:255) * 256;
colorcells[i].blue = (((j+2)%3)?0:255) * 256;
colorcells[i].pixel = j;
colorcells[i].flags = DoRed | DoGreen | DoBlue;
}
XStoreColors(dpy, cmap, colorcells, i);
/* set a few extra colors */
(void) HGU_XGetColorPixel(XtDisplay(w), cmap, 1.0, 0.0, 0.0);
(void) HGU_XGetColorPixel(XtDisplay(w), cmap, 0.0, 1.0, 0.0);
(void) HGU_XGetColorPixel(XtDisplay(w), cmap, 0.0, 0.0, 1.0);
return;
}
/****************************************************************************************************
* This returns the name of the newly installed colormap. If do_widgets_flag
* is false, don't install colormaps on the widgets, just on the topLevel.
*/
char *x_change_colormap( int delta, int do_widgets_flag )
{
int dump_cmap_list, n_enabled;
Cmaplist *cursor;
dump_cmap_list = 0; /* for debugging */
if( dump_cmap_list ) {
printf( "---- on entry to x_change_colormap, here is colormap_list\n" );
dump_Cmaplist( colormap_list );
}
/* Make sure at least one colormap is enabled. As a failsafe, is none
* are enabled, enable the first one on the list
*/
cursor = colormap_list;
if( check_cmaplist_magic( cursor ) != 0 ) {
fprintf( stderr, "Error, trying to change colormaps in a cmaplist with an invalid element\n" );
exit(-1);
}
n_enabled = colormap_list->enabled;
while( cursor->next != NULL ) {
if( check_cmaplist_magic( cursor ) != 0 ) {
fprintf( stderr, "Error, trying to change colormaps in a cmaplist with an invalid element\n" );
exit(-1);
}
cursor = cursor->next;
n_enabled = n_enabled + cursor->enabled;
}
if( n_enabled == 0 ) {
printf( "Warning, no colormaps enabled in x_change_colormap -- using first on list\n" );
colormap_list->enabled = 1;
}
if( delta > 0 ) {
/* Advance to next enabled colormap. Might have to wrap
* around to the start to encounter an enabled one.
*/
if( current_colormap_list->next == NULL )
current_colormap_list = colormap_list; /* go to head of list */
else
current_colormap_list = current_colormap_list->next;
while( current_colormap_list->enabled == 0 ) {
if( current_colormap_list->next == NULL )
current_colormap_list = colormap_list;
else
current_colormap_list = current_colormap_list->next;
}
}
else if( delta < 0 ) {
/* delta < 0, go backwards on the list */
if( current_colormap_list->prev == NULL ) {
/* Go to last colormap */
while( current_colormap_list->next != NULL )
current_colormap_list = current_colormap_list->next;
}
else
current_colormap_list = current_colormap_list->prev;
/* Now go to an enabled colormap */
while( current_colormap_list->enabled == 0 ) {
if( current_colormap_list->prev == NULL ) {
/* Go to last colormap */
while( current_colormap_list->next != NULL )
current_colormap_list = current_colormap_list->next;
}
else
current_colormap_list = current_colormap_list->prev;
}
}
else
{
; /* We can be called with delta=0, if we changed to a new colormap in the options selection widget */
}
if( options.display_type == PseudoColor )
XStoreColors( XtDisplay(topLevel), current_colormap,
current_colormap_list->color_list,
options.n_colors+1 );
pixel_transform = current_colormap_list->pixel_transform;
return( current_colormap_list->name );
}
void
SplashInitPlatform(Splash * splash) {
int shapeVersionMajor, shapeVersionMinor;
// This setting enables the synchronous Xlib mode!
// Don't use it == 1 in production builds!
#if (defined DEBUG)
_Xdebug = 1;
#endif
pthread_mutex_init(&splash->lock, NULL);
// We should not ignore any errors.
//XSetErrorHandler(HandleError);
// XSetIOErrorHandler(HandleIOError);
XSetIOErrorHandler(NULL);
splash->display = XOpenDisplay(NULL);
if (!splash->display) {
splash->isVisible = -1;
return;
}
shapeSupported = XShapeQueryExtension(splash->display, &shapeEventBase,
&shapeErrorBase);
if (shapeSupported) {
XShapeQueryVersion(splash->display, &shapeVersionMajor,
&shapeVersionMinor);
}
splash->screen = XDefaultScreenOfDisplay(splash->display);
splash->visual = XDefaultVisualOfScreen(splash->screen);
switch (splash->visual->class) {
case TrueColor: {
int depth = XDefaultDepthOfScreen(splash->screen);
splash->byteAlignment = 1;
splash->maskRequired = shapeSupported;
initFormat(&splash->screenFormat, splash->visual->red_mask,
splash->visual->green_mask, splash->visual->blue_mask, 0);
splash->screenFormat.byteOrder =
(XImageByteOrder(splash->display) == LSBFirst ?
BYTE_ORDER_LSBFIRST : BYTE_ORDER_MSBFIRST);
splash->screenFormat.depthBytes = (depth + 7) / 8;
// TrueColor depth probably can't be less
// than 8 bits, and it's always byte padded
break;
}
case PseudoColor: {
int availableColors;
int numColors;
int numComponents[3];
unsigned long colorIndex[SPLASH_COLOR_MAP_SIZE];
XColor xColors[SPLASH_COLOR_MAP_SIZE];
int i;
int depth = XDefaultDepthOfScreen(splash->screen);
int scale = 65535 / MAX_COLOR_VALUE;
availableColors = GetNumAvailableColors(splash->display, splash->screen,
splash->visual->map_entries);
numColors = quantizeColors(availableColors, numComponents);
if (numColors > availableColors) {
// Could not allocate the color cells. Most probably
// the pool got exhausted. Disable the splash screen.
XCloseDisplay(splash->display);
splash->isVisible = -1;
splash->display = NULL;
splash->screen = NULL;
splash->visual = NULL;
fprintf(stderr, "Warning: unable to initialize the splashscreen. Not enough available color cells.\n");
return;
}
splash->cmap = AllocColors(splash->display, splash->screen,
numColors, colorIndex);
for (i = 0; i < numColors; i++) {
splash->colorIndex[i] = colorIndex[i];
}
initColorCube(numComponents, splash->colorMap, splash->dithers,
splash->colorIndex);
for (i = 0; i < numColors; i++) {
xColors[i].pixel = colorIndex[i];
xColors[i].red = (unsigned short)
QUAD_RED(splash->colorMap[colorIndex[i]]) * scale;
xColors[i].green = (unsigned short)
QUAD_GREEN(splash->colorMap[colorIndex[i]]) * scale;
xColors[i].blue = (unsigned short)
QUAD_BLUE(splash->colorMap[colorIndex[i]]) * scale;
xColors[i].flags = DoRed | DoGreen | DoBlue;
}
XStoreColors(splash->display, splash->cmap, xColors, numColors);
initFormat(&splash->screenFormat, 0, 0, 0, 0);
splash->screenFormat.colorIndex = splash->colorIndex;
splash->screenFormat.depthBytes = (depth + 7) / 8; // or always 8?
splash->screenFormat.colorMap = splash->colorMap;
splash->screenFormat.dithers = splash->dithers;
splash->screenFormat.numColors = numColors;
splash->screenFormat.byteOrder = BYTE_ORDER_NATIVE;
break;
}
default:
; /* FIXME: should probably be fixed, but javaws splash screen doesn't support other visuals either */
}
}
dsxc_lutput (void)
/* C-- */
{
float tcol[LVX*3];
int k, istat, ka, kdiv;
char flags;
unsigned short int j;
/* Cbegin */
DSOPEN = F77_NAMED_COMMON(ds_genb).dsopen;
PDSOPEN = F77_NAMED_COMMON(ds_panelb).pdsopen;
NUMDDCOL = F77_NAMED_COMMON(lutacom).numddcol;
(void) dsxc_lutload ( tcol ); /* Load LUT into working LUT */
flags = DoRed | DoGreen | DoBlue;
if ( DSOPEN || PDSOPEN ) {
if ( OWNCOL ) {
kdiv = LVX/NUMDDCOL;
for ( k = 15; k<15+LVX; k++ ) {
ka = 15 + ((k-15)/kdiv);
COLOUR[ka].pixel = PC_ID[ka];
COLOUR[ka].flags = flags;
j = tcol[3*(k-15)+0]*65535.0;
COLOUR[ka].red = j;
j = tcol[3*(k-15)+1]*65535.0;
COLOUR[ka].green = j;
j = tcol[3*(k-15)+2]*65535.0;
COLOUR[ka].blue = j;
}
XStoreColors ( VD_ID, CM_ID, COLOUR, 15+NUMDDCOL );
XInstallColormap ( VD_ID, CM_ID );
XFlush ( VD_ID );
}
else {
for ( k = 15; k < 15+LVX; k++ ) {
COLOUR[k].flags = flags;
j = tcol[3*(k-15)+0]*65535.0;
COLOUR[k].red = j;
j = tcol[3*(k-15)+1]*65535.0;
COLOUR[k].green = j;
j = tcol[3*(k-15)+2]*65535.0;
COLOUR[k].blue = j;
istat = XAllocColor ( VD_ID, CM_ID, &COLOUR[k] );
if ( istat==0 ) {
(void) c_printo ( "ERROR: Colour pixel not allocated" );
PC_ID[k] = 0 ;
}
else
PC_ID[k] = COLOUR[k].pixel;
}
XFlush ( VD_ID );
}
}
}
dsxc_lutcol (void)
/* C-- */
{
int k, ka, kdiv;
Status istat;
unsigned short int c;
char flags;
/* Cbegin */
DSOPEN = F77_NAMED_COMMON(ds_genb).dsopen;
PDSOPEN = F77_NAMED_COMMON(ds_panelb).pdsopen;
NUMDDCOL = F77_NAMED_COMMON(lutacom).numddcol;
flags = DoRed | DoGreen | DoBlue;
if ( DSOPEN || PDSOPEN ) {
(void) dsxc_lutvget();
if ( OWNCOL ) {
kdiv = LVX/NUMDDCOL;
for ( k = 15; k<15+LVX; k++ ) {
ka = 15 + ((k-15)/kdiv);
COLOUR[ka].pixel = PC_ID[ka];
COLOUR[ka].flags = flags;
c = LUTC_VAL[(k-15)][0]*65535.0;
COLOUR[ka].red = c;
c = LUTC_VAL[(k-15)][1]*65535.0;
COLOUR[ka].green = c;
c = LUTC_VAL[(k-15)][2]*65535.0;
COLOUR[ka].blue = c;
}
XStoreColors ( VD_ID, CM_ID, COLOUR, 15+NUMDDCOL );
XInstallColormap ( VD_ID, CM_ID );
XFlush ( VD_ID );
}
else {
for (k = 15; k<15+LVX; k++ ) {
COLOUR[k].flags = flags;
c = LUTC_VAL[(k-15)][0]*65535.0;
COLOUR[k].red = c;
c = LUTC_VAL[(k-15)][1]*65535.0;
COLOUR[k].green = c;
c = LUTC_VAL[(k-15)][2]*65535.0;
COLOUR[k].blue = c;
istat = XAllocColor ( VD_ID, CM_ID, &COLOUR[k] );
if ( istat==0 ) {
(void) c_printo ( "ERROR,x_lut: Colour pixel not allocated" );
PC_ID[k] = 0;
}
else
PC_ID[k] = COLOUR[k].pixel;
}
XFlush ( VD_ID );
}
}
}
void
WindowDevice::initWindow(void) {
// set the display and screen variables
#ifdef _UNIX
theDisplay = XOpenDisplay(""); // init a display connection
if (theDisplay == 0) { // and check we got one
opserr << "WindowDevice::initX11() - could not connect to display\n";
exit(-1);
}
theScreen = DefaultScreen(theDisplay);
// set the defualt foreground and background colors
// foreground = BlackPixel(theDisplay, theScreen);
// background = WhitePixel(theDisplay, theScreen);
// lets try using the default colormap
cmap = DefaultColormap(theDisplay, theScreen);
// we now try to allocate some color cells from the colormap
// we start by tring to obtain 256 colors, then 192, finally 64
// if we can't get these (and as a last resort) we create a new color map
if (XAllocColorCells(theDisplay, cmap, false, NULL, 0, pixels, 256) != 0) {
// we were able to allocate 256 colors from the table for our use
colorFlag = 0;
int cnt = 0;
for (int red =0; red <8; red++) {
for (int green = 0; green<8; green++) {
for (int blue =0; blue<4; blue++) {
colors[cnt].pixel = pixels[32*red + 4*green + blue];
colors[cnt].red = (65536/7)*red;
colors[cnt].green = (65536/7)*green;
colors[cnt].blue = (65536/3)*blue;
colors[cnt].flags = DoRed | DoGreen | DoBlue;
cnt++;
}
}
}
XStoreColors(theDisplay, cmap, colors, cnt);
foreground = pixels[0];
background = pixels[255];
} else if (XAllocColorCells(theDisplay, cmap, false, NULL, 0, pixels, 192) != 0) {
// we were able to allocate 192 colors from the table for our use
colorFlag = 1;
int cnt = 0;
for (int red =0; red <8; red++) {
for (int green = 0; green<6; green++) {
for (int blue =0; blue<4; blue++) {
colors[cnt].pixel = pixels[24*red + 4*green + blue];
colors[cnt].red = (65536/7)*red;
colors[cnt].green = (65536/5)*green;
colors[cnt].blue = (65536/3)*blue;
colors[cnt].flags = DoRed | DoGreen | DoBlue;
cnt++;
}
}
}
XStoreColors(theDisplay, cmap, colors, cnt);
foreground = pixels[0];
background = pixels[191];
} else if (XAllocColorCells(theDisplay, cmap, false, NULL, 0, pixels, 64) != 0) {
colorFlag = 2;
int cnt = 0;
for (int red =0; red <4; red++) {
for (int green = 0; green<4; green++) {
for (int blue =0; blue<4; blue++) {
colors[cnt].pixel = pixels[16*red + 4*green + blue];
colors[cnt].red = (65536/3)*red;
colors[cnt].green = (65536/3)*green;
colors[cnt].blue = (65536/3)*blue;
colors[cnt].flags = DoRed | DoGreen | DoBlue;
cnt++;
}
}
}
XStoreColors(theDisplay, cmap, colors, cnt);
foreground = pixels[0];
background = pixels[63];
} else {
colorFlag = 3;
// lets create our own color table -
// problem with this is that screen colors change as we enter
opserr << "WindowDevice::initWindow() - could not add any colors to the\n";
opserr << "existing colormap - will try to create our own colormap\n";
}
#else
#endif
}
main()
{
Window w2;
Display *dpy = XOpenDisplay(NIL);
assert(dpy);
Screen *scr = DefaultScreenOfDisplay(dpy);
// CreateWindow
Window w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
0, NIL);
XDestroyWindow(dpy, w);
// CreateWindow with arguments
XSetWindowAttributes swa;
swa.background_pixel = WhitePixelOfScreen(scr);
swa.bit_gravity = NorthWestGravity;
swa.border_pixel = BlackPixelOfScreen(scr);
swa.colormap = DefaultColormapOfScreen(scr);
swa.cursor = None;
swa.win_gravity = NorthGravity;
w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixel | CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWWinGravity,
&swa);
// CreateWindow with other arguments
XDestroyWindow(dpy, w);
Pixmap pixmap = XCreatePixmap(dpy, RootWindowOfScreen(scr), 45, 25, DefaultDepthOfScreen(scr));
assert(pixmap);
swa.background_pixmap = pixmap;
swa.border_pixmap = pixmap;
w = XCreateWindow(dpy, RootWindowOfScreen(scr), 10, 100, 200, 300, 0, CopyFromParent,
CopyFromParent, CopyFromParent,
CWBackPixmap | CWBorderPixmap,
&swa);
// ChangeWindowAttributes
swa.backing_planes = 0x1;
swa.backing_pixel = WhitePixelOfScreen(scr);
swa.save_under = True;
swa.event_mask = KeyPressMask | KeyReleaseMask;
swa.do_not_propagate_mask = ButtonPressMask | Button4MotionMask;
swa.override_redirect = False;
XChangeWindowAttributes(dpy, w, CWBackingPlanes | CWBackingPixel | CWSaveUnder | CWEventMask
| CWDontPropagate | CWOverrideRedirect, &swa);
// GetWindowAttributes
XWindowAttributes wa;
Status success = XGetWindowAttributes(dpy, w, &wa);
// DestroyWindow (done)
// DestroySubwindows
w2 = XCreateWindow(dpy, w, 20, 30, 40, 50, 3, CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XDestroySubwindows(dpy, w);
// ChangeSaveSet
// Display *dpy2 = XOpenDisplay(NIL);
// assert(dpy2);
// XAddToSaveSet(dpy2, w);
// XCloseDisplay(dpy2);
// ReparentWindow
w2 = XCreateWindow(dpy, RootWindowOfScreen(scr), 20, 30, 40, 50, 3,
CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XReparentWindow(dpy, w2, w, 10, 5);
// MapWindow
XMapWindow(dpy, w);
// MapSubwindows
XMapSubwindows(dpy, w);
// UnmapWindow
XUnmapWindow(dpy, w);
// UnmapSubwindows
XMapWindow(dpy, w);
XUnmapSubwindows(dpy, w2);
XMapSubwindows(dpy, w);
// ConfigureWindow
Window w3 = XCreateWindow(dpy, w, 10, 50, 100, 10, 2,
CopyFromParent, CopyFromParent, CopyFromParent, 0, NIL);
XMapWindow(dpy, w3);
XWindowChanges wc;
wc.x = -5;
wc.y = -10;
wc.width = 50;
wc.height = 40;
wc.border_width = 7;
wc.sibling = w2;
wc.stack_mode = Opposite;
XConfigureWindow(dpy, w3,
CWX | CWY | CWWidth | CWHeight | CWBorderWidth | CWSibling | CWStackMode,
&wc);
// CirculateWindow
XCirculateSubwindows(dpy, w, RaiseLowest);
// GetGeometry
Window root;
int x, y;
unsigned width, height, border_width, depth;
XGetGeometry(dpy, w, &root, &x, &y, &width, &height, &border_width, &depth);
// QueryTree
Window parent;
Window *children;
unsigned nchildren;
success = XQueryTree(dpy, w, &root, &parent, &children, &nchildren);
XFree(children);
// InternAtom
Atom a = XInternAtom(dpy, "WM_PROTOCOLS", True);
// GetAtomName
char *string = XGetAtomName(dpy, XA_PRIMARY);
XFree(string);
// ChangeProperty
XStoreName(dpy, w, "test window");
// DeleteProperty
XDeleteProperty(dpy, w, XA_WM_NAME);
// GetProperty
// TODO
// ListProperties
int num_prop;
Atom *list = XListProperties(dpy, w, &num_prop);
XFree(list);
// SetSelectionOwner
XSetSelectionOwner(dpy, XA_PRIMARY, w, 12000);
XSetSelectionOwner(dpy, XA_SECONDARY, w, CurrentTime);
// GetSelectionOwner
Window wx = XGetSelectionOwner(dpy, XA_PRIMARY);
// ConvertSelection
XConvertSelection(dpy, XA_SECONDARY, XA_CURSOR, XA_POINT, w, CurrentTime);
// SendEvent
// GrabPointer
std::cerr << "Grabbing" << std::endl;
int res = XGrabPointer(dpy, w, False, Button5MotionMask | PointerMotionHintMask,
GrabModeSync, GrabModeAsync, w, None, CurrentTime);
XSync(dpy, False);
// sleep(5);
// UngrabPointer
std::cerr << "Ungrabbing" << std::endl;
XUngrabPointer(dpy, CurrentTime);
// GrabButton
XGrabButton(dpy, 3, ShiftMask | ControlMask, w, False, PointerMotionHintMask | Button2MotionMask,
GrabModeAsync, GrabModeSync, None, None);
XGrabButton(dpy, 2, AnyModifier, w, False, PointerMotionHintMask | Button2MotionMask,
GrabModeAsync, GrabModeSync, None, None);
// UngrabButton
XUngrabButton(dpy, 2, LockMask, w);
// ChangeActivePointerGrab
XChangeActivePointerGrab(dpy, ButtonPressMask, None, CurrentTime);
// GrabKeyboard
XGrabKeyboard(dpy, w, True, GrabModeSync, GrabModeSync, 12000);
// UngrabKeyboard
XUngrabKeyboard(dpy, 13000);
// GrabKey
XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Tab), ShiftMask | Mod3Mask, w, True, GrabModeSync,
GrabModeSync);
// UngrabKey
XUngrabKey(dpy, AnyKey, AnyModifier, w);
// AllowEvents
XAllowEvents(dpy, AsyncPointer, 14000);
// GrabServer
XGrabServer(dpy);
// UngrabServer
XUngrabServer(dpy);
// QueryPointer
Window child;
int root_x, root_y, win_x, win_y;
unsigned mask;
Bool bres = XQueryPointer(dpy, w, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask);
// GetMotionEvents
int nevents;
XGetMotionEvents(dpy, w, 15000, 16000, &nevents);
// TranslateCoordinates
int dest_x, dest_y;
XTranslateCoordinates(dpy, w, w2, 10, 20, &dest_x, &dest_y, &child);
// WarpPointer
XWarpPointer(dpy, w, w2, 0, 0, 100, 100, 20, 30);
// SetInputFocus
XSetInputFocus(dpy,w, RevertToPointerRoot, 17000);
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, 17000);
// GetInputFocus
Window focus;
int revert_to;
XGetInputFocus(dpy, &focus, &revert_to);
// QueryKeymap
char keys_return[32];
XQueryKeymap(dpy, keys_return);
// OpenFont
Font fid = XLoadFont(dpy, "cursor");
// CloseFont
XUnloadFont(dpy, fid);
// QueryFont
XFontStruct *fs = XLoadQueryFont(dpy, "cursor");
assert(fs);
// QueryTextExtents
int direction, font_ascent, font_descent;
XCharStruct overall;
XQueryTextExtents(dpy, fs -> fid, "toto", 4, &direction, &font_ascent, &font_descent, &overall);
XQueryTextExtents(dpy, fs -> fid, "odd__length", 11, &direction, &font_ascent, &font_descent, &overall);
XChar2b c2bs;
c2bs.byte1 = '$';
c2bs.byte2 = 'B';
XQueryTextExtents16(dpy, fs -> fid, &c2bs, 1, &direction, &font_ascent, &font_descent, &overall);
XQueryTextExtents(dpy, fs -> fid, longString, strlen(longString), &direction, &font_ascent,
&font_descent, &overall);
// ListFonts
int actual_count;
char **fontList = XListFonts(dpy, "*", 100, &actual_count);
XFree((char *)fontList);
// ListFontsWithInfo
int count;
XFontStruct *info;
char **names = XListFontsWithInfo(dpy, "*", 100, &count, &info);
XFreeFontInfo(names, info, count);
// SetFontPath
// GetFontPath
int npaths;
char **charList = XGetFontPath(dpy, &npaths);
char **charList2 = new char *[npaths + 1];
memcpy(charList2, charList, npaths * sizeof(char *));
charList2[npaths] = charList2[0];
XSetFontPath(dpy, charList2, npaths + 1);
XSetFontPath(dpy, charList, npaths); // Reset to some reasonnable value
XFreeFontPath(charList);
delete [] charList2;
// CreatePixmap
Pixmap pix2 = XCreatePixmap(dpy, w, 100, 200, DefaultDepthOfScreen(scr));
// FreePixmap
XFreePixmap(dpy, pix2);
// CreateGC
Pixmap bitmap = XCreateBitmapFromData(dpy, RootWindowOfScreen(scr),
"\000\000\001\000\000\001\000\000\001\377\377\377", 3, 4);
XGCValues gcv;
gcv.function = GXand;
gcv.plane_mask = 0x1;
gcv.foreground = WhitePixelOfScreen(scr);
gcv.background = BlackPixelOfScreen(scr);
gcv.line_width = 2;
gcv.line_style = LineDoubleDash;
gcv.cap_style = CapProjecting;
gcv.join_style = JoinRound;
gcv.fill_style = FillStippled;
gcv.fill_rule = EvenOddRule;
gcv.arc_mode = ArcPieSlice;
gcv.tile = pixmap;
gcv.stipple = bitmap;
gcv.ts_x_origin = 3;
gcv.ts_y_origin = 4;
gcv.font = fs -> fid;
gcv.subwindow_mode = ClipByChildren;
gcv.graphics_exposures = True;
gcv.clip_x_origin = 5;
gcv.clip_y_origin = 6;
gcv.clip_mask = bitmap;
gcv.dash_offset = 1;
gcv.dashes = 0xc2;
GC gc = XCreateGC(dpy, w,
GCFunction | GCPlaneMask | GCForeground | GCBackground | GCLineWidth
| GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle | GCFillRule | GCTile
| GCStipple | GCTileStipXOrigin | GCTileStipYOrigin | GCFont | GCSubwindowMode
| GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin | GCClipMask | GCDashOffset
| GCDashList | GCArcMode,
&gcv);
// ChangeGC
gcv.function = GXandReverse;
// Only a few of these should appear, since the values are cached on the client side by the Xlib.
XChangeGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, &gcv);
// CopyGC
GC gc2 = XCreateGC(dpy, w, 0, NIL);
XCopyGC(dpy, gc, GCFunction | GCLineStyle | GCStipple | GCGraphicsExposures | GCDashList, gc2);
// SetDashes
XSetDashes(dpy, gc, 3, "\001\377\001", 3);
// SetClipRectangles
XRectangle rectangles[] = { { 10, 20, 30, 40 }, { 100, 200, 5, 3 }, { -5, 1, 12, 24 } };
XSetClipRectangles(dpy, gc, 12, 9, rectangles, SIZEOF(rectangles), Unsorted);
// FreeGC
// done already
// ClearArea
XClearArea(dpy, w, 30, 10, 10, 100, False);
// CopyArea
XCopyArea(dpy, w, pixmap, gc, 0, 0, 100, 100, 10, 10);
// CopyPlane
// This won't work if the Screen doesn't have at least 3 planes
XCopyPlane(dpy, pixmap, w, gc, 20, 10, 40, 30, 0, 0, 0x4);
// PolyPoint
XDrawPoint(dpy, w, gc, 1, 2);
XPoint points[] = { { 3, 4 }, { 5, 6 } };
XDrawPoints(dpy, w, gc, points, SIZEOF(points), CoordModeOrigin);
// PolyLine
XDrawLines(dpy, w, gc, points, SIZEOF(points), CoordModePrevious);
// PolySegment
XSegment segments[] = { { 7, 8, 9, 10 }, { 11, 12, 13, 14 }, { 15, 16, 17, 18 } };
XDrawSegments(dpy, w, gc, segments, SIZEOF(segments));
// PolyRectangle
XDrawRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));
// PolyArc
XArc arcs[] = { { 10, 20, 30, 40, 50, 60 }, { -70, 80, 90, 100, 110, 120 },
{ 10, 20, 30, 40, 50, -30 } };
XDrawArcs(dpy, w, gc, arcs, SIZEOF(arcs));
// FillPoly
XFillPolygon(dpy, w, gc, points, SIZEOF(points), Convex, CoordModePrevious);
// PolyFillRectangle
XFillRectangles(dpy, w, gc, rectangles, SIZEOF(rectangles));
// PolyFillArc
XFillArcs(dpy, w, gc, arcs, SIZEOF(arcs));
// PutImage
// GetImage
XImage *image = XGetImage(dpy, w, 10, 20, 40, 30, AllPlanes, ZPixmap);
XPutImage(dpy, w, gc, image, 0, 0, 50, 60, 40, 30);
XSync(dpy, False); // Make the next request starts at the beginning of a packet
// PolyText8
XTextItem textItems[3];
textItems[0].chars = "toto";
textItems[0].nchars = strlen(textItems[0].chars);
textItems[0].delta = -3;
textItems[0].font = fs->fid;
textItems[1].chars = "titi";
textItems[1].nchars = strlen(textItems[1].chars);
textItems[1].delta = 3;
textItems[1].font = None;
textItems[2].chars = "tutu";
textItems[2].nchars = strlen(textItems[2].chars);
textItems[2].delta = 0;
textItems[2].font = fs->fid;
XDrawText(dpy, w, gc, 10, 10, textItems, 3);
XTextItem textItems2[3];
textItems2[0].chars = "totox";
textItems2[0].nchars = strlen(textItems2[0].chars);
textItems2[0].delta = -3;
textItems2[0].font = fs->fid;
textItems2[1].chars = "titi";
textItems2[1].nchars = strlen(textItems2[1].chars);
textItems2[1].delta = 3;
textItems2[1].font = None;
textItems2[2].chars = "tutu";
textItems2[2].nchars = strlen(textItems2[2].chars);
textItems2[2].delta = 0;
textItems2[2].font = fs->fid;
XDrawText(dpy, w, gc, 10, 10, textItems2, 3);
// PolyText16
XChar2b c2b2[] = { 0, 't', 0, 'x' };
XTextItem16 items16[] = { { &c2bs, 1, -5, None }, { NULL, 0, 0, None }, { c2b2, 2, 0, fs -> fid } };
XDrawText16(dpy, w, gc, 10, 0, items16, SIZEOF(items16));
// ImageText8
XDrawImageString(dpy, w, gc, 10, 10, "toto", 4);
// ImageText16
XDrawImageString16(dpy, w, gc, 10, 10, &c2bs, 1);
XDrawImageString16(dpy, w, gc, 10, 20, c2b2, 2);
// CreateColormap
// Don't forget to tell the kids how it was when we had only 8 bits per pixel.
Colormap colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);
// FreeColormap
XFreeColormap(dpy, colormap);
colormap = XCreateColormap(dpy, w, DefaultVisualOfScreen(scr), None);
// CopyColormapAndFree
Colormap colormap2 = XCopyColormapAndFree(dpy, colormap);
// InstallColormap
XInstallColormap(dpy, colormap2);
// UninstallColormap
XUninstallColormap(dpy, colormap2);
// ListInstalledColormaps
int num;
Colormap *colormapList = XListInstalledColormaps(dpy, w, &num);
// AllocColor
XColor screen;
screen.red = 0;
screen.green = 32767;
screen.blue = 65535;
screen.flags = DoRed | DoGreen | DoBlue;
success = XAllocColor(dpy, colormap, &screen);
// AllocNamedColor
XColor screen2, exact;
success = XAllocNamedColor(dpy, colormap, "Wheat", &screen2, &exact);
// AllocColorCells
unsigned long plane_masks, pixels;
success = XAllocColorCells(dpy, colormap, False, &plane_masks, 1, &pixels, 1);
// AllocColorPlanes
unsigned long rmask, gmask, bmask;
success = XAllocColorPlanes(dpy, colormap, False, &pixels, 1, 0, 0, 0, &rmask, &gmask, &bmask);
// FreeColors
unsigned long pixels2[2] = { screen.pixel, screen2.pixel };
XFreeColors(dpy, colormap, pixels2, 2, 0);
// StoreColors
success = XAllocColorCells(dpy, colormap, False, NIL, 0, pixels2, 2);
// On many contemporary (that is, year 2000) video cards, you can't allocate read / write cells
// I want my requests to be sent, however.
if (!success) {
XSetErrorHandler(errorHandler);
}
XColor colors[2];
colors[0] = screen; colors[0].pixel = pixels2[0];
colors[1] = screen2; colors[1].pixel = pixels2[1];
XStoreColors(dpy, colormap, colors, 2);
// StoreNamedColor
XStoreNamedColor(dpy, colormap, "Wheat", colors[0].pixel, DoBlue);
XSync(dpy, False);
XSetErrorHandler(NIL); // Restore the default handler
// QueryColors
screen2.pixel = WhitePixelOfScreen(scr);
XQueryColor(dpy, colormap, &screen2);
// LookupColor
success = XLookupColor(dpy, colormap, "DarkCyan", &exact, &screen);
// CreateCursor
Cursor cursor = XCreatePixmapCursor(dpy, pixmap, None, &exact, colors, 10, 10);
// CreateGlyphCursor
Cursor cursor2 = XCreateGlyphCursor(dpy, fs -> fid, fs -> fid, 'X', 0, &exact, colors);
// FreeCursor
XFreeCursor(dpy, cursor2);
// RecolorCursor
XRecolorCursor(dpy, cursor, colors, &exact);
// QueryBestSize
success = XQueryBestSize(dpy, CursorShape, RootWindowOfScreen(scr), 100, 20, &width, &height);
// QueryExtension
int major_opcode, first_event, first_error;
XQueryExtension(dpy, "toto", &major_opcode, &first_event, &first_error);
// ListExtensions
int nextensions;
char **extensionList = XListExtensions(dpy, &nextensions);
for(char **p = extensionList; nextensions; nextensions--, p++) std::cout << *p << std::endl;
XFree(extensionList);
// ChangeKeyboardMapping
// GetKeyboardMapping
int min_keycodes, max_keycodes;
XDisplayKeycodes(dpy, &min_keycodes, &max_keycodes);
int keysyms_per_keycode;
KeySym *keysyms = XGetKeyboardMapping(dpy, min_keycodes, max_keycodes - min_keycodes + 1,
&keysyms_per_keycode);
XChangeKeyboardMapping(dpy, min_keycodes, keysyms_per_keycode, keysyms,
max_keycodes - min_keycodes + 1);
// ChangeKeyboardControl
// GetKeyboardControl
XKeyboardState keyboardState;
XGetKeyboardControl(dpy, &keyboardState);
XKeyboardControl keyboardValues;
keyboardValues.key_click_percent = keyboardState.key_click_percent;
keyboardValues.bell_percent = keyboardState.bell_percent;
keyboardValues.bell_pitch = keyboardState.bell_pitch;
keyboardValues.bell_duration = keyboardState.bell_duration;
keyboardValues.led = 1;
keyboardValues.led_mode = LedModeOn;
keyboardValues.key = min_keycodes;
keyboardValues.auto_repeat_mode = AutoRepeatModeDefault;
XChangeKeyboardControl(dpy,
KBKeyClickPercent | KBBellPercent | KBBellPitch | KBBellDuration
| KBLed | KBLedMode | KBKey | KBAutoRepeatMode,
&keyboardValues);
// Bell
XBell(dpy, 90);
// ChangePointerControl
// GetPointerControl
int accel_numerator, accel_denominator, threshold;
XGetPointerControl(dpy, &accel_numerator, &accel_denominator, &threshold);
XChangePointerControl(dpy, True, True, accel_numerator, accel_denominator, threshold);
// SetScreenSaver
// GetScreenSaver
int timeout, interval, prefer_blanking, allow_exposures;
XGetScreenSaver(dpy, &timeout, &interval, &prefer_blanking, &allow_exposures);
XSetScreenSaver(dpy, timeout, interval, prefer_blanking, allow_exposures);
// ChangeHosts
// ListHosts
int nhosts;
Bool state;
XHostAddress *hostList = XListHosts(dpy, &nhosts, &state);
XHostAddress host;
host.family = FamilyInternet;
host.length = 4;
host.address = "\001\002\003\004";
XAddHost(dpy, &host);
// SetAccessControl
XSetAccessControl(dpy, EnableAccess);
// SetCloseDownMode
XSetCloseDownMode(dpy, RetainTemporary);
// KillClient
XKillClient(dpy, AllTemporary);
// RotateProperties
Atom properties[] = { XInternAtom(dpy, "CUT_BUFFER0", False),
XInternAtom(dpy, "CUT_BUFFER1", False),
XInternAtom(dpy, "CUT_BUFFER2", False) };
XRotateWindowProperties(dpy, RootWindowOfScreen(scr), properties, SIZEOF(properties), -1);
// ForceScreenSaver
XForceScreenSaver(dpy, ScreenSaverReset);
// SetPointerMapping
// GetPointerMapping
unsigned char map[64];
int map_length = XGetPointerMapping(dpy, map, 64);
XSetPointerMapping(dpy, map, map_length);
// SetModifierMapping
// GetModifierMapping
XModifierKeymap *modmap = XGetModifierMapping(dpy);
XSetModifierMapping(dpy, modmap);
// NoOperation
XNoOp(dpy);
for(;;) {
XEvent e;
XNextEvent(dpy, &e);
std::cout << "Got an event of type " << e.type << std::endl;
}
}
static void
make_color_path(Display * dpy, Colormap cmap,
int npoints, int *h, double *s, double *v,
XColor * colors, int *ncolorsP,
Bool allocate_p,
Bool writable_p)
{
int i, k;
int total_ncolors = *ncolorsP;
int ncolors[MAXPOINTS]; /* number of pixels per edge */
double dh[MAXPOINTS]; /* distance between pixels, per edge (0 - 360.0) */
double ds[MAXPOINTS]; /* distance between pixels, per edge (0 - 1.0) */
double dv[MAXPOINTS]; /* distance between pixels, per edge (0 - 1.0) */
if (npoints == 0) {
*ncolorsP = 0;
return;
} else if (npoints == 2) { /* using make_color_ramp() will be faster */
make_color_ramp(dpy, cmap,
h[0], s[0], v[0], h[1], s[1], v[1],
colors, ncolorsP,
True, /* closed_p */
allocate_p, writable_p);
return;
} else if (npoints >= MAXPOINTS) {
npoints = MAXPOINTS - 1;
}
AGAIN:
{
double DH[MAXPOINTS]; /* Distance between H values in the shortest
direction around the circle, that is, the
distance between 10 and 350 is 20.
(Range is 0 - 360.0.)
*/
double edge[MAXPOINTS]; /* lengths of edges in unit HSV space. */
double ratio[MAXPOINTS]; /* proportions of the edges (total 1.0) */
double circum = 0;
double one_point_oh = 0; /* (debug) */
for (i = 0; i < npoints; i++) {
int j = (i + 1) % npoints;
double d = ((double) (h[i] - h[j])) / 360;
if (d < 0)
d = -d;
if (d > 0.5)
d = 0.5 - (d - 0.5);
DH[i] = d;
}
for (i = 0; i < npoints; i++) {
int j = (i + 1) % npoints;
edge[i] = sqrt((DH[i] * DH[j]) +
((s[j] - s[i]) * (s[j] - s[i])) +
((v[j] - v[i]) * (v[j] - v[i])));
circum += edge[i];
}
#ifdef DEBUG
(void) fprintf(stderr, "\ncolors:");
for (i = 0; i < npoints; i++)
(void) fprintf(stderr, " (%d, %.3f, %.3f)", h[i], s[i], v[i]);
(void) fprintf(stderr, "\nlengths:");
for (i = 0; i < npoints; i++)
(void) fprintf(stderr, " %.3f", edge[i]);
#endif /* DEBUG */
if (circum < 0.0001)
goto FAIL;
for (i = 0; i < npoints; i++) {
ratio[i] = edge[i] / circum;
one_point_oh += ratio[i];
}
#ifdef DEBUG
(void) fprintf(stderr, "\nratios:");
for (i = 0; i < npoints; i++)
(void) fprintf(stderr, " %.3f", ratio[i]);
#endif /* DEBUG */
if (one_point_oh < 0.99999 || one_point_oh > 1.00001)
abort();
/* space the colors evenly along the circumference -- that means that the
number of pixels on a edge is proportional to the length of that edge
(relative to the lengths of the other edges.)
*/
for (i = 0; i < npoints; i++)
ncolors[i] = (int) (total_ncolors * ratio[i]);
#ifdef DEBUG
(void) fprintf(stderr, "\npixels:");
for (i = 0; i < npoints; i++)
(void) fprintf(stderr, " %d", ncolors[i]);
(void) fprintf(stderr, " (%d)\n", total_ncolors);
#endif /* DEBUG */
for (i = 0; i < npoints; i++) {
int j = (i + 1) % npoints;
if (ncolors[i] > 0) {
dh[i] = 360 * (DH[i] / ncolors[i]);
ds[i] = (s[j] - s[i]) / ncolors[i];
dv[i] = (v[j] - v[i]) / ncolors[i];
}
}
}
(void) memset(colors, 0, (*ncolorsP) * sizeof (*colors));
k = 0;
for (i = 0; i < npoints; i++) {
int distance, direction, j;
distance = h[(i + 1) % npoints] - h[i];
direction = (distance >= 0 ? -1 : 1);
if (distance > 180)
distance = 180 - (distance - 180);
else if (distance < -180)
distance = -(180 - ((-distance) - 180));
else
direction = -direction;
#ifdef DEBUG
(void) fprintf(stderr, "point %d: %3d %.2f %.2f\n",
i, h[i], s[i], v[i]);
(void) fprintf(stderr, " h[i]=%d dh[i]=%.2f ncolors[i]=%d\n",
h[i], dh[i], ncolors[i]);
#endif /* DEBUG */
for (j = 0; j < ncolors[i]; j++, k++) {
double hh = (h[i] + (j * dh[i] * direction));
if (hh < 0)
hh += 360;
else if (hh > 360)
hh -= 0;
colors[k].flags = DoRed | DoGreen | DoBlue;
hsv_to_rgb((int)
hh,
(s[i] + (j * ds[i])),
(v[i] + (j * dv[i])),
&colors[k].red, &colors[k].green, &colors[k].blue);
#ifdef DEBUG
(void) fprintf(stderr, "point %d+%d: %.2f %.2f %.2f %04X %04X %04X\n",
i, j,
hh,
(s[i] + (j * ds[i])),
(v[i] + (j * dv[i])),
colors[k].red, colors[k].green, colors[k].blue);
#endif /* DEBUG */
}
}
/* Floating-point round-off can make us decide to use fewer colors. */
if (k < *ncolorsP) {
*ncolorsP = k;
if (k <= 0)
return;
}
if (!allocate_p)
return;
if (writable_p) {
unsigned long *pixels = (unsigned long *)
malloc(sizeof (unsigned long) * ((*ncolorsP) + 1));
/* allocate_writable_colors() won't do here, because we need exactly this
number of cells, or the color sequence we've chosen won't fit. */
if (!XAllocColorCells(dpy, cmap, False, 0, 0, pixels, *ncolorsP)) {
free(pixels);
goto FAIL;
}
for (i = 0; i < *ncolorsP; i++)
colors[i].pixel = pixels[i];
free(pixels);
XStoreColors(dpy, cmap, colors, *ncolorsP);
} else {
for (i = 0; i < *ncolorsP; i++) {
XColor color;
color = colors[i];
if (XAllocColor(dpy, cmap, &color)) {
colors[i].pixel = color.pixel;
} else {
free_colors(dpy, cmap, colors, i);
goto FAIL;
}
}
}
return;
FAIL:
/* we weren't able to allocate all the colors we wanted;
decrease the requested number and try again.
*/
total_ncolors = (total_ncolors > 170 ? total_ncolors - 20 :
total_ncolors > 100 ? total_ncolors - 10 :
total_ncolors > 75 ? total_ncolors - 5 :
total_ncolors > 25 ? total_ncolors - 3 :
total_ncolors > 10 ? total_ncolors - 2 :
total_ncolors > 2 ? total_ncolors - 1 :
0);
*ncolorsP = total_ncolors;
if (total_ncolors > 0)
goto AGAIN;
}
/*---------------------------- HandleEvent --------------------------*/
int HandleEvent(XEvent *event)
{
int i;
if(theEvent.xany.window==mainW) {
switch (event->type) {
case Expose: {
XExposeEvent *exp_event = (XExposeEvent *) event;
if (exp_event->window==mainW) {
DrawWindow(exp_event->x,exp_event->y,
exp_event->width, exp_event->height);
}
}
break;
case EnterNotify: {
if (Selected_Visual_Class==DirectColor)
XStoreColors(theDisp,NewCmap,newC,ColorMapSize);
if (Selected_Visual_Class!=TrueColor)
XInstallColormap(theDisp,NewCmap);
}
break;
case LeaveNotify: {
if (Selected_Visual_Class==DirectColor)
XStoreColors(theDisp,NewCmap,rootC,ColorMapSize);
}
break;
case KeyPress: { /* allow a quit from the image window */
Handle_KeyPress(event);
}
break;
case MotionNotify: {
Handle_Motion(event);
}
break;
case ConfigureNotify: {
XConfigureEvent *conf_event = (XConfigureEvent *) event;
if (conf_event->window == cmdW &&
(conf_event->width != cmd_width ||
conf_event->height != cmd_height))
XResizeWindow(theDisp,cmdW,cmd_width,cmd_height);
if (conf_event->window == mainW &&
(conf_event->width != zWidth+(color_bar?color_bar_width:0) ||
conf_event->height != zHeight+info_height))
Resize(conf_event->width-(color_bar?color_bar_width:0),
conf_event->height-info_height);
}
break;
case ButtonPress: {
if (theEvent.xbutton.button==Button1) {
if (selzoom_active) {
Selective_Zoom((caddr_t)&one);
break;
}
XDefineCursor(theDisp,mainW,roiCursor);
XFlush(theDisp);
if (roi_present) draw_roi(roi_x1, roi_y1, roi_x2, roi_y2);
roi_active = 1;
roi_x1 = theEvent.xmotion.x < zWidth ?
(theEvent.xmotion.x>0 ?
theEvent.xmotion.x : 0) : zWidth-1;
roi_y1 = theEvent.xmotion.y < zHeight ?
(theEvent.xmotion.y>0 ?
theEvent.xmotion.y : 0) : zHeight-1;
roi_x2 = roi_x1;
roi_y2 = roi_y1;
draw_roi(roi_x1, roi_y1, roi_x2, roi_y2);
break;
}
if (theEvent.xbutton.button==Button2) {
XDefineCursor(theDisp,mainW,wlCursor);
XClearArea(theDisp,mainW,0,zHeight,
zWidth,zHeight+info_height,False);
XDrawImageString(theDisp,mainW,theMGC,
zWidth-XTextWidth(ol_text_finfo,
wl_msg,strlen(wl_msg))-4,
zHeight+info_height-4,wl_msg,strlen(wl_msg));
XDrawImageString(theDisp,mainW,theMGC,4,
zHeight+info_height-4,loc_msg,strlen(loc_msg));
XFlush(theDisp);
break;
}
if (theEvent.xbutton.button==Button3) {
/* note: not really 'iconic' anymore, simply map or unmap */
if (cmdW_State==NormalState) {
XUnmapWindow(theDisp,cmdW);
cmdW_State = IconicState;
}
else {
XMapWindow(theDisp,cmdW);
cmdW_State = NormalState;
}
break;
}
}
break;
case ButtonRelease: {
int xa, xb, ya, yb;
if (theEvent.xbutton.button==Button1 && roi_active) {
roi_active = 0;
xa = roi_x1*(Width-1)/(zWidth-1);
xb = roi_x2*(Width-1)/(zWidth-1);
ya = roi_y1*(Height-1)/(zHeight-1);
yb = roi_y2*(Height-1)/(zHeight-1);
roi_stats(xa, ya, xb, yb, 0);
XDefineCursor(theDisp,mainW,mainCursor);
XFlush(theDisp);
}
if (theEvent.xbutton.button==Button2) {
XDefineCursor(theDisp,mainW,mainCursor);
XFlush(theDisp);
if (Scale_Data && (oUpper != Upper || oLower != Lower)) {
Rescale();
Window_Level(Lower,Upper);
oLower=Lower; oUpper=Upper;
}
XClearArea(theDisp,mainW,0,zHeight,
zWidth,zHeight+info_height,False);
if (wl_display)
XDrawImageString(theDisp,mainW,theMGC,
zWidth-XTextWidth(ol_text_finfo,wl_msg,strlen(wl_msg))-4,
zHeight+info_height-4,wl_msg,strlen(wl_msg));
XDrawImageString(theDisp,mainW,theMGC,4,
zHeight+info_height-4,loc_msg,strlen(loc_msg));
update_sliders();
update_msgs();
}
}
break;
case UnmapNotify: {
if (bitmap_pad==8) {
if (Interpolation_Type==BILINEAR) {
bilinear_byte_to_byte(byte_Image, Width, Height,
icon_byte_image, ICON_WIDTH, ICON_HEIGHT);
}
else {
nneighbour_byte_to_byte(byte_Image, Width, Height,
icon_byte_image, ICON_WIDTH, ICON_HEIGHT);
}
}
else {
if (Interpolation_Type==BILINEAR) {
bilinear_rgbp_to_rgbp(byte_Image, Width, Height,
icon_byte_image, ICON_WIDTH, ICON_HEIGHT);
}
else {
nneighbour_rgbp_to_rgbp(byte_Image, Width, Height,
icon_byte_image, ICON_WIDTH, ICON_HEIGHT);
}
}
XPutImage(theDisp,iconW,theMGC,iconImage,0,0,0,0,
ICON_WIDTH, ICON_HEIGHT);
}
break;
case CirculateNotify:
case MapNotify:
case DestroyNotify:
case GravityNotify:
case ReparentNotify:
default:
break;
} /* end of switch */
}
/* other command Window events */
if(theEvent.xany.window==cmdW) {
switch (event->type) {
case Expose: {
update_msgs();
}
break;
case EnterNotify: {
if (Selected_Visual_Class==DirectColor)
XStoreColors(theDisp,NewCmap,newC,ColorMapSize);
if (Selected_Visual_Class!=TrueColor)
XInstallColormap(theDisp,NewCmap);
}
break;
case LeaveNotify: {
if (Selected_Visual_Class==DirectColor)
XStoreColors(theDisp,NewCmap,rootC,ColorMapSize);
}
break;
case UnmapNotify: {
cmdW_State = IconicState;
}
break;
case MapNotify: {
cmdW_State = NormalState;
}
break;
case ConfigureNotify: {
XConfigureEvent *conf_event = (XConfigureEvent *) event;
if (conf_event->window == cmdW &&
(conf_event->width != cmd_width ||
conf_event->height != cmd_height))
XResizeWindow(theDisp,cmdW,cmd_width,cmd_height);
}
break;
default: break;
}
}
/* button press events */
if (XFindContext(theDisp, theEvent.xany.window, xwin_context,
(caddr_t *) &which_xwin)==0) {
if(*(which_xwin->event_handler)!=NULL)
(*(which_xwin->event_handler))(which_xwin);
if (Scale_Data && (oUpper != Upper || oLower != Lower)) {
Rescale();
oLower=Lower; oUpper=Upper;
}
}
}
void x_create_colormap( char *name, unsigned char r[256], unsigned char g[256], unsigned char b[256] )
{
Colormap orig_colormap, new_colormap;
Display *display;
int i, status=0, enabled;
XColor *color;
unsigned long plane_masks[1], pixels[1];
Cmaplist *cmaplist, *cml;
static int first_time_through = FALSE;
char sl_cmap_name[1020];
Stringlist *sl;
/*
printf( "----------------------\n" );
printf( "in x_create_colormap, here is state stringlist:\n" );
stringlist_dump( read_in_state );
printf( "----------------------\n" );
*/
display = XtDisplay( topLevel );
if( colormap_list == NULL )
first_time_through = TRUE;
else
first_time_through = FALSE;
/* Make a new Cmaplist structure, and link it into the list */
new_cmaplist( &cmaplist );
cmaplist->name = (char *)malloc( (strlen(name)+1)*sizeof(char) );
strcpy( cmaplist->name, name );
/* Figure out if, according to our saved state, this colormap
* should be enabled or not. If we don't find this colormap
* in the list, default to 'Enabled'
*/
if( strlen(name) > 1000 ) {
fprintf( stderr, "Error, colormap name is too long: %s\n", name );
exit(-1);
}
snprintf( sl_cmap_name, 1018, "CMAP_%s", name );
sl = stringlist_match_string_exact( read_in_state, sl_cmap_name );
if( sl == NULL ) {
/* People seem to find this message confusing
printf( "did not find color map %s in state file: enabling by default\n", sl_cmap_name );
*/
cmaplist->enabled = 1;
}
else
{
if( sl->sltype != SLTYPE_INT ) {
fprintf( stderr, "Error, saved TYPE for colormap %s is not an int\n", sl_cmap_name );
enabled = 1;
}
else
enabled = *((int *)(sl->aux));
cmaplist->enabled = enabled;
}
if( first_time_through )
colormap_list = cmaplist;
else
{
cml = colormap_list;
while( cml->next != NULL )
cml = cml->next;
cml->next = cmaplist;
cmaplist->prev = cml;
}
if( first_time_through ) {
/* First time through, allocate the read/write entries in the colormap.
* We always do ten more than the number of colors requested so that
* black can indicate 'fill_value' entries, and the other color entries
* (which are the window elements) can be colored as desired.
*/
current_colormap_list = cmaplist;
/* TrueColor device */
if( options.display_type == TrueColor ) {
for( i=0; i<(options.n_colors+options.n_extra_colors); i++ ) {
(cmaplist->color_list+i)->pixel = (long)i;
*(cmaplist->pixel_transform+i) = (ncv_pixel)i;
}
}
/* Shared colormap, PseudoColor device */
if( (!options.private_colormap) && (options.display_type == PseudoColor) ) {
/* Try the standard colormap, and see if
* it has enough available colorcells.
*/
orig_colormap = DefaultColormap( display, 0 );
current_colormap = orig_colormap;
i = 0;
status = 1;
while( (i < (options.n_colors+options.n_extra_colors)) && (status != 0) ) {
status = XAllocColorCells( display, orig_colormap, True,
plane_masks, 0, pixels, 1 );
(cmaplist->color_list+i)->pixel = *pixels;
*(cmaplist->pixel_transform+i) = (ncv_pixel)*pixels;
i++;
}
}
/* standard colormap failed for PseudoColor, allocate a private colormap */
if( (options.display_type == PseudoColor) &&
((status == 0) || (options.private_colormap)) ) {
printf( "Using private colormap...\n" );
new_colormap = XCreateColormap(
display,
RootWindow( display, DefaultScreen( display ) ),
XDefaultVisualOfScreen( XtScreen( topLevel ) ),
AllocNone );
current_colormap = new_colormap;
for( i=0; i<(options.n_colors+options.n_extra_colors); i++ )
{
status = XAllocColorCells( display, new_colormap,
True, plane_masks,
0, pixels, 1 );
if( status == 0 ) {
fprintf( stderr, "ncview: x_create_colormap: couldn't allocate \n" );
fprintf( stderr, "requested number of colorcells in a private colormap\n" );
fprintf( stderr, "Try requesting fewer colors with the -nc option\n" );
exit( -1 );
}
(cmaplist->color_list+i)->pixel = *pixels;
*(cmaplist->pixel_transform+i) = (ncv_pixel)*pixels;
}
}
pixel_transform = cmaplist->pixel_transform;
}
else
{
/* if NOT the first time through, just set the pixel values */
for( i=0; i<options.n_colors+options.n_extra_colors; i++ ) {
(cmaplist->color_list+i)->pixel =
(current_colormap_list->color_list+i)->pixel;
*(cmaplist->pixel_transform+i) =
(ncv_pixel)(current_colormap_list->color_list+i)->pixel;
}
}
/* Set the first ten colors including black, the color used for "Fill_Value" entries */
for( i=0; i<options.n_extra_colors; i++ ) {
color = cmaplist->color_list+i;
color->flags = DoRed | DoGreen | DoBlue;
color->red = 256*(unsigned int)255;
color->green = 256*(unsigned int)255;
color->blue = 256*(unsigned int)255;
}
color = cmaplist->color_list+1;
color->flags = DoRed | DoGreen | DoBlue;
color->red = 256*(unsigned int)0;
color->green = 256*(unsigned int)0;
color->blue = 256*(unsigned int)0;
for( i=options.n_extra_colors; i<options.n_colors+options.n_extra_colors; i++ )
{
color = cmaplist->color_list+i;
color->flags = DoRed | DoGreen | DoBlue;
color->red = (unsigned int)
(256*interp( i-options.n_extra_colors, options.n_colors, r, 256 ));
color->green = (unsigned int)
(256*interp( i-options.n_extra_colors, options.n_colors, g, 256 ));
color->blue = (unsigned int)
(256*interp( i-options.n_extra_colors, options.n_colors, b, 256 ));
}
if( (options.display_type == PseudoColor) && first_time_through )
XStoreColors( XtDisplay(topLevel), current_colormap, current_colormap_list->color_list,
options.n_colors+options.n_extra_colors );
}
/* copied from make_random_colormap in colors.c */
static void
make_mondrian_colormap (Screen *screen, Visual *visual, Colormap cmap,
XColor *colors, int *ncolorsP,
Bool allocate_p,
Bool *writable_pP,
Bool verbose_p)
{
Display *dpy = DisplayOfScreen (screen);
Bool wanted_writable = (allocate_p && writable_pP && *writable_pP);
int ncolors = 8;
int i;
if (*ncolorsP <= 0) return;
/* If this visual doesn't support writable cells, don't bother trying. */
if (wanted_writable && !has_writable_cells(screen, visual))
*writable_pP = False;
for (i = 0; i < ncolors; i++)
{
colors[i].flags = DoRed|DoGreen|DoBlue;
colors[i].red = 0;
colors[i].green = 0;
colors[i].blue = 0;
switch(i) {
case 0: case 1: case 2: case 3: case 7: /* white */
colors[i].red = 0xE800;
colors[i].green = 0xE800;
colors[i].blue = 0xE800;
break;
case 4:
colors[i].red = 0xCFFF; break; /* red */
case 5:
colors[i].red = 0x2000;
colors[i].blue = 0xCFFF; break; /* blue */
case 6:
colors[i].red = 0xDFFF; /* yellow */
colors[i].green = 0xCFFF; break;
}
}
if (!allocate_p)
return;
RETRY_NON_WRITABLE:
if (writable_pP && *writable_pP)
{
unsigned long *pixels = (unsigned long *)
malloc(sizeof(*pixels) * (ncolors + 1));
allocate_writable_colors (screen, cmap, pixels, &ncolors);
if (ncolors > 0)
for (i = 0; i < ncolors; i++)
colors[i].pixel = pixels[i];
free (pixels);
if (ncolors > 0)
XStoreColors (dpy, cmap, colors, ncolors);
}
else
{
for (i = 0; i < ncolors; i++)
{
XColor color;
color = colors[i];
if (!XAllocColor (dpy, cmap, &color))
break;
colors[i].pixel = color.pixel;
}
ncolors = i;
}
/* If we tried for writable cells and got none, try for non-writable. */
if (allocate_p && ncolors == 0 && writable_pP && *writable_pP)
{
ncolors = *ncolorsP;
*writable_pP = False;
goto RETRY_NON_WRITABLE;
}
#if 0
/* I don't think we need to bother copying or linking to the complain
function. */
if (verbose_p)
complain(*ncolorsP, ncolors, wanted_writable,
wanted_writable && *writable_pP);
#endif
*ncolorsP = ncolors;
}
/*-------------------------------------------------------------*/
void setup_display(Widget w)
{
int i,j, cindex;
int theScreen;
XColor *colors = NULL;
XGCValues xgcv;
Colormap theColormap;
XVisualInfo *p_visinfo;
XVisualInfo *vis_list;
XVisualInfo vis_template;
Widget *list_w = NULL; /* List of widgets with its own colormap */
theScreen = DefaultScreen(XtDisplay(w));
vis_template.screen = theScreen;
vis_list = XGetVisualInfo(XtDisplay(w),VisualScreenMask, &vis_template, &j);
for (i=0, p_visinfo = vis_list; i<j;i++, p_visinfo++)
{
if(p_visinfo->class == PseudoColor && p_visinfo->depth == 8)
{ theVisual = p_visinfo->visual;
vis_depth = p_visinfo->depth;
break;
}
}
theVisual = DefaultVisual(XtDisplay(w),theScreen);
vis_depth = 8;
/* Create the XColor entries for the colormap */
if((colors = (XColor *)calloc(COLORMAP_SIZE, sizeof(XColor))) == NULL) {
fprintf(stderr, "No memory for setting up colormap\n");
exit(1);
}
/* Set up the color cells to greyscale */
for(cindex = 0; cindex < COLORMAP_SIZE; cindex++) {
colors[cindex].red = CSCALE * cindex;
colors[cindex].green = CSCALE * cindex;
colors[cindex].blue = CSCALE * cindex;
colors[cindex].pixel = cindex;
colors[cindex].flags = DoRed | DoGreen | DoBlue;
}
/* Create the colormap */
theColormap = XCreateColormap(XtDisplay(top_level), RootWindow(XtDisplay(top_level), theScreen),
theVisual, AllocAll);
/* Store the colors into the colormap */
XStoreColors(XtDisplay(top_level), theColormap, colors, COLORMAP_SIZE);
/* Set the background and foreground colors before free(colors) */
bg = colors[0].pixel;
fg = colors[255].pixel;
ysmap=XCopyColormapAndFree(XtDisplay(top_level), theColormap);
/* Now we can release the memory used by the colors */
/* because the X server already has this information. */
free(colors);
/* Set background, foreground, visual_depth and colormap for draw_1 */
argcount = 0;
XtSetArg(args[argcount], XmNforeground, fg ); argcount++;
XtSetArg(args[argcount], XmNbackground, bg ); argcount++;
XtSetArg(args[argcount], XmNdepth , vis_depth ); argcount++;
XtSetArg(args[argcount], XmNcolormap , theColormap); argcount++;
XtSetValues(draw_1, args, argcount);
/* Set background, foreground, visual_depth and colormap for draw_2 */
argcount = 0;
XtSetArg(args[argcount], XmNforeground, fg ); argcount++;
XtSetArg(args[argcount], XmNbackground, bg ); argcount++;
XtSetArg(args[argcount], XmNdepth , vis_depth ); argcount++;
XtSetArg(args[argcount], XmNcolormap , theColormap); argcount++;
XtSetValues(draw_2, args, argcount);
/* Set the WM_COLORMAP_WINDOWS property so that the Motif */
/* window manager knows about the windows that have their */
/* own colormap. */
if(theColormap != DefaultColormap(XtDisplay(top_level), theScreen)) {
list_w = (Widget *) malloc(2*sizeof(Widget));
list_w[0] = draw_1;
list_w[1] = draw_2;
XtSetWMColormapWindows(top_level, list_w, (Cardinal) 2);
}
/* Define a GC for both drawing areas with these colors */
xgcv.foreground = fg;
xgcv.background = bg;
image_gc_1 = XCreateGC(XtDisplay(w), XtWindow(draw_1),
(GCForeground | GCBackground), &xgcv);
image_gc_2 = XCreateGC(XtDisplay(w), XtWindow(draw_2),
(GCForeground | GCBackground), &xgcv);
/* Define a GC to be used in editing image operations*/
xgcv.foreground = fg ^ bg;
xgcv.background = bg;
xgcv.function = GXxor;
xorGC = XtGetGC(draw_1, GCForeground | GCBackground | GCFunction, &xgcv);
xgcv.foreground = fg;
xgcv.background = bg;
theGC = XtGetGC(draw_1, GCForeground | GCBackground, &xgcv);
}
int main (void)
{
int i;
int allocateOK;
ximg = NULL;
d = XOpenDisplay (NULL);
if (!d)
fputs ("Couldn't open display\n", stderr), exit (1);
screen = DefaultScreen (d);
gc = DefaultGC (d, screen);
/* Find a visual */
vis.screen = screen;
vlist = XGetVisualInfo (d, VisualScreenMask, &vis, &match);
if (!vlist)
fputs ("No matched visuals\n", stderr), exit (1);
vis = vlist[0];
XFree (vlist);
// That's not a fair comparison colormap_size is depth in bits!
// if (vis.colormap_size < COLORS)
// printf("Colormap is too small: %i.\n",vis.colormap_size); // , exit (1);
printf("Colour depth: %i\n",vis.colormap_size);
win = XCreateSimpleWindow (d, DefaultRootWindow (d),
0, 0, WIN_W, WIN_H, 0,
WhitePixel (d, screen), BlackPixel (d, screen));
int xclass=get_xvisinfo_class(vis);
// printf("class = %i\n",xclass);
stylee = ( vis.depth > 8 ? styleeTrueColor : styleePrivate );
// printf("stylee=%i\n",stylee);
if ( get_xvisinfo_class(vis) % 2 == 1) { /* The odd numbers can redefine colors */
// printf("%i\n",get_xvisinfo_class(vis));
colormap = DefaultColormap (d, screen);
Visual *defaultVisual=DefaultVisual(d,screen);
/* Allocate cells */
allocateOK = (XAllocColorCells (d, colormap, 1,
NULL, 0, color, COLORS) != 0);
// printf("Allocated OK? %i\n",allocateOK);
if (allocateOK) {
// printf("Allocated OK\n");
// This doesn't work for installed colormap!
/* Modify the colorcells */
for (i = 0; i < COLORS; i++)
xrgb[i].pixel = color[i];
XStoreColors (d, colormap, xrgb, COLORS);
} else {
colormap = XCreateColormap(d,win,defaultVisual,AllocNone);
// redocolors();
}
// black = XBlackPixel(d,screen);
// white = XWhitePixel(d,screen);
} else if ( get_xvisinfo_class(vis) == TrueColor) {
colormap = DefaultColormap (d, screen);
// printf("TrueColor %i = %i\n",xclass,TrueColor);
/* This will lookup the color and sets the xrgb[i].pixel value */
// for (i = 0; i < COLORS; i++)
// XAllocColor (d, colormap, &xrgb[i]);
} else
fprintf (stderr, "Not content with visual class %d.\n",
get_xvisinfo_class(vis) ), exit (1);
/* Find out if MITSHM is supported and useable */
printf ("MITSHM: ");
if (XShmQueryVersion (d, &mitshm_major_code,
&mitshm_minor_code, &shared_pixmaps)) {
int (*handler) (Display *, XErrorEvent *);
ximg = XShmCreateImage (d, vis.visual,
vis.depth, XShmPixmapFormat (d),
NULL, &shminfo, WIN_W, WIN_H);
shminfo.shmid = shmget (IPC_PRIVATE,
ximg->bytes_per_line * ximg->height,
IPC_CREAT | 0777);
shminfo.shmaddr = (char *)shmat (shminfo.shmid, 0, 0);
ximg->data = (char *)shminfo.shmaddr;
handler = XSetErrorHandler (mitshm_handler);
XShmAttach (d, &shminfo); /* Tell the server to attach */
XSync (d, 0);
XSetErrorHandler (handler);
shmctl (shminfo.shmid, IPC_RMID, 0);
/* Mark this shm segment for deletion at once. The segment will
* automatically become released when both the server and this
* client have detached from it.
* (Process termination automagically detach shm segments) */
if (!can_use_mitshm) {
shmdt (shminfo.shmaddr);
ximg = NULL;
}
}
if (ximg == NULL) {
can_use_mitshm = 0;
/* XInitImage(ximg); */
ximg = XCreateImage (d, vis.visual, vis.depth, ZPixmap,
0, (char *)malloc (WIN_W * WIN_H), WIN_W, WIN_H, 8, 0);
}
if (can_use_mitshm)
printf ("YES!\n");
else
printf ("NO, using fallback instead.\n");
// DrawFractal (ximg,xrgb);
XSelectInput (d, win, ButtonPressMask | ExposureMask);
XMapWindow (d, win);
real_main();
// XNextEvent (d, &ev);
// switch (ev.type) {
// case ButtonPress:
// should_quit = 1;
// break;
// case Expose:
// if (can_use_mitshm)
// XShmPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H, True);
// else
// XPutImage (d, win, gc, img, 0, 0, 0, 0, WIN_W, WIN_H);
// break;
// default:
// break;
// }
if (get_xvisinfo_class(vis) % 2 == 1 || get_xvisinfo_class(vis) == TrueColor) {
unsigned long color[COLORS];
if (allocateOK) {
for (i = 0; i < COLORS; i++)
color[i] = xrgb[i].pixel;
XFreeColors (d, colormap, color, COLORS, 0);
} /* Allocated colors freed */
} else {
XUninstallColormap (d, colormap);
}
if (can_use_mitshm) {
XShmDetach (d, &shminfo); /* Server detached */
XDestroyImage (ximg); /* Image struct freed */
shmdt (shminfo.shmaddr); /* We're detached */
} else
XDestroyImage (ximg); /* Image struct freed */
XDestroyWindow (d, win); /* Window removed */
XCloseDisplay (d); /* Display disconnected */
/* So you can see how your computer compares to your friend's */
getrusage (RUSAGE_SELF, &resource_utilization);
float seconds=(float)resource_utilization.ru_utime.tv_sec
+(float)resource_utilization.ru_utime.tv_usec*0.000000001;
printf("CPU seconds per frame: %f\n",seconds/(float)frameno);
// printf ("CPU seconds consumed: %ds and %dµs\n",
// (int) resource_utilization.ru_utime.tv_sec,
// (int) resource_utilization.ru_utime.tv_usec);
return 0;
}
