예제 #1
0
void Viewer::Initialize(const int w, const int h) {
  if (!m_pWnd) {
#ifndef WIN32
    // TODO(mingyu): Why no need to glutInit on Windows?
    int argc = 0;
    char** argv;
    glutInit(&argc, argv);
#endif
    m_pWnd = new CVD::GLWindow(CVD::ImageRef(w, h));
    int x_pos, y_pos;
#ifdef WIN32
    x_pos = (GetSystemMetrics(SM_CXSCREEN) - w) / 2;
    y_pos = (GetSystemMetrics(SM_CYSCREEN) - h) / 2;
#elif defined(__linux__)
    int num_sizes;
    Display *dpy = XOpenDisplay(NULL);
    Window root = RootWindow(dpy, 0);
    XRRScreenSize *xrrs = XRRSizes(dpy, 0, &num_sizes);
    XRRScreenConfiguration *conf = XRRGetScreenInfo(dpy, root);
    Rotation original_rotation;
    SizeID original_size_id = XRRConfigCurrentConfiguration(conf, &original_rotation);
    x_pos = (xrrs[original_size_id].width - w) / 2;
    y_pos = (xrrs[original_size_id].height - h) / 2;
    XCloseDisplay(dpy);
#else
    // TODO(mingyu): OSX support
#endif
    m_pWnd->set_position(CVD::ImageRef(x_pos, y_pos));
    glewInit();
  }
  OnResize(CVD::ImageRef(w, h));
  m_handler.Initialize(this, &Viewer::OnKeyDown, &Viewer::OnKeyUp, &Viewer::OnMouseMove,
                       &Viewer::OnMouseDown, &Viewer::OnMouseUp, &Viewer::OnMouseDraging,
                       &Viewer::OnMouseDoubleClicked, &Viewer::OnResize);
}
예제 #2
0
void Viewer::OnResize(const CVD::ImageRef &size) {
  m_pWnd->set_size(size);
  int x_pos, y_pos;
#ifdef WIN32
  x_pos = (GetSystemMetrics(SM_CXSCREEN) - size.x) / 2;
  y_pos = (GetSystemMetrics(SM_CYSCREEN) - size.y) / 2;
#elif defined(__linux__)
  int num_sizes;
  Display *dpy = XOpenDisplay(NULL);
  Window root = RootWindow(dpy, 0);
  XRRScreenSize *xrrs = XRRSizes(dpy, 0, &num_sizes);
  XRRScreenConfiguration *conf = XRRGetScreenInfo(dpy, root);
  Rotation original_rotation;
  SizeID original_size_id = XRRConfigCurrentConfiguration(conf, &original_rotation);
  x_pos = (xrrs[original_size_id].width - size.x) / 2;
  y_pos = (xrrs[original_size_id].height - size.y) / 2;
  XCloseDisplay(dpy);
#else
  // TODO(mingyu): OSX support
#endif
  m_pWnd->set_position(CVD::ImageRef(x_pos, y_pos));
  glViewport(0, 0, size.x, size.y);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0, size.x, size.y, 0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}
예제 #3
0
QSize native_res_for_monitior()
{
	Display* dpy = QX11Info::display();
	int major_version_return;
	int minor_version_return;
	XRRQueryVersion(dpy, &major_version_return, &minor_version_return);

	int event_base_return;
	int error_base_return;

	if (!XRRQueryExtension(dpy, &event_base_return, &error_base_return))
	{
		return QSize();
	}

	qDebug() << "XRandR extension supported";

	int nscreen_sizes = 0;

	XRRScreenSize * screen_sizes;
	screen_sizes = XRRSizes(dpy, QX11Info::appScreen(), &nscreen_sizes);

	for ( int i = 0 ; i < nscreen_sizes; i++ )
	{
		XRRScreenSize ss = screen_sizes[i];
		QSize qss(ss.width, ss.height);
		return qss;
	}

	return QSize();
}
예제 #4
0
void RandRScreen::loadSettings()
{
    if(d->config)
        XRRFreeScreenConfigInfo(d->config);

    d->config = XRRGetScreenInfo(qt_xdisplay(), RootWindow(qt_xdisplay(), m_screen));
    Q_ASSERT(d->config);

    Rotation rotation;
    m_currentSize = m_proposedSize = XRRConfigCurrentConfiguration(d->config, &rotation);
    m_currentRotation = m_proposedRotation = rotation;

    m_pixelSizes.clear();
    m_mmSizes.clear();
    int numSizes;
    XRRScreenSize *sizes = XRRSizes(qt_xdisplay(), m_screen, &numSizes);
    for(int i = 0; i < numSizes; i++)
    {
        m_pixelSizes.append(QSize(sizes[i].width, sizes[i].height));
        m_mmSizes.append(QSize(sizes[i].mwidth, sizes[i].mheight));
    }

    m_rotations = XRRRotations(qt_xdisplay(), m_screen, &rotation);

    m_currentRefreshRate = m_proposedRefreshRate = refreshRateHzToIndex(m_currentSize, XRRConfigCurrentRate(d->config));
}
예제 #5
0
/*
 * @brief gets a screen's primary output's possible sizes
 * @param root window which's primary output will be queried
 * @param num number of sizes reported as supported by the screen's primary output
 * @return an array of sizes reported as supported by the screen's primary output or - if query failed - NULL
 */
