示例#1
0
////////////////////////////////////////////////////////////
/// Cleanup graphical resources attached to the window
////////////////////////////////////////////////////////////
void WindowImplX11::CleanUp()
{
    // Restore the previous video mode (in case we were running in fullscreen)
    if (ourFullscreenWindow == this)
    {
        // Get current screen info
        XRRScreenConfiguration* Config = XRRGetScreenInfo(ourDisplay, RootWindow(ourDisplay, ourScreen));
        if (Config) 
        {
            // Get the current rotation
            Rotation CurrentRotation;
            XRRConfigCurrentConfiguration(Config, &CurrentRotation);

            // Reset the video mode
            XRRSetScreenConfig(ourDisplay, Config, RootWindow(ourDisplay, ourScreen), myOldVideoMode, CurrentRotation, CurrentTime);

            // Free the configuration instance
            XRRFreeScreenConfigInfo(Config);
        } 

        // Reset the fullscreen window
        ourFullscreenWindow = NULL;
    }

    // Unhide the mouse cursor (in case it was hidden)
    ShowMouseCursor(true);

    // Destroy the OpenGL context
    if (myGLContext)
    {
        glXDestroyContext(ourDisplay, myGLContext);
        myGLContext = NULL;
    }
}
示例#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
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);
}
示例#4
0
void RenderContextImplGLX::SetVideoModeImpl(const VideoMode& mode) {
    if (xrandrSupported) {
        Window rootWnd = RootWindow(display, screenIndex);
        XRRScreenConfiguration *screenConfig = XRRGetScreenInfo(display,
                                               rootWnd);

        if (screenConfig) {

            int size = -1;
            int nsizes = 0;
            XRRScreenSize* screenSize = XRRConfigSizes(screenConfig, &nsizes);
            for (int i = 0; i < nsizes; ++i) {
                if (mode.width == uint16(screenSize[i].width)
                        && mode.height == uint16(screenSize[i].height)) {
                    size = i;
                    break;
                }
            }
            if (size < 0)
                // invalid mode
                return;
            Rotation current_rotation;
            XRRConfigCurrentConfiguration(screenConfig, &current_rotation);
            XRRSetScreenConfigAndRate(display, screenConfig, rootWnd, size,
                                      current_rotation, mode.refreshRate, CurrentTime);
            XRRFreeScreenConfigInfo(screenConfig);
            Trace(String("Video mode changed to:") + VideoMode::ToString(mode));
        }
    }
}
示例#5
0
文件: unix_vid.c 项目: ewirch/qfusion
/*
** VID_GetDisplaySize
*/
qboolean VID_GetDisplaySize( int *width, int *height )
{
	XRRScreenConfiguration *xrrConfig;
	XRRScreenSize *xrrSizes;
	Display *dpy;
	Window root;
	Rotation rotation;
	SizeID size_id;
	int num_sizes;

	dpy = XOpenDisplay( NULL );
	if( dpy )
	{
		root = DefaultRootWindow( dpy );
		xrrConfig = XRRGetScreenInfo( dpy, root );
		xrrSizes = XRRConfigSizes( xrrConfig, &num_sizes );
		size_id = XRRConfigCurrentConfiguration( xrrConfig, &rotation );

		*width = xrrSizes[size_id].width;
		*height = xrrSizes[size_id].height;

		XCloseDisplay( dpy );
		return qtrue;
	}

	return qfalse;
}
示例#6
0
/*
 * @brief sets a given screen's primary output's orientation
 * @param root window which's screen's primary output will be queried
 * @param orientation orientation which should be set for the root window's screen primary output
 * @return EINA_TRUE if the primary output's orientation could be successfully altered
 */
