int main(int argc, char** argv) { // Create display. Display* dpy = CreateDisplay(); int screen = XDefaultScreen(dpy); int depth = XDefaultDepth(dpy, screen); Window root_win = XDefaultRootWindow(dpy); int numScreens = 1; Drawable screens[] = { root_win }; axRect dpy_rect = axRect(0, 0, XDisplayWidth(dpy, screen), XDisplayHeight(dpy, screen)); // Setup GLX. XVisualInfo* v_info = GetGLXVisualInfo(dpy); Visual* visual = v_info->visual; Colormap colormap = XCreateColormap(dpy, root_win, visual, AllocNone); glEnable(GL_TEXTURE_2D); // Create window. axRect window_rect(0, 0, 500, 500); Window win = CreateWindow(dpy, window_rect, root_win, colormap, v_info); // Pixmap back_buffer = XCreatePixmap(dpy, win, // window_rect.size.x, window_rect.size.y, // screen); GLXContext glx_context = glXCreateContext(dpy, v_info, NULL, GL_TRUE); //GC gc; glXMakeCurrent(dpy, win, glx_context); //glXMakeCurrent( AX_GLOBAL_DISPLAY, win, gc->GetGLX_GC() ); //Window win = XCreateSimpleWindow(dpy, RootWindow(dpy, s), 10, 10, 660, 200, 1, // BlackPixel(dpy, s), WhitePixel(dpy, s)); XSelectInput(dpy, win, StructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask ); // Show window. XMapWindow(dpy, win); //XFlush(dpy); XStoreName(dpy, win, "axLib"); //XSelectInput(dpy, win, ExposureMask | KeyPressMask); //XMapWindow(dpy, win); // #if defined(__APPLE_CC__) // XStoreName(dpy, win, "Geeks3D.com - X11 window under Mac OS X (Lion)"); // #else // XStoreName(dpy, win, "Geeks3D.com - X11 window under Linux (Mint 10)"); // #endif MainLoop(dpy, win, window_rect); XDestroyWindow(dpy, win); XCloseDisplay(dpy); return 0; }
VideoMode Monitor::GetCurrentVideoMode() { #if defined(FastOSWindows) DEVMODE dm; memset(&dm, 0, sizeof(DEVMODE)); dm.dmSize = sizeof(DEVMODE); EnumDisplaySettingsEx(mWin32DeviceName.GetWString().mData, ENUM_CURRENT_SETTINGS, &dm, 0); return VideoMode(dm.dmPelsWidth, dm.dmPelsHeight, dm.dmBitsPerPel, dm.dmDisplayFrequency); #elif defined(FastOSLinux) XRRScreenResources *xrrScreenResources = (XRRScreenResources*)mDisplay->GetXRRScreenResources(); ::Display *xdisplay = (::Display*)mDisplay->GetXDisplay(); RRMode mode = ((XRRCrtcInfo*)mXRRCrtcInfo)->mode; // Find matching mode ID for (Int i = 0; i < xrrScreenResources->nmode; i++) { if (mode == xrrScreenResources->modes[i].id) { XRRModeInfo &xrrModeInfo = xrrScreenResources->modes[i]; return VideoMode(xrrModeInfo.width, xrrModeInfo.height, XDefaultDepth(xdisplay, mID), (Int)(xrrModeInfo.dotClock / (xrrModeInfo.hTotal * xrrModeInfo.vTotal))); } } return VideoMode(); #elif defined(FastOSMacOSX) VideoMode vm; QZGetCurrentVideoMode(mMacMonitorID, &vm); return vm; #endif }
bool getAvailableDisplayModes(list<DisplayMode> * lstDisplayModes) { Display * display; XF86VidModeModeInfo ** modes; int nbModes; display = XOpenDisplay(0); int screen = DefaultScreen(display); int bpp = XDefaultDepth(display, screen); XF86VidModeGetAllModeLines(display, screen, &nbModes, &modes); for (int i = 0; i < nbModes; i++) { // Check it's not already added bool skip = false; for (DisplayMode &mode : (*lstDisplayModes)) { if (mode.iWidth == modes[i]->hdisplay && mode.iHeight == modes[i]->vdisplay) { skip = true; break; } } if (!skip) { lstDisplayModes->push_back(DisplayMode(modes[i]->hdisplay, modes[i]->vdisplay, bpp)); } } XFree(modes); return true; }
static display init(XRRScreenResources* sr, RROutput output) { display result; XRROutputInfo* oi = XRRGetOutputInfo(g_display, sr, output); if (oi->connection == RR_Connected) { result.scale = 1; result.name = oi->name; result.color_depth = XDefaultDepth(g_display, g_screen); result.color_depth_per_component = result.color_depth >= 24? 8 : 0; result.crtc = oi->crtc; result.output = output; XRRCrtcInfo* ci = XRRGetCrtcInfo(g_display, sr, oi->crtc); result.rect.left = ci->x; result.rect.top = ci->y; result.rect.width = ci->width; result.rect.height = ci->height; if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270) { std::swap(result.rect.width, result.rect.height); } XRRFreeCrtcInfo(ci); result.work_rect = result.rect; } XRRFreeOutputInfo(oi); return result; }
void x_resize(size_t width, size_t height) { if (X.win_width == width && X.win_height == height) { return; } debug("%lux%lu", (long unsigned)width, (long unsigned)height); /* Update pixmap */ if (X.pixmap) XFreePixmap(X.dpy, X.pixmap); X.pixmap = XCreatePixmap(X.dpy, X.window, width, height, XDefaultDepth(X.dpy, X.screen)); XSetForeground(X.dpy, X.gc, config.background); XFillRectangle(X.dpy, X.pixmap, X.gc, 0, 0, width, height); X.win_width = width; X.win_height = height; size_t glyphs_w = X.win_width / X.glyph_width; size_t glyphs_h = X.win_height / X.glyph_height; term_resize(glyphs_w, glyphs_h); }
void x_init_window() { uint32_t mask = CWBackPixel | CWEventMask; XSetWindowAttributes values; values.background_pixel = config.background; values.event_mask = KeyPressMask | ExposureMask | StructureNotifyMask; size_t width = X.glyph_width * config.cols; size_t height = X.glyph_height * config.rows; Window parent = XRootWindow(X.dpy, X.screen); X.window = XCreateWindow(X.dpy, parent, 0, 0, /* x, y */ width, height, 0, /* border width */ XDefaultDepth(X.dpy, X.screen), InputOutput, XDefaultVisual(X.dpy, X.screen), mask, &values); }
void getimage(int left, int top, int right, int bottom, void *bitmap) { int X; int Y; int width; int height; bgi_image *bm = (bgi_image*)bitmap; Pixmap pixmap; XGCValues op_gcv; GC op_gc; X = left + VPorigin.x; Y = top + VPorigin.y; width = right - left + 1; height = bottom - top + 1; pixmap = XCreatePixmap(dpy, window, width, height, XDefaultDepth(dpy, DefaultScreen(dpy))); op_gc = XCreateGC(dpy, drawable, 0, NULL); XCopyGC(dpy, gc, (GCBackground | GCForeground | GCPlaneMask), op_gc); op_gcv.function = GXcopy; XChangeGC(dpy, op_gc, GCFunction, &op_gcv); XCopyArea(dpy, drawable, pixmap, op_gc, X, Y, width, height, 0, 0); bm->width = width; bm->height = height; bm->pixmap = pixmap; XFreeGC(dpy, op_gc); }
void xresize(struct framebuffer *xw, struct terminal *term, XEvent *ev) { XConfigureEvent *e = &ev->xconfigure; if (e->width != term->width || e->height != term->height) { term->width = e->width; term->height = e->height; term->lines = term->height / cell_height; term->cols = term->width / cell_width; XFreePixmap(xw->dpy, xw->buf); xw->buf = XCreatePixmap(xw->dpy, xw->win, term->width, term->height, XDefaultDepth(xw->dpy, xw->sc)); free(term->line_dirty); term->line_dirty = (bool *) emalloc(sizeof(bool) * term->lines); free(term->tabstop); term->tabstop = (bool *) emalloc(sizeof(bool) * term->cols); free(term->cells); term->cells = (struct cell *) emalloc(sizeof(struct cell) * term->cols * term->lines); reset(term); ioctl(term->fd, TIOCSWINSZ, &(struct winsize) {.ws_row = term->lines, .ws_col = term->cols, .ws_xpixel = 0, .ws_ypixel = 0});
int createPixmapForTexture(GLXContextType *glxContext, GLuint texture, uint32_t width, uint32_t height, Pixmap *pixmap, GLXPixmap *glxPixmap) { int i; if (!glxContext || !texture || !width || !height || !pixmap || !glxPixmap) return -1; Display *x11Display = glxContext->x11Display; // query/choose config/attributes for GLXPixmap/Pixmap const int pixmapAttr[] = { GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT, GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT, GL_NONE}; const int fbConfigAttr[] = { GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT, GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT, GLX_BIND_TO_TEXTURE_RGB_EXT, GL_TRUE, GLX_Y_INVERTED_EXT, GL_TRUE, GL_NONE}; int numFbConfigs; GLXFBConfig *fbConfig = glXChooseFBConfig(x11Display, DefaultScreen(x11Display), fbConfigAttr, &numFbConfigs); ASSERT(fbConfig && numFbConfigs); int depth = XDefaultDepth(x11Display, DefaultScreen(x11Display)); *pixmap = XCreatePixmap(x11Display, DEFAULT_ROOT_WINDOW(x11Display), width, height, depth); ASSERT(*pixmap); *glxPixmap = glXCreatePixmap(x11Display, *fbConfig, *pixmap, pixmapAttr); ASSERT(*glxPixmap); glBindTexture(GL_TEXTURE_2D, texture); glXBindTexImageEXT_func(x11Display, *glxPixmap, GLX_FRONT_LEFT_EXT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); ASSERT_GL_ERROR(); return 0; }
static xrandrt_t *xrandrt_init(const char *display_name) { xrandrt_t *xr; int fd; Display *disp; disp = XOpenDisplay(display_name); if ((xr = malloc(sizeof(*xr))) == NULL) { if (disp != NULL) XCloseDisplay(disp); } else { fd = XConnectionNumber(disp); memset(xr, 0, sizeof(*xr)); xr->disp = disp; xr->chan = g_io_channel_unix_new(fd); xr->evsrc = g_io_add_watch(xr->chan, G_IO_IN|G_IO_HUP|G_IO_ERR, xevent_cb,xr); printf("videoep: xrandr initialized\n"); { Window root; Visual *vis; int sno; unsigned long wp; unsigned long bp; Window win; int depth; XSetWindowAttributes attr; unsigned long mask; root = XDefaultRootWindow(disp); sno = XDefaultScreen(disp); vis = XDefaultVisual(disp, sno); depth = XDefaultDepth(disp, sno); bp = XBlackPixel(disp, sno); wp = XWhitePixel(disp, sno); mask = CWBackPixel | CWBorderPixel | CWEventMask; attr.background_pixel = wp; attr.border_pixel = bp; attr.event_mask = ButtonPressMask | FocusChangeMask; win = XCreateWindow(disp, root, 50,50, 400,300, 1, depth, InputOutput, vis, mask, &attr); XMapWindow(disp,win); XFlush(disp); } } return xr; }
static inline int displayDepth() { #if PLATFORM(QT) return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen()); #elif PLATFORM(GTK) return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default())); #else return 0; #endif }
value caml_gr_new_image(int w, int h) { value res = alloc_custom(&image_ops, sizeof(struct grimage), w * h, Max_image_mem); Width_im(res) = w; Height_im(res) = h; Data_im(res) = XCreatePixmap(caml_gr_display, caml_gr_window.win, w, h, XDefaultDepth(caml_gr_display, caml_gr_screen)); Mask_im(res) = None; return res; }
void subScreenResize(void) { int i; assert(subtle); /* Update screens */ for(i = 0; i < subtle->screens->ndata; i++) { SubScreen *s = SCREEN(subtle->screens->data[i]); /* Add strut */ s->geom.x = s->base.x + subtle->styles.subtle.padding.left; s->geom.y = s->base.y + subtle->styles.subtle.padding.top; s->geom.width = s->base.width - subtle->styles.subtle.padding.left - subtle->styles.subtle.padding.right; s->geom.height = s->base.height - subtle->styles.subtle.padding.top - subtle->styles.subtle.padding.bottom; /* Update panels */ if(s->flags & SUB_SCREEN_PANEL1) { XMoveResizeWindow(subtle->dpy, s->panel1, s->base.x, s->base.y, s->base.width, subtle->ph); XMapRaised(subtle->dpy, s->panel1); /* Update height */ s->geom.y += subtle->ph; s->geom.height -= subtle->ph; } else XUnmapWindow(subtle->dpy, s->panel1); if(s->flags & SUB_SCREEN_PANEL2) { XMoveResizeWindow(subtle->dpy, s->panel2, s->base.x, s->base.y + s->base.height - subtle->ph, s->base.width, subtle->ph); XMapRaised(subtle->dpy, s->panel2); /* Update height */ s->geom.height -= subtle->ph; } else XUnmapWindow(subtle->dpy, s->panel2); /* Create/update drawable for double buffering */ if(s->drawable) XFreePixmap(subtle->dpy, s->drawable); s->drawable = XCreatePixmap(subtle->dpy, ROOT, s->base.width, subtle->ph, XDefaultDepth(subtle->dpy, DefaultScreen(subtle->dpy))); } ScreenPublish(); subSubtleLogDebugSubtle("Resize\n"); } /* }}} */
static inline int displayDepth() { #if PLATFORM(QT) return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen()); #elif PLATFORM(GTK) return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default())); #elif PLATFORM(EFL) && defined(HAVE_ECORE_X) return ecore_x_default_depth_get(NetscapePlugin::x11HostDisplay(), ecore_x_default_screen_get()); #else return 0; #endif }
void xresize(xwindow *xw, terminal *term, XEvent *ev) { int lines, cols; XFreePixmap(xw->dsp, xw->buf); lines = ev->xconfigure.height / term->cell_size.y; cols = ev->xconfigure.width / term->cell_size.x; xw->buf = XCreatePixmap(xw->dsp, xw->win, ev->xconfigure.width, ev->xconfigure.height, XDefaultDepth(xw->dsp, xw->sc)); resize(term, lines, cols); }
struct pipe_screen* vl_screen_create(Display *display, int screen) { struct xsp_pipe_winsys *xsp_winsys; assert(display); xsp_winsys = CALLOC_STRUCT(xsp_pipe_winsys); if (!xsp_winsys) return NULL; xsp_winsys->base.buffer_create = xsp_buffer_create; xsp_winsys->base.user_buffer_create = xsp_user_buffer_create; xsp_winsys->base.buffer_map = xsp_buffer_map; xsp_winsys->base.buffer_unmap = xsp_buffer_unmap; xsp_winsys->base.buffer_destroy = xsp_buffer_destroy; xsp_winsys->base.surface_buffer_create = xsp_surface_buffer_create; xsp_winsys->base.fence_reference = xsp_fence_reference; xsp_winsys->base.fence_signalled = xsp_fence_signalled; xsp_winsys->base.fence_finish = xsp_fence_finish; xsp_winsys->base.flush_frontbuffer = xsp_flush_frontbuffer; xsp_winsys->base.get_name = xsp_get_name; xsp_winsys->base.destroy = xsp_destroy; xsp_winsys->display = display; xsp_winsys->screen = screen; xsp_winsys->fbimage = XCreateImage ( display, XDefaultVisual(display, screen), XDefaultDepth(display, screen), ZPixmap, 0, NULL, 0, /* Don't know the width and height until flush_frontbuffer */ 0, 32, 0 ); if (!xsp_winsys->fbimage) { FREE(xsp_winsys); return NULL; } XInitImage(xsp_winsys->fbimage); return softpipe_create_screen(&xsp_winsys->base); }
/* Procedure d'initialisation du serveur X et des variables globales*/ void Xinit(int IsFather) { char *name; Atom myatom; int i=16; /* Connextion au serveur X */ #ifdef DEBUG __bounds_debug_no_checking=True; #endif x11base->display=XOpenDisplay(NULL); if (x11base->display==NULL) { fprintf(stderr,"Enable to open display.\n"); exit(1); } #ifdef DEBUG __bounds_debug_no_checking=False; #endif if (IsFather) { name=(char*)calloc(sizeof(char),strlen("FvwmScript")+5); do { sprintf(name,"%c%xFvwmScript",161,i); i++; myatom=XInternAtom(x11base->display,name,False); } while (XGetSelectionOwner(x11base->display,myatom)!=None); x11base->TabScriptId[1]=name; x11base->TabScriptId[0]=NULL; } x11base->NbChild=0; x11base->screen=DefaultScreen(x11base->display); x11base->WhitePix=WhitePixel(x11base->display,x11base->screen); x11base->BlackPix=BlackPixel(x11base->display,x11base->screen); x11base->depth=XDefaultDepth(x11base->display,x11base->screen); x11base->colormap = DefaultColormap(x11base->display,x11base->screen); x11base->root = RootWindow(x11base->display,x11base->screen); x_fd = XConnectionNumber(x11base->display); }
display display::from_window(window const* w) { Window root = w? *w : g_root; display result; if (randr.is_available) { XRRScreenResources* sr = XRRGetScreenResources(g_display, root); RROutput primary = XRRGetOutputPrimary(g_display, g_root); result = init(sr, primary); XRRFreeScreenResources(sr); } else { result.scale = 1; result.color_depth = XDefaultDepth(g_display, g_screen); result.color_depth_per_component = result.color_depth >= 24? 8 : 0; result.rect = result.work_rect = rectangle<int>(0, 0, DisplayWidthMM(g_display, g_screen), DisplayHeightMM(g_display, g_screen)); } return result; }
XVisualInfo *glXChooseVisual(Display *display, int screen, int *attributes) { // apparently can't trust the Display I'm passed? if (xDisplay == NULL) { xDisplay = display; } int default_depth = XDefaultDepth(display, screen); if (default_depth != 16 && default_depth != 24) printf("libGL: unusual desktop color depth %d\n", default_depth); XVisualInfo *visual = (XVisualInfo *)malloc(sizeof(XVisualInfo)); if (!XMatchVisualInfo(display, screen, default_depth, TrueColor, visual)) { printf("libGL: XMatchVisualInfo failed in glXChooseVisual\n"); return NULL; } return visual; }
/* ------------------------------------------------------------------ */ int initGraphics() { theDisplay = XOpenDisplay(XDisplayName(NULL)); if (theDisplay == NULL) { printf("You need to run the program under X-window.\n\n"); exit(1); } theScreen = XDefaultScreen(theDisplay); rootW = RootWindow(theDisplay, theScreen); theGC = XDefaultGC(theDisplay, theScreen); theCmap = XDefaultColormap(theDisplay, theScreen); theVisual = DefaultVisual(theDisplay, theScreen); theDepth = XDefaultDepth(theDisplay, theScreen); // fprintf(stderr, "Visual %x Depth %d\n", theVisual, theDepth); pScreen = XDefaultScreenOfDisplay(theDisplay); sW = XWidthOfScreen(pScreen); sH = XHeightOfScreen(pScreen); theFont = XLoadFont(theDisplay, FONT10 ); XSetFont(theDisplay, theGC, theFont); return 0; }
value caml_gr_resize_window (value vx, value vy) { caml_gr_check_open (); caml_gr_window.w = Int_val (vx); caml_gr_window.h = Int_val (vy); XResizeWindow (caml_gr_display, caml_gr_window.win, caml_gr_window.w, caml_gr_window.h); XFreeGC(caml_gr_display, caml_gr_bstore.gc); XFreePixmap(caml_gr_display, caml_gr_bstore.win); caml_gr_bstore.w = caml_gr_window.w; caml_gr_bstore.h = caml_gr_window.h; caml_gr_bstore.win = XCreatePixmap(caml_gr_display, caml_gr_window.win, caml_gr_bstore.w, caml_gr_bstore.h, XDefaultDepth(caml_gr_display, caml_gr_screen)); caml_gr_bstore.gc = XCreateGC(caml_gr_display, caml_gr_bstore.win, 0, NULL); XSetBackground(caml_gr_display, caml_gr_bstore.gc, caml_gr_background); caml_gr_clear_graph (); return Val_unit; }
/* Funktion erzeugt ein Fenster */ static int create_window (void) { char *window_name = "Einfaches Fenster - hallo_x"; char *icon_name = "window"; static XSizeHints size_hints; Window rootwin; width = WINDOW_WIDTH; height = WINDOW_HEIGHT; /* X-Sitzung öffnen */ display = XOpenDisplay (NULL); /* Fehlerüberprüfung */ if (display == NULL) { printf ("Verbindung zum X-Server fehlgeschlagen?!?\n"); exit(EXIT_FAILURE); } /* Standardbildschirm eines Displays */ screen = XDefaultScreen (display); /* Standardtiefe des Screens - Anzahl der Ebenen */ depth = XDefaultDepth (display, screen); rootwin = RootWindow (display, screen); win = XCreateSimpleWindow ( display, rootwin, 100, 10, width, height, 5, BlackPixel (display, screen), WhitePixel (display, screen) ); size_hints.flags = PSize | PMinSize | PMaxSize; size_hints.min_width = width; size_hints.max_width = width; size_hints.min_height = height; size_hints.max_height = height; XSetStandardProperties ( display, win, window_name, icon_name, None, 0, 0, &size_hints ); /* Erwünschte Events, auf die das Fenster reagieren soll ... */ XSelectInput (display, win, ButtonPressMask | KeyPressMask); /* Fenster anzeigen */ XMapWindow (display, win); return 1; }
int main(int argc, char ** argv) { setbuf(stdout, NULL); setbuf(stderr, NULL); Display * display = XOpenDisplay(NULL); assert(display != NULL); XSynchronize(display, True); XtAppContext context = XtCreateApplicationContext(); Widget appshell = XtVaAppInitialize(&context, "SoXtTest", NULL, 0, &argc, argv, NULL, NULL); fprintf(stderr, "appshell: %p\n", appshell); #if WANT_VISUALID int i, numvisuals; unsigned int wanted = WANT_VISUALID; XVisualInfo templ; XVisualInfo * visuals = XGetVisualInfo(display, VisualNoMask, &templ, &numvisuals); for ( i = 0; i < numvisuals; i++ ) { if ( visuals[i].visualid == wanted ) goto selected; } assert(0 && "no visual selected"); selected: Visual * visual = visuals[i].visual; int visualid = visuals[i].visualid; int depth = visuals[i].depth; Colormap colormap = 0; fprintf(stderr, "visualid: %d, depth: %d, class: %s\n", visualid, depth, visuals[i].c_class == DirectColor ? "DirectColor" : "Other"); int numcmaps; XStandardColormap * stdcolormaps = NULL; if ( XmuLookupStandardColormap(display, visuals[i].screen, visuals[i].visualid, visuals[i].depth, XA_RGB_DEFAULT_MAP, False, True) && XGetRGBColormaps(display, RootWindow(display, visuals[i].screen), &stdcolormaps, &numcmaps, XA_RGB_DEFAULT_MAP) ) { for ( int j = 0; j < numcmaps; j++ ) { if (stdcolormaps[j].visualid == visuals[i].visualid) { colormap = stdcolormaps[j].colormap; goto cont; } } colormap = XCreateColormap(display, RootWindow(display, visuals[i].screen), visuals[i].visual, AllocNone); fprintf(stderr, "standard RGB colormaps did not work with visual - created own (%ld)", colormap); } else { assert(0); } cont: fprintf(stderr, "colormap: %ld\n", colormap); #else Visual * visual = NULL; int depth = 0; Colormap colormap = 0; int snum = XDefaultScreen(display); visual = XDefaultVisual(display, snum); depth = XDefaultDepth(display, snum); colormap = XDefaultColormap(display, snum); fprintf(stderr, "visual: %p, depth: %d\n", visual, depth); fprintf(stderr, "colormap: %ld\n", colormap); #endif XtVaSetValues(appshell, XmNwidth, 100, XmNheight, 100, XmNvisual, visual, XmNcolormap, colormap, XmNdepth, depth, NULL); Widget form = XtVaCreateManagedWidget( "form", xmFormWidgetClass, appshell, NULL); Widget button = XtVaCreateManagedWidget( "button", xmPushButtonWidgetClass, form, XmNtopAttachment, XmATTACH_FORM, XmNleftAttachment, XmATTACH_FORM, XmNbottomAttachment, XmATTACH_FORM, XmNrightAttachment, XmATTACH_FORM, NULL); Pixmap pixmap = createPixmapFromXpm(button, home_xpm); XtVaSetValues(button, XmNlabelType, XmPIXMAP, XmNlabelPixmap, pixmap, XmNlabelInsensitivePixmap, pixmap, XmNselectPixmap, pixmap, XmNselectInsensitivePixmap, pixmap, NULL); Widget list[] = { appshell, form, button, NULL }; XtSetWMColormapWindows(appshell, list, 3); XtRealizeWidget(appshell); XtAppMainLoop(context); }
void main(int argc, char **argv) { XmStringTable ColumnDetails; int i,j; Cardinal n; Arg args[MAX_ARGS]; int test_num; char test_char; char ContainerName[NAME_LEN + 1]; Pixmap CollapsedStatePixmap, ExpandedStatePixmap; ContainerName[0] = '\0'; test_num = 0; test_char = '\0'; CommonTestInit(argc, argv); if (UserData != NULL) { if (strcmp(UserData, "a") == 0) test_num = 1; else if (strcmp(UserData, "b") == 0) test_num = 2; else if (strcmp(UserData, "c") == 0) test_num = 3; else if (strcmp(UserData, "d") == 0) test_num = 4; test_char = *UserData; free(UserData); } sprintf(ContainerName, "Container3%c", test_char); CollapsedStatePixmap = XCreatePixmapFromBitmapData(display, rootWindow, collapsedState_bits, collapsedState_width, collapsedState_height, CommonGetColor("black"), CommonGetColor("white"), XDefaultDepth(display, XDefaultScreen(display))); ExpandedStatePixmap = XCreatePixmapFromBitmapData(display, rootWindow, expandedState_bits, expandedState_width, expandedState_height, CommonGetColor("white"), CommonGetColor("black"), XDefaultDepth(display, XDefaultScreen(display))); ColumnHeadings = (XmStringTable) XtMalloc(NUM_COL * sizeof(XmString)); for (i = 0; i < NUM_COL; i++) ColumnHeadings[i] = XmStringGenerate(ColumnHeadingText[i], NULL, XmCHARSET_TEXT, NULL); n = 0; XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNlayoutType, XmOUTLINE); n++; XtSetArg(args[n], XmNautomaticSelection, XmNO_AUTO_SELECT); n++; XtSetArg(args[n], XmNdetailColumnHeading, ColumnHeadings); n++; XtSetArg(args[n], XmNdetailColumnHeadingCount, NUM_COL); n++; XtSetArg(args[n], XmNdetailOrderCount, NUM_COL-1); n++; XtSetArg(args[n], XmNcollapsedStatePixmap, CollapsedStatePixmap); n++; XtSetArg(args[n], XmNexpandedStatePixmap, ExpandedStatePixmap); n++; Container3 = XmCreateContainer(Shell1, ContainerName, args, n); XtManageChild(Container3); EntryDetails = (XmStringTable *) XtMalloc(NUM_OBJ * sizeof(XmStringTable)); for (i = 0; i < NUM_OBJ; i++) { ColumnDetails = (XmStringTable)XtMalloc((NUM_COL-1) * sizeof(XmString)); ColumnDetails[0] = XmStringGenerate(FullTitleText[i], NULL, XmCHARSET_TEXT, NULL); ColumnDetails[1] = XmStringGenerate(FlavorText[i], NULL, XmCHARSET_TEXT, NULL); ColumnDetails[2] = XmStringGenerate(AgeText[i], NULL, XmCHARSET_TEXT, NULL); EntryDetails[i] = ColumnDetails; } n = 0; XtSetArg(args[n], XmNx, 100); n++; XtSetArg(args[n], XmNy, 100); n++; XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[0]); n++; IconGad1 = XmCreateIconGadget(Container3, "IconGad1", args, n); XtManageChild(IconGad1); n = 0; XtSetArg(args[n], XmNx, 200); n++; XtSetArg(args[n], XmNy, 200); n++; XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[1]); n++; IconGad2 = XmCreateIconGadget(Container3, "IconGad2", args, n); XtManageChild(IconGad2); n = 0; XtSetArg(args[n], XmNx, 300); n++; XtSetArg(args[n], XmNy, 100); n++; XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[2]); n++; IconGad3 = XmCreateIconGadget(Container3, "IconGad3", args, n); XtManageChild(IconGad3); n = 0; XtSetArg(args[n], XmNx, 50); n++; XtSetArg(args[n], XmNy, 400); n++; XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNdetail, EntryDetails[3]); n++; IconGad4 = XmCreateIconGadget(Container3, "IconGad4", args, n); XtManageChild(IconGad4); n = 0; XtSetArg(args[n], XmNentryParent, IconGad3); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetail, EntryDetails[4]); n++; IconGad31 = XmCreateIconGadget(Container3, "IconGad31", args, n); XtManageChild(IconGad31); n = 0; XtSetArg(args[n], XmNentryParent, IconGad3); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetail, EntryDetails[5]); n++; IconGad32 = XmCreateIconGadget(Container3, "IconGad32", args, n); XtManageChild(IconGad32); n = 0; XtSetArg(args[n], XmNentryParent, IconGad32); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetail, EntryDetails[6]); n++; IconGad321 = XmCreateIconGadget(Container3, "IconGad321", args, n); XtManageChild(IconGad321); n = 0; XtSetArg(args[n], XmNentryParent, IconGad321); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNentryViewType, XmLARGE_ICON); n++; XtSetArg(args[n], XmNdetail, EntryDetails[7]); n++; IconGad3211 = XmCreateIconGadget(Container3, "IconGad3211", args, n); XtManageChild(IconGad3211); n = 0; XtSetArg(args[n], XmNentryParent, IconGad3); n++; XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++; XtSetArg(args[n], XmNentryViewType, XmSMALL_ICON); n++; XtSetArg(args[n], XmNdetail, EntryDetails[8]); n++; IconGad33 = XmCreateIconGadget(Container3, "IconGad33", args, n); XtManageChild(IconGad33); for (i = 0; i < NUM_OBJ; i++) { ColumnDetails = EntryDetails[i]; for (j = 0; j < NUM_COL-1; j++) XmStringFree(ColumnDetails[j]); XtFree((XtPointer)ColumnDetails); } XtFree((XtPointer)EntryDetails); XtRealizeWidget(Shell1); CommonPause(); if ((test_num == 1) || (test_num == 2)) { CommonPause(); CommonPause(); CommonPause(); CommonPause(); CommonPause(); for (i = 0; i < NUM_COL; i++) XmStringFree(ColumnHeadings[i]); XtFree((XtPointer)ColumnHeadings); } if (test_num == 3) { CommonPause(); for (i = 0; i < NUM_COL; i++) XmStringFree(ColumnHeadings[i]); XtFree((XtPointer)ColumnHeadings); } XtAppMainLoop(app_context); }
static void vo_x11_zoom (int mulriple) { unsigned long xswamask, event_mask; XSetWindowAttributes xswa; XSizeHints hint; XVisualInfo xvinfo; if (dlpctxp->pwidth * mulriple > screen_width || dlpctxp->pheight * mulriple > screen_height) { av_log (NULL, AV_LOG_INFO, "vo x11: zoom %d will > fullscrren\n", mulriple); return; } vo_lock (); if (Xvowin != None) { XClearWindow (Xdisplay, Xvowin); XUnmapWindow (Xdisplay, Xvowin); XDestroyWindow (Xdisplay, Xvowin); Xvowin = None; } if (Ximg) { Ximg->data = NULL; XDestroyImage (Ximg); Ximg = NULL; } avpicture_free (my_pic); av_free (my_pic); xswamask = CWBackingStore | CWBorderPixel; dw = dlpctxp->pwidth * mulriple; dh = dlpctxp->pheight * mulriple; dx = (screen_width - dw) / 2; dy = (screen_height - dh) / 2; Xdepth = XDefaultDepth (Xdisplay, 0); if (!XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, DirectColor, &xvinfo)) XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, TrueColor, &xvinfo); xswa.background_pixel = 0; xswa.border_pixel = 0; xswa.backing_store = Always; xswa.bit_gravity = StaticGravity; Xvowin = XCreateWindow (Xdisplay, Xrootwin, dx, dy, dw, dh, 0, Xdepth, CopyFromParent, CopyFromParent, xswamask, &xswa); hint.x = dx; hint.y = dy; hint.width = dw; hint.height = dh; hint.flags = PPosition | PSize; XSetStandardProperties (Xdisplay, Xvowin, Xtitle, Xtitle, None, NULL, 0, &hint); XMapWindow (Xdisplay, Xvowin); XClearWindow (Xdisplay, Xvowin); event_mask = StructureNotifyMask | KeyPressMask | ExposureMask; XSelectInput (Xdisplay, Xvowin, event_mask); XSync (Xdisplay, False); Ximg = XCreateImage (Xdisplay, xvinfo.visual, Xdepth, ZPixmap, 0, NULL, dw, dh, 8, 0); if (dw < 600) Xfont = Xfont_120; else Xfont = Xfont_240; if (Xfont) XSetFont (Xdisplay, Xvogc, Xfont->fid); my_pic = av_mallocz (sizeof (AVPicture)); avpicture_alloc (my_pic, my_pic_fmt, dw, dh); vo_unlock (); }
static int vo_x11_init () { int ret; unsigned long xswamask, event_mask; XSetWindowAttributes xswa; XSizeHints hint; XVisualInfo xvinfo; char *dspname; xswamask = CWBackingStore | CWBorderPixel; src_pic_fmt = dlpctxp->pixfmt; dw = dlpctxp->pwidth; dh = dlpctxp->pheight; dspname = XDisplayName (NULL); av_log (NULL, AV_LOG_INFO, "Open X11 display %s\n", dspname); Xdisplay = XOpenDisplay (dspname); if (!Xdisplay) { av_log (NULL, AV_LOG_ERROR, "X11,%d: XOpenDisplay\n", __LINE__); return -1; } Xscreen = DefaultScreen (Xdisplay); Xrootwin = RootWindow (Xdisplay, Xscreen); screen_width = DisplayWidth (Xdisplay, Xscreen); screen_height = DisplayHeight (Xdisplay, Xscreen); dx = (screen_width - dw) / 2; dy = (screen_height - dh) / 2; Xdepth = XDefaultDepth (Xdisplay, 0); if (!XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, DirectColor, &xvinfo)) XMatchVisualInfo (Xdisplay, Xscreen, Xdepth, TrueColor, &xvinfo); xswa.background_pixel = 0; xswa.border_pixel = 0; xswa.backing_store = Always; xswa.bit_gravity = StaticGravity; Xvowin = XCreateWindow (Xdisplay, Xrootwin, dx, dy, dw, dh, 0, Xdepth, CopyFromParent, CopyFromParent, xswamask, &xswa); hint.x = dx; hint.y = dy; hint.width = dw; hint.height = dh; hint.flags = PPosition | PSize; XSetStandardProperties (Xdisplay, Xvowin, Xtitle, Xtitle, None, NULL, 0, &hint); XMapWindow (Xdisplay, Xvowin); XClearWindow (Xdisplay, Xvowin); event_mask = StructureNotifyMask | KeyPressMask | ExposureMask; XSelectInput (Xdisplay, Xvowin, event_mask); XSync (Xdisplay, False); Xvogc = XCreateGC (Xdisplay, Xrootwin, 0L, NULL); XSetForeground (Xdisplay, Xvogc, WhitePixel (Xdisplay, Xscreen)); Ximg = XCreateImage (Xdisplay, xvinfo.visual, Xdepth, ZPixmap, 0, NULL, dw, dh, 8, 0); { int i, fontcount; char **list; list = XListFonts (Xdisplay, "-*-helvetica-*-*-*-*-0-0-*-*-*-0-*-*", 200, &fontcount); for (i = 0; i < fontcount; i++) { if (NULL == Xfont_120) Xfont_120 = LoadQueryScalableFont (Xdisplay, Xscreen, list[i], 120); if (NULL == Xfont_240) Xfont_240 = LoadQueryScalableFont (Xdisplay, Xscreen, list[i], 240); if (Xfont_120 && Xfont_240) break; } XFreeFontNames (list); if (NULL == Xfont_120 || NULL == Xfont_240) { av_log (NULL, AV_LOG_ERROR, "XLoadQueryFont: failed\n"); } if (dw < 600) Xfont = Xfont_120; else Xfont = Xfont_240; if (Xfont) XSetFont (Xdisplay, Xvogc, Xfont->fid); } switch (Ximg->bits_per_pixel) { case 32: my_pic_fmt = PIX_FMT_RGB32; break; case 24: my_pic_fmt = PIX_FMT_RGB24; break; case 16: my_pic_fmt = PIX_FMT_RGB565; break; case 15: my_pic_fmt = PIX_FMT_RGB555; break; case 8: my_pic_fmt = PIX_FMT_RGB8; break; } av_log (NULL, AV_LOG_INFO, "bits_per_pixel: %d\n", Ximg->bits_per_pixel); /*----------------------------------------------------------------------------- * my picture for rgb *-----------------------------------------------------------------------------*/ my_pic = av_mallocz (sizeof (AVPicture)); ret = avpicture_alloc (my_pic, my_pic_fmt, dw, dh); if (-1 == ret) { av_log (NULL, AV_LOG_ERROR, "avpicture alloc error\n"); return -1; } vo_lock_init (); return 0; }
VALUE subIconInit(int argc, VALUE *argv, VALUE self) { SubtlextIcon *i = NULL; Data_Get_Struct(self, SubtlextIcon, i); if(i) { VALUE data[3] = { Qnil }; rb_scan_args(argc, argv, "12", &data[0], &data[1], &data[2]); subSubtlextConnect(NULL); ///< Implicit open connection /* Find or create icon */ if(T_STRING == rb_type(data[0])) ///< Icon path { int hotx = 0, hoty = 0; char buf[100] = { 0 }; #ifdef HAVE_WORDEXP_H /* Expand tildes in path */ wordexp_t we; if(0 == wordexp(RSTRING_PTR(data[0]), &we, 0)) { snprintf(buf, sizeof(buf), "%s", we.we_wordv[0]); wordfree(&we); } else #endif /* HAVE_WORDEXP_H */ snprintf(buf, sizeof(buf), "%s", RSTRING_PTR(data[0])); /* Find file */ if(-1 == access(buf, R_OK)) { char *home = NULL; /* Combine paths */ if((home = getenv("XDG_DATA_HOME"))) { snprintf(buf, sizeof(buf), "%s/subtle/icons/%s", home, RSTRING_PTR(data[0])); } else { snprintf(buf, sizeof(buf), "%s/.local/share/subtle/icons/%s", getenv("HOME"), RSTRING_PTR(data[0])); } if(-1 == access(buf, R_OK)) rb_raise(rb_eStandardError, "Icon not found `%s'", RSTRING_PTR(data[0])); } /* Reading bitmap or pixmap icon file */ if(BitmapSuccess != XReadBitmapFile(display, DefaultRootWindow(display), buf, &i->width, &i->height, &i->pixmap, &hotx, &hoty)) { #ifdef HAVE_X11_XPM_H XpmAttributes attrs; /* We could define a color to use on transparent areas, but * this can be done on init only, so we just ignore it and * expect pixmaps to have no transparent areas at all */ /* Init attributes */ attrs.colormap = DefaultColormap(display, DefaultScreen(display)); attrs.depth = DefaultDepth(display, DefaultScreen(display)); attrs.visual = DefaultVisual(display, DefaultScreen(display)); attrs.valuemask = XpmColormap|XpmDepth|XpmVisual; if(XpmSuccess == XpmReadFileToPixmap(display, DefaultRootWindow(display), buf, &i->pixmap, NULL, &attrs)) { i->flags |= ICON_PIXMAP; i->width = attrs.width; i->height = attrs.height; } else #endif /* HAVE_X11_XPM_H */ { rb_raise(rb_eStandardError, "Malormed icon"); return Qnil; } } else i->flags |= ICON_BITMAP; } else if(FIXNUM_P(data[0]) && FIXNUM_P(data[1])) ///< Icon dimensions { int depth = 1; /* Create pixmap or bitmap */ if(Qtrue == data[2]) { i->flags |= ICON_PIXMAP; depth = XDefaultDepth(display, DefaultScreen(display)); } else i->flags |= ICON_BITMAP; /* Create empty pixmap */ i->width = FIX2INT(data[0]); i->height = FIX2INT(data[1]); i->pixmap = XCreatePixmap(display, DefaultRootWindow(display), i->width, i->height, depth); } else if(FIXNUM_P(data[0])) { XRectangle geom = { 0 }; i->flags |= (ICON_BITMAP|ICON_FOREIGN); i->pixmap = NUM2LONG(data[0]); subSharedPropertyGeometry(display, i->pixmap, &geom); i->width = geom.width; i->height = geom.height; } else rb_raise(rb_eArgError, "Unexpected value-types"); /* Update object */ rb_iv_set(i->instance, "@width", INT2FIX(i->width)); rb_iv_set(i->instance, "@height", INT2FIX(i->height)); rb_iv_set(i->instance, "@pixmap", LONG2NUM(i->pixmap)); XSync(display, False); ///< Sync all changes subSharedLogDebugSubtlext("new=icon, width=%03d, height=%03d\n", i->width, i->height); } return Qnil; } /* }}} */
void caml_gr_handle_event(XEvent * event) { switch (event->type) { case Expose: XCopyArea(caml_gr_display, caml_gr_bstore.win, caml_gr_window.win, caml_gr_window.gc, event->xexpose.x, event->xexpose.y + caml_gr_bstore.h - caml_gr_window.h, event->xexpose.width, event->xexpose.height, event->xexpose.x, event->xexpose.y); XFlush(caml_gr_display); break; case ConfigureNotify: caml_gr_window.w = event->xconfigure.width; caml_gr_window.h = event->xconfigure.height; if (caml_gr_window.w > caml_gr_bstore.w || caml_gr_window.h > caml_gr_bstore.h) { /* Allocate a new backing store large enough to accomodate both the old backing store and the current window. */ struct canvas newbstore; newbstore.w = max(caml_gr_window.w, caml_gr_bstore.w); newbstore.h = max(caml_gr_window.h, caml_gr_bstore.h); newbstore.win = XCreatePixmap(caml_gr_display, caml_gr_window.win, newbstore.w, newbstore.h, XDefaultDepth(caml_gr_display, caml_gr_screen)); newbstore.gc = XCreateGC(caml_gr_display, newbstore.win, 0, NULL); XSetBackground(caml_gr_display, newbstore.gc, caml_gr_white); XSetForeground(caml_gr_display, newbstore.gc, caml_gr_white); XFillRectangle(caml_gr_display, newbstore.win, newbstore.gc, 0, 0, newbstore.w, newbstore.h); XSetForeground(caml_gr_display, newbstore.gc, caml_gr_color); if (caml_gr_font != NULL) XSetFont(caml_gr_display, newbstore.gc, caml_gr_font->fid); /* Copy the old backing store into the new one */ XCopyArea(caml_gr_display, caml_gr_bstore.win, newbstore.win, newbstore.gc, 0, 0, caml_gr_bstore.w, caml_gr_bstore.h, 0, newbstore.h - caml_gr_bstore.h); /* Free the old backing store */ XFreeGC(caml_gr_display, caml_gr_bstore.gc); XFreePixmap(caml_gr_display, caml_gr_bstore.win); /* Use the new backing store */ caml_gr_bstore = newbstore; XFlush(caml_gr_display); } break; case MappingNotify: XRefreshKeyboardMapping(&(event->xmapping)); break; case KeyPress: { KeySym thekey; char keytxt[256]; int nchars; char * p; nchars = XLookupString(&(event->xkey), keytxt, sizeof(keytxt), &thekey, 0); for (p = keytxt; nchars > 0; p++, nchars--) caml_gr_enqueue_event(event->type, event->xkey.x, event->xkey.y, BUTTON_STATE(event->xkey.state), *p); break; } case ButtonPress: case ButtonRelease: caml_gr_enqueue_event(event->type, event->xbutton.x, event->xbutton.y, event->type == ButtonPress, 0); break; case MotionNotify: caml_gr_enqueue_event(event->type, event->xmotion.x, event->xmotion.y, BUTTON_STATE(event->xmotion.state), 0); break; } }
int QWaylandReadbackEglIntegration::depth() const { return XDefaultDepth(mDisplay,mScreen); }
value caml_gr_open_graph(value arg) { char display_name[256], geometry_spec[64]; char * p, * q; XSizeHints hints; int ret; XEvent event; int x, y, w, h; XWindowAttributes attributes; if (caml_gr_initialized) { caml_gr_clear_graph(); } else { /* Parse the argument */ for (p = String_val(arg), q = display_name; *p != 0 && *p != ' '; p++) if (q < display_name + sizeof(display_name) - 1) *q++ = *p; *q = 0; while (*p == ' ') p++; for (q = geometry_spec; *p != 0; p++) if (q < geometry_spec + sizeof(geometry_spec) - 1) *q++ = *p; *q = 0; /* Open the display */ if (caml_gr_display == NULL) { caml_gr_display = XOpenDisplay(display_name); if (caml_gr_display == NULL) caml_gr_fail("Cannot open display %s", XDisplayName(display_name)); caml_gr_screen = DefaultScreen(caml_gr_display); caml_gr_black = BlackPixel(caml_gr_display, caml_gr_screen); caml_gr_white = WhitePixel(caml_gr_display, caml_gr_screen); caml_gr_background = caml_gr_white; caml_gr_colormap = DefaultColormap(caml_gr_display, caml_gr_screen); } /* Set up the error handlers */ XSetErrorHandler(caml_gr_error_handler); XSetIOErrorHandler(caml_gr_ioerror_handler); /* Parse the geometry specification */ hints.x = 0; hints.y = 0; hints.width = DEFAULT_SCREEN_WIDTH; hints.height = DEFAULT_SCREEN_HEIGHT; hints.flags = PPosition | PSize; hints.win_gravity = 0; ret = XWMGeometry(caml_gr_display, caml_gr_screen, geometry_spec, "", BORDER_WIDTH, &hints, &x, &y, &w, &h, &hints.win_gravity); if (ret & (XValue | YValue)) { hints.x = x; hints.y = y; hints.flags |= USPosition; } if (ret & (WidthValue | HeightValue)) { hints.width = w; hints.height = h; hints.flags |= USSize; } /* Initial drawing color is black */ caml_gr_color = 0; /* CAML COLOR */ /* Create the on-screen window */ caml_gr_window.w = hints.width; caml_gr_window.h = hints.height; caml_gr_window.win = XCreateSimpleWindow(caml_gr_display, DefaultRootWindow(caml_gr_display), hints.x, hints.y, hints.width, hints.height, BORDER_WIDTH, caml_gr_black, caml_gr_background); p = window_name; if (p == NULL) p = DEFAULT_WINDOW_NAME; /* What not use XSetWMProperties? */ XSetStandardProperties(caml_gr_display, caml_gr_window.win, p, p, None, NULL, 0, &hints); caml_gr_window.gc = XCreateGC(caml_gr_display, caml_gr_window.win, 0, NULL); XSetBackground(caml_gr_display, caml_gr_window.gc, caml_gr_background); XSetForeground(caml_gr_display, caml_gr_window.gc, caml_gr_black); /* Require exposure, resize and keyboard events */ caml_gr_selected_events = DEFAULT_SELECTED_EVENTS; XSelectInput(caml_gr_display, caml_gr_window.win, caml_gr_selected_events); /* Map the window on the screen and wait for the first Expose event */ XMapWindow(caml_gr_display, caml_gr_window.win); do { XNextEvent(caml_gr_display, &event); } while (event.type != Expose); /* Get the actual window dimensions */ XGetWindowAttributes(caml_gr_display, caml_gr_window.win, &attributes); caml_gr_window.w = attributes.width; caml_gr_window.h = attributes.height; /* Create the pixmap used for backing store */ caml_gr_bstore.w = caml_gr_window.w; caml_gr_bstore.h = caml_gr_window.h; caml_gr_bstore.win = XCreatePixmap(caml_gr_display, caml_gr_window.win, caml_gr_bstore.w, caml_gr_bstore.h, XDefaultDepth(caml_gr_display, caml_gr_screen)); caml_gr_bstore.gc = XCreateGC(caml_gr_display, caml_gr_bstore.win, 0, NULL); XSetBackground(caml_gr_display, caml_gr_bstore.gc, caml_gr_background); /* Clear the pixmap */ XSetForeground(caml_gr_display, caml_gr_bstore.gc, caml_gr_background); XFillRectangle(caml_gr_display, caml_gr_bstore.win, caml_gr_bstore.gc, 0, 0, caml_gr_bstore.w, caml_gr_bstore.h); XSetForeground(caml_gr_display, caml_gr_bstore.gc, caml_gr_black); /* Set the display and remember modes on */ caml_gr_display_modeflag = True ; caml_gr_remember_modeflag = True ; /* The global data structures are now correctly initialized. In particular, caml_gr_sigio_handler can now handle events safely. */ caml_gr_initialized = True; /* If possible, request that system calls be restarted after the EVENT_SIGNAL signal. */ #ifdef POSIX_SIGNALS #ifdef SA_RESTART { struct sigaction action; sigaction(EVENT_SIGNAL, NULL, &action); action.sa_flags |= SA_RESTART; sigaction(EVENT_SIGNAL, &action, NULL); } #endif #endif #ifdef USE_ASYNC_IO /* If BSD-style asynchronous I/O are supported: arrange for I/O on the connection to trigger the SIGIO signal */ ret = fcntl(ConnectionNumber(caml_gr_display), F_GETFL, 0); fcntl(ConnectionNumber(caml_gr_display), F_SETFL, ret | FASYNC); fcntl(ConnectionNumber(caml_gr_display), F_SETOWN, getpid()); #endif } #ifdef USE_INTERVAL_TIMER /* If BSD-style interval timers are provided, use the real-time timer to poll events. */ { struct itimerval it; it.it_interval.tv_sec = 0; it.it_interval.tv_usec = 250000; it.it_value.tv_sec = 0; it.it_value.tv_usec = 250000; setitimer(ITIMER_REAL, &it, NULL); } #endif #ifdef USE_ALARM /* The poor man's solution: use alarm to poll events. */ alarm(1); #endif /* Position the current point at origin */ caml_gr_x = 0; caml_gr_y = 0; /* Reset the color cache */ caml_gr_init_color_cache(); caml_gr_init_direct_rgb_to_pixel(); return Val_unit; }