EAPI Ecore_X_Randr_Screen_Size_MM *
ecore_x_randr_screen_primary_output_sizes_get(Ecore_X_Window root, int *num)
{
#ifdef ECORE_XRANDR
   Ecore_X_Randr_Screen_Size_MM *ret = NULL;
   XRRScreenSize *sizes;
   int i, n;

   /* we don't have to free sizes, because they're hold in a cache inside X*/
   sizes =
      XRRSizes(_ecore_x_disp, XRRRootToScreen(_ecore_x_disp,
                                                    root), &n);
   if ((!sizes) || (n <= 0)) return NULL;
   ret = calloc(n, sizeof(Ecore_X_Randr_Screen_Size_MM));
   if (!ret)
      return NULL;

   if (num)
      *num = n;

   for (i = 0; i < n; i++)
     {
        ret[i].width = sizes[i].width;
        ret[i].height = sizes[i].height;
        ret[i].width_mm = sizes[i].mwidth;
        ret[i].height_mm = sizes[i].mheight;
     }
   return ret;
#else /* ifdef ECORE_XRANDR */
   return NULL;
#endif /* ifdef ECORE_XRANDR */
} /* ecore_x_randr_screen_primary_output_sizes_get */
예제 #6
0
std::vector<DisplayModeDescriptor> LinuxDisplay::QuerySupportedDisplayModes() const
{
    std::vector<DisplayModeDescriptor> displayModeDescs;
    
    DisplayModeDescriptor modeDesc;
    
    /* Get all screen sizes from X11 extension Xrandr */
    int numSizes = 0;
    auto scrSizes = XRRSizes(GetNative(), screen_, &numSizes);
    
    for (int i = 0; i < numSizes; ++i)
    {
        /* Initialize resolution */
        modeDesc.resolution.width   = static_cast<std::uint32_t>(scrSizes[i].width);
        modeDesc.resolution.height  = static_cast<std::uint32_t>(scrSizes[i].height);
        
        /* Add one display mode for each rate */
        int numRates = 0;
        auto rates = XRRRates(GetNative(), screen_, i, &numRates);
        
        for (int j = 0; j < numRates; ++j)
        {
            modeDesc.refreshRate = static_cast<std::uint32_t>(rates[j]);
            displayModeDescs.push_back(modeDesc);
        }
    }

    /* Sort final display mode list and remove duplciate entries */
    FinalizeDisplayModes(displayModeDescs);

    return displayModeDescs;
}
예제 #7
0
void GuiCalibratorX11::redraw()
{
#ifdef HAVE_X11_XRANDR
    // check that screensize did not change
    int nsizes;
    XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes);
    if (nsizes != 0 && (display_width != randrsize->width ||
                        display_height != randrsize->height)) {
        set_display_size(randrsize->width, randrsize->height);
    }