EAPI Eina_Bool
ecore_x_randr_screen_primary_output_orientation_set(
   Ecore_X_Window root,
   Ecore_X_Randr_Orientation
   orientation)
{
#ifdef ECORE_XRANDR
   XRRScreenConfiguration *xrr_screen_cfg = NULL;
   int sizeid;
   Rotation crot;
   Eina_Bool ret = EINA_FALSE;
   if (!(xrr_screen_cfg = XRRGetScreenInfo(_ecore_x_disp, root)))
      return EINA_FALSE;

   sizeid = XRRConfigCurrentConfiguration(xrr_screen_cfg, &crot);
   if (!XRRSetScreenConfig(_ecore_x_disp, xrr_screen_cfg, root, sizeid,
                           orientation, CurrentTime))
      ret = EINA_TRUE;

   if (xrr_screen_cfg)
      XRRFreeScreenConfigInfo(xrr_screen_cfg);

   return ret;
#else /* ifdef ECORE_XRANDR */
   return EINA_FALSE;
#endif /* ifdef ECORE_XRANDR */
} /* ecore_x_randr_screen_primary_output_orientation_set */
示例#7
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));
}
JNIEXPORT jint JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeGetDisplayModeIndex
(JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused)))
{
#ifdef HAVE_XRANDR	

	GdkDisplay *display;
	XRRScreenConfiguration *config;
	SizeID index;
	Rotation rotation;
	
	display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv);
	
	gdk_threads_enter();
	
	config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW());

	index = XRRConfigCurrentConfiguration (config, &rotation);

    XRRFreeScreenConfigInfo (config);

	gdk_threads_leave();
	
	return (int) index;

#else

    JCL_ThrowException(env,
                       "java/lang/InternalError",
                       "Method should not have been invoked.");
   
    return -1;
   
