/* * 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); } }
NS_CC_BEGIN int CCDevice::getDPI() { static int dpi = -1; if (dpi == -1) { Display *dpy; char *displayname = NULL; int scr = 0; /* Screen number */ dpy = XOpenDisplay (displayname); /* * there are 2.54 centimeters to an inch; so there are 25.4 millimeters. * * dpi = N pixels / (M millimeters / (25.4 millimeters / 1 inch)) * = N pixels / (M inch / 25.4) * = N * 25.4 pixels / M inch */ double xres = ((((double) DisplayWidth(dpy,scr)) * 25.4) / ((double) DisplayWidthMM(dpy,scr))); dpi = (int) (xres + 0.5); //printf("dpi = %d\n", dpi); } return dpi; }
/* * 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); } }
float X11Display::queryPPMM() { ::Display * pDisplay = XOpenDisplay(0); float ppmm = getScreenResolution().x/float(DisplayWidthMM(pDisplay, 0)); XCloseDisplay(pDisplay); return ppmm; }
static float calcDisplayDensity() { const char* current_display = getenv("DISPLAY"); if (current_display != NULL) { Display * x11display = XOpenDisplay(current_display); if (x11display != NULL) { /* try x direct */ float dpi_height = floor(DisplayHeight(x11display, 0) / (DisplayHeightMM(x11display, 0) * 0.039370) + 0.5); float dpi_width = floor(DisplayWidth(x11display, 0) / (DisplayWidthMM(x11display, 0) * 0.039370) +0.5); XCloseDisplay(x11display); return std::max(dpi_height,dpi_width) / 96.0; } } /* return manually specified dpi */ return g_settings->getFloat("screen_dpi")/96.0; }
void cdGetScreenSize(int *width, int *height, double *width_mm, double *height_mm) { static int first = 1; static int dpy_width, dpy_height, dpy_width_mm, dpy_height_mm; if (first) { Display* drv_display = XOpenDisplay(NULL); int drv_screen = DefaultScreen (drv_display); dpy_width = DisplayWidth(drv_display,drv_screen); dpy_height = DisplayHeight(drv_display,drv_screen); dpy_width_mm = DisplayWidthMM(drv_display,drv_screen); dpy_height_mm = DisplayHeightMM(drv_display,drv_screen); XCloseDisplay(drv_display); first = 0; } if (width) *width = dpy_width; if (height) *height = dpy_height; if (width_mm) *width_mm = dpy_width_mm; if (height_mm) *height_mm = dpy_height_mm; }
bool x11_get_metrics(void *data, enum display_metric_types type, float *value) { unsigned screen_no = 0; Display *dpy = (Display*)XOpenDisplay(NULL); int pixels_x = DisplayWidth(dpy, screen_no); int pixels_y = DisplayHeight(dpy, screen_no); int physical_width = DisplayWidthMM(dpy, screen_no); int physical_height = DisplayHeightMM(dpy, screen_no); (void)pixels_y; XCloseDisplay(dpy); switch (type) { case DISPLAY_METRIC_MM_WIDTH: *value = (float)physical_width; break; case DISPLAY_METRIC_MM_HEIGHT: *value = (float)physical_height; break; case DISPLAY_METRIC_DPI: *value = ((((float)pixels_x) * 25.4) / ((float)physical_width)); break; case DISPLAY_METRIC_NONE: default: *value = 0; return false; } return true; }
XRRConfiguration::XRRConfiguration(Display *_dpy, Window _win) : dpy(_dpy) , win(_win) , screenResources(nullptr), outputInfo(nullptr), crtcInfo(nullptr) , fullMode(0) , fs_fb_width(0), fs_fb_height(0), fs_fb_width_mm(0), fs_fb_height_mm(0) , bValid(true), bIsFullscreen(false) { int XRRMajorVersion, XRRMinorVersion; if (!XRRQueryVersion(dpy, &XRRMajorVersion, &XRRMinorVersion) || (XRRMajorVersion < 1 || (XRRMajorVersion == 1 && XRRMinorVersion < 3))) { WARN_LOG(VIDEO, "XRRExtension not supported."); bValid = false; return; } screenResources = XRRGetScreenResourcesCurrent(dpy, win); screen = DefaultScreen(dpy); fb_width = DisplayWidth(dpy, screen); fb_height = DisplayHeight(dpy, screen); fb_width_mm = DisplayWidthMM(dpy, screen); fb_height_mm = DisplayHeightMM(dpy, screen); INFO_LOG(VIDEO, "XRRExtension-Version %d.%d", XRRMajorVersion, XRRMinorVersion); Update(); }
QSize MythXDisplay::GetDisplayDimensions(void) { MythXLocker locker(this); int displayWidthMM = DisplayWidthMM( m_disp, m_screen_num); int displayHeightMM = DisplayHeightMM(m_disp, m_screen_num); return QSize(displayWidthMM, displayHeightMM); }
// Retrieve system content scale via folklore heuristics // static void getSystemContentScale(float* xscale, float* yscale) { // NOTE: Fall back to the display-wide DPI instead of RandR monitor DPI if // Xft.dpi retrieval below fails as we don't currently have an exact // policy for which monitor a window is considered to "be on" float xdpi = DisplayWidth(_glfw.x11.display, _glfw.x11.screen) * 25.4f / DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen); float ydpi = DisplayHeight(_glfw.x11.display, _glfw.x11.screen) * 25.4f / DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen); // NOTE: Basing the scale on Xft.dpi where available should provide the most // consistent user experience (matches Qt, Gtk, etc), although not // always the most accurate one char* rms = XResourceManagerString(_glfw.x11.display); if (rms) { XrmDatabase db = XrmGetStringDatabase(rms); if (db) { XrmValue value; char* type = NULL; if (XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value)) { if (type && strcmp(type, "String") == 0) xdpi = ydpi = atof(value.addr); } XrmDestroyDatabase(db); } } *xscale = xdpi / 96.f; *yscale = ydpi / 96.f; }
void wxDisplaySizeMM(int *width, int *height) { Display *dpy = (Display*) wxGetDisplay(); if ( width ) *width = DisplayWidthMM(dpy, DefaultScreen (dpy)); if ( height ) *height = DisplayHeightMM(dpy, DefaultScreen (dpy)); }
static void gst_vaapi_display_x11_get_size_mm( GstVaapiDisplay *display, guint *pwidth, guint *pheight ) { GstVaapiDisplayX11Private * const priv = GST_VAAPI_DISPLAY_X11(display)->priv; guint width_mm, height_mm; if (!priv->x11_display) return; width_mm = DisplayWidthMM(priv->x11_display, priv->x11_screen); height_mm = DisplayHeightMM(priv->x11_display, priv->x11_screen); #ifdef HAVE_XRANDR /* XXX: fix up physical size if the display is rotated */ if (priv->use_xrandr) { XRRScreenConfiguration *xrr_config = NULL; XRRScreenSize *xrr_sizes; Window win; int num_xrr_sizes, size_id, screen; Rotation rotation; do { win = DefaultRootWindow(priv->x11_display); screen = XRRRootToScreen(priv->x11_display, win); xrr_config = XRRGetScreenInfo(priv->x11_display, win); if (!xrr_config) break; size_id = XRRConfigCurrentConfiguration(xrr_config, &rotation); if (rotation == RR_Rotate_0 || rotation == RR_Rotate_180) break; xrr_sizes = XRRSizes(priv->x11_display, screen, &num_xrr_sizes); if (!xrr_sizes || size_id >= num_xrr_sizes) break; width_mm = xrr_sizes[size_id].mheight; height_mm = xrr_sizes[size_id].mwidth; } while (0); if (xrr_config) XRRFreeScreenConfigInfo(xrr_config); } #endif if (pwidth) *pwidth = width_mm; if (pheight) *pheight = height_mm; }
/* * StripMisc_init * * Initializes global constants. */ void StripMisc_init (Display *display, int screen) { horizontal_pixels_per_mm = ((float)DisplayWidth(display, screen) / (float)DisplayWidthMM(display, screen)); vertical_pixels_per_mm = ((float)DisplayHeight(display, screen) / (float)DisplayHeightMM(display, screen)); }
int x11_init(GraceApp *gapp) { X11Stuff *xstuff = gapp->gui->xstuff; XGCValues gc_val; long mrsize; int max_path_limit; xstuff->screennumber = DefaultScreen(xstuff->disp); xstuff->root = RootWindow(xstuff->disp, xstuff->screennumber); xstuff->gc = DefaultGC(xstuff->disp, xstuff->screennumber); xstuff->depth = DisplayPlanes(xstuff->disp, xstuff->screennumber); /* init colormap */ xstuff->cmap = DefaultColormap(xstuff->disp, xstuff->screennumber); /* redefine colormap, if needed */ if (gapp->gui->install_cmap == CMAP_INSTALL_ALWAYS) { xstuff->cmap = XCopyColormapAndFree(xstuff->disp, xstuff->cmap); gapp->gui->private_cmap = TRUE; } /* set GCs */ if (gapp->gui->invert) { gc_val.function = GXinvert; } else { gc_val.function = GXxor; } gcxor = XCreateGC(xstuff->disp, xstuff->root, GCFunction, &gc_val); /* XExtendedMaxRequestSize() appeared in X11R6 */ #if XlibSpecificationRelease > 5 mrsize = XExtendedMaxRequestSize(xstuff->disp); #else mrsize = 0; #endif if (mrsize <= 0) { mrsize = XMaxRequestSize(xstuff->disp); } max_path_limit = (mrsize - 3)/2; if (max_path_limit < get_max_path_limit(grace_get_canvas(gapp->grace))) { char buf[128]; sprintf(buf, "Setting max drawing path length to %d (limited by the X server)", max_path_limit); errmsg(buf); set_max_path_limit(grace_get_canvas(gapp->grace), max_path_limit); } xstuff->dpi = rint(MM_PER_INCH*DisplayWidth(xstuff->disp, xstuff->screennumber)/ DisplayWidthMM(xstuff->disp, xstuff->screennumber)); return RETURN_SUCCESS; }
/* Xlib font utils define */ static XFontStruct *LoadQueryScalableFont (Display * dpy, int screen, char *name, int size) { int i, j, field; char newname[500]; /* big enough for a long font name */ int res_x, res_y; /* resolution values for this screen */ /* catch obvious errors */ if ((name == NULL) || (name[0] != '-')) return NULL; /* calculate our screen resolution in dots per inch. 25.4mm = 1 inch */ res_x = DisplayWidth (dpy, screen) / (DisplayWidthMM (dpy, screen) / 25.4); res_y = DisplayHeight (dpy, screen) / (DisplayHeightMM (dpy, screen) / 25.4); /* copy the font name, changing the scalable fields as we do so */ for (i = j = field = 0; name[i] != '\0' && field <= 14; i++) { newname[j++] = name[i]; if (name[i] == '-') { field++; switch (field) { case 7: /* pixel size */ case 12: /* average width */ /* change from "-0-" to "-*-" */ newname[j] = '*'; j++; if (name[i + 1] != '\0') i++; break; case 8: /* point size */ /* change from "-0-" to "-<size>-" */ sprintf (&newname[j], "%d", size); while (newname[j] != '\0') j++; if (name[i + 1] != '\0') i++; break; case 9: /* x-resolution */ case 10: /* y-resolution */ /* change from an unspecified resolution to res_x or res_y */ sprintf (&newname[j], "%d", (field == 9) ? res_x : res_y); while (newname[j] != '\0') j++; while ((name[i + 1] != '-') && (name[i + 1] != '\0')) i++; break; } } } newname[j] = '\0'; /* if there aren't 14 hyphens, it isn't a well formed name */ if (field != 14) return NULL; return XLoadQueryFont (dpy, newname); }
void processEvents() { while (XPending(x_dpy)) { XEvent ev; XNextEvent(x_dpy, &ev); switch (ev.type) { case KeyPress: case KeyRelease: onKey(ev.xkey.window, ev.xkey.state, ev.xkey.keycode, ev.type == KeyPress ? 1 : 2); break; case ButtonPress: case ButtonRelease: onMouse(ev.xbutton.window, ev.xbutton.x, ev.xbutton.y, ev.xbutton.state, ev.xbutton.button, ev.type == ButtonPress ? 1 : 2); break; case MotionNotify: onMouse(ev.xmotion.window, ev.xmotion.x, ev.xmotion.y, ev.xmotion.state, 0, 0); break; case FocusIn: case FocusOut: onFocus(ev.xmotion.window, ev.type == FocusIn); break; case Expose: // A non-zero Count means that there are more expose events coming. For // example, a non-rectangular exposure (e.g. from a partially overlapped // window) will result in multiple expose events whose dirty rectangles // combine to define the dirty region. Go's paint events do not provide // dirty regions, so we only pass on the final X11 expose event. if (ev.xexpose.count == 0) { onExpose(ev.xexpose.window); } break; case ConfigureNotify: onConfigure(ev.xconfigure.window, ev.xconfigure.x, ev.xconfigure.y, ev.xconfigure.width, ev.xconfigure.height, DisplayWidth(x_dpy, DefaultScreen(x_dpy)), DisplayWidthMM(x_dpy, DefaultScreen(x_dpy))); break; case ClientMessage: if ((ev.xclient.message_type != wm_protocols) || (ev.xclient.format != 32)) { break; } Atom a = ev.xclient.data.l[0]; if (a == wm_delete_window) { onDeleteWindow(ev.xclient.window); } else if (a == wm_take_focus) { XSetInputFocus(x_dpy, ev.xclient.window, RevertToParent, ev.xclient.data.l[1]); } break; } } }
int NvCtrlGetScreenWidthMM(NvCtrlAttributeHandle *handle) { NvCtrlAttributePrivateHandle *h; if (!handle) return -1; h = (NvCtrlAttributePrivateHandle *) handle; if (h->target_type != NV_CTRL_TARGET_TYPE_X_SCREEN) return -1; return DisplayWidthMM(h->dpy, h->target_id); } /* NvCtrlGetScreenWidthMM() */
/* * Class: jogamp_newt_driver_x11_RandR13 * Method: setScreenViewport0 * Signature: (JIJIIII)Z */ JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_RandR13_setScreenViewport0 (JNIEnv *env, jclass clazz, jlong display, jint screen_idx, jlong screenResources, jint x, jint y, jint width, jint height) { Display * dpy = (Display *) (intptr_t) display; Window root = RootWindow(dpy, (int)screen_idx); XRRScreenResources *resources = (XRRScreenResources *) (intptr_t) screenResources; jboolean res = JNI_FALSE; if( NULL == resources ) { // n/a return JNI_FALSE; } XRRSetScreenSize (dpy, root, width, height, DisplayWidthMM(dpy, screen_idx), DisplayHeightMM(dpy, screen_idx)); return JNI_TRUE; }
JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_RandR13_dumpInfo0 (JNIEnv *env, jclass clazz, jlong display, jint screen_idx, jlong screenResources) { Display * dpy = (Display *) (intptr_t) display; Window root = RootWindow(dpy, (int)screen_idx); XRRScreenResources *resources = (XRRScreenResources *) (intptr_t) screenResources; int pos[] = { 0, 0 } ; int i, j, minWidth, minHeight, maxWidth, maxHeight; int vs_width = DisplayWidth(dpy, screen_idx); int vs_height = DisplayHeight(dpy, screen_idx); int vs_width_mm = DisplayWidthMM(dpy, screen_idx); int vs_height_mm = DisplayHeightMM(dpy, screen_idx); fprintf(stderr, "ScreenVirtualSize: %dx%d %dx%d mm\n", vs_width, vs_height, vs_width_mm, vs_height_mm); XRRGetScreenSizeRange (dpy, root, &minWidth, &minHeight, &maxWidth, &maxHeight); fprintf(stderr, "XRRGetScreenSizeRange: %dx%d .. %dx%d\n", minWidth, minHeight, maxWidth, maxHeight); if( NULL == resources ) { fprintf(stderr, "XRRScreenResources NULL\n"); return; } fprintf(stderr, "XRRScreenResources %p: Crtc count %d\n", resources, resources->ncrtc); for(i=0; i<resources->ncrtc; i++) { RRCrtc crtc = resources->crtcs[i]; XRRCrtcInfo *xrrCrtcInfo = XRRGetCrtcInfo (dpy, resources, crtc); fprintf(stderr, "Crtc[%d] %#lx: %d/%d %dx%d, rot 0x%X, mode.id %#lx\n", i, crtc, xrrCrtcInfo->x, xrrCrtcInfo->y, xrrCrtcInfo->width, xrrCrtcInfo->height, xrrCrtcInfo->rotations, xrrCrtcInfo->mode); for(j=0; j<xrrCrtcInfo->noutput; j++) { fprintf(stderr, " Crtc[%d].Output[%d].id %#lx\n", i, j, xrrCrtcInfo->outputs[j]); dumpOutput(" ", dpy, screen_idx, resources, j, xrrCrtcInfo->outputs[j]); } XRRFreeCrtcInfo(xrrCrtcInfo); } dumpOutputs("XRRScreenResources.outputs", dpy, (int)screen_idx, resources, resources->noutput, resources->outputs); fprintf(stderr, "XRRScreenResources %p: Mode count %d\n", resources, resources->nmode); for(i=0; i<resources->nmode; i++) { XRRModeInfo *mode = &resources->modes[i]; unsigned int dots = mode->hTotal * mode->vTotal; float refresh = getVRefresh(mode); fprintf(stderr, "Mode[%d, id %#lx]: %ux%u@%f, name %s\n", i, mode->id, mode->width, mode->height, refresh, SAFE_STRING(mode->name)); } }
static Bool get_screen_sizemm(Display *dpy, int screen_idx, int fb_width, int fb_height, int *fb_width_mm, int *fb_height_mm, int *pre_fb_width, int *pre_fb_height) { *pre_fb_width = DisplayWidth (dpy, screen_idx); *pre_fb_height = DisplayHeight (dpy, screen_idx); Bool fb_change; if (fb_width != *pre_fb_width || fb_height != *pre_fb_height ) { float dpi = (25.4 * *pre_fb_height) / DisplayHeightMM(dpy, screen_idx); *fb_width_mm = (25.4 * fb_width) / dpi; *fb_height_mm = (25.4 * fb_height) / dpi; fb_change = True; } else { *fb_width_mm = DisplayWidthMM (dpy, screen_idx); *fb_height_mm = DisplayHeightMM (dpy, screen_idx); fb_change = False; } return fb_change; }
static void gst_vaapi_display_x11_get_size_mm( GstVaapiDisplay *display, guint *pwidth, guint *pheight ) { GstVaapiDisplayX11Private * const priv = GST_VAAPI_DISPLAY_X11(display)->priv; if (!priv->x11_display) return; if (pwidth) *pwidth = DisplayWidthMM(priv->x11_display, priv->x11_screen); if (pheight) *pheight = DisplayHeightMM(priv->x11_display, priv->x11_screen); }
QXlibScreen::QXlibScreen() : mFormat(QImage::Format_RGB32) #if !defined(QT_NO_OPENGL) && defined(QT_OPENGL_ES_2) , mEGLDisplay(0) #endif { char *display_name = getenv("DISPLAY"); Display *display = XOpenDisplay(display_name); mDisplay = new QXlibDisplay(display); #ifndef DONT_USE_MIT_SHM int MIT_SHM_extension_supported = XShmQueryExtension (mDisplay->nativeDisplay()); Q_ASSERT(MIT_SHM_extension_supported == True); #endif original_x_errhandler = XSetErrorHandler(qt_x_errhandler); if (qgetenv("DO_X_SYNCHRONIZE").toInt()) XSynchronize(mDisplay->nativeDisplay(), true); mScreen = DefaultScreen(mDisplay->nativeDisplay()); XSelectInput(mDisplay->nativeDisplay(),rootWindow(), KeymapStateMask | EnterWindowMask | LeaveWindowMask | PropertyChangeMask); int width = DisplayWidth(mDisplay->nativeDisplay(), mScreen); int height = DisplayHeight(mDisplay->nativeDisplay(), mScreen); mGeometry = QRect(0,0,width,height); int physicalWidth = DisplayWidthMM(mDisplay->nativeDisplay(), mScreen); int physicalHeight = DisplayHeightMM(mDisplay->nativeDisplay(), mScreen); mPhysicalSize = QSize(physicalWidth,physicalHeight); int xSocketNumber = XConnectionNumber(mDisplay->nativeDisplay()); mDepth = DefaultDepth(mDisplay->nativeDisplay(),mScreen); #ifdef MYX11_DEBUG qDebug() << "X socket:"<< xSocketNumber; #endif QSocketNotifier *sock = new QSocketNotifier(xSocketNumber, QSocketNotifier::Read, this); connect(sock, SIGNAL(activated(int)), this, SLOT(eventDispatcher())); mCursor = new QXlibCursor(this); mKeyboard = new QXlibKeyboard(this); }
static void get_dpi(Display *dpy, int screen, int *x, int *y) { double xres, yres; /* * there are 2.54 centimeters to an inch; so there are 25.4 millimeters. * * dpi = N pixels / (M millimeters / (25.4 millimeters / 1 inch)) * = N pixels / (M inch / 25.4) * = N * 25.4 pixels / M inch */ xres = ((((double) DisplayWidth(dpy, screen)) * 25.4) / ((double) DisplayWidthMM(dpy, screen))); yres = ((((double) DisplayHeight(dpy, screen)) * 25.4) / ((double) DisplayHeightMM(dpy, screen))); *x = (int) (xres + 0.5); *y = (int) (yres + 0.5); }
display display::from_window(window const* w) { Window root = w? *w : g_root; display result; if (randr.is_available) { XRRScreenResources* sr = XRRGetScreenResources(g_display, root); RROutput primary = XRRGetOutputPrimary(g_display, g_root); result = init(sr, primary); XRRFreeScreenResources(sr); } else { result.scale = 1; result.color_depth = XDefaultDepth(g_display, g_screen); result.color_depth_per_component = result.color_depth >= 24? 8 : 0; result.rect = result.work_rect = rectangle<int>(0, 0, DisplayWidthMM(g_display, g_screen), DisplayHeightMM(g_display, g_screen)); } return result; }
main() { Display * display; int screen; char * display_name=NULL; Window root; Visual* visual; /* Connect to X display server. */ display=XOpenDisplay(display_name); /* Get screen ID */ screen=DefaultScreen(display); printf("\n\tInformation extracted from the X server\n"); printf("\t---------------------------------------\n\n"); printf(" X server by \'%s\'\n", ServerVendor(display)); printf(" X Server protocol %d\n", ProtocolVersion(display)); printf(" X server Release %d\n", VendorRelease(display)); printf(" Screen is %dmm high.\n", DisplayHeightMM(display, screen)); printf(" Screen is %dmm wide.\n", DisplayWidthMM(display, screen)); printf(" Screen is %d pixels high.\n", DisplayHeight(display, screen)); printf(" Screen is %d pixels wide.\n", DisplayWidth(display, screen)); visual = DefaultVisual(display,screen); printf(" %3d Colour map entries", visual->map_entries); printf(" (Number of colours on the screen at one time).\n"); printf(" %3d Display planes (bits per screen pixel).\n", DisplayPlanes(display, screen)); printf(" There is %d screen(s).\n", ScreenCount (display)); }
int __aa_X_getsize(struct aa_context *c,struct xdriverdata *d) { unsigned int px, py; int tmp; Window wtmp; XSync(d->dp, 0); XGetGeometry(d->dp, d->wi, &wtmp, &tmp, &tmp, &px, &py, (unsigned int *) &tmp, (unsigned int *) &tmp); tmp = 0; if (px != d->pixelwidth || py != d->pixelheight) tmp = 1; d->pixelwidth = px; d->pixelheight = py; if (tmp) { if (d->pixmapmode) XFreePixmap(d->dp, d->pi); if (!getenv("AABlink")) d->pi = XCreatePixmap(d->dp, d->wi, d->pixelwidth, d->pixelheight, DefaultDepth(d->dp, d->screen)); else d->pi = BadAlloc; if (d->pi == BadAlloc) { d->pixmapmode = 0; XSetWindowBackground(d->dp, d->wi, d->inverted ? d->invertedblack : d->black); } else { d->pixmapmode = 1; XFillRectangle(d->dp, d->pi, d->blackGC, 0, 0, d->pixelwidth, d->pixelheight); XSetWindowBackgroundPixmap(d->dp, d->wi, d->pi); } c->driverparams.mmwidth = DisplayWidthMM(d->dp, d->screen) * d->pixelwidth / DisplayWidth(d->dp, d->screen); c->driverparams.mmheight = DisplayHeightMM(d->dp, d->screen) * d->pixelheight / DisplayHeight(d->dp, d->screen); if (d->previoust != NULL) free(d->previoust), free(d->previousa); d->previoust=NULL; d->previousa=NULL; X_flush(c); XFlush(d->dp); } XSync(d->dp, 0); return (tmp); }
QSize UIDisplay::GetPhysicalSizePriv(void) { int displayWidthMM = 400; int displayHeightMM = 225; // TODO use display when needed const char *displaystring = NULL; Display* display = XOpenDisplay(displaystring); if (display) { int screen = DefaultScreen(display); displayWidthMM = DisplayWidthMM (display, screen); displayHeightMM = DisplayHeightMM(display, screen); XCloseDisplay(display); } else { LOG(VB_GENERAL, LOG_ERR, "Failed to open X display."); } return QSize(displayWidthMM, displayHeightMM); }
int getScreenResolution() { int result; #ifdef VAR_HAS_UI #ifdef ANDROID result = 160; int tmp; char buf[PROP_VALUE_MAX]; if (__system_property_get("qemu.sf.lcd_density", buf) > 0) { if (sscanf(buf, "%d", &tmp)) { result = tmp; } } else if (__system_property_get("ro.sf.lcd_density", buf) > 0) { if (sscanf(buf, "%d", &tmp)) { result = tmp; } } #else #ifdef osx result = 0; #else Display *display = XOpenDisplay(NULL); int scr = 0; double xres = ((((double) DisplayWidth(display,scr)) * 25.4) / ((double) DisplayWidthMM(display,scr))); double yres = ((((double) DisplayHeight(display,scr)) * 25.4) / ((double) DisplayHeightMM(display,scr))); int xr = (int) (xres + 0.5); int yr = (int) (yres + 0.5); result = MIN(xr, yr); XCloseDisplay(display); #endif #endif #else result = 0; #endif return result; }
unsigned platform_abstraction::screen_dpi(bool x_requested) { #ifdef NANA_WINDOWS auto hdc = ::GetDC(nullptr); auto dots = static_cast<unsigned>(::GetDeviceCaps(hdc, (x_requested ? LOGPIXELSX : LOGPIXELSY))); ::ReleaseDC(nullptr, hdc); return dots; #else auto & spec = ::nana::detail::platform_spec::instance(); auto disp = spec.open_display(); auto screen = ::XDefaultScreen(disp); double dots = 0.5; if (x_requested) dots += ((((double)DisplayWidth(disp, screen)) * 25.4) / ((double)DisplayWidthMM(disp, screen))); else dots += ((((double)DisplayHeight(disp, screen)) * 25.4) / ((double)DisplayHeightMM(disp, screen))); return static_cast<unsigned>(dots); #endif }
/* CENTRY */ int GLUTAPIENTRY glutGet(GLenum param) { Window win, root; int x, y, value; unsigned int width, height, border, depth; switch (param) { case GLUT_INIT_WINDOW_X: return __glutInitX; case GLUT_INIT_WINDOW_Y: return __glutInitY; case GLUT_INIT_WINDOW_WIDTH: return __glutInitWidth; case GLUT_INIT_WINDOW_HEIGHT: return __glutInitHeight; case GLUT_INIT_DISPLAY_MODE: return __glutDisplayMode; case GLUT_WINDOW_X: XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win, __glutRoot, 0, 0, &x, &y, &win); return x; case GLUT_WINDOW_Y: XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win, __glutRoot, 0, 0, &x, &y, &win); return y; case GLUT_WINDOW_WIDTH: if (!__glutCurrentWindow->reshape) { XGetGeometry(__glutDisplay, __glutCurrentWindow->win, &root, &x, &y, &width, &height, &border, &depth); return width; } return __glutCurrentWindow->width; case GLUT_WINDOW_HEIGHT: if (!__glutCurrentWindow->reshape) { XGetGeometry(__glutDisplay, __glutCurrentWindow->win, &root, &x, &y, &width, &height, &border, &depth); return height; } return __glutCurrentWindow->height; #ifdef __OS2__ #define GET_CONFIG(attrib) \ { if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) \ glXGetConfig( __glutCurrentWindow->vis, attrib, &value); \ else \ glXGetConfig(__glutCurrentWindow->overlay->vis, attrib, &value); \ } \ #else #define GET_CONFIG(attrib) { \ if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \ glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \ attrib, &value); \ } else { \ glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \ attrib, &value); \ } \ } #endif case GLUT_WINDOW_BUFFER_SIZE: GET_CONFIG(GLX_BUFFER_SIZE); return value; case GLUT_WINDOW_STENCIL_SIZE: GET_CONFIG(GLX_STENCIL_SIZE); return value; case GLUT_WINDOW_DEPTH_SIZE: GET_CONFIG(GLX_DEPTH_SIZE); return value; case GLUT_WINDOW_RED_SIZE: GET_CONFIG(GLX_RED_SIZE); return value; case GLUT_WINDOW_GREEN_SIZE: GET_CONFIG(GLX_GREEN_SIZE); return value; case GLUT_WINDOW_BLUE_SIZE: GET_CONFIG(GLX_BLUE_SIZE); return value; case GLUT_WINDOW_ALPHA_SIZE: GET_CONFIG(GLX_ALPHA_SIZE); return value; case GLUT_WINDOW_ACCUM_RED_SIZE: GET_CONFIG(GLX_ACCUM_RED_SIZE); return value; case GLUT_WINDOW_ACCUM_GREEN_SIZE: GET_CONFIG(GLX_ACCUM_GREEN_SIZE); return value; case GLUT_WINDOW_ACCUM_BLUE_SIZE: GET_CONFIG(GLX_ACCUM_BLUE_SIZE); return value; case GLUT_WINDOW_ACCUM_ALPHA_SIZE: GET_CONFIG(GLX_ACCUM_ALPHA_SIZE); return value; case GLUT_WINDOW_DOUBLEBUFFER: GET_CONFIG(GLX_DOUBLEBUFFER); return value; case GLUT_WINDOW_RGBA: GET_CONFIG(GLX_RGBA); return value; case GLUT_WINDOW_COLORMAP_SIZE: GET_CONFIG(GLX_RGBA); if (value) { return 0; } else { #if defined(_WIN32) || defined(__OS2__) /* KLUDGE: we always assume 256 colors in CI mode on Win32 */ return 256; #else if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { return __glutCurrentWindow->vis->visual->map_entries; } else { return __glutCurrentWindow->overlay->vis->visual->map_entries; } #endif /* _WIN32 */ } case GLUT_WINDOW_PARENT: return __glutCurrentWindow->parent ? __glutCurrentWindow->parent->num + 1 : 0; case GLUT_WINDOW_NUM_CHILDREN: { int num = 0; GLUTwindow *children = __glutCurrentWindow->children; while (children) { num++; children = children->siblings; } return num; } case GLUT_WINDOW_NUM_SAMPLES: #if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample) if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) { GET_CONFIG(GLX_SAMPLES_SGIS); return value; } else { return 0; } #else /* Independent of GLX server support, multisampling not supported by GLX client-side. */ return 0; #endif case GLUT_WINDOW_STEREO: GET_CONFIG(GLX_STEREO); return value; case GLUT_WINDOW_CURSOR: return __glutCurrentWindow->cursor; case GLUT_SCREEN_WIDTH: return DisplayWidth(__glutDisplay, __glutScreen); case GLUT_SCREEN_HEIGHT: return DisplayHeight(__glutDisplay, __glutScreen); case GLUT_SCREEN_WIDTH_MM: return DisplayWidthMM(__glutDisplay, __glutScreen); case GLUT_SCREEN_HEIGHT_MM: return DisplayHeightMM(__glutDisplay, __glutScreen); case GLUT_MENU_NUM_ITEMS: return __glutCurrentMenu->num; case GLUT_DISPLAY_MODE_POSSIBLE: { XVisualInfo *vi; Bool dummy, visAlloced; void *fbc; #if defined(_WIN32) /* Our fake glXChooseVisual (which is called by __glutDetermineVisual) needs an HDC to work with, so grab one from the "root" window. */ XHDC = GetDC(GetDesktopWindow()); #endif vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc); #if defined(_WIN32) ReleaseDC(GetDesktopWindow(), XHDC); #endif if (vi) { if (visAlloced) XFree(vi); return 1; } return 0; } case GLUT_ELAPSED_TIME: { #ifdef OLD_VMS struct timeval6 elapsed, beginning, now; #else struct timeval elapsed, beginning, now; #endif __glutInitTime(&beginning); GETTIMEOFDAY(&now); TIMEDELTA(elapsed, now, beginning); /* Return elapsed milliseconds. */ #if defined(__vms) && ( __VMS_VER < 70000000 ) return (int) (elapsed.val / TICKS_PER_MILLISECOND); #else return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000)); #endif } case GLUT_WINDOW_FORMAT_ID: #if defined(__OS2__) return wglGetPixelFormat(__glutCurrentWindow->hdc); #elif defined(_WIN32) return GetPixelFormat(__glutCurrentWindow->hdc); #else if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { return (int) __glutCurrentWindow->vis->visualid; } else { return (int) __glutCurrentWindow->overlay->vis->visualid; } #endif default: __glutWarning("invalid glutGet parameter: %d", param); return -1; } }