#endif

    // Print the text
    int text_height = font_info->ascent + font_info->descent;
    int text_width = -1;
    for (int i = 0; i != help_lines; i++) {
        text_width = std::max(text_width, XTextWidth(font_info,
            help_text[i].c_str(), help_text[i].length()));
    }

    int x = (display_width - text_width) / 2;
    int y = (display_height - text_height) / 2 - 60;
    XSetForeground(display, gc, pixel[BLACK]);
    XSetLineAttributes(display, gc, 2, LineSolid, CapRound, JoinRound);
    XDrawRectangle(display, win, gc, x - 10, y - (help_lines*text_height) - 10,
                text_width + 20, (help_lines*text_height) + 20);

    // Print help lines
    y -= 3;
    for (int i = help_lines-1; i != -1; i--) {
        int w = XTextWidth(font_info, help_text[i].c_str(), help_text[i].length());
        XDrawString(display, win, gc, x + (text_width-w)/2, y,
                help_text[i].c_str(), help_text[i].length());
        y -= text_height;
    }

    // Draw the points
    for (int i = 0; i <= calibrator->get_numclicks(); i++) {
        // set color: already clicked or not
        if (i < calibrator->get_numclicks())
            XSetForeground(display, gc, pixel[WHITE]);
        else
            XSetForeground(display, gc, pixel[RED]);
        XSetLineAttributes(display, gc, 1, LineSolid, CapRound, JoinRound);

        XDrawLine(display, win, gc, X[i] - cross_lines, Y[i],
                X[i] + cross_lines, Y[i]);
        XDrawLine(display, win, gc, X[i], Y[i] - cross_lines,
                X[i], Y[i] + cross_lines);
        XDrawArc(display, win, gc, X[i] - cross_circle, Y[i] - cross_circle,
                (2 * cross_circle), (2 * cross_circle), 0, 360 * 64);
    }

    // Draw the clock background
    XSetForeground(display, gc, pixel[DIMGRAY]);
    XSetLineAttributes(display, gc, 0, LineSolid, CapRound, JoinRound);
    XFillArc(display, win, gc, (display_width-clock_radius)/2, (display_height - clock_radius)/2,
                clock_radius, clock_radius, 0, 360 * 64);
}
예제 #8
0
파일: randr.cpp 프로젝트: Fat-Zer/tdelibs
KDE_EXPORT void RandRScreen::loadSettings()
{
	if (d->config) {
		XRRFreeScreenConfigInfo(d->config);
	}

	d->config = XRRGetScreenInfo(tqt_xdisplay(), RootWindow(tqt_xdisplay(), m_screen));

	Rotation rotation;
	if (d->config) {
		m_currentSize = m_proposedSize = XRRConfigCurrentConfiguration(d->config, &rotation);
		m_currentRotation = m_proposedRotation = rotation;
	}
	else {
		m_currentSize = m_proposedSize = 0;
		m_currentRotation = m_proposedRotation = 0;
	}

	m_pixelSizes.clear();
	m_mmSizes.clear();

	if (d->config) {
		int numSizes;
		XRRScreenSize* sizes = XRRSizes(tqt_xdisplay(), m_screen, &numSizes);
		for (int i = 0; i < numSizes; i++) {
			m_pixelSizes.append(TQSize(sizes[i].width, sizes[i].height));
			m_mmSizes.append(TQSize(sizes[i].mwidth, sizes[i].mheight));
		}

		m_rotations = XRRRotations(tqt_xdisplay(), m_screen, &rotation);
	}
	else {
		// Great, now we have to go after the information manually.  Ughh.
		ScreenInfo *screeninfo = internal_read_screen_info(tqt_xdisplay());
		XRROutputInfo *output_info = screeninfo->outputs[m_screen]->info;
		CrtcInfo *current_crtc = screeninfo->outputs[m_screen]->cur_crtc;
		int numSizes = output_info->nmode;
		for (int i = 0; i < numSizes; i++) {
			XRRModeInfo *xrrmode;
			xrrmode = internal_find_mode_by_xid (screeninfo, output_info->modes[i]);
			TQSize newSize = TQSize(xrrmode->width, xrrmode->height);
			if (!m_pixelSizes.contains(newSize)) {
				m_pixelSizes.append(newSize);
				m_mmSizes.append(TQSize(output_info->mm_width, output_info->mm_height));
			}
		}
		if (current_crtc) {
			m_rotations = current_crtc->rotations;
			m_currentRotation = m_proposedRotation = current_crtc->cur_rotation;
		}
	}

	if (d->config) {
		m_currentRefreshRate = m_proposedRefreshRate = refreshRateHzToIndex(m_currentSize, XRRConfigCurrentRate(d->config));
	}
	else {
		m_currentRefreshRate = m_proposedRefreshRate = 0;
	}
}
예제 #9
0
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;
}
예제 #10
0
void RenderContextImplGLX::EnumVideoModes(VideoModeList& videoModes) {
    // check for xrandr support
    videoModes.clear();
    bool fallback = false;
    if ((xrandrSupported = IsXRandrSupported())) {
        XRRScreenSize* screenSize;
        int nsizes = 0;

        Trace("XRANDR is enabled");
        screenSize = XRRSizes(display, screenIndex, &nsizes);
        if (!nsizes)
            fallback = true;
        videoModes.reserve((size_t) nsizes);
        for (int i = 0; i < nsizes; ++i) {
            VideoMode vmode;
            vmode.width = uint16(screenSize[i].width);
            vmode.height = uint16(screenSize[i].height);

            int nrates;
            short* rates = XRRRates(display, screenIndex, i, &nrates);
            for (int j = 0; j < nrates; ++j) {
                vmode.refreshRate = uint16(rates[j]);
                videoModes.push_back(vmode);
            }
        }
        Window root = RootWindow(display, screenIndex);
        Rotation rotation;
        XRRScreenConfiguration *conf = XRRGetScreenInfo(display, root);
        int currsize = XRRConfigCurrentConfiguration(conf, &rotation);
        VideoMode current = VideoMode(screenSize[currsize].width,
                                      screenSize[currsize].height, XRRConfigCurrentRate(conf));
        std::sort(videoModes.begin(), videoModes.end());
        auto it = std::find(videoModes.begin(), videoModes.end(), current);
        if (it != videoModes.end())
            baseContext->SetOriginalVideoMode((uint32)(it - videoModes.begin()));
        else {
            videoModes.push_back(current);
            baseContext->SetOriginalVideoMode((uint32)videoModes.size() - 1);
        }
        XRRFreeScreenConfigInfo(conf);
    } /* check vid modes*/
    if (fallback || !videoModes.size()) {
        VideoMode vmode;
        vmode.width = DisplayWidth(display, screenIndex);
        vmode.height = DisplayHeight(display, screenIndex);
        vmode.refreshRate = 0;
        videoModes.push_back(vmode);
        baseContext->SetOriginalVideoMode((uint32)videoModes.size() - 1);
        Error("Viewmode set in fallback mode!");
    }
}
예제 #11
0
int getScreenSize(int& width, int& height)
{
    int num_sizes;
    Rotation original_rotation;

    Window root = RootWindow(s_display, 0);
    XRRScreenSize *xrrs = XRRSizes(s_display, 0, &num_sizes);

    XRRScreenConfiguration *conf = XRRGetScreenInfo(s_display, root);
    short original_rate          = XRRConfigCurrentRate(conf);
    SizeID original_size_id      = XRRConfigCurrentConfiguration(conf, &original_rotation);

    //xrrs[2] is correct, so I have to figure out how to determine this programmatically.
    width  = xrrs[original_size_id].width;
    height = xrrs[original_size_id].height;
 }
예제 #12
0
bool C4AbstractApp::GetIndexedDisplayMode(int32_t iIndex, int32_t *piXRes, int32_t *piYRes, int32_t *piBitDepth, int32_t *piRefreshRate, uint32_t iMonitor)
{
#ifdef GDK_WINDOWING_X11
	Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
	int n;
	XRRScreenSize * sizes = XRRSizes(dpy, XDefaultScreen(dpy), &n);
	if (iIndex < n && iIndex >= 0)
	{
		*piXRes = sizes[iIndex].width;
		*piYRes = sizes[iIndex].height;
		*piBitDepth = 32;
		return true;
	}
	return false;
#endif
}
예제 #13
0
/*
 * @brief get the current set size of a given screen's primary output
 * @param root window which's primary output will be queried
 * @param w the current size's width
 * @param h the current size's height
 * @param w_mm the current size's width in mm
 * @param h_mm the current size's height in mm
 * @param size_index of current set size to be used with ecore_x_randr_primary_output_size_set()
 */