#endif	
}
示例#9
0
bool DisplayResX::SwitchToVideoMode(int width, int height, double desired_rate)
{
    double rate;
    DisplayResScreen desired_screen(width, height, 0, 0, -1.0, desired_rate);
    int idx = DisplayResScreen::FindBestMatch(m_videoModesUnsorted,
              desired_screen, rate);

    if (idx >= 0)
    {
        short finalrate;
        MythXDisplay *display = NULL;
        XRRScreenConfiguration *cfg = GetScreenConfig(display);

        if (!cfg)
            return false;

        Rotation rot;

        XRRConfigCurrentConfiguration(cfg, &rot);

        // Search real xrandr rate for desired_rate
        finalrate = (short) rate;

        for (uint i = 0; i < m_videoModes.size(); i++)
        {
            if ((m_videoModes[i].Width() == width) &&
                    (m_videoModes[i].Height() == height))
            {
                if (m_videoModes[i].Custom())
                {
                    finalrate = m_videoModes[i].realRates[rate];
                    LOG(VB_PLAYBACK, LOG_INFO,
                        QString("Dynamic TwinView rate found, set %1Hz as "
                                "XRandR %2") .arg(rate) .arg(finalrate));
                }

                break;
            }
        }

        Window root = display->GetRoot();

        Status status = XRRSetScreenConfigAndRate(display->GetDisplay(), cfg,
                        root, idx, rot, finalrate,
                        CurrentTime);

        XRRFreeScreenConfigInfo(cfg);
        delete display;

        if (RRSetConfigSuccess != status)
            LOG(VB_GENERAL, LOG_ERR,
                "XRRSetScreenConfigAndRate() call failed.");

        return RRSetConfigSuccess == status;
    }

    LOG(VB_GENERAL, LOG_ERR, "Desired Resolution and FrameRate not found.");

    return false;
}
void XRandRToggler::setFullMode(const bool enable) {
    SizeID currentID = XRRConfigCurrentConfiguration(config, &rotation);
    int currentRate = XRRConfigCurrentRate(config);

    SizeID newID;
    int newRate;

    if (enable) {
        newID = fullResIndex;
        newRate = infoVector[fullResIndex].rates[fullRateIndex] / 10;

        if (!isFull) {
            originalResIndex = currentID;
            originalRate = currentRate;
        }
    } else {
        newID = originalResIndex;
        newRate = originalRate;
    }

    if (newID != currentID || newRate != currentRate) {
        XRRSetScreenConfigAndRate(QX11Info::display(), config, QX11Info::appRootWindow(), newID, rotation, newRate, CurrentTime);

        if (newRate != currentRate)
            emit rateChange(newRate * 10);
    }

    isFull = enable;
}
示例#11
0
bool DisplayResX::SwitchToVideoMode(int width, int height, short desired_rate)
{
    short rate;
    DisplayResScreen desired_screen(width, height, 0, 0, -1.0, desired_rate);
    int idx = DisplayResScreen::FindBestMatch(m_video_modes_unsorted,
                                              desired_screen, rate);
    if (idx >= 0)
    {
        Display *display = NULL;
        XRRScreenConfiguration *cfg = GetScreenConfig(display);
        if (!cfg)
            return false;

        X11L;
        Rotation rot;
        XRRConfigCurrentConfiguration(cfg, &rot);
        
        Window root = DefaultRootWindow(display);
        Status status = XRRSetScreenConfigAndRate(display, cfg, root, idx,
                                                  rot, rate, CurrentTime);
        
        XRRFreeScreenConfigInfo(cfg);
        XCloseDisplay(display);
        X11U;

        if (RRSetConfigSuccess != status)
            cerr<<"DisplaResX: XRRSetScreenConfigAndRate() call failed."<<endl;
        return RRSetConfigSuccess == status;
    }
    cerr<<"DisplaResX: Desired Resolution and FrameRate not found."<<endl;
    return false;
}
示例#12
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;
	}
}
示例#13
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;
}
VideoMode VideoModeImpl::getDesktopMode()
{
    VideoMode desktopMode;

    // Open a connection with the X server
    Display* display = OpenDisplay();
    if (display)
    {
        // Retrieve the default screen number
        int screen = DefaultScreen(display);

        // Check if the XRandR extension is present
        int version;
        if (XQueryExtension(display, "RANDR", &version, &version, &version))
        {
            // Get the current configuration
            XRRScreenConfiguration* config = XRRGetScreenInfo(display, RootWindow(display, screen));
            if (config)
            {
                // Get the current video mode
                Rotation currentRotation;
                int currentMode = XRRConfigCurrentConfiguration(config, &currentRotation);

                // Get the available screen sizes
                int nbSizes;
                XRRScreenSize* sizes = XRRConfigSizes(config, &nbSizes);
                if (sizes && (nbSizes > 0))
                    desktopMode = VideoMode(sizes[currentMode].width, sizes[currentMode].height, DefaultDepth(display, screen));

                // Free the configuration instance
                XRRFreeScreenConfigInfo(config);
            }
            else
            {
                // Failed to get the screen configuration
                err() << "Failed to retrieve the screen configuration while trying to get the desktop video modes" << std::endl;
            }
        }
        else
        {
            // XRandr extension is not supported : we cannot get the video modes
            err() << "Failed to use the XRandR extension while trying to get the desktop video modes" << std::endl;
        }

        // Close the connection with the X server
        CloseDisplay(display);
    }
    else
    {
        // We couldn't connect to the X server
        err() << "Failed to connect to the X server while trying to get the desktop video modes" << std::endl;
    }

    return desktopMode;
}
void X11EGLSupport::switchMode(uint& width, uint& height, short& frequency)
{
    if (!mRandr)
        return;

    int size = 0;
    int newSize = -1;

    VideoModes::iterator mode;
    VideoModes::iterator end = mVideoModes.end();
    VideoMode *newMode = 0;

    for(mode = mVideoModes.begin(); mode != end; size++)
    {
        if (mode->first.first >= static_cast<int>(width) &&
                mode->first.second >= static_cast<int>(height))
        {
            if (!newMode ||
                    mode->first.first < newMode->first.first ||
                    mode->first.second < newMode->first.second)
            {
                newSize = size;
                newMode = &(*mode);
            }
        }

        VideoMode* lastMode = &(*mode);

        while (++mode != end && mode->first == lastMode->first)
        {
            if (lastMode == newMode && mode->second == frequency)
            {
                newMode = &(*mode);
            }
        }
    }

    if (newMode && *newMode != mCurrentMode)
    {
        XRRScreenConfiguration *screenConfig =
            XRRGetScreenInfo((Display*)mNativeDisplay, DefaultRootWindow((Display*)mNativeDisplay));
        if (screenConfig)
        {
            Rotation currentRotation;

            XRRConfigCurrentConfiguration (screenConfig, &currentRotation);
            XRRSetScreenConfigAndRate((Display*)mNativeDisplay, screenConfig, DefaultRootWindow((Display*)mNativeDisplay),
                                      newSize, currentRotation, newMode->second, CurrentTime);
            XRRFreeScreenConfigInfo(screenConfig);
            mCurrentMode = *newMode;
            LogManager::getSingleton().logMessage("Entered video mode " + StringConverter::toString(mCurrentMode.first.first) + "x" + StringConverter::toString(mCurrentMode.first.second) + " @ " + StringConverter::toString(mCurrentMode.second) + "MHz");
        }
    }
}
示例#16
0
int set_x11videomode(const x11videomode_t * xvidmode, x11screen_t * x11screen)
{
    int err ;
    XRRScreenConfiguration * screen_config = 0 ;

    if (!isextxrandr_x11display(display_x11screen(x11screen))) {
        err = ENOSYS ;
        goto ONERR;
    }

    Display * sys_display = display_x11screen(x11screen)->sys_display ;
    screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ;
    if (!screen_config) {
        err = ENOSYS ;
        goto ONERR;
    }

    Rotation current_rotation ;
    uint16_t current_size = XRRConfigCurrentConfiguration(screen_config, &current_rotation) ;

    int            sizes_count ;
    XRRScreenSize  * sizes = XRRConfigSizes(screen_config, &sizes_count) ;
    if (  !sizes
            || (current_size >= sizes_count)) {
        err = EOVERFLOW ;
        goto ONERR;
    }

    if (  xvidmode->modeid > sizes_count
            || xvidmode->width_in_pixel  != (uint32_t) sizes[xvidmode->modeid].width
            || xvidmode->height_in_pixel != (uint32_t) sizes[xvidmode->modeid].height) {
        err = EINVAL ;
        goto ONERR;
    }

    if (XRRSetScreenConfig( sys_display, screen_config,
                            RootWindow(sys_display, number_x11screen(x11screen)),
                            xvidmode->modeid, current_rotation, CurrentTime)) {
        err = EOPNOTSUPP ;
        goto ONERR;
    }

    XRRFreeScreenConfigInfo(screen_config) ;

    return 0 ;
ONERR:
    if (screen_config) {
        XRRFreeScreenConfigInfo(screen_config) ;
    }
    TRACEEXIT_ERRLOG(err);
    return err ;
}
示例#17
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!");
    }
}
示例#18
0
////////////////////////////////////////////////////////////
/// Switch to fullscreen mode
////////////////////////////////////////////////////////////
void WindowImplX11::SwitchToFullscreen(const VideoMode& Mode)
{
    // Check if the XRandR extension is present
    int Version;
    if (XQueryExtension(ourDisplay, "RANDR", &Version, &Version, &Version))
    {
        // Get the current configuration
        XRRScreenConfiguration* Config = XRRGetScreenInfo(ourDisplay, RootWindow(ourDisplay, ourScreen));
        if (Config)
        {
            // Get the current rotation
            Rotation CurrentRotation;
            myOldVideoMode = XRRConfigCurrentConfiguration(Config, &CurrentRotation);

            // Get the available screen sizes
            int NbSizes;
            XRRScreenSize* Sizes = XRRConfigSizes(Config, &NbSizes);
            if (Sizes && (NbSizes > 0))
            {
                // Search a matching size
                for (int i = 0; i < NbSizes; ++i)
                {
                    if ((Sizes[i].width == static_cast<int>(Mode.Width)) && (Sizes[i].height == static_cast<int>(Mode.Height)))
                    {
                        // Switch to fullscreen mode
                        XRRSetScreenConfig(ourDisplay, Config, RootWindow(ourDisplay, ourScreen), i, CurrentRotation, CurrentTime);

                        // Set "this" as the current fullscreen window
                        ourFullscreenWindow = this;
                        break;
                    }
                }
            }

            // Free the configuration instance
            XRRFreeScreenConfigInfo(Config);
        }
        else
        {
            // Failed to get the screen configuration
            std::cerr << "Failed to get the current screen configuration for fullscreen mode, switching to windiw mode" << std::endl;
        }
    }
    else
    {
        // XRandr extension is not supported : we cannot use fullscreen mode
        std::cerr << "Fullscreen is not supported, switching to window mode" << std::endl;
    }
}
示例#19
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;
 }
