//--------------------------------------------------------------------------- // GLX init //--------------------------------------------------------------------------- bool Pipe::configInit() { const std::string displayName = getXDisplayString(); const char* cDisplayName = ( displayName.empty() ? 0 : displayName.c_str( )); Display* xDisplay = XOpenDisplay( cDisplayName ); if( !xDisplay ) { setError( ERROR_GLXPIPE_DEVICE_NOTFOUND ); LBWARN << getError() << " " << XDisplayName( displayName.c_str( )) << ": " << lunchbox::sysError << std::endl; return false; } int major, event, error; if( !XQueryExtension( xDisplay, "GLX", &major, &event, &error )) { setError( ERROR_GLXPIPE_GLX_NOTFOUND ); XCloseDisplay( xDisplay ); return false; } setXDisplay( xDisplay ); LBVERB << "Opened X display " << XDisplayName( displayName.c_str( )) << " @" << xDisplay << ", device " << getPipe()->getDevice() << std::endl; return _configInitGLXEW(); }
static int DGA_Available(void) { const char *display; Display *dpy; int available; /* The driver is available is available if the display is local and the DGA 2.0+ extension is available, and we can map mem. */ available = 0; display = NULL; if ( (strncmp(XDisplayName(display), ":", 1) == 0) || (strncmp(XDisplayName(display), "unix:", 5) == 0) ) { dpy = XOpenDisplay(display); if ( dpy ) { int events, errors, major, minor; if ( SDL_NAME(XDGAQueryExtension)(dpy, &events, &errors) && SDL_NAME(XDGAQueryVersion)(dpy, &major, &minor) ) { int screen; screen = DefaultScreen(dpy); if ( (major >= 2) && SDL_NAME(XDGAOpenFramebuffer)(dpy, screen) ) { available = 1; SDL_NAME(XDGACloseFramebuffer)(dpy, screen); } } XCloseDisplay(dpy); } } return(available); }
QByteArray UINVControl::GetNVEDID(Display *XDisplay, int Screen) { if (!NVControlAvailable(XDisplay)) return QByteArray(); QMutexLocker locker(gNVCtrlLock); QByteArray result; if (!XNVCTRLIsNvScreen(XDisplay, Screen)) { LOG(VB_GENERAL, LOG_ERR, QString("NV-CONTROL is not available on screen %1 of display '%2'") .arg(Screen).arg(XDisplayName(NULL))); return result; } int displays = 0; Bool ok = XNVCTRLQueryAttribute(XDisplay, Screen, 0, NV_CTRL_CONNECTED_DISPLAYS, &displays); if (ok != True) { LOG(VB_GENERAL, LOG_ERR, "Failed to retrieve display list"); return result; } int displaycount = ListDisplays(displays); if (displaycount != 1) { LOG(VB_GENERAL, LOG_WARNING, "There is more than one physical display attached to this screen. Ignoring EDID"); return result; } int edid = NV_CTRL_EDID_AVAILABLE_FALSE; ok = XNVCTRLQueryAttribute(XDisplay, Screen, displays, NV_CTRL_EDID_AVAILABLE, &edid); if (ok != True) { LOG(VB_GENERAL, LOG_INFO, "Failed to check EDID_AVAILABLE attribute"); return result; } if (edid != NV_CTRL_EDID_AVAILABLE_TRUE) { LOG(VB_GENERAL, LOG_INFO, "EDID not available"); return result; } unsigned char* data = NULL; int datalength = 0; ok = XNVCTRLQueryBinaryData(XDisplay, Screen, displays, NV_CTRL_BINARY_DATA_EDID, &data, &datalength); if (ok != True) { LOG(VB_GENERAL, LOG_INFO, QString("EDID not available on screen %1 of display '%2'") .arg(Screen).arg(XDisplayName(NULL))); return result; } result = QByteArray((const char*)data, datalength); delete data; return result; }
static SDL_bool have_mitshm(void) { /* Only use shared memory on local X servers */ if ( (SDL_strncmp(XDisplayName(NULL), ":", 1) == 0) || (SDL_strncmp(XDisplayName(NULL), "unix:", 5) == 0) ) { return SDL_X11_HAVE_SHM; } return SDL_FALSE; }
Display *xwin_init(const char *display_name, const char *prgname, const char *classname, int argc, char **argv, int *pscreen, unsigned int *pw, unsigned int *ph) { XWindowAttributes xwa; /* FILE *f; f = fopen("bee.raw", "rb"); fread(leftarrow_bits, 1, 32, f); fclose(f); f = fopen("beemask.raw", "rb"); fread(rightarrow_bits, 1, 32, f); fclose(f); frickelfix(leftarrow_bits); frickelfix(rightarrow_bits); */ if ((_wndh_gl.display = XOpenDisplay(display_name)) == NULL) { fprintf(stderr, "failed to connect to X server %s\n", XDisplayName(display_name)); exit (EXIT_FAILURE); } XSynchronize(_wndh_gl.display, True); _wndh_gl.default_screen = DefaultScreen(_wndh_gl.display); _wndh_gl.width = DisplayWidth(_wndh_gl.display, _wndh_gl.default_screen); _wndh_gl.height = DisplayHeight(_wndh_gl.display, _wndh_gl.default_screen); _wndh_gl.black = BlackPixel(_wndh_gl.display, _wndh_gl.default_screen); _wndh_gl.white = WhitePixel(_wndh_gl.display, _wndh_gl.default_screen); _wndh_gl.root_window = RootWindow(_wndh_gl.display, _wndh_gl.default_screen); XGetWindowAttributes(_wndh_gl.display, _wndh_gl.root_window, &xwa); _wndh_gl.depth = xwa.depth; _wndh_gl.uparr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window, uparrow_bits, uparrow_width, uparrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth); _wndh_gl.dnarr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window, downarrow_bits, downarrow_width, downarrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth); _wndh_gl.lfarr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window, leftarrow_bits, leftarrow_width, leftarrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth); _wndh_gl.rtarr_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window, rightarrow_bits, rightarrow_width, rightarrow_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth); _wndh_gl.sizer_pix = XCreatePixmapFromBitmapData(_wndh_gl.display, _wndh_gl.root_window, sizer_bits, sizer_width, sizer_height, _wndh_gl.black, _wndh_gl.white, _wndh_gl.depth); _wndh_gl.wm_del_atom = XInternAtom(_wndh_gl.display, "WM_DELETE_WINDOW", True); strncpy(_wndh_gl.prgname, prgname, WH_MAX_NAMELENGTH); strncpy(_wndh_gl.classname, classname, WH_MAX_NAMELENGTH); _wndh_gl.argc = argc; _wndh_gl.argv = argv; *pscreen = _wndh_gl.default_screen; *pw = _wndh_gl.width; *ph = _wndh_gl.height; #ifdef DEBUG printf("connected to X server %s\n", XDisplayName(display_name)); #endif return (_wndh_gl.display); }
int main(void) { Display *dpy; Window root; size_t i, x, ret, len; if (!(dpy = XOpenDisplay(NULL))) die("Couldn't open display '%s'\n", XDisplayName(NULL)); root = DefaultRootWindow(dpy); len = sizeof(sfuncs) / sizeof(sfuncs[0]); for (;;) { memset(ststr, '\0', STATUSSZ); for (i = 0, x = 0; i < len; i++, x += ret) ret = (*sfuncs[i])(&(ststr[x]), STATUSSZ - x); XStoreName(dpy, root, ststr); XSync(dpy, False); sleep(delay); } XCloseDisplay(dpy); return 0; }
/****************************************************************************** StartMeUp - Do X initialization things ******************************************************************************/ void StartMeUp() { if (!(dpy = XOpenDisplay(""))) { fprintf(stderr,"%s: can't open display %s", Module, XDisplayName("")); exit (1); } x_fd = XConnectionNumber(dpy); screen= DefaultScreen(dpy); Root = RootWindow(dpy, screen); d_depth = DefaultDepth(dpy, screen); ScreenHeight = DisplayHeight(dpy,screen); ScreenWidth = DisplayWidth(dpy,screen); if ((ButtonFont=XLoadQueryFont(dpy,font_string))==NULL) { if ((ButtonFont=XLoadQueryFont(dpy,"fixed"))==NULL) exit(1); } fontheight = ButtonFont->ascent+ButtonFont->descent; win_width=XTextWidth(ButtonFont,"XXXXXXXXXXXXXXX",10); }
int main(int argc, char **argv) { Display *d; struct timespec interval; interval.tv_sec = 0; interval.tv_nsec = 100000000; if(!(d = XOpenDisplay(NULL))) { fprintf(stderr, "\"%s\" can't open.\n", XDisplayName(NULL)); exit(EXIT_FAILURE); } int ignore; if(!(XQueryExtension(d, "XTEST", &ignore, &ignore, &ignore))) { fprintf(stderr, "\"XTEST\" extension disabled.\n"); exit(EXIT_FAILURE); } while(1){ XTestFakeButtonEvent(d, RMB, True, 0); XTestFakeButtonEvent(d, RMB, False, 0); nanosleep(&interval, NULL); XSync(d, False); } XCloseDisplay(d); exit(EXIT_SUCCESS); }
void init(void) { load("libEGL.so.1"); display = XOpenDisplay(NULL); if (!display) { std::cerr << "error: unable to open display " << XDisplayName(NULL) << "\n"; exit(1); } screen = DefaultScreen(display); eglDisplay = eglGetDisplay((EGLNativeDisplayType)display); if (eglDisplay == EGL_NO_DISPLAY) { std::cerr << "error: unable to get EGL display\n"; XCloseDisplay(display); exit(1); } EGLint major, minor; if (!eglInitialize(eglDisplay, &major, &minor)) { std::cerr << "error: unable to initialize EGL display\n"; XCloseDisplay(display); exit(1); } }
int main(int argc, char **argv) { Display *dpy; Atom *atom; int i,natoms; /* connect to X server */ if ((dpy=XOpenDisplay(NULL))==NULL) { fprintf(stderr,"Cannot connect to display %s\n", XDisplayName(NULL)); exit(-1); } /* list properties of root window */ atom = XListProperties(dpy,DefaultRootWindow(dpy),&natoms); printf("Number of properties = %d\n",natoms); for (i=0; i<natoms; i++) printf("property[%d] = %s\n",i,XGetAtomName(dpy,atom[i])); /* close connection to X server */ XCloseDisplay(dpy); return EXIT_SUCCESS; }
static int x11IOErrorHandler(Display *dpy) { const char * dpyName = XDisplayName(NULL); const char * errnoStr = strerror(errno); char threadName[80]; int shallBeDetached = 0; JNIEnv *jniEnv = NativewindowCommon_GetJNIEnv(jvmHandle, jvmVersion, &shallBeDetached); (void) NativewindowCommon_GetStaticStringMethod(jniEnv, X11UtilClazz, getCurrentThreadNameID, threadName, sizeof(threadName), "n/a"); fprintf(stderr, "Nativewindow X11 IOError (Thread %s): Display %p (%s): %s\n", threadName, dpy, dpyName, errnoStr); (*jniEnv)->CallStaticVoidMethod(jniEnv, X11UtilClazz, dumpStackID); if (NULL != jniEnv) { NativewindowCommon_FatalError(jniEnv, "Nativewindow X11 IOError (Thread %s): Display %p (%s): %s", threadName, dpy, dpyName, errnoStr); if (shallBeDetached) { (*jvmHandle)->DetachCurrentThread(jvmHandle); } } if(NULL!=origIOErrorHandler) { origIOErrorHandler(dpy); } return 0; }
static Display *disp(void) { if(!disp_var) { disp_var = XOpenDisplay(0); if(!disp_var) errx(1, "cannot open X display %s", XDisplayName(0)); } return(disp_var); }
int pg_win_rename(char *name) { int screen, pgwinids[N_PGWINS], npgwins; char *display_name=NULL; Window pgwins[N_PGWINS]; /* Connect to X server */ if ((dpy = XOpenDisplay(display_name)) == NULL ) { nferrormsg("cpgwinrename(): Couldn't connect to X server %s!", XDisplayName(display_name)); return 0; } screen = DefaultScreen(dpy); npgwins = 0; if (!pg_get_wins(RootWindow(dpy, screen), pgwins, pgwinids, &npgwins)) { nferrormsg("cpgwinrename(): Couldn't get PGPLOT window IDs!"); return 0; } else if (npgwins > N_PGWINS) { nferrormsg("cpgwinrename(): Too many PGPLOT windows!"); return 0; } /* Rename */ if (npgwins) XStoreName(dpy, pgwins[idxival(pgwinids, npgwins, ijmax(pgwinids, npgwins))], name); /* Disconnect from X server */ XCloseDisplay(dpy); return 1; }
void aX_open_second_disp(char *display_name, aX_default_resources *defres) { char *disp_res; XrmDatabase serverDB; if((defres->disp = XOpenDisplay(display_name)) == NULL) { fprintf(stderr, "%s: aX_open_second_disp: cannot connect to X server %s\n", prog_name, XDisplayName(display_name)); exit(-1); } disp_res = XResourceManagerString(defres->disp); if(disp_res) serverDB = XrmGetStringDatabase(disp_res); else serverDB = NULL; XrmMergeDatabases(serverDB, &rDB); get_def_res(defres); add_disp(defres); }
int x11_shadow_subsystem_base_init(x11ShadowSubsystem* subsystem) { if (subsystem->display) return 1; /* initialize once */ if (!getenv("DISPLAY")) setenv("DISPLAY", ":0", 1); if (!XInitThreads()) return -1; subsystem->display = XOpenDisplay(NULL); if (!subsystem->display) { WLog_ERR(TAG, "failed to open display: %s", XDisplayName(NULL)); return -1; } subsystem->xfds = ConnectionNumber(subsystem->display); subsystem->number = DefaultScreen(subsystem->display); subsystem->screen = ScreenOfDisplay(subsystem->display, subsystem->number); subsystem->depth = DefaultDepthOfScreen(subsystem->screen); subsystem->width = WidthOfScreen(subsystem->screen); subsystem->height = HeightOfScreen(subsystem->screen); subsystem->root_window = RootWindow(subsystem->display, subsystem->number); return 1; }
void init_key(void) { if(!(dpy = XOpenDisplay(NULL))) { fprintf(stderr, "error: can not open display %s", XDisplayName(NULL)); exit(1); } screen = DefaultScreen(dpy); root = RootWindow(dpy, screen); opt_key = conf_get_key(); modmask = conf_get_mod(); int i, j; XModifierKeymap *modmap = XGetModifierMapping(dpy); for(i = 0; i < 8; i++) { for(j = 0; j < modmap->max_keypermod; j++) { if(modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock)) numlockmask = (1 << i); } } XFreeModifiermap(modmap); }
int main(){ Display *display_name; int depth,screen,connection; /*Opening display and setting defaults*/ display_name = XOpenDisplay(NULL); screen = DefaultScreen(display_name); depth = DefaultDepth(display_name,screen); connection = ConnectionNumber(display_name); /*Displaying the info gathered*/ printf("The display is::%s\n",XDisplayName((char*)display_name)); printf("Width::%d\tHeight::%d\n", DisplayWidth(display_name,screen), DisplayHeight(display_name,screen)); printf("Connection number is %d\n",connection); if(depth == 1) printf("You live in prehistoric times\n"); else printf("You've got a coloured monitor with depth of %d\n", depth); /*Closing the display*/ XCloseDisplay(display_name); }
/* * Pøipojit k serveru, zjistit o nìm informace */ static void open_display(void) { display_name = XDisplayName(NULL); if(!(display = XOpenDisplay(display_name))) { fprintf(stderr, "Cannot connect to X server \"%s\"\n", display_name); exit(1); } debug("Connected to X server \"%s\"\n", display_name); screen_num = DefaultScreen(display); screen = DefaultScreenOfDisplay(display); debug("Default screen number is %d\n", screen_num); screen_width = DisplayWidth(display, screen_num); screen_height = DisplayHeight(display, screen_num); screen_width_mm = DisplayWidthMM(display, screen_num); screen_height_mm = DisplayHeightMM(display, screen_num); debug("Screen size is %ux%u pixels, %ux%u mm\n", screen_width, screen_height, screen_width_mm, screen_height_mm); root = RootWindow(display, screen_num); black = BlackPixel(display, screen_num); white = WhitePixel(display, screen_num); debug("Root window ID is %#lx, black is %#lx, white is %#lx\n", root, black, white); def_gc = DefaultGC(display, screen_num); if(!(def_font = XQueryFont(display, XGContextFromGC(def_gc)))) { fprintf(stderr, "XQueryFont() failed\n"); exit(1); } }
/* * Pøipojit k serveru, zjistit o nìm informace */ static void open_display(void) { display_name = XDisplayName(NULL); if(!(display = XOpenDisplay(display_name))) { fprintf(stderr, "Cannot connect to X server \"%s\"\n", display_name); exit(1); } debug("Connected to X server \"%s\"\n", display_name); screen_num = DefaultScreen(display); screen = DefaultScreenOfDisplay(display); debug("Default screen number is %d\n", screen_num); screen_width = DisplayWidth(display, screen_num); screen_height = DisplayHeight(display, screen_num); screen_width_mm = DisplayWidthMM(display, screen_num); screen_height_mm = DisplayHeightMM(display, screen_num); debug("Screen size is %ux%u pixels, %ux%u mm\n", screen_width, screen_height, screen_width_mm, screen_height_mm); root = RootWindow(display, screen_num); black = BlackPixel(display, screen_num); white = WhitePixel(display, screen_num); debug("Root window ID is %#lx, black is %#lx, white is %#lx\n", root, black, white); def_gc = DefaultGC(display, screen_num); /* Toto volání XQueryFont() do def_font->fid neulo¾í ID fontu, ale * grafického kontextu! Nevím, jak získat ID nebo jméno standardního * fontu. */ if(!(def_font = XQueryFont(display, XGContextFromGC(def_gc)))) { fprintf(stderr, "XQueryFont() failed\n"); exit(1); } }
void setup_environ(int scr) { char *tmp, *ptr; char *display; int tmp_len; display=XDisplayName(wglobal.display); tmp_len = strlen(display)+16; tmp=ALLOC_N(char, tmp_len); if(tmp==NULL){ warn_err(); return; } snprintf(tmp, tmp_len, "DISPLAY=%s", display); ptr=strchr(tmp, ':'); if(ptr!=NULL){ ptr=strchr(ptr, '.'); if(ptr!=NULL) *ptr='\0'; } if(scr>=0){ int curr_len=strlen(tmp); snprintf(tmp+curr_len, tmp_len-curr_len, ".%i", scr); } putenv(tmp); /*XFree(display);*/ }
void open_display(char *display_name) { if ((display = XOpenDisplay(display_name)) == NULL) { fprintf(stderr, "%s: Can't open display '%s'\n", cmnd, XDisplayName(display_name)); exit(2); } }
void fl_open_display() { fl_display = XOpenDisplay(dname); if (!fl_display) { fprintf(stderr,"Can't open display: %s\n",XDisplayName(dname)); exit(1); } fl_screen = DefaultScreen(fl_display); }
void meta_ui_init (int *argc, char ***argv) { if (!gtk_init_check (argc, argv)) meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL)); meta_stock_icons_init (); }
boolean xf_pre_connect(freerdp* instance) { xfInfo* xfi; rdpSettings* settings; xfi = (xfInfo*) xzalloc(sizeof(xfInfo)); SET_XFI(instance, xfi); xfi->instance = instance; settings = instance->settings; settings->order_support[NEG_DSTBLT_INDEX] = True; settings->order_support[NEG_PATBLT_INDEX] = True; settings->order_support[NEG_SCRBLT_INDEX] = True; settings->order_support[NEG_OPAQUE_RECT_INDEX] = True; settings->order_support[NEG_DRAWNINEGRID_INDEX] = False; settings->order_support[NEG_MULTIDSTBLT_INDEX] = False; settings->order_support[NEG_MULTIPATBLT_INDEX] = False; settings->order_support[NEG_MULTISCRBLT_INDEX] = False; settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = True; settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = False; settings->order_support[NEG_LINETO_INDEX] = True; settings->order_support[NEG_POLYLINE_INDEX] = True; settings->order_support[NEG_MEMBLT_INDEX] = True; settings->order_support[NEG_MEM3BLT_INDEX] = False; settings->order_support[NEG_SAVEBITMAP_INDEX] = True; settings->order_support[NEG_GLYPH_INDEX_INDEX] = True; settings->order_support[NEG_FAST_INDEX_INDEX] = True; settings->order_support[NEG_FAST_GLYPH_INDEX] = True; settings->order_support[NEG_POLYGON_SC_INDEX] = False; settings->order_support[NEG_POLYGON_CB_INDEX] = False; settings->order_support[NEG_ELLIPSE_SC_INDEX] = False; settings->order_support[NEG_ELLIPSE_CB_INDEX] = False; freerdp_chanman_pre_connect(GET_CHANMAN(instance), instance); xfi->display = XOpenDisplay(NULL); if (xfi->display == NULL) { printf("xf_pre_connect: failed to open display: %s\n", XDisplayName(NULL)); return False; } xf_kbd_init(xfi); xfi->xfds = ConnectionNumber(xfi->display); xfi->screen_number = DefaultScreen(xfi->display); xfi->screen = ScreenOfDisplay(xfi->display, xfi->screen_number); xfi->depth = DefaultDepthOfScreen(xfi->screen); xfi->big_endian = (ImageByteOrder(xfi->display) == MSBFirst); xfi->decoration = True; xfi->mouse_motion = True; return True; }
// ###################################################################### AutomateXWin::AutomateXWin(const char* win_name) : itsDisplay(NULL), itsScreen(0), itsImage(NULL), itsWidth(0), itsHeight(0), itsDepth(0) { char *dispName = XDisplayName(NULL); unsigned num_tries; int event_base, error_base; int major_version, minor_version; itsDisplay = XOpenDisplay(dispName); if(!itsDisplay) LFATAL("XOpenDisplay(%s) failed\n", dispName); if (!XTestQueryExtension (itsDisplay, &event_base, &error_base, &major_version, &minor_version)) { XCloseDisplay(itsDisplay); LFATAL("XTest extension not supported on server"); } LINFO("XTestQueryExtension passed."); LINFO("XTest information for server \"%s\":", DisplayString(itsDisplay)); LINFO(" Major version: %d", major_version); LINFO(" Minor version: %d", minor_version); LINFO(" First event number: %d", event_base); LINFO(" First error number: %d", error_base); itsScreen = DefaultScreen(itsDisplay); itsRootWin = RootWindow(itsDisplay, itsScreen); for(num_tries=0;;) { itsWindow = XWindowByName(itsDisplay, itsRootWin, win_name); if(itsWindow) break; if(++num_tries == 100) LFATAL("XWindowByName\n"); usleep(20000); } XFlush(itsDisplay); XSync(itsDisplay, False); #ifdef USE_SHM if(!XShmQueryExtension(itsDisplay)) LFATAL("XShmQueryExtension"); #endif GetWindowGeometry(); if(!XMatchVisualInfo(itsDisplay, itsScreen, itsDepth, DirectColor, &itsVInfo)) { return; } }
bool createGLXContextAndWindow(glx_state_t *state, const device_config_t& device_config) { int rgba_attribs[] = { GLX_RGBA , GLX_RED_SIZE , 1, GLX_GREEN_SIZE , 1, GLX_BLUE_SIZE , 1, GLX_ALPHA_SIZE , 1, //GLX_STENCIL_SIZE , 8, //GLX_DOUBLEBUFFER , True, None }; XVisualInfo *visinfo; XSetWindowAttributes attrs; state->dpy = XOpenDisplay (NULL); if (!state->dpy) { warnx ("Failed to open display: %s\n", XDisplayName (0)); return false; } visinfo = glXChooseVisual (state->dpy, DefaultScreen (state->dpy), rgba_attribs); if (visinfo == NULL) { warnx ("Failed to create RGBA and double-buffered visuals\n"); XCloseDisplay (state->dpy); return NULL; } attrs.colormap = XCreateColormap (state->dpy, RootWindow (state->dpy, visinfo->screen), visinfo->visual, AllocNone); attrs.border_pixel = 0; state->window = XCreateWindow (state->dpy, DefaultRootWindow (state->dpy), 0, 0, device_config.width, device_config.height, 0, // border width visinfo->depth, InputOutput, visinfo->visual, CWBorderPixel | CWColormap | CWEventMask, &attrs); state->width = device_config.width; state->height = device_config.height; XMapWindow (state->dpy, state->window); //state->gc = XCreateGC(state->dpy, state->window, 0, NULL); state->glx_context = glXCreateContext (state->dpy, visinfo, NULL, True); XFree (visinfo); if (state->glx_context == NULL) { warnx ("Could not create glx context\n"); XCloseDisplay (state->dpy); return false; } return true; }
static int x11IOErrorHandler(Display *dpy) { fprintf(stderr, "Nativewindow X11 IOError: Display %p (%s): %s\n", dpy, XDisplayName(NULL), strerror(errno)); // _FatalError(x11ErrorHandlerJNIEnv, "Nativewindow X11 IOError: Display %p (%s): %s", dpy, XDisplayName(NULL), strerror(errno)); if(NULL!=origIOErrorHandler) { origIOErrorHandler(dpy); } return 0; }
static cairo_surface_t * _cairo_boilerplate_xlib_render_0_0_create_surface (const char *name, cairo_content_t content, double width, double height, double max_width, double max_height, cairo_boilerplate_mode_t mode, void **closure) { xlib_target_closure_t *xtc; Display *dpy; int screen; Pixmap pixmap; cairo_surface_t *surface, *dummy; *closure = xtc = xcalloc (1, sizeof (xlib_target_closure_t)); width = ceil (width); if (width < 1) width = 1; height = ceil (height); if (height < 1) height = 1; xtc->dpy = dpy = XOpenDisplay (NULL); if (xtc->dpy == NULL) { free (xtc); CAIRO_BOILERPLATE_DEBUG (("Failed to open display: %s\n", XDisplayName(0))); return NULL; } screen = DefaultScreen (dpy); pixmap = XCreatePixmap (dpy, DefaultRootWindow (dpy), 1, 1, DefaultDepth (dpy, screen)); dummy = cairo_xlib_surface_create (dpy, pixmap, DefaultVisual (dpy, screen), 1, 1); cairo_xlib_device_debug_cap_xrender_version (cairo_surface_get_device (dummy), 0, 0); if (mode == CAIRO_BOILERPLATE_MODE_TEST) surface = _cairo_boilerplate_xlib_test_create_surface (dpy, content, width, height, xtc); else /* mode == CAIRO_BOILERPLATE_MODE_PERF */ surface = _cairo_boilerplate_xlib_perf_create_surface (dpy, content, width, height, xtc); cairo_surface_destroy (dummy); XFreePixmap (dpy, pixmap); if (surface == NULL || cairo_surface_status (surface)) _cairo_boilerplate_xlib_cleanup (xtc); return surface; }
void initXWin(int argc, char **argv) { int pos; XWMHints wmhints; XSizeHints shints; winsize=astep ? ASTEPSIZE : NORMSIZE; if((d_display=XOpenDisplay(display))==NULL) { fprintf(stderr,"%s : Unable to open X display '%s'.\n", NAME, XDisplayName(display)); exit(1); } _XA_GNUSTEP_WM_FUNC=XInternAtom(d_display, "_GNUSTEP_WM_FUNCTION", 0); deleteWin=XInternAtom(d_display, "WM_DELETE_WINDOW", 0); w_root=DefaultRootWindow(d_display); shints.x=0; shints.y=0; shints.flags=0; pos=(XWMGeometry(d_display, DefaultScreen(d_display), position, NULL, 0, &shints, &shints.x, &shints.y, &shints.width, &shints.height, &shints.win_gravity) & (XValue | YValue)); shints.min_width=winsize; shints.min_height=winsize; shints.max_width=winsize; shints.max_height=winsize; shints.base_width=winsize; shints.base_height=winsize; shints.flags=PMinSize | PMaxSize | PBaseSize; createWin(&w_main, shints.x, shints.y); if(wmaker || astep || pos) shints.flags |= USPosition; if(wmaker) { wmhints.initial_state=WithdrawnState; wmhints.flags=WindowGroupHint | StateHint | IconWindowHint; createWin(&w_icon, shints.x, shints.y); w_activewin=w_icon; wmhints.icon_window=w_icon; } else { wmhints.initial_state=NormalState; wmhints.flags=WindowGroupHint | StateHint; w_activewin=w_main; } wmhints.window_group=w_main; XSetWMHints(d_display, w_main, &wmhints); XSetWMNormalHints(d_display, w_main, &shints); XSetCommand(d_display, w_main, argv, argc); XStoreName(d_display, w_main, NAME); XSetIconName(d_display, w_main, NAME); XSetWMProtocols(d_display, w_activewin, &deleteWin, 1); }
void _refresh( tWindow* p){ Display *d; Window w; cairo_surface_t *ps; cairo_t *cr; float margx, margy, x1, x2, x3, x4, y1, y2, y3, y4; if (!p->valid) return; /* might be good for windoze */ if (vb) printf("window _refresh:%p\n",(void*)p); mutex_lock(&p->mutex); if (vb) printf("window _refresh got lock\n"); d = p->display; w = p->window; /* and blit to X */ ps = cairo_xlib_surface_create(d, w, DefaultVisual(d,DefaultScreen(d)), p->width, p->height); if (ps==NULL){ fprintf(stderr, "%s: can't open cairo xlib surface\n",XDisplayName(NULL)); exit(1); } cr = cairo_create(ps); /* centred blit */ margx = (p->width - p->surf_width)/2; margy = (p->height - p->surf_height)/2; x1=0; x2=margx; x3=p->width-margx; x4=p->width; y1=0; y2=margy; y3=p->height-margy; y4=p->height; cairo_set_source_rgba(cr,0.5,0.5,0.6,1.0); cairo_rectangle(cr, x1,y1,x2,y4); /* left */ cairo_rectangle(cr, x3,y1,x4,y4); /* right */ cairo_rectangle(cr, x2,y1,x3,y2); /* middle upper */ cairo_rectangle(cr, x2,y3,x3,y4); /* middle lower */ cairo_fill(cr); /* doesn't like translate of 0.5 here.. */ if (vb) printf("marge:%g,%g\n",margx,margy); cairo_translate(cr,(int)margx,(int)margy); cairo_set_source_surface(cr,p->surf,0,0); cairo_paint(cr); cairo_destroy(cr); cairo_surface_flush(ps); cairo_surface_flush(p->surf); cairo_surface_destroy(ps); XFlush(p->display); /* was XSync(p->display,True) */ mutex_unlock(&p->mutex); }