EAPI void
ecore_x_randr_screen_primary_output_current_size_get(Ecore_X_Window root,
                                                     int           *w,
                                                     int           *h,
                                                     int           *w_mm,
                                                     int           *h_mm,
                                                     int           *size_index)
{
#ifdef ECORE_XRANDR
   XRRScreenSize *sizes;
   XRRScreenConfiguration *sc = NULL;
   int index;
   Rotation orientation;
   int n;

   if (!(sc = XRRGetScreenInfo(_ecore_x_disp, root)))
     {
        ERR("Couldn't get screen information for %d", root);
        return;
     }

   index = XRRConfigCurrentConfiguration(sc, &orientation);

   sizes =
      XRRSizes(_ecore_x_disp, XRRRootToScreen(_ecore_x_disp,
                                                    root), &n);
   if ((index < n) && (index >= 0))
     {
        if (w)
           *w = sizes[index].width;

        if (h)
           *h = sizes[index].height;

        if (w_mm)
           *w_mm = sizes[index].mwidth;

        if (h_mm)
           *h_mm = sizes[index].mheight;

        if (size_index)
           *size_index = index;
     }

   XRRFreeScreenConfigInfo(sc);
#endif /* ifdef ECORE_XRANDR */
} /* ecore_x_randr_screen_primary_output_current_size_get */
void CDisplaySettingsList::GetAllDisplaySettings( void )
{
int      numsizes;
XRRScreenSize *xrrs;
Display *dpy;
int index = 0;

dpy     = XOpenDisplay(NULL);
xrrs    = XRRSizes(dpy, 0, &numsizes);

clear();

for (int wn = 0; wn < numsizes; wn++) 
	{
	CDisplaySettings settings;
	short *pfreq;
	int numfreq;

	pfreq = XRRRates(dpy, 0, wn, &numfreq );

	for (int freq = 0; freq < numfreq; freq++)
		{
		settings.m_index = index++;

		settings.m_pelswidth = xrrs[freq].width;
		settings.m_pelsheight = xrrs[freq].height;
		settings.m_displayvertfreq = pfreq[freq];

		settings.m_bitsperpel = -1;

		// The horizontal freq must be width * height * vertfreq
		settings.m_displayhorizfreq = 
			settings.m_pelsheight * settings.m_displayvertfreq;
	
		if ( settings.m_bitsperpel > 0)
			{
			settings.m_displayhorizfreq *= settings.m_bitsperpel;
			};

		settings.m_displaybandwidth =
			settings.m_displayhorizfreq * settings.m_pelswidth;
	
		push_back(settings);
		}
	}
}
예제 #15
0
void SetScreenSize(int width, int height, XVisualInfo *visual) {
    XRRScreenSize *sizes;
    int snum, rnum, i;
    short *rates;

    cg_screen_conf = XRRGetScreenInfo(cg_display, cg_window);
    cg_orig_size   = XRRConfigCurrentConfiguration(cg_screen_conf, &cg_rotation);
    cg_orig_rate   = XRRConfigCurrentRate(cg_screen_conf);

    /* Get the available resolutions */
    sizes = XRRSizes(cg_display, visual->screen, &snum);
    for(i = 0; i < snum; i++) {
        if((sizes[i].width == width) && (sizes[i].height == height)) {
            rates = XRRRates(cg_display, visual->screen, i, &rnum);
            XRRSetScreenConfigAndRate(cg_display, cg_screen_conf,
                                      DefaultRootWindow(cg_display), i,
                                      cg_rotation, rates[0], CurrentTime);
        }
    }
}
예제 #16
0
void QxtScreenPrivate::init_sys()
{
#ifdef HAVE_XRANDR
    Display* display = XOpenDisplay(NULL);
    Window root = RootWindow(display, screen);
    XRRScreenConfiguration* config = XRRGetScreenInfo(display, root);

    // available resolutions & rates
    if (availResos.isEmpty() || availRates.isEmpty())
    {
        availResos.clear();
        availRates.clear();

        int sizeCount = 0;
        XRRScreenSize* sizes = XRRSizes(display, 0, &sizeCount);
        for (int i = 0; i < sizeCount; ++i)
        {
            QSize reso(sizes[i].width, sizes[i].height);
            if (!availResos.contains(reso))
                availResos += reso;

            int rateCount = 0;
            short* rates = XRRConfigRates(config, i, &rateCount);
            for (int j = 0; j < rateCount; ++j)
                availRates.insertMulti(reso, rates[j]);
        }
    }

    // current resolution & rate
    if (!currReso.isValid() || currRate < 0)
    {
        Rotation rotation;
        SizeID sizeId = XRRConfigCurrentConfiguration(config, &rotation);
        currReso = availResos.at(sizeId);
        currRate = XRRConfigCurrentRate(config);
    }

    XRRFreeScreenConfigInfo(config);
    XCloseDisplay(display);
#endif // HAVE_XRANDR
}
예제 #17
0
/*
 Gets current desktop resolution and frequency
*/
static void
libgadget_sidebar_get_size (int *width, int *height, int *width_desktop)
{
	int num_sizes;
	Rotation original_rotation;

	Display *dpy = XOpenDisplay (NULL);
	Window root = RootWindow (dpy, 0);
	XRRScreenSize *xrrs = XRRSizes (dpy, 0, &num_sizes);

	XRRScreenConfiguration *conf = XRRGetScreenInfo (dpy, root);
	short original_rate = XRRConfigCurrentRate (conf);
	SizeID original_size_id = XRRConfigCurrentConfiguration (conf, &original_rotation);

	/* Save data */
	*width = (xrrs[original_size_id].width * PERCENTUAL_WIDTH_SIZE) / 100;
	*width_desktop = xrrs[original_size_id].width;
	*height = xrrs[original_size_id].height - 25;
	
	XCloseDisplay (dpy);
}
예제 #18
0
/*
 * r_desktop_init:
 *
 */
