static size_t _gfx_x11_init_modes( Screen* scr, XRRScreenResources* res) { /* Split depth */ GFXColorDepth depth; _gfx_split_depth( XDefaultDepthOfScreen(scr), &depth.redBits, &depth.greenBits, &depth.blueBits ); /* Reserve space for all modes */ size_t first = gfx_vector_get_size(&_gfx_x11.modes); gfx_vector_reserve(&_gfx_x11.modes, first + res->nmode); unsigned int i; for(i = 0; i < res->nmode; ++i) { /* Skip refresh rate of zero */ unsigned int refresh = 0; if(res->modes[i].hTotal && res->modes[i].vTotal) { refresh = (unsigned int)lround((double)res->modes[i].dotClock / ((double)res->modes[i].hTotal * (double)res->modes[i].vTotal)); } if(refresh) { /* Create new mode */ GFX_X11_Mode mode; mode.id = res->modes[i].id; mode.mode.width = res->modes[i].width; mode.mode.height = res->modes[i].height; mode.mode.depth = depth; mode.mode.refresh = refresh; gfx_vector_insert(&_gfx_x11.modes, &mode, _gfx_x11.modes.end); } } return first; }
void main(int argc, char **argv) { int i,j,k, x_return, y_return; float D; unsigned int width_return, height_return, border_width_return, depth_return; Window root_return; char *display_name; int screen; XSetWindowAttributes winAttributes; char *window_name = "sbXcityfly"; char *icon_name = "sbXcityfly"; static ButtonRec buttonDefs[]={ {&buttonDefs[1], "1", "Translation ON ", 0, SPW_BwFlagRoundButton}, {&buttonDefs[2], "2", "Rotation ON ", 0, SPW_BwFlagRoundButton}, {&buttonDefs[3], "3", "Single Axis Filter OFF", 0, SPW_BwFlagRoundButton}, {&buttonDefs[4], "4", "Roll ON ", 0, SPW_BwFlagRoundButton}, {&buttonDefs[5], "5", "Decrease sensitivity", 0, SPW_BwFlagRoundButton}, {&buttonDefs[6], "Sensi", "Sensitivity: 1 ", 0, SPW_BwFlagNoButton}, {&buttonDefs[7], "6", "Increase sensitivity", 0, SPW_BwFlagRoundButton}, {&buttonDefs[8], "7", " ", 0, SPW_BwFlagRoundButton}, {&buttonDefs[9], "8", "Rezero", 0, SPW_BwFlagRoundButton}, {&buttonDefs[10], "P", "Reset View", 0, SPW_BwFlagRoundButton}, {&buttonDefs[11], NULL, NULL, 0, SPW_BwFlagSeparator}, {&buttonDefs[12], "ESC", "Quit", XK_Escape, SPW_BwFlagKey}, {NULL, NULL, NULL, 0, SPW_BwFlagSeparator}, }; /* * Connect to the X Server */ if ((display_name=getenv("DISPLAY")) == NULL) display_name=":0"; if ((Spw_Dpy=XOpenDisplay(display_name)) == NULL) { fprintf(stderr,"%s: Could not open X Display\n",argv[0]); exit(1); } screen=DefaultScreen(Spw_Dpy); Spw_Gc=DefaultGC(Spw_Dpy,screen); XSetBackground(Spw_Dpy,Spw_Gc,BlackPixel(Spw_Dpy,screen)); XSetForeground(Spw_Dpy,Spw_Gc,WhitePixel(Spw_Dpy,screen)); winAttributes.background_pixel=BlackPixel(Spw_Dpy,screen); /* * Create the main window proportional to the root window */ XGetGeometry(Spw_Dpy, DefaultRootWindow(Spw_Dpy), &root_return, &x_return,&y_return, &width_return, &height_return,& border_width_return, &depth_return); Spw_WindowSize = .8 * MIN(height_return,width_return); Spw_WindowWidth = Spw_WindowSize; Spw_WindowHeight = Spw_WindowSize; Spw_mainWindow = XCreateWindow(Spw_Dpy,DefaultRootWindow(Spw_Dpy), 250, 0, Spw_WindowWidth, Spw_WindowHeight,1, CopyFromParent,CopyFromParent,CopyFromParent, CWBackPixel,&winAttributes); Spw_mainBuffer= XCreatePixmap(Spw_Dpy, Spw_mainWindow, Spw_WindowWidth, Spw_WindowHeight, XDefaultDepthOfScreen(XDefaultScreenOfDisplay(Spw_Dpy))); /* * Select the colors to draw in */ Spw_white = AllocPublicColor(0xffff,0xffff,0xffff); Spw_black = AllocPublicColor(0x0000,0x0000,0x0000); Spw_grey = AllocPublicColor(0xffff,0xffff,0xffff); Spw_green = AllocPublicColor(0x0000,0xffff,0x0000); /* * Set up and map the window */ XStoreName(Spw_Dpy, Spw_mainWindow, argv[0]); setWindowHints(Spw_mainWindow, argv, argc, window_name, icon_name, "sbXcityfly", "SBxcityfly"); XMapWindow(Spw_Dpy, Spw_mainWindow); /* * Initialize the Spaceball and Button Window */ if (!(SPW_InputCheckForSpaceball(Spw_Dpy, Spw_mainWindow, "sbXcityfly")) ) { fprintf (stderr, "Sorry, no Spaceball found!\n"); exit(0); } Spw_ButtonWindow=SPW_BwInit(Spw_Dpy, DefaultScreenOfDisplay(Spw_Dpy), "sbXcityfly", buttonDefs); if(!Spw_ButtonWindow) { fprintf(stderr, "Error: BwInit returned NULL\n"); exit(-1); } SpwUpdateButtons(); /* * Set up the geometry to be displayed */ D = 1.0/tan( (double) ((M_PI/180.0)*(FOV/2.0)) ); SPW_InitializeMatrix(Spw_Persp, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0, -1.0/D, 0.0, 0.0, 0.0, 0.0); GetUniqPoints(bldg, buniq, Spw_SizeBldg ); GetUniqPoints(land, luniq, Spw_SizeLand ); /* * Go into main loop, clean up if we ever exit cleanly */ DispatchLoop(); XDestroyWindow(Spw_Dpy, Spw_mainWindow); XCloseDisplay(Spw_Dpy); } /* end of main */
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); } }
/*--------------------------------------------------------*/ 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); }
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 */ } }
int screen::IMPL::depth() const { return XDefaultDepthOfScreen( _xscrn ); }