示例#20
0
    /**
     * Returns the currently active mode as specified in the Xrandr config.
     * Also determines the display's current rotation angle.
     */
    DisplayMode currentMode() const
    {
        DisplayMode mode;
        de::zap(mode);

        if(!_conf) return mode;

        SizeID currentSize = XRRConfigCurrentConfiguration(_conf, &displayRotation);

        // Update the current mode.
        mode.width = _sizes[currentSize].width;
        mode.height = _sizes[currentSize].height;
        mode.depth = displayDepth;
        mode.refreshRate = XRRConfigCurrentRate(_conf);
        return mode;
    }
示例#21
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 */
示例#22
0
void RotationDaemon::rotate(int angle)
{
    // XXX: technically this is leaked
    static XRRScreenConfiguration *config = XRRGetScreenInfo(QX11Info::display(), DefaultRootWindow(QX11Info::display()));

    ushort rotation;
    ushort size;
    size = XRRConfigCurrentConfiguration(config, &rotation);

    short rate;
    rate = XRRConfigCurrentRate(config);

    unsigned long timestamp, current_time;
    timestamp = XRRTimes(QX11Info::display(), XDefaultScreen(QX11Info::display()), &current_time);

    qDebug() << "RotationDaemon::rotate(" << angle << ")";
    XRRSetScreenConfigAndRate(QX11Info::display(), config, DefaultRootWindow(QX11Info::display()), size, angle, rate, timestamp);
}
示例#23
0
int initcurrent_x11videomode(/*out*/x11videomode_t * current_xvidmode, x11screen_t * x11screen)
{
    int err ;
    XRRScreenConfiguration * screen_config = 0 ;

    if (!isextxrandr_x11display(display_x11screen(x11screen))) {
        err = ENOSYS ;
        goto ONERR;
    }

    Display * sys_display = display_x11screen(x11screen)->sys_display ;
    screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ;
    if (!screen_config) {
        err = ENOSYS ;
        goto ONERR;
    }

    Rotation current_rotation ;
    uint16_t current_size = XRRConfigCurrentConfiguration(screen_config, &current_rotation) ;

    int           sizes_count ;
    XRRScreenSize * sizes = XRRConfigSizes(screen_config, &sizes_count) ;
    if (  !sizes
            || (current_size >= sizes_count)) {
        err = EOVERFLOW ;
        goto ONERR;
    }

    current_xvidmode->modeid          = current_size ;
    current_xvidmode->width_in_pixel  = (uint32_t) sizes[current_size].width ;
    current_xvidmode->height_in_pixel = (uint32_t) sizes[current_size].height ;

    XRRFreeScreenConfigInfo(screen_config) ;

    return 0 ;
ONERR:
    if (screen_config) {
        XRRFreeScreenConfigInfo(screen_config) ;
    }
    TRACEEXIT_ERRLOG(err);
    return err ;
}
示例#24
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);
        }
    }
}
XRandRToggler::XRandRToggler() :
    config(XRRGetScreenInfo(QX11Info::display(), QX11Info::appRootWindow())),
    originalResIndex(0),
    fullResIndex(0),
    rotation(0),
    fullRateIndex(0),
    originalRate(0),
    isFull(false)
{
    fullResIndex = originalResIndex = XRRConfigCurrentConfiguration(config, &rotation);
    originalRate = XRRConfigCurrentRate(config);

    int nSizes;
    XRRScreenSize *randrSizes = XRRConfigSizes(config, &nSizes);

    for (int i = 0; i < nSizes; ++i) {
        ResInfo info;
        info.w = randrSizes[i].width;
        info.h = randrSizes[i].height;

        int nHz;
        short *rates = XRRConfigRates(config, i, &nHz);

        for (int j = 0; j < nHz; ++j)
            info.rates.push_back(rates[j] * 10);

        infoVector.push_back(info);
    }

    {
        unsigned i = 0;

        while (i < infoVector[fullResIndex].rates.size() && infoVector[fullResIndex].rates[i] != originalRate * 10)
            ++i;

        if (i == infoVector[fullResIndex].rates.size())
            infoVector[fullResIndex].rates.push_back(originalRate * 10);

        fullRateIndex = i;
    }
}
示例#26
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
}
const QRect XRandRToggler::fullScreenRect(const QWidget */*wdgt*/) const {
    int w, h;

    {
        int nSizes = 0;
        XRRScreenSize *randrSizes = XRRConfigSizes(config, &nSizes);

        Rotation rot = rotation;
        SizeID currentID = XRRConfigCurrentConfiguration(config, &rot);

        if (currentID < nSizes) {
            w = randrSizes[currentID].width;
            h = randrSizes[currentID].height;
        } else {
            w = infoVector[fullResIndex].w;
            h = infoVector[fullResIndex].h;
        }
    }

    return QRect(0, 0, w, h);
}
示例#28
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);
}
示例#29
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();
}
示例#30
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);
}