void setup(void) { int x, y, screen; XSetWindowAttributes wa; #ifdef XINERAMA int n; XineramaScreenInfo *info; #endif screen = DefaultScreen(dc->dpy); root = RootWindow(dc->dpy, screen); utf8 = XInternAtom(dc->dpy, "UTF8_STRING", False); normcol[ColBG] = getcolor(dc, normbgcolor); normcol[ColFG] = getcolor(dc, normfgcolor); selcol[ColBG] = getcolor(dc, selbgcolor); selcol[ColFG] = getcolor(dc, selfgcolor); /* menu geometry */ bh = dc->font.height + 2; lines = MAX(lines, 0); mh = (MAX(MIN(lines + 1, itemcount), 1)) * bh; if(height < mh) { height = mh; } #ifdef XINERAMA if((info = XineramaQueryScreens(dc->dpy, &n))) { int i, di; unsigned int du; Window dw; XQueryPointer(dc->dpy, root, &dw, &dw, &x, &y, &di, &di, &du); for(i = 0; i < n; i++) if((monitor == info[i].screen_number) || (monitor < 0 && INRECT(x, y, info[i].x_org, info[i].y_org, info[i].width, info[i].height))) break; x = info[i].x_org; y = info[i].y_org + (topbar ? 0 : info[i].height - height); mw = info[i].width; XFree(info); } else #endif { x = 0; y = topbar ? 0 : DisplayHeight(dc->dpy, screen) - height; mw = DisplayWidth(dc->dpy, screen); } /* menu window */ wa.override_redirect = True; wa.background_pixmap = ParentRelative; wa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask; win = XCreateWindow(dc->dpy, root, x, y, mw, height, 0, DefaultDepth(dc->dpy, screen), CopyFromParent, DefaultVisual(dc->dpy, screen), CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa); grabkeyboard(); resizedc(dc, mw, height); inputw = MIN(inputw, mw/3); promptw = prompt ? textw(dc, prompt) : 0; XMapRaised(dc->dpy, win); text[0] = '\0'; match(); }
WireFrame * wireframeCreate (Client *c) { ScreenInfo *screen_info; WireFrame *wireframe; XSetWindowAttributes attrs; XVisualInfo xvisual_info; Visual *xvisual; int depth; g_return_val_if_fail (c != NULL, None); TRACE ("entering wireframeCreate"); screen_info = c->screen_info; wireframe = g_new0 (WireFrame, 1); wireframe->screen_info = screen_info; wireframe->mapped = FALSE; wireframe->width = 0; wireframe->height = 0; wireframe->cr = NULL; wireframe->surface = NULL; wireframe->alpha = (compositorIsActive (screen_info) ? 0.5 : 1.0); if (compositorIsActive (screen_info) && XMatchVisualInfo (myScreenGetXDisplay (screen_info), screen_info->screen, 32, TrueColor, &xvisual_info)) { xvisual = xvisual_info.visual; depth = xvisual_info.depth; wireframe->xcolormap = XCreateColormap (myScreenGetXDisplay (screen_info), screen_info->xroot, xvisual, AllocNone); } else { xvisual = screen_info->visual; depth = screen_info->depth; wireframe->xcolormap = screen_info->cmap; } attrs.override_redirect = True; attrs.colormap = wireframe->xcolormap; attrs.background_pixel = BlackPixel (myScreenGetXDisplay (screen_info), screen_info->screen); attrs.border_pixel = BlackPixel (myScreenGetXDisplay (screen_info), screen_info->screen); wireframe->xwindow = XCreateWindow (myScreenGetXDisplay (screen_info), screen_info->xroot, frameExtentX (c), frameExtentY (c), frameExtentWidth (c), frameExtentHeight (c), 0, depth, InputOutput, xvisual, CWOverrideRedirect | CWColormap | CWBackPixel | CWBorderPixel, &attrs); if (compositorIsActive (screen_info)) { /* Cairo */ wireframeInitColor (wireframe); wireframe->surface = cairo_xlib_surface_create (myScreenGetXDisplay (screen_info), wireframe->xwindow, xvisual, frameExtentWidth (c), frameExtentHeight (c)); wireframe->cr = cairo_create (wireframe->surface); cairo_set_line_width (wireframe->cr, OUTLINE_WIDTH_CAIRO); cairo_set_line_join (wireframe->cr, CAIRO_LINE_JOIN_MITER); } wireframeUpdate (c, wireframe); return (wireframe); }
int X11_CreateWindow(_THIS, SDL_Window * window) { SDL_VideoData *data = (SDL_VideoData *) _this->driverdata; SDL_DisplayData *displaydata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata; Display *display = data->display; int screen = displaydata->screen; Visual *visual; int depth; XSetWindowAttributes xattr; Window w; XSizeHints *sizehints; XWMHints *wmhints; XClassHint *classhints; Atom _NET_WM_WINDOW_TYPE; Atom _NET_WM_WINDOW_TYPE_NORMAL; int wmstate_count; Atom wmstate_atoms[3]; #if SDL_VIDEO_DRIVER_X11_XINERAMA /* FIXME if ( use_xinerama ) { x = xinerama_info.x_org; y = xinerama_info.y_org; } */ #endif #if SDL_VIDEO_OPENGL_GLX if (window->flags & SDL_WINDOW_OPENGL) { XVisualInfo *vinfo; vinfo = X11_GL_GetVisual(_this, display, screen); if (!vinfo) { return -1; } visual = vinfo->visual; depth = vinfo->depth; XFree(vinfo); } else #endif #ifdef SDL_VIDEO_DRIVER_PANDORA if (window->flags & SDL_WINDOW_OPENGL) { XVisualInfo *vinfo; vinfo = X11_GLES_GetVisual(_this, display, screen); if (!vinfo) { return -1; } visual = vinfo->visual; depth = vinfo->depth; XFree(vinfo); } else #endif { visual = displaydata->visual; depth = displaydata->depth; } xattr.override_redirect = False; xattr.background_pixel = 0; xattr.border_pixel = 0; xattr.colormap = XCreateColormap(display, RootWindow(display, screen), visual, AllocNone); w = XCreateWindow(display, RootWindow(display, screen), window->x, window->y, window->w, window->h, 0, depth, InputOutput, visual, (CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWColormap), &xattr); if (!w) { SDL_SetError("Couldn't create window"); return -1; } #if SDL_VIDEO_DRIVER_PANDORA /* Create the GLES window surface */ _this->gles_data->egl_surface = _this->gles_data->eglCreateWindowSurface(_this->gles_data-> egl_display, _this->gles_data->egl_config, (NativeWindowType) w, NULL); if (_this->gles_data->egl_surface == EGL_NO_SURFACE) { SDL_SetError("Could not create GLES window surface"); return -1; } #endif sizehints = XAllocSizeHints(); if (sizehints) { if (!(window->flags & SDL_WINDOW_RESIZABLE)) { sizehints->min_width = sizehints->max_width = window->w; sizehints->min_height = sizehints->max_height = window->h; sizehints->flags = PMaxSize | PMinSize; } sizehints->x = window->x; sizehints->y = window->y; sizehints->flags |= USPosition; XSetWMNormalHints(display, w, sizehints); XFree(sizehints); } if (window->flags & SDL_WINDOW_BORDERLESS) { SDL_bool set; Atom WM_HINTS; /* We haven't modified the window manager hints yet */ set = SDL_FALSE; /* First try to set MWM hints */ WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True); if (WM_HINTS != None) { /* Hints used by Motif compliant window managers */ struct { unsigned long flags; unsigned long functions; unsigned long decorations; long input_mode; unsigned long status; } MWMHints = { (1L << 1), 0, 0, 0, 0}; XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32, PropModeReplace, (unsigned char *) &MWMHints, sizeof(MWMHints) / 4); set = SDL_TRUE; } /* Now try to set KWM hints */ WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True); if (WM_HINTS != None) { long KWMHints = 0; XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32, PropModeReplace, (unsigned char *) &KWMHints, sizeof(KWMHints) / 4); set = SDL_TRUE; } /* Now try to set GNOME hints */ WM_HINTS = XInternAtom(display, "_WIN_HINTS", True); if (WM_HINTS != None) { long GNOMEHints = 0; XChangeProperty(display, w, WM_HINTS, WM_HINTS, 32, PropModeReplace, (unsigned char *) &GNOMEHints, sizeof(GNOMEHints) / 4); set = SDL_TRUE; } /* Finally set the transient hints if necessary */ if (!set) { XSetTransientForHint(display, w, RootWindow(display, screen)); } } else { SDL_bool set; Atom WM_HINTS; /* We haven't modified the window manager hints yet */ set = SDL_FALSE; /* First try to unset MWM hints */ WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", True); if (WM_HINTS != None) { XDeleteProperty(display, w, WM_HINTS); set = SDL_TRUE; } /* Now try to unset KWM hints */ WM_HINTS = XInternAtom(display, "KWM_WIN_DECORATION", True); if (WM_HINTS != None) { XDeleteProperty(display, w, WM_HINTS); set = SDL_TRUE; } /* Now try to unset GNOME hints */ WM_HINTS = XInternAtom(display, "_WIN_HINTS", True); if (WM_HINTS != None) { XDeleteProperty(display, w, WM_HINTS); set = SDL_TRUE; } /* Finally unset the transient hints if necessary */ if (!set) { XDeleteProperty(display, w, XA_WM_TRANSIENT_FOR); } } /* Set the input hints so we get keyboard input */ wmhints = XAllocWMHints(); if (wmhints) { wmhints->input = True; wmhints->flags = InputHint; XSetWMHints(display, w, wmhints); XFree(wmhints); } /* Set the class hints so we can get an icon (AfterStep) */ classhints = XAllocClassHint(); if (classhints != NULL) { classhints->res_name = data->classname; classhints->res_class = data->classname; XSetClassHint(display, w, classhints); XFree(classhints); } /* Set the window manager state */ wmstate_count = X11_GetWMStateProperty(_this, window, wmstate_atoms); if (wmstate_count > 0) { XChangeProperty(display, w, data->_NET_WM_STATE, XA_ATOM, 32, PropModeReplace, (unsigned char *)wmstate_atoms, wmstate_count); } else { XDeleteProperty(display, w, data->_NET_WM_STATE); } /* Let the window manager know we're a "normal" window */ _NET_WM_WINDOW_TYPE = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False); _NET_WM_WINDOW_TYPE_NORMAL = XInternAtom(display, "_NET_WM_WINDOW_TYPE_NORMAL", False); XChangeProperty(display, w, _NET_WM_WINDOW_TYPE, XA_ATOM, 32, PropModeReplace, (unsigned char *)&_NET_WM_WINDOW_TYPE_NORMAL, 1); /* Allow the window to be deleted by the window manager */ XSetWMProtocols(display, w, &data->WM_DELETE_WINDOW, 1); if (SetupWindowData(_this, window, w, SDL_TRUE) < 0) { XDestroyWindow(display, w); return -1; } #ifdef X_HAVE_UTF8_STRING { Uint32 fevent = 0; pXGetICValues(((SDL_WindowData *) window->driverdata)->ic, XNFilterEvents, &fevent, NULL); XSelectInput(display, w, (FocusChangeMask | EnterWindowMask | LeaveWindowMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | KeyPressMask | KeyReleaseMask | PropertyChangeMask | StructureNotifyMask | KeymapStateMask | fevent)); } #else { XSelectInput(display, w, (FocusChangeMask | EnterWindowMask | LeaveWindowMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | KeyPressMask | KeyReleaseMask | PropertyChangeMask | StructureNotifyMask | KeymapStateMask)); } #endif XFlush(display); return 0; }
void setup(void) { XSetWindowAttributes wa; XTextProperty str; XSizeHints *sizeh; XClassHint *ch; int i, sh, sw, ls; /* init screen */ screen = DefaultScreen(dpy); root = RootWindow(dpy, screen); sw = DisplayWidth(dpy, screen) - 1; sh = DisplayHeight(dpy, screen) - 1; initfont(font); /* init atoms */ /* init appearance */ for (i = 0, www = 0; i < nentries; i++) { ls = textnw(entries[i]->label, strlen(entries[i]->label)); if (ls > www) www = ls; } www *= widthscaling; if (!ww) { if (horizontal) { ww = www * nentries; } else { ww = www; } } if (!wh) { if (horizontal) { wh = dc.font.height * heightscaling; } else { wh = nentries * dc.font.height * heightscaling; } } if (!wy) wy = (sh - wh) / 2; if (wy < 0) wy = sh + wy - wh; if (!wx) wx = (sw - ww) / 2; if (wx < 0) wx = sw + wx - ww; dc.norm[ColBG] = getcolor(normbgcolor); dc.norm[ColFG] = getcolor(normfgcolor); dc.press[ColBG] = getcolor(pressbgcolor); dc.press[ColFG] = getcolor(pressfgcolor); dc.high[ColBG] = getcolor(highlightbgcolor); dc.high[ColFG] = getcolor(highlightfgcolor); dc.drawable = XCreatePixmap(dpy, root, ww, wh, DefaultDepth(dpy, screen)); dc.gc = XCreateGC(dpy, root, 0, 0); if(!dc.font.set) XSetFont(dpy, dc.gc, dc.font.xfont->fid); for(i = 0; i < nentries; i++) entries[i]->pressed = 0; wa.override_redirect = !wmborder; wa.border_pixel = dc.norm[ColFG]; wa.background_pixel = dc.norm[ColBG]; win = XCreateWindow(dpy, root, wx, wy, ww, wh, 0, CopyFromParent, CopyFromParent, CopyFromParent, CWOverrideRedirect | CWBorderPixel | CWBackingPixel, &wa); XSelectInput(dpy, win, StructureNotifyMask|KeyReleaseMask| ButtonReleaseMask|ButtonPressMask| ExposureMask|LeaveWindowMask|PointerMotionMask); sizeh = XAllocSizeHints(); sizeh->flags = PMaxSize | PMinSize; sizeh->min_width = sizeh->max_width = ww; sizeh->min_height = sizeh->max_height = wh; XStringListToTextProperty(&name, 1, &str); ch = XAllocClassHint(); ch->res_class = name; ch->res_name = name; XSetWMProperties(dpy, win, &str, &str, NULL, 0, sizeh, NULL, ch); XFree(ch); XFree(str.value); XFree(sizeh); XMapRaised(dpy, win); updateentries(); drawmenu(); }
void Create_Window (char *geometry) { short q; Visual *vid; XSetWindowAttributes xswa; XSizeHints sizehint; XWMHints wmhints; int depth; unsigned char wname[256]; /* Window Name */ unsigned long vmask = CWEventMask | CWBackPixel | CWBackingStore; depth = DefaultDepth (display.dpy, display.screen); xswa.event_mask = 0; xswa.background_pixel = display.bg; xswa.backing_store = Always; debug_printf ("DefaultVisual id=%d bp-rgb=%d map-entries=%d\n", (int) (*DefaultVisual (display.dpy, display.screen)).visualid, (*DefaultVisual (display.dpy, display.screen)).bits_per_rgb, (*DefaultVisual (display.dpy, display.screen)).map_entries); vid = DefaultVisual (display.dpy, display.screen); display.cmap = XDefaultColormap (display.dpy, display.screen); display.win = XCreateWindow (display.dpy, display.root, winX, winY, display.winW, display.winH, 0, depth, InputOutput, /* vid , */ DefaultVisual (display.dpy, display.screen), /* PseudoColor, */ vmask, &xswa); sizehint.x = winX - 100; sizehint.y = winY; sizehint.width = display.winW; sizehint.height = display.winH; sizehint.min_width = display.winW; sizehint.min_height = display.winH; sizehint.max_width = display.winW; sizehint.max_height = display.winH; /* GCS FIX: Be careful about resizing the opening screen */ /* WCK: Fixed. We lock it now, and unlock it after the opening screen. not gorgeous, but it works for now. Still need to clean up.*/ #define NO_RESIZABLE_WINDOWS 1 if (geometry != NULL) { #if defined (NO_RESIZABLE_WINDOWS) sizehint.flags = USPosition | USSize | PMinSize | PMaxSize; #else sizehint.flags = USPosition | USSize | PMinSize; #endif } else { #if defined (NO_RESIZABLE_WINDOWS) sizehint.flags = PPosition | PSize | PMinSize | PMaxSize; #else sizehint.flags = PPosition | PSize | PMinSize; #endif } XSetNormalHints (display.dpy, display.win, &sizehint); display.protocol_atom = XInternAtom (display.dpy, "WM_PROTOCOLS", False); display.kill_atom = XInternAtom (display.dpy, "WM_DELETE_WINDOW", False); /* Title */ sprintf ((char *) wname, _("xlincity, Version %s, " "(Copyright) IJ Peters - copying policy GNU GPL"), VERSION); XChangeProperty (display.dpy, display.win, XA_WM_NAME, XA_STRING, 8, PropModeReplace, wname, strlen ((char *) wname)); /* Window Manager Hints (This is supposed to make input work.) */ wmhints.flags = InputHint; wmhints.input = True; XSetWMHints (display.dpy, display.win, &wmhints); /* GCS - 2003/08/15 - Cygwin doesn't generate the MapEvent unless the mask enabled before XMapWindow is called. Therefore, XSelectInput needs to be called before XMapWindow */ XSelectInput (display.dpy, display.win, KeyPressMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | StructureNotifyMask); XMapWindow (display.dpy, display.win); for (q = 0; q < 256; q++) { display.pixcolour_gc[q] = XCreateGC (display.dpy ,display.win, 0, NULL); XSetForeground (display.dpy, display.pixcolour_gc[q], q); XSetBackground (display.dpy, display.pixcolour_gc[q], display.bg); XSetGraphicsExposures (display.dpy, display.pixcolour_gc[q], False); } }
/* * Setup X11 wnd System */ void X11_SetupWindow (GF_VideoOutput * vout) { X11VID (); const char *sOpt; xWindow->display = XOpenDisplay (NULL); xWindow->screennum = DefaultScreen (xWindow->display); xWindow->screenptr = DefaultScreenOfDisplay (xWindow->display); xWindow->visual = DefaultVisualOfScreen (xWindow->screenptr); xWindow->depth = DefaultDepth (xWindow->display, xWindow->screennum); switch (xWindow->depth) { case 8: xWindow->pixel_format = GF_PIXEL_GREYSCALE; break; case 16: xWindow->pixel_format = GF_PIXEL_RGB_565; break; case 24: xWindow->pixel_format = GF_PIXEL_RGB_32; break; default: xWindow->pixel_format = GF_PIXEL_GREYSCALE; break; } xWindow->bpp = xWindow->depth / 8; xWindow->bpp = xWindow->bpp == 3 ? 4 : xWindow->bpp; vout->max_screen_width = DisplayWidth(xWindow->display, xWindow->screennum); vout->max_screen_height = DisplayHeight(xWindow->display, xWindow->screennum); /* * Full screen wnd */ xWindow->full_wnd = XCreateWindow (xWindow->display, RootWindowOfScreen (xWindow->screenptr), 0, 0, vout->max_screen_width, vout->max_screen_height, 0, xWindow->depth, InputOutput, xWindow->visual, 0, NULL); XSelectInput(xWindow->display, xWindow->full_wnd, FocusChangeMask | ExposureMask | PointerMotionMask | ButtonReleaseMask | ButtonPressMask | KeyPressMask | KeyReleaseMask); if (!xWindow->par_wnd) { xWindow->w_width = 320; xWindow->w_height = 20; xWindow->wnd = XCreateWindow (xWindow->display, RootWindowOfScreen(xWindow->screenptr), 0, 0, xWindow->w_width, xWindow->w_height, 0, xWindow->depth, InputOutput, xWindow->visual, 0, NULL); XMapWindow (xWindow->display, (Window) xWindow->wnd); } else { XWindowAttributes pwa; XGetWindowAttributes(xWindow->display, xWindow->par_wnd, &pwa); xWindow->w_width = pwa.width; xWindow->w_height = pwa.height; xWindow->wnd = XCreateWindow (xWindow->display, xWindow->par_wnd, pwa.x, pwa.y, xWindow->w_width, xWindow->w_height, 0, xWindow->depth, InputOutput, xWindow->visual, 0, NULL); XMapWindow (xWindow->display, (Window) xWindow->wnd); } XSync(xWindow->display, False); XUnmapWindow (xWindow->display, (Window) xWindow->wnd); XSync(xWindow->display, False); old_handler = XSetErrorHandler(X11_BadAccess_ByPass); selectinput_err = 0; XSelectInput(xWindow->display, xWindow->wnd, FocusChangeMask | StructureNotifyMask | PropertyChangeMask | ExposureMask | PointerMotionMask | ButtonReleaseMask | ButtonPressMask | KeyPressMask | KeyReleaseMask); XSync(xWindow->display, False); XSetErrorHandler(old_handler); if (selectinput_err) { XSelectInput(xWindow->display, xWindow->wnd, StructureNotifyMask | PropertyChangeMask | ExposureMask | KeyPressMask | KeyReleaseMask); GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Cannot select input focus\n")); } XSync(xWindow->display, False); XMapWindow (xWindow->display, (Window) xWindow->wnd); XSizeHints *Hints = XAllocSizeHints (); Hints->flags = PSize | PMinSize; Hints->min_width = 32; Hints->min_height = 32; Hints->max_height = 4096; Hints->max_width = 4096; if (!xWindow->par_wnd) { XSetWMNormalHints (xWindow->display, xWindow->wnd, Hints); XStoreName (xWindow->display, xWindow->wnd, "GPAC X11 Output"); } Hints->x = 0; Hints->y = 0; Hints->flags |= USPosition; XSetWMNormalHints (xWindow->display, xWindow->full_wnd, Hints); XFree (Hints); xWindow->the_gc = XCreateGC (xWindow->display, xWindow->wnd, 0, NULL); xWindow->videoaccesstype = VIDEO_XI_STANDARD; #ifdef GPAC_HAS_X11_SHM sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "UseHardwareMemory"); if (sOpt && !strcmp(sOpt, "yes")) { int XShmMajor, XShmMinor; Bool XShmPixmaps; if (XShmQueryVersion(xWindow->display, &XShmMajor, &XShmMinor, &XShmPixmaps)) { /*this is disabled due to flip pb (we cannot reposition backbuffer)*/ if (0 && XShmPixmaps && (XShmPixmapFormat(xWindow->display) == ZPixmap)) { xWindow->videoaccesstype = VIDEO_XI_SHMPIXMAP; } else { xWindow->videoaccesstype = VIDEO_XI_SHMSTD; GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using X11 Hardware Blit\n")); } } } #endif GF_SAFEALLOC(xWindow->back_buffer, X11WrapSurface); xWindow->back_buffer->id = -1; XSetWindowAttributes xsw; xsw.border_pixel = WhitePixel (xWindow->display, xWindow->screennum); xsw.background_pixel = BlackPixel (xWindow->display, xWindow->screennum); xsw.win_gravity = NorthWestGravity; XChangeWindowAttributes (xWindow->display, xWindow->wnd, CWBackPixel | CWWinGravity, &xsw); xsw.override_redirect = True; XChangeWindowAttributes(xWindow->display, xWindow->full_wnd, CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWWinGravity, &xsw); if (!xWindow->par_wnd) { xWindow->WM_DELETE_WINDOW = XInternAtom (xWindow->display, "WM_DELETE_WINDOW", False); XSetWMProtocols(xWindow->display, xWindow->wnd, &xWindow->WM_DELETE_WINDOW, 1); } { XEvent ev; long mask; memset (&ev, 0, sizeof (ev)); ev.xclient.type = ClientMessage; ev.xclient.window = RootWindowOfScreen (xWindow->screenptr); ev.xclient.message_type = XInternAtom (xWindow->display, "KWM_KEEP_ON_TOP", False); ev.xclient.format = 32; ev.xclient.data.l[0] = xWindow->full_wnd; ev.xclient.data.l[1] = CurrentTime; mask = SubstructureRedirectMask; XSendEvent (xWindow->display,RootWindowOfScreen (xWindow->screenptr), False, mask, &ev); } #ifdef GPAC_HAS_OPENGL if (xWindow->is_3D_out) { int attribs[64]; int i; i=0; attribs[i++] = GLX_RGBA; attribs[i++] = GLX_RED_SIZE; attribs[i++] = 5; attribs[i++] = GLX_GREEN_SIZE; attribs[i++] = 5; attribs[i++] = GLX_BLUE_SIZE; attribs[i++] = 5; attribs[i++] = GLX_DEPTH_SIZE; attribs[i++] = 16; if (xWindow->gl_cfg.double_buffered) attribs[i++] = GLX_DOUBLEBUFFER; attribs[i++] = None; xWindow->glx_visualinfo = glXChooseVisual(xWindow->display, xWindow->screennum, attribs); if (!xWindow->glx_visualinfo) { GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Error selecting GL display\n")); } } #endif xWindow->setup_done = 1; }
bool GLWindow::Create() { assert ( !IsDestroyed() ); assert ( IsDisposed() ); XVisualInfo *vi; Colormap cmap; int dpyWidth, dpyHeight; int i; int glxMajorVersion, glxMinorVersion; int vidModeMajorVersion, vidModeMinorVersion; XF86VidModeModeInfo **modes; int modeNum; int bestMode; Atom wmDelete; Window winDummy; unsigned int borderDummy; /* set best mode to current */ bestMode = 0; /* get a connection */ hDC = XOpenDisplay(0); screen = DefaultScreen(hDC); XF86VidModeQueryVersion(hDC, &vidModeMajorVersion, &vidModeMinorVersion); printf("XF86VidModeExtension-Version %d.%d\n", vidModeMajorVersion, vidModeMinorVersion); XF86VidModeGetAllModeLines(hDC, screen, &modeNum, &modes); /* save desktop-resolution before switching modes */ deskMode = *modes[0]; /* look for mode with requested resolution */ for (i = 0; i < modeNum; i++) if ((modes[i]->hdisplay == Width) && (modes[i]->vdisplay == Height)) bestMode = i; /* get an appropriate visual */ vi = glXChooseVisual(hDC, screen, attrListDbl); if (vi == NULL) { vi = glXChooseVisual(hDC, screen, attrListSgl); printf("Only Singlebuffered Visual!\n"); } else printf("Got Doublebuffered Visual!\n"); glXQueryVersion(hDC, &glxMajorVersion, &glxMinorVersion); printf("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion); /* create a GLX context */ glctx = glXCreateContext(hDC, vi, 0, GL_TRUE); /* create a color map */ cmap = XCreateColormap(hDC, RootWindow(hDC, vi->screen), vi->visual, AllocNone); attr.colormap = cmap; attr.border_pixel = 0; if (FL_fullscreen) { XF86VidModeSwitchToMode(hDC, screen, modes[bestMode]); XF86VidModeSetViewPort(hDC, screen, 0, 0); dpyWidth = modes[bestMode]->hdisplay; dpyHeight = modes[bestMode]->vdisplay; printf("Resolution %dx%d\n", dpyWidth, dpyHeight); XFree(modes); /* create a fullscreen window */ attr.override_redirect = True; attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | FocusChangeMask | EnterWindowMask | StructureNotifyMask; win = XCreateWindow(hDC, RootWindow(hDC, vi->screen), 0, 0, dpyWidth, dpyHeight, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect, &attr); XWarpPointer(hDC, None, win, 0, 0, 0, 0, 0, 0); XMapRaised(hDC, win); XGrabKeyboard(hDC, win, True, GrabModeAsync, GrabModeAsync, CurrentTime); XGrabPointer(hDC, win, True, ButtonPressMask, GrabModeAsync, GrabModeAsync, win, None, CurrentTime); } else { /* create a window in window mode*/ attr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask | StructureNotifyMask; win = XCreateWindow(hDC, RootWindow(hDC, vi->screen), 0, 0, Width, Height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &attr); /* only set window title and handle wm_delete_events if in windowed mode */ wmDelete = XInternAtom(hDC, "WM_DELETE_WINDOW", True); XSetWMProtocols(hDC, win, &wmDelete, 1); XSetStandardProperties(hDC, win, Title, Title, None, NULL, 0, NULL); XMapRaised(hDC, win); } /* connect the glx-context to the window */ glXMakeCurrent(hDC, win, glctx); XGetGeometry(hDC, win, &winDummy, &x, &y, &Width, &Height, &borderDummy, &depth); printf("Depth %d\n", depth); if (glXIsDirect(hDC, glctx)) printf("Congrats, you have Direct Rendering!\n"); else printf("Sorry, no Direct Rendering possible!\n"); OnCreate(); this->Resize(Width, Height); return true; }
static gboolean clutter_backend_egl_create_context (ClutterBackend *backend, GError **error) { ClutterBackendEGL *backend_egl; ClutterBackendX11 *backend_x11; EGLConfig config; EGLint config_count = 0; EGLBoolean status; EGLint cfg_attribs[] = { /* NB: This must be the first attribute, since we may * try and fallback to no stencil buffer */ EGL_STENCIL_SIZE, 8, EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6, EGL_BLUE_SIZE, 5, EGL_BUFFER_SIZE, EGL_DONT_CARE, #ifdef HAVE_COGL_GLES2 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, #else /* HAVE_COGL_GLES2 */ EGL_SURFACE_TYPE, EGL_WINDOW_BIT, #endif /* HAVE_COGL_GLES2 */ EGL_NONE }; EGLDisplay edpy; gint retry_cookie = 0; XVisualInfo *xvisinfo; XSetWindowAttributes attrs; backend = clutter_get_default_backend (); backend_egl = CLUTTER_BACKEND_EGL (backend); if (backend_egl->egl_context != EGL_NO_CONTEXT) return TRUE; backend_x11 = CLUTTER_BACKEND_X11 (backend); edpy = clutter_eglx_display (); retry: /* Here we can change the attributes depending on the fallback count... */ /* Some GLES hardware can't support a stencil buffer: */ if (retry_cookie == 1) { g_warning ("Trying with stencil buffer disabled..."); cfg_attribs[1 /* EGL_STENCIL_SIZE */] = 0; } /* XXX: at this point we only have one fallback */ status = eglChooseConfig (edpy, cfg_attribs, &config, 1, &config_count); if (status != EGL_TRUE || config_count == 0) { g_warning ("eglChooseConfig failed"); goto fail; } if (G_UNLIKELY (backend_egl->egl_context == EGL_NO_CONTEXT)) { #ifdef HAVE_COGL_GLES2 static const EGLint attribs[3] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; backend_egl->egl_context = eglCreateContext (edpy, config, EGL_NO_CONTEXT, attribs); #else /* Seems some GLES implementations 1.x do not like attribs... */ backend_egl->egl_context = eglCreateContext (edpy, config, EGL_NO_CONTEXT, NULL); #endif if (backend_egl->egl_context == EGL_NO_CONTEXT) { g_warning ("Unable to create a suitable EGL context"); goto fail; } backend_egl->egl_config = config; CLUTTER_NOTE (GL, "Created EGL Context"); } /* COGL assumes that there is always a GL context selected; in order * to make sure that an EGL context exists and is made current, we use * a dummy, offscreen override-redirect window to which we can always * fall back if no stage is available */ xvisinfo = clutter_backend_x11_get_visual_info (backend_x11); if (xvisinfo == NULL) { g_critical ("Unable to find suitable GL visual."); return FALSE; } attrs.override_redirect = True; attrs.colormap = XCreateColormap (backend_x11->xdpy, backend_x11->xwin_root, xvisinfo->visual, AllocNone); attrs.border_pixel = 0; backend_egl->dummy_xwin = XCreateWindow (backend_x11->xdpy, backend_x11->xwin_root, -100, -100, 1, 1, 0, xvisinfo->depth, CopyFromParent, xvisinfo->visual, CWOverrideRedirect | CWColormap | CWBorderPixel, &attrs); XFree (xvisinfo); backend_egl->dummy_surface = eglCreateWindowSurface (edpy, backend_egl->egl_config, (NativeWindowType) backend_egl->dummy_xwin, NULL); if (backend_egl->dummy_surface == EGL_NO_SURFACE) { g_critical ("Unable to create an EGL surface"); return FALSE; } eglMakeCurrent (edpy, backend_egl->dummy_surface, backend_egl->dummy_surface, backend_egl->egl_context); return TRUE; fail: /* NB: We currently only support a single fallback option */ if (retry_cookie == 0) { retry_cookie = 1; goto retry; } return FALSE; }
int main(int argc, char**argv) { char **missing_charset_list; int missing_charset_count; XGCValues xgcv; unsigned long mask; Display* dpy; int scr; gi_window_id_t w, root; XSetWindowAttributes set_attr; int i; XIMStyle *style; static char buf[128]; KeySym keysym = 0; Status status; XWMHints wm_hints; XClassHint class_hints; XIMStyle input_style = 0; char **font_name_list; char *def_string; gi_ufont_t **font_struct_list; char **font_encoding_list; int nb_font; int len = 0; int no_xim = 0; printf ("A -> %c \n", XUtf8Tolower('A')); if (!setlocale(LC_ALL, "")) puts("locale not supported by C library, locale unchanged"); if (!XSetLocaleModifiers("")) puts("X locale modifiers not supported, using default"); dpy = gi_init(); if (!dpy) { puts("cannot open display.\n"); exit(-1); } scr = DefaultScreen(dpy); root = RootWindow(dpy, scr); set_attr.event_mask = KeyPressMask|FocusChangeMask; set_attr.background_pixel = WhitePixel(dpy, DefaultScreen(dpy)); set_attr.border_pixel = BlackPixel(dpy, DefaultScreen(dpy)); w = XCreateWindow(dpy, root, 10,10,200,100,0, DefaultDepth(dpy, DefaultScreen(dpy)), InputOutput, DefaultVisual(dpy, DefaultScreen(dpy)), CWEventMask | CWBackPixel | CWBorderPixel, &set_attr); if (!w) { puts("cannot creat window.\n"); exit(-1); } class_hints.res_name = "test"; class_hints.res_class = "Test"; wm_hints.input = True; wm_hints.flags = InputHint; XmbSetWMProperties(dpy, w, "test", "test", NULL, 0, NULL, &wm_hints, &class_hints); XMapWindow(dpy, w); xim_im = XOpenIM(dpy, NULL, "test", "Test"); if (!xim_im) { puts("cannot Open Input Manager: Try default.\n"); XSetLocaleModifiers("@im="); xim_im = XOpenIM(dpy, NULL, "test", "Test"); if (!xim_im) { puts("Failed exiting.\n"); exit(-1); } } XGetIMValues (xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL); for (i = 0, style = xim_styles->supported_styles; i < xim_styles->count_styles; i++, style++) { if (i == 0 && *style == (XIMStatusNone|XIMPreeditNone)) { printf("this is not a XIM server !!!\n"); no_xim = 1; } printf("input style : 0x%X\n", *style); } xim_ic = XCreateIC(xim_im, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing), XNClientWindow, w, XNFocusWindow, w, NULL); if (!xim_ic) { puts("cannot create Input Context.\n"); exit(-1); } XFree(xim_styles); XSetICFocus(xim_ic); /*************************************************************** * I don't recommend to use a font base name list similar * to the following one in a real application ;-) * You should use an iso8859-1 font, plus a single font for * your language. ***************************************************************/ fontset = XCreateUtf8FontStruct(dpy, "-*-*-*-*-*-*-*-*-*-*-*-*-iso8858-3," /* not valid */ "-*-*-medium-r-*-*-*-*-*-*-*-*-iso8859-1," "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-6," "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-8," "-*-*-*-*-*-*-*-*-*-*-*-*-ksc5601.1987-0," "-*-symbol-*-*-*-*-*-*-*-*-*-*-adobe-fontspecific," "-*-*-*-*-*-*-*-*-*-*-*-*-iso8859-2," "-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1," "-*-*-*-*-*-*-*-*-*-*-*-*-jisx0208.1983-0," "-*-*-*-*-*-*-*-*-*-*-*-*-jisx0212.1990-0," "-*-*-*-*-*-*-*-*-*-*-*-*-big5-0," "-*-*-*-*-*-*-*-*-*-*-*-*-jisx0201.1976-0," "-*-unifont-*-*-*-*-*-*-*-*-*-*-iso10646-1[0x300 0x400_0x500]," "-*-*-*-*-*-*-*-*-*-*-*-*-*-*"); /* THIS PART IS NOT REQUIERED */ nb_font = fontset->nb_font; while (nb_font > 0) { nb_font--; if (fontset->fonts[nb_font]) { printf("encoding=\"\" fid=%d \n %s\n", /* fontset->encodings[nb_font], */ fontset->fonts[nb_font]->fid, fontset->font_name_list[nb_font]); } } /* END OF NOT REQUIERED PART*/ mask = (GCForeground | GCBackground); xgcv.foreground = BlackPixel(dpy, DefaultScreen(dpy)); xgcv.background = WhitePixel(dpy, DefaultScreen(dpy)); gc = gi_create_gc( w, mask, &xgcv); if (!gc) { puts("cannot create Graphic Context.\n"); exit(-1); } /***************************************************************/ while (1) { int filtered; static gi_msg_t xevent; static XVaNestedList list1 = 0; int r; XNextEvent(dpy, &xevent); if (xevent.type == KeyPress) { XKeyEvent *e = (XKeyEvent*) &xevent; printf ("0x%X %d\n", e->state, e->keycode); } if (xevent.type == DestroyNotify) { /* XIM server has crashed */ no_xim = 1; XSetLocaleModifiers("@im="); xim_im = XOpenIM(dpy, NULL, "test", "Test"); if (xim_im) { xim_ic = XCreateIC(xim_im, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing), XNClientWindow, w, XNFocusWindow, w, NULL); } else { xim_ic = NULL; } if (!xim_ic) { puts("Crash recovery failed. exiting.\n"); exit(-1); } } if (xevent.type != DestroyNotify) { filtered = XFilterEvent(&xevent, 0); } if (xevent.type == FocusOut && xim_ic) XUnsetICFocus(xim_ic); if (xevent.type == FocusIn && xim_ic) XSetICFocus(xim_ic); if (xevent.type == KeyPress && !filtered) { len = XUtf8LookupString(xim_ic, &xevent.xkey, buf, 127, &keysym, &status); if (len == 1 && buf[0] == '\b') { x -= XUtf8TextWidth(fontset, buf, len); XUtf8DrawImageString(dpy, w, fontset, gc, x, y, buf, len); } else if (len == 1 && buf[0] == '\r') { y += fontset->ascent + fontset->descent; x = 0; XCloseIM(xim_im); } else { XUtf8DrawImageString(dpy, w, fontset, gc, x, y, buf, len); x += XUtf8TextWidth(fontset, buf, len); } XUtf8DrawString(dpy, w, fontset, gc, 0, 20, jp_txt, strlen(jp_txt)); XUtf8DrawString(dpy, w, fontset, gc, 50, 90, rtl_txt, strlen(rtl_txt)); XUtf8DrawRtlString(dpy, w, fontset, gc, 50, 90, rtl_txt, strlen(rtl_txt)); buf[len] = 0; printf("'%s' %d %x\n", buf, keysym, keysym); buf[0] = 0; } if (filtered) { printf("Dead key\n"); } } XFreeUtf8FontStruct(dpy, fontset); return 0; }
int main( int argc, char ** argv) { MouseEvent event, prevevent; MouseEvent *pEvent = &event; prevevent.type = EVENT_NULL; prevevent.value = 0; Display *dpy; /* X server connection */ Window win; XWindowAttributes winattr; int xtest_major_version = 0; int xtest_minor_version = 0; int dummy; SOCKET s, s_accept; struct sockaddr_in s_add; //from anyone! struct sockaddr s_client; socklen_t s_client_size = sizeof( struct sockaddr ); int port = PORT; int recvsize; int button, yDelta = 0, yTmp; printf("RemotePad Server for X11 version %s\n", kVersionX11); printf("Application launched.\n"); /* * Open the display using the $DISPLAY environment variable to locate * the X server. See Section 2.1. */ if ((dpy = XOpenDisplay(NULL)) == NULL) { printf("%s: can't open DISPLAY: %s\n", argv[0], XDisplayName(NULL)); exit(1); } Bool success = XTestQueryExtension(dpy, &dummy, &dummy, &xtest_major_version, &xtest_minor_version); if(success == False || xtest_major_version < 2 || (xtest_major_version <= 2 && xtest_minor_version < 2)) { printf("XTEST extension not supported\n"); exit(1); } /* * create a small unmapped window on a screen just so xdm can use * it as a handle on which to killclient() us. */ win = XCreateWindow(dpy, DefaultRootWindow(dpy), 0, 0, 1, 1, 0, CopyFromParent, InputOutput, CopyFromParent, 0, (XSetWindowAttributes*)0); /* * get keyboard mapping to detect modifier keys for each keysym */ XDisplayKeycodes(dpy, &minKeycode, &maxKeycode); int keycodeCount = maxKeycode - minKeycode + 1; keyboardMapping = XGetKeyboardMapping(dpy, minKeycode, keycodeCount, &keysymsPerKeycode); //network stuff //configure socket if ( ( s = socket( PF_INET, SOCK_STREAM, 0 ) ) == -1 ) { perror ( "Failed to create socket :(" ); exit( 2 ); } int yes = 1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void *)&yes, sizeof(yes)); memset( &s_add, 0, sizeof( struct sockaddr_in ) ); s_add.sin_family = AF_INET; s_add.sin_port = htons( port ); s_add.sin_addr.s_addr = INADDR_ANY; if ( bind( s, (struct sockaddr * )&s_add, sizeof( struct sockaddr_in ) ) == -1 ) { perror( "Failed to bind socket" ); exit( 2 ); } if( listen( s , 1 ) ) { perror( "Can't listen!" ); exit( 2 ); } while( 1 ) { if(!findInterfaceAddresses(s)) printf("waiting for clients\n"); struct timeval tv; while (1) { fd_set fdset; FD_ZERO(&fdset); FD_SET(s, &fdset); tv.tv_sec = 5; tv.tv_usec = 0; select(s+1, &fdset, NULL, NULL, &tv); if (FD_ISSET(s, &fdset)) break; // sending a keep-alive event for an X server XGetWindowAttributes(dpy, win, &winattr); } s_accept = accept( s, &s_client, &s_client_size ); if ( s_accept == -1 ) { perror( "failed to accept!" ); return -1; } else { printf("Connected!\n"); } tv.tv_sec = 5; tv.tv_usec = 0; setsockopt(s_accept, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv)); gettimeofday(&tv, NULL); MouseEvent versionEvent = {htonl(EVENT_VERSION), htonl(kVersionX11Current), htonl(tv.tv_sec), htonl(tv.tv_usec*1000)}; send(s_accept, (void *)&versionEvent, sizeof(MouseEvent), 0); while( 1 ) { recvsize = recv( s_accept, pEvent, sizeof( MouseEvent ), MSG_WAITALL ); if ( recvsize == sizeof( MouseEvent ) )//got data { event.type = ntohl(event.type); event.value = ntohl(event.value); event.tv_sec = ntohl(event.tv_sec); event.tv_nsec = ntohl(event.tv_nsec); switch( event.type ) { case EVENT_MOUSE_DELTA_X: // following event should be EVENT_MOUSE_DELTA_Y break; case EVENT_MOUSE_DELTA_Y: // printf( "move: %d, %d!\n", pEvent->move_info.dx, pEvent->move_info.dy ); if (prevevent.type == EVENT_MOUSE_DELTA_X) { XTestFakeRelativeMotionEvent( dpy, prevevent.value, event.value, 0 ); } else { // printf( "stray event EVENT_MOUSE_DELTA_Y\n" ); } break; case EVENT_MOUSE_DELTA_W: //no x-scrolling :-/ break; case EVENT_MOUSE_DELTA_Z: //no x-scrolling :-/ yDelta += event.value; if ( yDelta < 0 )//down { button = BUTTON_SCROLL_DOWN; yTmp = - yDelta; } else { button = BUTTON_SCROLL_UP; yTmp = yDelta; } // send as many clicks as necessary (ty synergy for this) for( ; yTmp >= SCROLL_AMT; yTmp -= SCROLL_AMT ) { XTestFakeButtonEvent( dpy, button, 1, 0 ); XTestFakeButtonEvent( dpy, button, 0, 0 ); } //fix yTmp: if ( yDelta < 0 )//we were scrolling down { yDelta = -yTmp; } else { yDelta = yTmp; } break; case EVENT_MOUSE_DOWN: //printf( "mouse down: %d", pEvent->button_info.button ); button = ButtonNumber[MouseNumber(event.value) % NButtons]; XTestFakeButtonEvent( dpy, button, 1, 0 ); break; case EVENT_MOUSE_UP: //printf( "mouse up: %d", pEvent->button_info.button ); button = ButtonNumber[MouseNumber(event.value) % NButtons]; XTestFakeButtonEvent( dpy, button, 0, 0 ); break; case EVENT_KEY_UP: case EVENT_KEY_DOWN: handleKeyEvent( dpy, pEvent ); break; case EVENT_ASCII: simulateKeyWithUnichar(dpy, pEvent); break; default: //printf( "unknown message type: %d\n", event.type ); break; } prevevent = event; XFlush( dpy ); } else if ( recvsize > 0 ) { // printf( "partial recv!\n" ); } else if ( recvsize == 0 ) { //connection terminated close( s_accept ); break; //exit this while loop, wait for another connection } else if (errno == EAGAIN) { // sending a keep-alive event for an X server XGetWindowAttributes(dpy, win, &winattr); // sending a keep-alive packet struct timeval tv; gettimeofday(&tv, NULL); MouseEvent event = {htonl(EVENT_NULL), 0, htonl(tv.tv_sec), htonl(tv.tv_usec*1000)}; send(s_accept, (void *)&event, sizeof(event), 0); } else { perror( "error in recv" ); shutdown(s_accept, SHUT_RDWR); close(s_accept); break; } } printf("Disconnected!\n"); } //shouldn't get here! return 0; }
QXcbWindow::QXcbWindow(QWidget *tlw) : QPlatformWindow(tlw) , m_context(0) { m_screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWidget(tlw)); setConnection(m_screen->connection()); const quint32 mask = XCB_CW_BACK_PIXMAP | XCB_CW_EVENT_MASK; const quint32 values[] = { // XCB_CW_BACK_PIXMAP XCB_NONE, // XCB_CW_EVENT_MASK XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_FOCUS_CHANGE }; #if defined(XCB_USE_GLX) || defined(XCB_USE_EGL) if (tlw->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenGL && QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL) || tlw->platformWindowFormat().alpha()) { #if defined(XCB_USE_GLX) XVisualInfo *visualInfo = qglx_findVisualInfo(DISPLAY_FROM_XCB(m_screen),m_screen->screenNumber(), tlw->platformWindowFormat()); #elif defined(XCB_USE_EGL) EGLDisplay eglDisplay = connection()->egl_display(); EGLConfig eglConfig = q_configFromQPlatformWindowFormat(eglDisplay,tlw->platformWindowFormat(),true); VisualID id = QXlibEglIntegration::getCompatibleVisualId(DISPLAY_FROM_XCB(this), eglDisplay, eglConfig); XVisualInfo visualInfoTemplate; memset(&visualInfoTemplate, 0, sizeof(XVisualInfo)); visualInfoTemplate.visualid = id; XVisualInfo *visualInfo; int matchingCount = 0; visualInfo = XGetVisualInfo(DISPLAY_FROM_XCB(this), VisualIDMask, &visualInfoTemplate, &matchingCount); #endif //XCB_USE_GLX if (visualInfo) { m_depth = visualInfo->depth; m_format = (m_depth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32; Colormap cmap = XCreateColormap(DISPLAY_FROM_XCB(this), m_screen->root(), visualInfo->visual, AllocNone); XSetWindowAttributes a; a.background_pixel = WhitePixel(DISPLAY_FROM_XCB(this), m_screen->screenNumber()); a.border_pixel = BlackPixel(DISPLAY_FROM_XCB(this), m_screen->screenNumber()); a.colormap = cmap; m_window = XCreateWindow(DISPLAY_FROM_XCB(this), m_screen->root(), tlw->x(), tlw->y(), tlw->width(), tlw->height(), 0, visualInfo->depth, InputOutput, visualInfo->visual, CWBackPixel|CWBorderPixel|CWColormap, &a); printf("created GL window: %d\n", m_window); } else { qFatal("no window!"); } } else #endif //defined(XCB_USE_GLX) || defined(XCB_USE_EGL) { m_window = xcb_generate_id(xcb_connection()); m_depth = m_screen->screen()->root_depth; m_format = (m_depth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32; Q_XCB_CALL(xcb_create_window(xcb_connection(), XCB_COPY_FROM_PARENT, // depth -- same as root m_window, // window id m_screen->root(), // parent window id tlw->x(), tlw->y(), tlw->width(), tlw->height(), 0, // border width XCB_WINDOW_CLASS_INPUT_OUTPUT, // window class m_screen->screen()->root_visual, // visual 0, // value mask 0)); // value list printf("created regular window: %d\n", m_window); } Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values)); xcb_atom_t properties[4]; int propertyCount = 0; properties[propertyCount++] = atom(QXcbAtom::WM_DELETE_WINDOW); properties[propertyCount++] = atom(QXcbAtom::WM_TAKE_FOCUS); properties[propertyCount++] = atom(QXcbAtom::_NET_WM_PING); if (m_screen->syncRequestSupported()) properties[propertyCount++] = atom(QXcbAtom::_NET_WM_SYNC_REQUEST); if (tlw->windowFlags() & Qt::WindowContextHelpButtonHint) properties[propertyCount++] = atom(QXcbAtom::_NET_WM_CONTEXT_HELP); Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, atom(QXcbAtom::WM_PROTOCOLS), XCB_ATOM_ATOM, 32, propertyCount, properties)); m_syncValue.hi = 0; m_syncValue.lo = 0; if (m_screen->syncRequestSupported()) { m_syncCounter = xcb_generate_id(xcb_connection()); Q_XCB_CALL(xcb_sync_create_counter(xcb_connection(), m_syncCounter, m_syncValue)); Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, atom(QXcbAtom::_NET_WM_SYNC_REQUEST_COUNTER), XCB_ATOM_CARDINAL, 32, 1, &m_syncCounter)); } if (isTransient(tlw) && tlw->parentWidget()) { // ICCCM 4.1.2.6 QWidget *p = tlw->parentWidget()->window(); xcb_window_t parentWindow = p->winId(); Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32, 1, &parentWindow)); } // set the PID to let the WM kill the application if unresponsive long pid = getpid(); Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window, atom(QXcbAtom::_NET_WM_PID), XCB_ATOM_CARDINAL, 32, 1, &pid)); }
static void About_create_window(void) { const unsigned int windowWidth = ABOUT_WINDOW_WIDTH, buttonWindowHeight = 2*BTN_BORDER + buttonFont->ascent + buttonFont->descent, windowHeight = ABOUT_WINDOW_HEIGHT; unsigned textWidth; XSetWindowAttributes sattr; unsigned long mask; /* * Create the window and initialize window name. */ mask = 0; sattr.background_pixel = colors[windowColor].pixel; mask |= CWBackPixel; sattr.border_pixel = colors[borderColor].pixel; mask |= CWBorderPixel; if (colormap != 0) { sattr.colormap = colormap; mask |= CWColormap; } sattr.backing_store = Always; mask |= CWBackingStore; aboutWindow = XCreateWindow(dpy, DefaultRootWindow(dpy), 0, 0, windowWidth, windowHeight, 2, (int)dispDepth, InputOutput, visual, mask, &sattr); XStoreName(dpy, aboutWindow, "XPilot - information"); XSetIconName(dpy, aboutWindow, "XPilot/info"); XSetTransientForHint(dpy, aboutWindow, topWindow); textWidth = XTextWidth(buttonFont, "CLOSE", 5); about_close_b = XCreateSimpleWindow(dpy, aboutWindow, BORDER, (int)(windowHeight - BORDER - buttonWindowHeight - 4), 2*BTN_BORDER + textWidth, buttonWindowHeight, 0, 0, colors[buttonColor].pixel); /* * Create 'buttons' in the window. */ textWidth = XTextWidth(buttonFont, "PREV", 4); about_prev_b = XCreateSimpleWindow(dpy, aboutWindow, (int)(windowWidth / 2 - BTN_BORDER - textWidth / 2), (int)(windowHeight - BORDER - buttonWindowHeight - 4), 2*BTN_BORDER + textWidth, buttonWindowHeight, 0, 0, colors[buttonColor].pixel); textWidth = XTextWidth(buttonFont, "NEXT", 4); about_next_b = XCreateSimpleWindow(dpy, aboutWindow, (int)(windowWidth - BORDER - 2*BTN_BORDER - textWidth), (int)(windowHeight - BORDER - buttonWindowHeight - 4), 2*BTN_BORDER + textWidth, buttonWindowHeight, 0, 0, colors[buttonColor].pixel); XSelectInput(dpy, about_close_b, ExposureMask | ButtonPressMask | ButtonReleaseMask); XSelectInput(dpy, about_next_b, ExposureMask | ButtonPressMask | ButtonReleaseMask); XSelectInput(dpy, about_prev_b, ExposureMask | ButtonPressMask | ButtonReleaseMask); XSelectInput(dpy, aboutWindow, ExposureMask); Expose_about_window(); XMapSubwindows(dpy, aboutWindow); }
int wincreat( int x, int y, int width, int height, char *title) { XSetWindowAttributes swa; Colormap cmap; XVisualInfo *vi; int dummy; GLXContext glcx; XEvent event; int attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 16, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_DOUBLEBUFFER, None }; if( !(dpy = XOpenDisplay( NULL )) ) /* defaults to $DISPLAY */ { fprintf( stderr, "Unable to open display.\n" ); exit( 1 ); } else { /*printf( "Connected to display... %s (%s).\n", dpy->display_name, dpy->vendor );*/ } /* end if( ) */ if( !glXQueryExtension( dpy, &dummy, &dummy ) ) { fprintf( stderr, "Unable to query GLX extensions.\n" ); exit( 1 ); } /* end if( ) */ if( !(vi = glXChooseVisual( dpy, DefaultScreen( dpy ), attributes )) ) { fprintf( stderr, "Unable get a visual.\n" ); exit( 1 ); } /* end if( ) */ if( vi->class != TrueColor ) { fprintf( stderr, "Need TrueColor class.\n" ); exit( 1 ); } if( !(glcx = glXCreateContext( dpy, vi, None, GL_TRUE )) ) { fprintf( stderr, "Unable create a GL context.\n" ); exit( 1 ); } /* end if( ) */ cmap = XCreateColormap( dpy, RootWindow( dpy, vi->screen ), vi->visual, AllocNone ); swa.colormap = cmap; swa.border_pixel = 0; swa.event_mask = ExposureMask | KeyPressMask | StructureNotifyMask; glwin = XCreateWindow( dpy, RootWindow( dpy, vi->screen ), x, y, width, height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &swa ); /* Make a clear cursor so it looks like we have none. */ { Pixmap pixmap; Cursor cursor; XColor color; char clear_bits[32]; memset(clear_bits, 0, sizeof(clear_bits)); pixmap = XCreatePixmapFromBitmapData(dpy, glwin, clear_bits, 16, 16, 1, 0, 1); cursor = XCreatePixmapCursor(dpy, pixmap, pixmap, &color, &color, 8, 8); XDefineCursor(dpy, glwin, cursor); XFreePixmap(dpy, pixmap); } XSetStandardProperties( dpy, glwin, title, title, None, NULL, 0, NULL ); if( !glXMakeCurrent( dpy, glwin, glcx ) ) { fprintf( stderr, "Failed to make the GL context current.\n" ); exit( 1 ); } XMapWindow( dpy, glwin ); XIfEvent( dpy, &event, WaitForMapNotify, (char *)glwin ); return( 1 ); } /* end int APIENTRY pglc_wincreat( ) */
/* * Create an RGB, double-buffered window. * Return the window and context handles. */ static void make_window( Display *dpy, const char *name, int x, int y, int width, int height, Window *winRet, GLXContext *ctxRet) { int attrib[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 1, None }; int scrnum; XSetWindowAttributes attr; unsigned long mask; Window root; Window win; GLXContext ctx; XVisualInfo *visinfo; scrnum = DefaultScreen( dpy ); root = RootWindow( dpy, scrnum ); visinfo = glXChooseVisual( dpy, scrnum, attrib ); if (!visinfo) { printf("Error: couldn't get an RGB, Double-buffered visual\n"); exit(1); } /* window attributes */ attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow( dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr ); /* set hints and properties */ { XSizeHints sizehints; sizehints.x = x; sizehints.y = y; sizehints.width = width; sizehints.height = height; sizehints.flags = USSize | USPosition; XSetNormalHints(dpy, win, &sizehints); XSetStandardProperties(dpy, win, name, name, None, (char **)NULL, 0, &sizehints); } ctx = glXCreateContext( dpy, visinfo, NULL, True ); if (!ctx) { printf("Error: glXCreateContext failed\n"); exit(1); } XFree(visinfo); *winRet = win; *ctxRet = ctx; }
int main() { Display *dpy; int attrib[] = { GLX_RGBA, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_DEPTH_SIZE, 24, None }; int eventbase, errorbase; int screen; Window root, win; XVisualInfo *visinfo; XSetWindowAttributes attr; GLXContext ctx; dpy = XOpenDisplay(NULL); if(NULL == dpy) { fprintf(stderr, "error: unable to open display!\n"); return EXIT_FAILURE; } if(!glXQueryExtension(dpy, &eventbase, &errorbase)) { fprintf(stderr, "GLX is not available!\n"); return EXIT_FAILURE; } screen = DefaultScreen(dpy); root = RootWindow(dpy, screen); visinfo = glXChooseVisual(dpy, screen, attrib); if(!visinfo) { fprintf(stderr, "error: couldn't get an RGBA, double-buffered visual!\n"); return EXIT_FAILURE; } attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask; win = XCreateWindow(dpy, root, /*x*/ 0, /*y*/ 0, /*width*/ 400, /*height*/ 400, 0, visinfo->depth, InputOutput, visinfo->visual, CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &attr); ctx = glXCreateContext(dpy, visinfo, NULL, True ); if(!ctx) { fprintf(stderr, "error: glXCreateContext failed!\n"); return EXIT_FAILURE; } XMapWindow(dpy, win); glXMakeCurrent(dpy, win, ctx); event_loop(dpy); return EXIT_SUCCESS; }
/* * createXworkWindow() * * Utility to create an X-Window. * Borrowed heavily from function by the same name in xcontrol.c * */ static Window createXWorkWindow(Display *dpy, CROddp* psa) { Window win; static XWMHints xwmh = { (InputHint | StateHint ),/* flags */ True, /* input */ NormalState, /* initial_state */ 0, /* icon pixmap */ 0, /* icon window */ 0, 0, /* icon location */ 0, /* icon mask */ 0 /* Window group */ }; static XClassHint xch = { "xgks", /* resource name */ "Xgks" /* class name */ }; XSizeHints xsh = { /* Size hints for window manager*/ (PMinSize), 0,0, /* obsolete ???? */ DEFAULT_WIDTH, /* obsolete ???? */ DEFAULT_HEIGHT, /* obsolete ???? */ MIN_WIDTH, MIN_HEIGHT, /* minimum usefull win dim */ 0,0, /* max dim (not used) */ 0,0, /* not used */ {0,0}, /* not used */ {0,0}, /* not used */ 0, 0, /* dimensions of window */ 0 }; char *geometry=NULL; int geom_mask = 0; XSetWindowAttributes xswa; /* Set Window Attribute struct */ XTextProperty window_name, icon_name; unsigned long bw = 0; /* Border width */ XEvent event; /* Event received */ Atom wm_del; xsh.x = psa->window_pos_x; xsh.y = psa->window_pos_y; xsh.width = psa->image_width; xsh.height = psa->image_height; geom_mask = XValue | YValue | WidthValue | HeightValue; /* * see if user specified a window position. */ if ((geom_mask & XValue) || (geom_mask & YValue)) { xsh.flags |= USPosition; } /* * deal with negative position */ if ((geom_mask & XValue) && (geom_mask & XNegative)) { xsh.x = DisplayWidth (dpy, DefaultScreen(dpy)) + xsh.x - xsh.width - bw * 2; } if ((geom_mask & YValue) && (geom_mask & YNegative)) { xsh.y = DisplayWidth (dpy, DefaultScreen(dpy)) + xsh.y - xsh.height - bw * 2; } /* * see if user specified a dimension, else we use program defaults */ if ((geom_mask & WidthValue) || (geom_mask & HeightValue)) { xsh.flags |= USSize; } else { xsh.flags |= PSize; } /* * Ensure that the window's colormap field points to the default * colormap, so that the window manager knows the correct * colormap to use for the window. */ xswa.bit_gravity = CenterGravity; xswa.backing_store = WhenMapped; xswa.background_pixel = WhitePixel(dpy, DefaultScreen(dpy)); xswa.border_pixel = WhitePixel(dpy, DefaultScreen(dpy)); /* * Create the Window with the information in the XSizeHints, the * border width, and the border & background pixels. */ win = XCreateWindow(dpy, RootWindow(dpy,DefaultScreen(dpy)), xsh.x, xsh.y, xsh.width, xsh.height, bw,CopyFromParent,InputOutput,CopyFromParent, (CWBitGravity|CWBackingStore|CWBackPixel|CWBorderPixel),&xswa); /* * Set the standard properties for the window managers. */ window_name.encoding = XA_STRING; window_name.format = 8; window_name.value = (unsigned char *) psa->window_title; window_name.nitems = strlen ((char *)window_name.value); icon_name.encoding = XA_STRING; icon_name.format = 8; icon_name.value = (unsigned char *) psa->icon_title; icon_name.nitems = strlen ((char *)icon_name.value); XSetWMProperties(dpy,win,&window_name,&icon_name,NULL,0,&xsh,&xwmh, &xch); /* * Select notification of Expose event that is generated when * the window is first mapped (becomes visible) to the screen. */ XSelectInput(dpy, win, ExposureMask); /* * Map the window to make it visible. */ XMapWindow(dpy, win); /* * get expose event as window becomes visible. we can't * draw until after this */ while(1) { /* get next event */ XNextEvent(dpy, &event); /* * find the last expose event on the event queue. */ if (event.type == Expose && event.xexpose.count == 0) { /* * Remove any other pending Expose events from * the queue to avoid multiple repaints. */ /*SUPPRESS570*/ while (XCheckTypedEvent(dpy, Expose, &event)); break; } } /* * Select input for "pause" and destroy of window. */ XSelectInput(dpy,win, (ButtonPressMask|KeyPressMask|StructureNotifyMask)); /* * Request clientMessage events for WM_DELETE_WINDOW. */ wm_del = XInternAtom(dpy,"WM_DELETE_WINDOW",False); XSetWMProtocols(dpy,win,&wm_del,1); return win; }
void wsCreateWindow(wsTWindow *win, int X, int Y, int wX, int hY, int bW, int cV, unsigned char D, char *label) { int depth; win->Property = D; if (D & wsShowFrame) win->Decorations = 1; wsHGC = DefaultGC(wsDisplay, wsScreen); wsWindowPosition(win, X, Y, wX, hY); win->Width = wX; win->Height = hY; win->OldX = win->X; win->OldY = win->Y; win->OldWidth = win->Width; win->OldHeight = win->Height; /* Border size for window. */ win->BorderWidth = bW; /* Hide Mouse Cursor */ win->wsCursor = None; win->wsMouseEventType = cV; win->wsCursorData[0] = 0; win->wsCursorPixmap = XCreateBitmapFromData(wsDisplay, wsRootWin, win->wsCursorData, 1, 1); if (!(cV & wsShowMouseCursor)) win->wsCursor = XCreatePixmapCursor(wsDisplay, win->wsCursorPixmap, win->wsCursorPixmap, &win->wsColor, &win->wsColor, 0, 0); depth = vo_find_depth_from_visuals(wsDisplay, wsScreen, NULL); if (depth < 15) { mp_msg(MSGT_GPLAYER, MSGL_FATAL, MSGTR_WS_ColorDepthTooLow); mplayer(MPLAYER_EXIT_GUI, EXIT_ERROR, 0); } XMatchVisualInfo(wsDisplay, wsScreen, depth, TrueColor, &win->VisualInfo); /* --- */ win->AtomLeaderClient = XInternAtom(wsDisplay, "WM_CLIENT_LEADER", False); win->AtomDeleteWindow = XInternAtom(wsDisplay, "WM_DELETE_WINDOW", False); win->AtomTakeFocus = XInternAtom(wsDisplay, "WM_TAKE_FOCUS", False); win->AtomRolle = XInternAtom(wsDisplay, "WM_WINDOW_ROLE", False); win->AtomWMSizeHint = XInternAtom(wsDisplay, "WM_SIZE_HINT", False); win->AtomWMNormalHint = XInternAtom(wsDisplay, "WM_NORMAL_HINT", False); win->AtomProtocols = XInternAtom(wsDisplay, "WM_PROTOCOLS", False); win->AtomsProtocols[0] = win->AtomDeleteWindow; win->AtomsProtocols[1] = win->AtomTakeFocus; win->AtomsProtocols[2] = win->AtomRolle; /* --- */ win->WindowAttrib.background_pixel = BlackPixel(wsDisplay, wsScreen); win->WindowAttrib.border_pixel = WhitePixel(wsDisplay, wsScreen); win->WindowAttrib.colormap = XCreateColormap(wsDisplay, wsRootWin, win->VisualInfo.visual, AllocNone); win->WindowAttrib.event_mask = StructureNotifyMask | FocusChangeMask | ExposureMask | PropertyChangeMask | EnterWindowMask | LeaveWindowMask | VisibilityChangeMask | KeyPressMask | KeyReleaseMask; if ((cV & wsHandleMouseButton)) win->WindowAttrib.event_mask |= ButtonPressMask | ButtonReleaseMask; if ((cV & wsHandleMouseMove)) win->WindowAttrib.event_mask |= PointerMotionMask; win->WindowAttrib.cursor = win->wsCursor; win->WindowAttrib.override_redirect = False; if (D & wsOverredirect) win->WindowAttrib.override_redirect = True; win->WindowMask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask | CWCursor | CWOverrideRedirect; win->WindowID = XCreateWindow(wsDisplay, (win->Parent != 0 ? win->Parent : wsRootWin), win->X, win->Y, win->Width, win->Height, win->BorderWidth, win->VisualInfo.depth, InputOutput, win->VisualInfo.visual, win->WindowMask, &win->WindowAttrib); wsClassHint.res_name = "MPlayer"; wsClassHint.res_class = "MPlayer"; XSetClassHint(wsDisplay, win->WindowID, &wsClassHint); win->SizeHint.flags = PPosition | PSize | PResizeInc | PWinGravity; // | PBaseSize; win->SizeHint.x = win->X; win->SizeHint.y = win->Y; win->SizeHint.width = win->Width; win->SizeHint.height = win->Height; if (D & wsMinSize) { win->SizeHint.flags |= PMinSize; win->SizeHint.min_width = win->Width; win->SizeHint.min_height = win->Height; } if (D & wsMaxSize) { win->SizeHint.flags |= PMaxSize; win->SizeHint.max_width = win->Width; win->SizeHint.max_height = win->Height; } win->SizeHint.height_inc = 1; win->SizeHint.width_inc = 1; win->SizeHint.base_width = win->Width; win->SizeHint.base_height = win->Height; win->SizeHint.win_gravity = StaticGravity; XSetWMNormalHints(wsDisplay, win->WindowID, &win->SizeHint); win->WMHints.flags = InputHint | StateHint; win->WMHints.input = True; win->WMHints.initial_state = NormalState; XSetWMHints(wsDisplay, win->WindowID, &win->WMHints); wsWindowDecoration(win, win->Decorations); XStoreName(wsDisplay, win->WindowID, label); XmbSetWMProperties(wsDisplay, win->WindowID, label, label, NULL, 0, NULL, NULL, NULL); XSetWMProtocols(wsDisplay, win->WindowID, win->AtomsProtocols, 3); XChangeProperty(wsDisplay, win->WindowID, win->AtomLeaderClient, XA_WINDOW, 32, PropModeReplace, (unsigned char *)&LeaderWindow, 1); wsTextProperty.value = label; wsTextProperty.encoding = XA_STRING; wsTextProperty.format = 8; wsTextProperty.nitems = strlen(label); XSetWMIconName(wsDisplay, win->WindowID, &wsTextProperty); win->wGC = XCreateGC(wsDisplay, win->WindowID, GCForeground | GCBackground, &win->wGCV); win->Visible = 0; win->Focused = 0; win->Mapped = 0; win->Rolled = 0; if (D & wsShowWindow) XMapWindow(wsDisplay, win->WindowID); wsCreateImage(win, win->Width, win->Height); /* End of creating -------------------------------------------------------------------------- */ { int i; for (i = 0; i < wsWLCount; i++) if (wsWindowList[i] == NULL) break; if (i == wsWLCount) { mp_msg(MSGT_GPLAYER, MSGL_FATAL, MSGTR_WS_TooManyOpenWindows); mplayer(MPLAYER_EXIT_GUI, EXIT_ERROR, 0); } wsWindowList[i] = win; } XFlush(wsDisplay); XSync(wsDisplay, False); win->ReDraw = NULL; win->ReSize = NULL; win->Idle = NULL; win->MouseHandler = NULL; win->KeyHandler = NULL; mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] window is created. ( %s ).\n", label); }
/* * we'll call this once for each thread, before the threads are created. */ static void create_window(struct winthread *wt, GLXContext shareCtx) { Window win; GLXContext ctx; int attrib[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DEPTH_SIZE, 1, GLX_DOUBLEBUFFER, None }; int scrnum; XSetWindowAttributes attr; unsigned long mask; Window root; XVisualInfo *visinfo; int width = 160, height = 160; int xpos = (wt->Index % 8) * (width + 10); int ypos = (wt->Index / 8) * (width + 20); scrnum = DefaultScreen(wt->Dpy); root = RootWindow(wt->Dpy, scrnum); visinfo = glXChooseVisual(wt->Dpy, scrnum, attrib); if (!visinfo) { Error("Unable to find RGB, Z, double-buffered visual"); } /* window attributes */ attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap(wt->Dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow(wt->Dpy, root, xpos, ypos, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr); if (!win) { Error("Couldn't create window"); } { XSizeHints sizehints; sizehints.x = xpos; sizehints.y = ypos; sizehints.width = width; sizehints.height = height; sizehints.flags = USSize | USPosition; XSetNormalHints(wt->Dpy, win, &sizehints); XSetStandardProperties(wt->Dpy, win, "glthreads", "glthreads", None, (char **)NULL, 0, &sizehints); } ctx = glXCreateContext(wt->Dpy, visinfo, shareCtx, True); if (!ctx) { Error("Couldn't create GLX context"); } XMapWindow(wt->Dpy, win); XSync(wt->Dpy, 0); /* save the info for this window/context */ wt->Win = win; wt->Context = ctx; wt->Angle = 0.0; wt->WinWidth = width; wt->WinHeight = height; wt->NewSize = GL_TRUE; }
/* * Create an RGB, double-buffered X window. * Return the window and context handles. */ static void make_x_window(Display *x_dpy, EGLDisplay egl_dpy, const char *name, int x, int y, int width, int height, Window *winRet, EGLContext *ctxRet, EGLSurface *surfRet) { static const EGLint attribs[] = { EGL_RED_SIZE, 1, EGL_GREEN_SIZE, 1, EGL_BLUE_SIZE, 1, EGL_DEPTH_SIZE, 1, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE }; static const EGLint ctx_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; int scrnum; XSetWindowAttributes attr; unsigned long mask; Window root; Window win; XVisualInfo *visInfo, visTemplate; int num_visuals; EGLContext ctx; EGLConfig config; EGLint num_configs; EGLint vid; scrnum = DefaultScreen( x_dpy ); root = RootWindow( x_dpy, scrnum ); if (!eglChooseConfig( egl_dpy, attribs, &config, 1, &num_configs)) { printf("Error: couldn't get an EGL visual config\n"); exit(1); } assert(config); assert(num_configs > 0); if (!eglGetConfigAttrib(egl_dpy, config, EGL_NATIVE_VISUAL_ID, &vid)) { printf("Error: eglGetConfigAttrib() failed\n"); exit(1); } /* The X window visual must match the EGL config */ visTemplate.visualid = vid; visInfo = XGetVisualInfo(x_dpy, VisualIDMask, &visTemplate, &num_visuals); if (!visInfo) { printf("Error: couldn't get X visual\n"); exit(1); } /* window attributes */ attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap( x_dpy, root, visInfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow( x_dpy, root, 0, 0, width, height, 0, visInfo->depth, InputOutput, visInfo->visual, mask, &attr ); /* set hints and properties */ { XSizeHints sizehints; sizehints.x = x; sizehints.y = y; sizehints.width = width; sizehints.height = height; sizehints.flags = USSize | USPosition; XSetNormalHints(x_dpy, win, &sizehints); XSetStandardProperties(x_dpy, win, name, name, None, (char **)NULL, 0, &sizehints); } #if USE_FULL_GL /* XXX fix this when eglBindAPI() works */ eglBindAPI(EGL_OPENGL_API); #else eglBindAPI(EGL_OPENGL_ES_API); #endif ctx = eglCreateContext(egl_dpy, config, EGL_NO_CONTEXT, ctx_attribs ); if (!ctx) { printf("Error: eglCreateContext failed\n"); exit(1); } /* test eglQueryContext() */ { EGLint val; eglQueryContext(egl_dpy, ctx, EGL_CONTEXT_CLIENT_VERSION, &val); assert(val == 2); } *surfRet = eglCreateWindowSurface(egl_dpy, config, win, NULL); if (!*surfRet) { printf("Error: eglCreateWindowSurface failed\n"); exit(1); } /* sanity checks */ { EGLint val; eglQuerySurface(egl_dpy, *surfRet, EGL_WIDTH, &val); assert(val == width); eglQuerySurface(egl_dpy, *surfRet, EGL_HEIGHT, &val); assert(val == height); assert(eglGetConfigAttrib(egl_dpy, config, EGL_SURFACE_TYPE, &val)); assert(val & EGL_WINDOW_BIT); } XFree(visInfo); *winRet = win; *ctxRet = ctx; }
void* platform::getNativeWindow() { Window root; XSetWindowAttributes swa; XSetWindowAttributes xattr; Atom wm_state; XWMHints hints; XEvent xev; EGLConfig ecfg; EGLint num_config; Window win; Display* x_display = XOpenDisplay(NULL); assert(x_display); /* * X11 native display initialization */ x_display = XOpenDisplay(NULL); if ( x_display == NULL ) { return EGL_FALSE; } root = DefaultRootWindow(x_display); swa.event_mask = ExposureMask | PointerMotionMask | KeyPressMask; win = XCreateWindow( x_display, root, 0, 0, 640, 480, 0, CopyFromParent, InputOutput, CopyFromParent, CWEventMask, &swa ); xattr.override_redirect = false; XChangeWindowAttributes ( x_display, win, CWOverrideRedirect, &xattr ); hints.input = true; hints.flags = InputHint; XSetWMHints(x_display, win, &hints); // make the window visible on the screen XMapWindow (x_display, win); XStoreName (x_display, win, "foo"); // get identifiers for the provided atom name strings wm_state = XInternAtom (x_display, "_NET_WM_STATE", false); memset ( &xev, 0, sizeof(xev) ); xev.type = ClientMessage; xev.xclient.window = win; xev.xclient.message_type = wm_state; xev.xclient.format = 32; xev.xclient.data.l[0] = 1; xev.xclient.data.l[1] = false; XSendEvent ( x_display, DefaultRootWindow ( x_display ), false, SubstructureNotifyMask, &xev ); //(eEGLNativeWindowType) win; return (void*) win; }
static cairo_surface_t * _cairo_boilerplate_vg_create_surface_glx (const char *name, cairo_content_t content, double width, double height, double max_width, double max_height, cairo_boilerplate_mode_t mode, int id, void **closure) { int rgba_attribs[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_ALPHA_SIZE, 1, GLX_DOUBLEBUFFER, None }; int rgb_attribs[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, None }; XVisualInfo *vi; Display *dpy; Colormap cmap; XSetWindowAttributes swa; cairo_surface_t *surface; cairo_vg_context_t *context; vg_closure_glx_t *vgc; vgc = malloc (sizeof (vg_closure_glx_t)); *closure = vgc; if (width == 0) width = 1; if (height == 0) height = 1; dpy = XOpenDisplay (NULL); vgc->dpy = dpy; if (vgc->dpy == NULL) { fprintf (stderr, "Failed to open display: %s\n", XDisplayName(0)); free (vgc); return NULL; } if (content == CAIRO_CONTENT_COLOR) vi = glXChooseVisual (dpy, DefaultScreen (dpy), rgb_attribs); else vi = glXChooseVisual (dpy, DefaultScreen (dpy), rgba_attribs); if (vi == NULL) { fprintf (stderr, "Failed to create RGB, double-buffered visual\n"); XCloseDisplay (dpy); free (vgc); return NULL; } vgc->ctx = glXCreateContext (dpy, vi, NULL, True); cmap = XCreateColormap (dpy, RootWindow (dpy, vi->screen), vi->visual, AllocNone); swa.colormap = cmap; swa.border_pixel = 0; vgc->win = XCreateWindow (dpy, RootWindow (dpy, vi->screen), -1, -1, 1, 1, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap, &swa); XFreeColormap (dpy, cmap); XFree (vi); XMapWindow (dpy, vgc->win); /* we need an active context to initialise VG */ glXMakeContextCurrent (dpy, vgc->win, vgc->win, vgc->ctx); #ifdef USE_AMANITH vgInitContextAM (width, height, VG_FALSE, VG_TRUE); #endif #ifdef USE_SHIVA vgCreateContextSH (width, height); #endif context = cairo_vg_context_create_for_glx (dpy, vgc->ctx); vgc->surface = cairo_vg_surface_create (context, content, width, height); cairo_vg_context_destroy (context); surface = vgc->surface; if (cairo_surface_status (surface)) _cairo_boilerplate_vg_cleanup_glx (vgc); return surface; }
int main(int argc, char **argv) { Display *dpy; XVisualInfo *vi; Colormap cmap; XSetWindowAttributes swa; Window win; GLXContext cx; XEvent event; int swap_flag = 1; /* get a connection */ dpy = XOpenDisplay(0); /* get an appropriate visual */ vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeListSgl); if (vi == NULL) { vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeListDbl); swap_flag = 1; } /* create a GLX context */ cx = glXCreateContext(dpy, vi, 0, GL_TRUE); /* create a color map */ cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone); /* create a window */ swa.colormap = cmap; swa.border_pixel = 0; swa.event_mask = StructureNotifyMask; win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 512, 512, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel|CWColormap|CWEventMask, &swa); XMapWindow(dpy, win); XIfEvent(dpy, &event, WaitForNotify, (char*)win); /* connect the context to the window */ glXMakeCurrent(dpy, win, cx); GLenum err = glewInit(); if (GLEW_OK != err) { printf("glew failed to init\n"); exit(1); } printf("glew initialized\n"); glViewport(0,0,512,512); glMatrixMode ( GL_PROJECTION ); // Select The Projection Matrix glLoadIdentity ( ); // Reset The Projection Matrix gluPerspective ( 80, 1, 1.0, 5000.0 ); glMatrixMode ( GL_MODELVIEW ); // Select The Model View Matrix glLoadIdentity ( ); // Reset The Model View Matrix /* clear the buffer */ glClearColor(1,1,0,1); GLuint list = glGenLists(1); glNewList(list, GL_COMPILE); glBegin(GL_TRIANGLES); glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Front) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f(-1.0f,-1.0f, 1.0f); // Left Of Triangle (Front) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f( 1.0f,-1.0f, 1.0f); // Right Of Triangle (Front) glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Right) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f( 1.0f,-1.0f, 1.0f); // Left Of Triangle (Right) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f( 1.0f,-1.0f, -1.0f); // Right Of Triangle (Right) glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Back) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f( 1.0f,-1.0f, -1.0f); // Left Of Triangle (Back) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f(-1.0f,-1.0f, -1.0f); // Right Of Triangle (Back) glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Left) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f(-1.0f,-1.0f,-1.0f); // Left Of Triangle (Left) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f(-1.0f,-1.0f, 1.0f); // Right Of Triangle (Left) glEnd(); // Done Drawing The Pyramid glEndList(); int i; for(i = 0; i < 100; i++) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The View glTranslatef(-1.5f,0.0f,-16.0f); // Move Left And Into The Screen glRotatef(0.5,0.0f,1.0f,0.0f); // Rotate The Pyramid On It's Y Axis glCallList(list); glFinish(); if (swap_flag) glXSwapBuffers(dpy,win); } /* wait a while */ sleep(2); }
static INLINE boolean st_hardpipe_load(void) { Display *dpy; int scrnum; Window root; int attribSingle[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None }; int attribDouble[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, None }; XVisualInfo *visinfo; GLXContext ctx = NULL; XSetWindowAttributes attr; unsigned long mask; int width = 100, height = 100; Window win; dpy = XOpenDisplay(NULL); if (!dpy) return FALSE; scrnum = 0; root = RootWindow(dpy, scrnum); visinfo = glXChooseVisual(dpy, scrnum, attribSingle); if (!visinfo) visinfo = glXChooseVisual(dpy, scrnum, attribDouble); if (!visinfo) return FALSE; ctx = glXCreateContext( dpy, visinfo, NULL, True ); if (!ctx) return FALSE; attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow(dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr); if (!glXMakeCurrent(dpy, win, ctx)) return FALSE; pfnGetGalliumScreenMESA = (PFNGETGALLIUMSCREENMESAPROC)glXGetProcAddressARB((const GLubyte *)"glXGetGalliumScreenMESA"); if(!pfnGetGalliumScreenMESA) return FALSE; pfnCreateGalliumContextMESA = (PFNCREATEGALLIUMCONTEXTMESAPROC)glXGetProcAddressARB((const GLubyte *)"glXCreateGalliumContextMESA"); if(!pfnCreateGalliumContextMESA) return FALSE; glXDestroyContext(dpy, ctx); XFree(visinfo); XDestroyWindow(dpy, win); XCloseDisplay(dpy); return TRUE; }
static int initEGL(void) { NativeWindowType window = 0; printf ("GL init\n"); EGLint numConfigs; EGLint majorVersion; EGLint minorVersion; #if defined(USE_X11) enum { _NET_WM_STATE_REMOVE =0, _NET_WM_STATE_ADD = 1, _NET_WM_STATE_TOGGLE =2 }; Window sRootWindow; XSetWindowAttributes sWA; unsigned int ui32Mask; int i32Depth; #endif EGLint *attribList = NULL; if (use_fsaa) { printf( "GLES: Using Full Scene Antialiasing\n" ); attribList = attrib_list_fsaa; } else { attribList = attrib_list; } #if defined(USE_X11) // Initializes the display and screen x11Display = XOpenDisplay( ":0" ); if (!x11Display) { printf("GLES Error: Unable to open X display\n"); return -1; } x11Screen = XDefaultScreen( x11Display ); // Gets the display parameters so we can pass the same parameters to the window to be created. sRootWindow = RootWindow(x11Display, x11Screen); i32Depth = DefaultDepth(x11Display, x11Screen); px11Visual = &x11Visual; XMatchVisualInfo( x11Display, x11Screen, i32Depth, TrueColor, px11Visual); if (!px11Visual) { printf("GLES Error: Unable to acquire visual\n"); return -1; } // Colormap of the specified visual type for the display. x11Colormap = XCreateColormap( x11Display, sRootWindow, px11Visual->visual, AllocNone ); sWA.colormap = x11Colormap; // List of events to be handled by the application. Add to these for handling other events. sWA.event_mask = StructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask; // Display capabilities list. ui32Mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap; // Creates the X11 window x11Window = XCreateWindow( x11Display, RootWindow(x11Display, x11Screen), 0, 0, iResX, iResY, 0, CopyFromParent, InputOutput, CopyFromParent, ui32Mask, &sWA); // Make the window viewable and flush the output buffer. XMapWindow(x11Display, x11Window); XFlush(x11Display); // Make the window fullscreen unsigned char fullScreen = 1; Atom wmState = XInternAtom(x11Display, "_NET_WM_STATE", False); Atom wmFullScreen = XInternAtom(x11Display,"_NET_WM_STATE_FULLSCREEN", False); XEvent xev; xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.window = x11Window; xev.xclient.message_type = wmState; xev.xclient.format = 32; xev.xclient.data.l[0] = (fullScreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE); xev.xclient.data.l[1] = wmFullScreen; xev.xclient.data.l[2] = 0; XSendEvent(x11Display, DefaultRootWindow(x11Display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); display = eglGetDisplay( (EGLNativeDisplayType)x11Display ); window = x11Window; #else display = eglGetDisplay( (EGLNativeDisplayType)0 ); #endif if( display == EGL_NO_DISPLAY ) { printf( "GLES EGL Error: GL No Display\n" ); return -1; } if( !eglInitialize( display, &majorVersion, &minorVersion ) ) { printf( "GLES EGL Error: eglInitialize failed\n" ); return -1; } if( !eglChooseConfig( display, attribList, &config, 1, &numConfigs ) ) { printf( "GLES EGL Error: eglChooseConfig failed\n" ); return -1; } context = eglCreateContext( display, config, NULL, NULL ); if( context==0 ) { printf( "GLES EGL Error: eglCreateContext failed\n" ); return -1; } #ifdef FAKE_WINDOW // broken Caanoo libs won't accept NULL window window = (NativeWindowType)1; #endif surface = eglCreateWindowSurface( display, config, window, NULL ); if (!TestEGLError("eglCreateWindowSurface")) return -1; eglMakeCurrent( display, surface, surface, context ); if (!TestEGLError("eglMakeCurrent")) return -1; printf("GLES init ok\n"); return 0; }
int32_t run(int _argc, char** _argv) { XInitThreads(); m_display = XOpenDisplay(0); int32_t screen = DefaultScreen(m_display); int32_t depth = DefaultDepth(m_display, screen); Visual* visual = DefaultVisual(m_display, screen); Window root = RootWindow(m_display, screen); XSetWindowAttributes windowAttrs; memset(&windowAttrs, 0, sizeof(windowAttrs) ); windowAttrs.background_pixmap = 0; windowAttrs.border_pixel = 0; windowAttrs.event_mask = 0 | ButtonPressMask | ButtonReleaseMask | ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ResizeRedirectMask | StructureNotifyMask ; m_window = XCreateWindow(m_display , root , 0, 0 , ENTRY_DEFAULT_WIDTH, ENTRY_DEFAULT_HEIGHT, 0, depth , InputOutput , visual , CWBorderPixel|CWEventMask , &windowAttrs ); const char *wmDeleteWindowName = "WM_DELETE_WINDOW"; Atom wmDeleteWindow; XInternAtoms(m_display, (char **)&wmDeleteWindowName, 1, False, &wmDeleteWindow); XSetWMProtocols(m_display, m_window, &wmDeleteWindow, 1); XMapWindow(m_display, m_window); XStoreName(m_display, m_window, "BGFX"); bgfx::x11SetDisplayWindow(m_display, m_window); MainThreadEntry mte; mte.m_argc = _argc; mte.m_argv = _argv; bx::Thread thread; thread.init(mte.threadFunc, &mte); while (!m_exit) { if (XPending(m_display) ) { XEvent event; XNextEvent(m_display, &event); switch (event.type) { case Expose: break; case ConfigureNotify: break; case ClientMessage: if((Atom)event.xclient.data.l[0] == wmDeleteWindow) { m_eventQueue.postExitEvent(); } break; case ButtonPress: case ButtonRelease: { const XButtonEvent& xbutton = event.xbutton; MouseButton::Enum mb; switch (xbutton.button) { case Button1: mb = MouseButton::Left; break; case Button2: mb = MouseButton::Middle; break; case Button3: mb = MouseButton::Right; break; default: mb = MouseButton::None; break; } if (MouseButton::None != mb) { m_eventQueue.postMouseEvent(xbutton.x , xbutton.y , 0 , mb , event.type == ButtonPress ); } } break; case MotionNotify: { const XMotionEvent& xmotion = event.xmotion; m_eventQueue.postMouseEvent(xmotion.x , xmotion.y , 0 ); } break; case KeyPress: case KeyRelease: { XKeyEvent& xkey = event.xkey; KeySym keysym = XLookupKeysym(&xkey, 0); switch (keysym) { case XK_Meta_L: setModifier(Modifier::LeftMeta, KeyPress == event.type); break; case XK_Meta_R: setModifier(Modifier::RightMeta, KeyPress == event.type); break; case XK_Control_L: setModifier(Modifier::LeftCtrl, KeyPress == event.type); break; case XK_Control_R: setModifier(Modifier::RightCtrl, KeyPress == event.type); break; case XK_Shift_L: setModifier(Modifier::LeftShift, KeyPress == event.type); break; case XK_Shift_R: setModifier(Modifier::RightShift, KeyPress == event.type); break; case XK_Alt_L: setModifier(Modifier::LeftAlt, KeyPress == event.type); break; case XK_Alt_R: setModifier(Modifier::RightAlt, KeyPress == event.type); break; default: { Key::Enum key = fromXk(keysym); if (Key::None != key) { m_eventQueue.postKeyEvent(key, m_modifiers, KeyPress == event.type); } } break; } } break; case ResizeRequest: { const XResizeRequestEvent& xresize = event.xresizerequest; XResizeWindow(m_display, m_window, xresize.width, xresize.height); } break; } } } thread.shutdown(); XUnmapWindow(m_display, m_window); XDestroyWindow(m_display, m_window); return EXIT_SUCCESS; }
bool LinuxWindowImpl::RunThread() { Thread::RunThread(); // Lock our use of the display connection.. XLockDisplay(GetDisplay()); int screenId = DefaultScreen(GetDisplay()); // Make sure we have glx extensions loaded. gladLoadGLX(GetDisplay(), screenId); // Make sure we've got a good version of GLX int majorGLX, minorGLX = 0; glXQueryVersion(GetDisplay(), &majorGLX, &minorGLX); if (majorGLX <= 1 && minorGLX < 3) { LOG(Log::CRITICAL) << "GLX 1.3 or greater is required.\n"; return false; } else { LOG(Log::DEFAULT) << "GLX version: " << majorGLX << "." << minorGLX << '\n'; } // Pick a visual info based on the context display settings. ::XVisualInfo* vi = GetVisualInfoFromSettings(GetDisplay(), screenId, settings); if (!vi) { LOG(Log::CRITICAL) << "Couldn't find an XVisualInfo that matches Context Settings!"; return false; } // Open the actual window. XSetWindowAttributes windowAttribs; windowAttribs.border_pixel = BlackPixel(GetDisplay(), screenId); windowAttribs.background_pixel = WhitePixel(GetDisplay(), screenId); windowAttribs.override_redirect = True; windowAttribs.colormap = XCreateColormap(GetDisplay(), RootWindow(GetDisplay(), screenId), vi->visual, AllocNone); windowAttribs.event_mask = ExposureMask | FocusChangeMask; window = XCreateWindow(GetDisplay(), RootWindow(GetDisplay(), screenId), 0, 0, width, height, 0, vi->depth, InputOutput, vi->visual, CWBackPixel | CWColormap | CWBorderPixel | CWEventMask, &windowAttribs); XClearWindow(GetDisplay(), window); XMapRaised(GetDisplay(), window); // Finished with the display XUnlockDisplay(GetDisplay()); Wait(); XLockDisplay(GetDisplay()); // Have to do this ridiculousness just to capture when the window is closed... Atom wmDeleteMessage = XInternAtom(GetDisplay(), "WM_DELETE_WINDOW", False); XSetWMProtocols(GetDisplay(), window, &wmDeleteMessage, 1); XUnlockDisplay(GetDisplay()); // Loop through the events dealing with them. running = true; while (running) { xcb_generic_event_t* event = xcb_wait_for_event(GetXCBConnection()); switch(event->response_type & ~0x80) { case XCB_EXPOSE: break; case XCB_CLIENT_MESSAGE: { xcb_client_message_event_t* clientMessage = (xcb_client_message_event_t*)event; if (clientMessage->data.data32[0] == wmDeleteMessage) running = false; break; } default: break; } free(event); } XFree(vi); XLockDisplay(GetDisplay()); XFreeColormap(LinuxWindowImpl::GetDisplay(), windowAttribs.colormap); XDestroyWindow(LinuxWindowImpl::GetDisplay(), window); XUnlockDisplay(GetDisplay()); return true; }
PuglView* puglCreate(PuglNativeWindow parent, const char* title, int width, int height, bool resizable, bool addToDesktop) { PuglView* view = (PuglView*)calloc(1, sizeof(PuglView)); PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals)); if (!view || !impl) { return NULL; } view->impl = impl; view->width = width; view->height = height; impl->display = XOpenDisplay(0); impl->screen = DefaultScreen(impl->display); XVisualInfo* vi = glXChooseVisual(impl->display, impl->screen, attrListDbl); if (!vi) { vi = glXChooseVisual(impl->display, impl->screen, attrListSgl); impl->doubleBuffered = False; printf("singlebuffered rendering will be used, no doublebuffering available\n"); } else { impl->doubleBuffered = True; printf("doublebuffered rendering available\n"); } int glxMajor, glxMinor; glXQueryVersion(impl->display, &glxMajor, &glxMinor); printf("GLX-Version %d.%d\n", glxMajor, glxMinor); impl->ctx = glXCreateContext(impl->display, vi, 0, GL_TRUE); Window xParent = parent ? (Window)parent : RootWindow(impl->display, impl->screen); Colormap cmap = XCreateColormap( impl->display, xParent, vi->visual, AllocNone); XSetWindowAttributes attr; memset(&attr, 0, sizeof(XSetWindowAttributes)); attr.colormap = cmap; attr.border_pixel = 0; attr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask; impl->win = XCreateWindow( impl->display, xParent, 0, 0, view->width, view->height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &attr); XSizeHints sizeHints; memset(&sizeHints, 0, sizeof(sizeHints)); if (!resizable) { sizeHints.flags = PMinSize|PMaxSize; sizeHints.min_width = width; sizeHints.min_height = height; sizeHints.max_width = width; sizeHints.max_height = height; XSetNormalHints(impl->display, impl->win, &sizeHints); } if (title) { XStoreName(impl->display, impl->win, title); } if (!parent) { Atom wmDelete = XInternAtom(impl->display, "WM_DELETE_WINDOW", True); XSetWMProtocols(impl->display, impl->win, &wmDelete, 1); } if (addToDesktop) { XMapRaised(impl->display, impl->win); } if (glXIsDirect(impl->display, impl->ctx)) { printf("DRI enabled\n"); } else { printf("No DRI available\n"); } XFree(vi); return view; }
static void createTheWindow() { XEvent event; int x,y, attr_mask; XSizeHints hints; XWMHints *startup_state; XTextProperty textprop; XSetWindowAttributes attr = {0,}; static char *title = "FTB's little OpenGL example - ARGB extension by WXD"; Xdisplay = XOpenDisplay(NULL); if (!Xdisplay) { fatalError("Couldn't connect to X server\n"); } Xscreen = DefaultScreen(Xdisplay); Xroot = RootWindow(Xdisplay, Xscreen); fbconfigs = glXChooseFBConfig(Xdisplay, Xscreen, VisData, &numfbconfigs); fbconfig = 0; for(int i = 0; i<numfbconfigs; i++) { visual = (XVisualInfo*) glXGetVisualFromFBConfig(Xdisplay, fbconfigs[i]); if(!visual) continue; pict_format = XRenderFindVisualFormat(Xdisplay, visual->visual); if(!pict_format) continue; fbconfig = fbconfigs[i]; if(pict_format->direct.alphaMask > 0) { break; } } if(!fbconfig) { fatalError("No matching FB config found"); } describe_fbconfig(fbconfig); /* Create a colormap - only needed on some X clients, eg. IRIX */ cmap = XCreateColormap(Xdisplay, Xroot, visual->visual, AllocNone); attr.colormap = cmap; attr.background_pixmap = None; attr.border_pixmap = None; attr.border_pixel = 0; attr.event_mask = StructureNotifyMask | EnterWindowMask | LeaveWindowMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | OwnerGrabButtonMask | KeyPressMask | KeyReleaseMask; attr_mask = CWBackPixmap| CWColormap| CWBorderPixel| CWEventMask; width = DisplayWidth(Xdisplay, DefaultScreen(Xdisplay))/2; height = DisplayHeight(Xdisplay, DefaultScreen(Xdisplay))/2; x=width/2, y=height/2; window_handle = XCreateWindow( Xdisplay, Xroot, x, y, width, height, 0, visual->depth, InputOutput, visual->visual, attr_mask, &attr); if( !window_handle ) { fatalError("Couldn't create the window\n"); } #if USE_GLX_CREATE_WINDOW int glXattr[] = { None }; glX_window_handle = glXCreateWindow(Xdisplay, fbconfig, window_handle, glXattr); if( !glX_window_handle ) { fatalError("Couldn't create the GLX window\n"); } #else glX_window_handle = window_handle; #endif textprop.value = (unsigned char*)title; textprop.encoding = XA_STRING; textprop.format = 8; textprop.nitems = strlen(title); hints.x = x; hints.y = y; hints.width = width; hints.height = height; hints.flags = USPosition|USSize; startup_state = XAllocWMHints(); startup_state->initial_state = NormalState; startup_state->flags = StateHint; XSetWMProperties(Xdisplay, window_handle,&textprop, &textprop, NULL, 0, &hints, startup_state, NULL); XFree(startup_state); XMapWindow(Xdisplay, window_handle); XIfEvent(Xdisplay, &event, WaitForMapNotify, (char*)&window_handle); if ((del_atom = XInternAtom(Xdisplay, "WM_DELETE_WINDOW", 0)) != None) { XSetWMProtocols(Xdisplay, window_handle, &del_atom, 1); } }
int main () { Display *display; Window win; XEvent report; XEvent msg; int x=10,y=10,h=100,w=100; display = XOpenDisplay(NULL); if (display == NULL) { fprintf(stderr, "couldn't connect to X server :0\n"); return 0; } win = XCreateWindow(display, RootWindow(display, 0), x, y, w, h, 0, CopyFromParent, CopyFromParent, CopyFromParent, 0, NULL); XSetWindowBackground(display,win,WhitePixel(display,0)); XSelectInput(display, win, (ExposureMask | StructureNotifyMask | GravityNotify)); XMapWindow(display, win); XFlush(display); sleep(1); XResizeWindow(display, win, w+5, h+5); XMoveWindow(display, win, x, y); while (1) { XNextEvent(display, &report); switch (report.type) { case MapNotify: printf("map notify\n"); break; case Expose: printf("exposed\n"); break; case GravityNotify: printf("gravity notify event 0x%x window 0x%x x %d y %d\n", report.xgravity.event, report.xgravity.window, report.xgravity.x, report.xgravity.y); break; case ConfigureNotify: { int se = report.xconfigure.send_event; int event = report.xconfigure.event; int window = report.xconfigure.window; int x = report.xconfigure.x; int y = report.xconfigure.y; int w = report.xconfigure.width; int h = report.xconfigure.height; int bw = report.xconfigure.border_width; int above = report.xconfigure.above; int or = report.xconfigure.override_redirect; printf("confignotify send %d ev 0x%x win 0x%x %i,%i-%ix%i bw %i\n" " above 0x%x ovrd %d\n", se,event,window,x,y,w,h,bw,above,or); break; } } } return 1; }
int32_t run(Filesystem* fs, ConfigSettings* cs) { // http://tronche.com/gui/x/xlib/display/XInitThreads.html Status xs = XInitThreads(); CE_ASSERT(xs != 0, "XInitThreads: error"); CE_UNUSED(xs); _x11_display = XOpenDisplay(NULL); CE_ASSERT(_x11_display != NULL, "XOpenDisplay: error"); int screen = DefaultScreen(_x11_display); int depth = DefaultDepth(_x11_display, screen); Visual* visual = DefaultVisual(_x11_display, screen); _x11_parent_window = (cs->parent_window == 0) ? RootWindow(_x11_display, screen) : (Window) cs->parent_window; // Create main window XSetWindowAttributes win_attribs; win_attribs.background_pixmap = 0; win_attribs.border_pixel = 0; win_attribs.event_mask = FocusChangeMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask; _x11_window = XCreateWindow(_x11_display , _x11_parent_window , 0 , 0 , cs->window_width , cs->window_height , 0 , depth , InputOutput , visual , CWBorderPixel | CWEventMask , &win_attribs); CE_ASSERT(_x11_window != None, "XCreateWindow: error"); // Do we have detectable autorepeat? Bool detectable; _x11_detectable_autorepeat = (bool) XkbSetDetectableAutoRepeat(_x11_display, true, &detectable); // Build hidden cursor Pixmap bm_no; XColor black, dummy; Colormap colormap; static char no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; colormap = XDefaultColormap(_x11_display, screen); XAllocNamedColor(_x11_display, colormap, "black", &black, &dummy); bm_no = XCreateBitmapFromData(_x11_display, _x11_window, no_data, 8, 8); _x11_hidden_cursor = XCreatePixmapCursor(_x11_display, bm_no, bm_no, &black, &black, 0, 0); _wm_delete_message = XInternAtom(_x11_display, "WM_DELETE_WINDOW", False); XSetWMProtocols(_x11_display, _x11_window, &_wm_delete_message, 1); oswindow_set_window(_x11_display, _x11_window); bgfx::x11SetDisplayWindow(_x11_display, _x11_window); XMapRaised(_x11_display, _x11_window); // Save screen configuration _screen_config = XRRGetScreenInfo(_x11_display, RootWindow(_x11_display, screen)); Rotation rr_old_rot; const SizeID rr_old_sizeid = XRRConfigCurrentConfiguration(_screen_config, &rr_old_rot); // Start main thread MainThreadArgs mta; mta.fs = fs; mta.cs = cs; Thread main_thread; main_thread.start(func, &mta); while (!s_exit) { pump_events(); } main_thread.stop(); // Restore previous screen configuration Rotation rr_rot; const SizeID rr_sizeid = XRRConfigCurrentConfiguration(_screen_config, &rr_rot); if (rr_rot != rr_old_rot || rr_sizeid != rr_old_sizeid) { XRRSetScreenConfig(_x11_display , _screen_config , RootWindow(_x11_display, screen) , rr_old_sizeid , rr_old_rot , CurrentTime); } XRRFreeScreenConfigInfo(_screen_config); XDestroyWindow(_x11_display, _x11_window); XCloseDisplay(_x11_display); return EXIT_SUCCESS; }