void
r_desktop_init()
{
    gint event_base;
    gint error_base;
    gint version_major;
    gint version_minor;
    gint sizes_count;
    XRRScreenSize* sizes;
    XRRScreenConfiguration *sc;
    
    if(!XRRQueryExtension(
        game->display,
        &event_base,
        &error_base
        )
    || !XRRQueryVersion(
        game->display,
        &version_major,
        &version_minor
        ))
    {
        g_error("XRandr not supported");
    }
    
    sc = XRRGetScreenInfo(game->display, DefaultRootWindow(game->display));
    self.size = XRRConfigCurrentConfiguration(sc, &self.rotation);
    self.rate = XRRConfigCurrentRate(sc);
    XRRFreeScreenConfigInfo(sc);

    sizes = XRRSizes(game->display, DefaultScreen(game->display), &sizes_count);
    self.default_width = sizes[self.size].width;
    self.default_height = sizes[self.size].height;
    self.default_rate = self.rate;
    self.current_width = self.default_width;
    self.current_height = self.default_height;
    self.current_rate = self.default_rate;

    _desktop_print_info();
}
예제 #19
0
void CommandInterpreter::queryResolution()
{
	int numberSizes;
    Rotation originalRotation;
    
    XRRScreenSize *xrrs = XRRSizes(display, 0, &numberSizes);
    
    XRRScreenConfiguration *configuration = XRRGetScreenInfo(display, RootWindow(display, 0));
    SizeID originalSize = XRRConfigCurrentConfiguration(configuration, &originalRotation);
    
    displayXResolution = xrrs[originalSize].width;
    displayYResolution = xrrs[originalSize].height;
    
    xOrigin = displayXResolution / 2;
    yOrigin = displayYResolution / 2;
    
    upBound = 70;
    downBound = displayYResolution - 70;
	
	printf("Server Dimensions: %i x %i.\n", displayXResolution, displayYResolution);
	printf("Origin of Screen %i: (%i, %i).\n", DefaultScreen(display), xOrigin, yOrigin);
}
예제 #20
0
/*
 * @brief sets a given screen's primary output size, but disables all other outputs at the same time
 * @param root window which's primary output will be queried
 * @param size_index within the list of sizes reported as supported by the root window's screen primary output
 * @return EINA_TRUE on success, EINA_FALSE on failure due to e.g. invalid times
 */
EAPI Eina_Bool
ecore_x_randr_screen_primary_output_size_set(Ecore_X_Window root,
                                             int            size_index)
{
#ifdef ECORE_XRANDR
   XRRScreenConfiguration *sc = NULL;
   XRRScreenSize *sizes;
   Eina_Bool ret = EINA_FALSE;
   int nsizes = 0;

   if (size_index >= 0 && _ecore_x_randr_root_validate(root))
     {
        sizes =
           XRRSizes(_ecore_x_disp, XRRRootToScreen(_ecore_x_disp,
                                                         root), &nsizes);

        if (size_index < nsizes)
          {
             sc = XRRGetScreenInfo(_ecore_x_disp, root);
             if (!XRRSetScreenConfig(_ecore_x_disp, sc,
                                     root, size_index,
                                     ECORE_X_RANDR_ORIENTATION_ROT_0, CurrentTime))
               {
                  ret = EINA_TRUE;
               }

             if (sc)
                XRRFreeScreenConfigInfo(sc);
          }
     }

   return ret;
#else /* ifdef ECORE_XRANDR */
   return EINA_FALSE;
#endif /* ifdef ECORE_XRANDR */
} /* ecore_x_randr_screen_primary_output_size_set */
예제 #21
0
GuiCalibratorX11::GuiCalibratorX11(Calibrator* calibrator0)
  : calibrator(calibrator0), time_elapsed(0)
{
    display = XOpenDisplay(NULL);
    if (display == NULL) {
        throw std::runtime_error("Unable to connect to X server");
    }
    screen_num = DefaultScreen(display);
    // Load font and get font information structure
    font_info = XLoadQueryFont(display, "9x15");
    if (font_info == NULL) {
        // fall back to native font
        font_info = XLoadQueryFont(display, "fixed");
        if (font_info == NULL) {
            XCloseDisplay(display);
            throw std::runtime_error("Unable to open neither '9x15' nor 'fixed' font");
        }
    }

#ifdef HAVE_X11_XRANDR
    // get screensize from xrandr
    int nsizes;
    XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes);
    if (nsizes != 0) {
        Rotation current = 0;
        XRRRotations(display, screen_num, &current);
        bool rot = current & RR_Rotate_90 || current & RR_Rotate_270;
        int width = rot ? randrsize->height : randrsize->width;
        int height = rot ? randrsize->width : randrsize->height;
        set_display_size(width, height);
    } else {
        set_display_size(DisplayWidth(display, screen_num),
                         DisplayHeight(display, screen_num));
    }
# else
    set_display_size(DisplayWidth(display, screen_num),
                     DisplayHeight(display, screen_num));
#endif

    // parse geometry string
    const char* geo = calibrator->get_geometry();
    if (geo != NULL) {
        int gw,gh;
        int res = sscanf(geo,"%dx%d",&gw,&gh);
        if (res != 2) {
            fprintf(stderr,"Warning: error parsing geometry string - using defaults.\n");
        } else {
            set_display_size( gw, gh );
        }
    }

    // Register events on the window
    XSetWindowAttributes attributes;
    attributes.override_redirect = True;
    attributes.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;

    win = XCreateWindow(display, RootWindow(display, screen_num),
                0, 0, display_width, display_height, 0,
                CopyFromParent, InputOutput, CopyFromParent,
                CWOverrideRedirect | CWEventMask,
                &attributes);
    XMapWindow(display, win);

    // Listen to events
    XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync,
                CurrentTime);
    XGrabPointer(display, win, False, ButtonPressMask, GrabModeAsync,
                GrabModeAsync, None, None, CurrentTime);

    Colormap colormap = DefaultColormap(display, screen_num);
    XColor color;
    for (int i = 0; i != NUM_COLORS; i++) {
        XParseColor(display, colormap, colors[i], &color);
        XAllocColor(display, colormap, &color);
        pixel[i] = color.pixel;
    }
    XSetWindowBackground(display, win, pixel[GRAY]);
    XClearWindow(display, win);

    gc = XCreateGC(display, win, 0, NULL);
    XSetFont(display, gc, font_info->fid);

    // Setup timer for animation
#ifdef HAVE_TIMERFD
    struct itimerspec timer;
    unsigned int period = time_step * 1000; // microseconds
    unsigned int sec = period/1000000;
    unsigned int ns = (period - (sec * 1000000)) * 1000;

    timer.it_value.tv_sec = sec;
    timer.it_value.tv_nsec = ns;
    timer.it_interval = timer.it_value;
    timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
    timerfd_settime(timer_fd, 0, &timer, NULL);
#else
    signal(SIGALRM, sigalarm_handler);
    struct itimerval timer;
    timer.it_value.tv_sec = time_step/1000;
    timer.it_value.tv_usec = (time_step % 1000) * 1000;
    timer.it_interval = timer.it_value;
    setitimer(ITIMER_REAL, &timer, NULL);
#endif
}
예제 #22
0
GuiCalibratorX11::GuiCalibratorX11(Calibrator* calibrator0)
  : calibrator(calibrator0), time_elapsed(0)
{
    display = XOpenDisplay(NULL);
    if (display == NULL) {
        throw std::runtime_error("Unable to connect to X server");
    }
    screen_num = DefaultScreen(display);
    // Load font and get font information structure
    font_info = XLoadQueryFont(display, "9x15");
    if (font_info == NULL) {
        // fall back to native font
        font_info = XLoadQueryFont(display, "fixed");
        if (font_info == NULL) {
            XCloseDisplay(display);
            throw std::runtime_error("Unable to open neither '9x15' nor 'fixed' font");
        }
    }

#ifdef HAVE_X11_XRANDR
    // get screensize from xrandr
    int nsizes;
    XRRScreenSize* randrsize = XRRSizes(display, screen_num, &nsizes);
    if (nsizes != 0) {
        set_display_size(randrsize->width, randrsize->height);
    } else {
        set_display_size(DisplayWidth(display, screen_num),
                         DisplayHeight(display, screen_num));
    }
# else
    set_display_size(DisplayWidth(display, screen_num),
                     DisplayHeight(display, screen_num));
#endif

    // Register events on the window
    XSetWindowAttributes attributes;
    attributes.override_redirect = True;
    attributes.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;

    win = XCreateWindow(display, RootWindow(display, screen_num),
                0, 0, display_width, display_height, 0,
                CopyFromParent, InputOutput, CopyFromParent,
                CWOverrideRedirect | CWEventMask,
                &attributes);
    XMapWindow(display, win);

    // Listen to events
    XGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync,
                CurrentTime);
    calib_input = calibrator->register_events();
    if (!calib_input) {
            XGrabPointer(display, win, False, ButtonPressMask, GrabModeAsync,
                GrabModeAsync, None, None, CurrentTime);
    }

    Colormap colormap = DefaultColormap(display, screen_num);
    XColor color;
    for (int i = 0; i != nr_colors; i++) {
        XParseColor(display, colormap, colors[i], &color);
        XAllocColor(display, colormap, &color);
        pixel[i] = color.pixel;
    }
    XSetWindowBackground(display, win, pixel[GRAY]);
    XClearWindow(display, win);

    gc = XCreateGC(display, win, 0, NULL);
    XSetFont(display, gc, font_info->fid);

    // Setup timer for animation
    signal(SIGALRM, sigalarm_handler);
    struct itimerval timer;
    timer.it_value.tv_sec = time_step/1000;
    timer.it_value.tv_usec = (time_step % 1000) * 1000;
    timer.it_interval = timer.it_value;
    setitimer(ITIMER_REAL, &timer, NULL);
}
예제 #23
0
bool iRandR::reload( bool _overwriteLatest, bool _overwriteDefaults ) {
   if ( !vIsRandRSupported_B )
      return false;

   SizeID lTemoID_suI;
   int lTempSizes_I;

   Rotation lTempRotate_XRR; // Exists only for XRRConfigCurrentConfiguration(...); to make it happy

   vConfig_XRR    = XRRGetScreenInfo( vDisplay_X11, vRootWindow_X11 );
   vResources_XRR = XRRGetScreenResources( vDisplay_X11, vRootWindow_X11 );

   lTemoID_suI                   = XRRConfigCurrentConfiguration( vConfig_XRR, &lTempRotate_XRR );
   XRRScreenSize *lTempSizes_XRR = XRRSizes( vDisplay_X11, 0, &lTempSizes_I );

   if ( lTemoID_suI < lTempSizes_I ) {
      vScreenWidth_uI  = static_cast<unsigned>( lTempSizes_XRR[lTemoID_suI].width );
      vScreenHeight_uI = static_cast<unsigned>( lTempSizes_XRR[lTemoID_suI].height );
   }

   if ( _overwriteLatest ) {
      vLatestConfig_RandR.primary = XRRGetOutputPrimary( vDisplay_X11, vRootWindow_X11 );

      for ( auto &elem : vLatestConfig_RandR.gamma )
         XRRFreeGamma( elem );

      vLatestConfig_RandR.gamma.clear();

      for ( int i = 0; i < vResources_XRR->ncrtc; ++i ) {
         vLatestConfig_RandR.gamma.push_back(
               XRRGetCrtcGamma( vDisplay_X11, vResources_XRR->crtcs[i] ) );
      }
   }

   if ( _overwriteDefaults ) {
      vDefaultConfig_RandR.primary = XRRGetOutputPrimary( vDisplay_X11, vRootWindow_X11 );

      for ( auto &elem : vDefaultConfig_RandR.gamma )
         XRRFreeGamma( elem );

      vDefaultConfig_RandR.gamma.clear();

      for ( int i = 0; i < vResources_XRR->ncrtc; ++i ) {
         vDefaultConfig_RandR.gamma.push_back(
               XRRGetCrtcGamma( vDisplay_X11, vResources_XRR->crtcs[i] ) );
      }
   }

   // Clear old data
   vCRTC_V_RandR.clear();
   vOutput_V_RandR.clear();
   vMode_V_RandR.clear();
   vLatestConfig_RandR.CRTCInfo.clear();


   // CRTC
   for ( int i = 0; i < vResources_XRR->ncrtc; ++i ) {
      internal::_crtc lTempCRTC_RandR;

      XRRCrtcInfo *lTempCRTCInfo_XRR =
            XRRGetCrtcInfo( vDisplay_X11, vResources_XRR, vResources_XRR->crtcs[i] );

      lTempCRTC_RandR.id        = vResources_XRR->crtcs[i];
      lTempCRTC_RandR.timestamp = lTempCRTCInfo_XRR->timestamp;
      lTempCRTC_RandR.posX      = lTempCRTCInfo_XRR->x;
      lTempCRTC_RandR.posY      = lTempCRTCInfo_XRR->y;
      lTempCRTC_RandR.width     = lTempCRTCInfo_XRR->width;
      lTempCRTC_RandR.height    = lTempCRTCInfo_XRR->height;
      lTempCRTC_RandR.mode      = lTempCRTCInfo_XRR->mode;
      lTempCRTC_RandR.rotation  = lTempCRTCInfo_XRR->rotation;
      lTempCRTC_RandR.rotations = lTempCRTCInfo_XRR->rotations;

      for ( int j = 0; j < lTempCRTCInfo_XRR->noutput; ++j ) {
         lTempCRTC_RandR.outputs.push_back( lTempCRTCInfo_XRR->outputs[j] );
      }

      for ( int j = 0; j < lTempCRTCInfo_XRR->npossible; ++j ) {
         lTempCRTC_RandR.possibleOutputs.push_back( lTempCRTCInfo_XRR->possible[j] );
      }

      vCRTC_V_RandR.push_back( lTempCRTC_RandR );
      XRRFreeCrtcInfo( lTempCRTCInfo_XRR );
   }


   // Output
   for ( int i = 0; i < vResources_XRR->noutput; ++i ) {
      internal::_output lTempOutput_RandR;

      XRROutputInfo *lTempOutputInfo_XRR =
            XRRGetOutputInfo( vDisplay_X11, vResources_XRR, vResources_XRR->outputs[i] );

      lTempOutput_RandR.id             = vResources_XRR->outputs[i];
      lTempOutput_RandR.timestamp      = lTempOutputInfo_XRR->timestamp;
      lTempOutput_RandR.crtc           = lTempOutputInfo_XRR->crtc;
      lTempOutput_RandR.name           = lTempOutputInfo_XRR->name;
      lTempOutput_RandR.mm_width       = lTempOutputInfo_XRR->mm_width;
      lTempOutput_RandR.mm_height      = lTempOutputInfo_XRR->mm_height;
      lTempOutput_RandR.connection     = lTempOutputInfo_XRR->connection;
      lTempOutput_RandR.subpixel_order = lTempOutputInfo_XRR->subpixel_order;
      lTempOutput_RandR.npreferred     = lTempOutputInfo_XRR->npreferred;

      for ( int j = 0; j < lTempOutputInfo_XRR->ncrtc; ++j ) {
         lTempOutput_RandR.crtcs.push_back( lTempOutputInfo_XRR->crtcs[j] );
      }

      for ( int j = 0; j < lTempOutputInfo_XRR->nclone; ++j ) {
         lTempOutput_RandR.clones.push_back( lTempOutputInfo_XRR->clones[j] );
      }

      for ( int j = 0; j < lTempOutputInfo_XRR->nmode; ++j ) {
         lTempOutput_RandR.modes.push_back( lTempOutputInfo_XRR->modes[j] );
      }

      vOutput_V_RandR.push_back( lTempOutput_RandR );
      XRRFreeOutputInfo( lTempOutputInfo_XRR );
   }


   // Modes
   for ( int i = 0; i < vResources_XRR->nmode; ++i ) {
      internal::_mode lTempMode_RandR;

      XRRModeInfo lTempModeInfo_XRR = vResources_XRR->modes[i];

      lTempMode_RandR.id         = lTempModeInfo_XRR.id;
      lTempMode_RandR.width      = lTempModeInfo_XRR.width;
      lTempMode_RandR.height     = lTempModeInfo_XRR.height;
      lTempMode_RandR.dotClock   = lTempModeInfo_XRR.dotClock;
      lTempMode_RandR.hSyncStart = lTempModeInfo_XRR.hSyncStart;
      lTempMode_RandR.hSyncEnd   = lTempModeInfo_XRR.hSyncEnd;
      lTempMode_RandR.hTotal     = lTempModeInfo_XRR.hTotal;
      lTempMode_RandR.hSkew      = lTempModeInfo_XRR.hSkew;
      lTempMode_RandR.vSyncStart = lTempModeInfo_XRR.vSyncStart;
      lTempMode_RandR.vSyncEnd   = lTempModeInfo_XRR.vSyncEnd;
      lTempMode_RandR.vTotal     = lTempModeInfo_XRR.vTotal;
      lTempMode_RandR.name       = lTempModeInfo_XRR.name;
      lTempMode_RandR.modeFlags  = lTempModeInfo_XRR.modeFlags;


      /* v refresh frequency in Hz */
      unsigned int lVTotalTemp = lTempMode_RandR.vTotal;

      if ( lTempMode_RandR.modeFlags & RR_DoubleScan )
         lVTotalTemp *= 2;

      if ( lTempMode_RandR.modeFlags & RR_Interlace )
         lVTotalTemp /= 2;

      if ( lTempMode_RandR.hTotal && lVTotalTemp )
         lTempMode_RandR.refresh = ( static_cast<double>( lTempMode_RandR.dotClock ) /
                                     ( static_cast<double>( lTempMode_RandR.hTotal ) *
                                       static_cast<double>( lVTotalTemp ) ) );
      else
         lTempMode_RandR.refresh = 0;


      /* h sync frequency in Hz */
      if ( lTempMode_RandR.hTotal )
         lTempMode_RandR.syncFreq = lTempMode_RandR.dotClock / lTempMode_RandR.hTotal;
      else
         lTempMode_RandR.syncFreq = 0;

      vMode_V_RandR.push_back( lTempMode_RandR );
   }


   vLatestConfig_RandR.CRTCInfo = vCRTC_V_RandR;

   if ( _overwriteLatest )
      vDefaultConfig_RandR.CRTCInfo = vCRTC_V_RandR;

   vMode_V_RandR.sort();

   return true;
}
예제 #24
0
void GuiCalibratorX11::detect_screen_geometry(int *width, int *height, int *x, int *y)
{
#ifdef HAVE_X11_XRANDR
    int ox = 0, oy = 0, gw = 0, gh = 0;

    if (calibrator->get_x_output()) {
        XRRScreenResources *resources = XRRGetScreenResources(display, RootWindow(display, screen_num));
        // Get the XID of the CRTC the selected output is connected to.
        RRCrtc crtc = get_crtc_id(display, resources, calibrator->get_x_output());
        if (crtc != (RRCrtc) -1) {
            XRRCrtcInfo *crtc_info = XRRGetCrtcInfo(display, resources, crtc);
            if (crtc_info->mode != None && crtc_info->noutput > 0) {
                ox = crtc_info->x;
                oy = crtc_info->y;
                gw = crtc_info->width;
                gh = crtc_info->height;
            } else
                printf("Warning: output \"%s\" resulted in an invalid CRTC.\n", calibrator->get_x_output());
            XRRFreeCrtcInfo(crtc_info);
        }

        XRRFreeScreenResources(resources);
    }

    if (gw == 0 || gh == 0) {
        int nsizes = 0;
        XRRScreenSize *randrsize = XRRSizes(display, screen_num, &nsizes);
        if (nsizes != 0) {
            Rotation current_rotation = 0;
            XRRScreenConfiguration *sc = XRRGetScreenInfo(display, RootWindow(display, screen_num));
            int current_size = XRRConfigCurrentConfiguration(sc, &current_rotation);

            if (current_size < nsizes) {
                XRRRotations(display, screen_num, &current_rotation);
                randrsize += current_size;

                bool rot = current_rotation & RR_Rotate_90 || current_rotation & RR_Rotate_270;
                gw = rot ? randrsize->height : randrsize->width;
                gh = rot ? randrsize->width : randrsize->height;
            }
        }
    }

    // Get screensize from xrandr
    if (gw > 0 && gh > 0) {
        *width = gw;
        *height = gh;
    } else {
        *width = DisplayWidth(display, screen_num);
        *height = DisplayHeight(display, screen_num);
    }

    if (x && y) {
        *x = ox;
        *y = oy;
    }
# else
    *width = DisplayWidth(display, screen_num);
    *height = DisplayHeight(display, screen_num);
    if (x && y) {
        *x = 0;
        *y = 0;
    }
#endif
}
예제 #25
0
/*
 * r_desktop_set_resolution:
 * @width:
 * @height:
 * @rate:
 *
 */
void
r_desktop_set_resolution(
    guint       width,
    guint       height,
    guint       rate
    )
{
    gint sizes_count;
    XRRScreenSize* sizes;
    gint rates_count;
    gshort* rates;
    gint i, d1, d2;
    gint best_size = -1;
    gshort best_rate = -1;
    XRRScreenConfiguration *sc;

    if(width == self.current_width && height == self.current_height)
    {
        return;
    }

#ifdef DEBUG
    g_debug("Old Video Mode: %dx%d %dHz", self.current_width, self.current_height, self.current_rate);
#endif

    if(width == self.default_width && height == self.default_height)
    {
        best_size = self.size;
        best_rate = self.rate;
        self.current_width = self.default_width;
        self.current_height = self.default_height;
        self.current_rate = self.rate;
    }
    else
    {
        sizes = XRRSizes(game->display, DefaultScreen(game->display), &sizes_count);
        d1  = (width - sizes[0].width) * (width - sizes[0].width)
            + (height - sizes[0].height) * (height - sizes[0].height);
        best_size = 0;
        for(i = 1; i < sizes_count; i++)
        {
            d2  = (width - sizes[i].width) * (width - sizes[i].width)
                + (height - sizes[i].height) * (height - sizes[i].height);
            if(d1 > d2)
            {
                d1 = d2;
                best_size = i;
            }
        }
        
        rates = XRRRates(game->display, DefaultScreen(game->display), best_size, &rates_count);
        best_rate = rates[0];
        for(i = 1; i < rates_count; i++)
        {
            if(rates[i] > best_rate)
            {
                best_rate = rates[i];
            }
        }
    
        self.current_width = sizes[best_size].width;
        self.current_height = sizes[best_size].height;
        self.current_rate = best_rate;
    }
    
#ifdef DEBUG
    g_debug("New Video Mode: %dx%d %dHz", self.current_width, self.current_height, self.current_rate);
#endif

    sc = XRRGetScreenInfo(game->display, DefaultRootWindow(game->display));
    XRRSetScreenConfigAndRate(
        game->display,
        sc,
        DefaultRootWindow(game->display),
        best_size,
        self.rotation,
        best_rate,
        CurrentTime
        );
    XRRFreeScreenConfigInfo(sc);
    XSync(game->display, True);
}