bool RandRScreen::applyProposed()
{
// kdDebug() << k_funcinfo << " size " << (SizeID)proposedSize() << ", rotation " << proposedRotation() << ", refresh " <<
// refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) << endl;
Status status;
if(proposedRefreshRate() < 0)
status = XRRSetScreenConfig(qt_xdisplay(), d->config, DefaultRootWindow(qt_xdisplay()), (SizeID)proposedSize(), (Rotation)proposedRotation(),
CurrentTime);
else
{
if(refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) <= 0)
{
m_proposedRefreshRate = 0;
}
status = XRRSetScreenConfigAndRate(qt_xdisplay(), d->config, DefaultRootWindow(qt_xdisplay()), (SizeID)proposedSize(),
(Rotation)proposedRotation(), refreshRateIndexToHz(proposedSize(), proposedRefreshRate()), CurrentTime);
}
// kdDebug() << "New size: " << WidthOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << ", " <<
// HeightOfScreen(ScreenOfDisplay(QPaintDevice::x11AppDisplay(), screen)) << endl;
if(status == RRSetConfigSuccess)
{
m_currentSize = m_proposedSize;
m_currentRotation = m_proposedRotation;
m_currentRefreshRate = m_proposedRefreshRate;
return true;
}
return false;
}
CD_APPLET_ON_CLICK_END
//\___________ Define here the entries you want to add to the menu when the user right-clicks on your icon or on its subdock or your desklet. The icon and the container that were clicked are available through the macros CD_APPLET_CLICKED_ICON and CD_APPLET_CLICKED_CONTAINER. CD_APPLET_CLICKED_ICON may be NULL if the user clicked in the container but out of icons. The menu where you can add your entries is available throught the macro CD_APPLET_MY_MENU; you can add sub-menu to it if you want.
#ifdef HAVE_X11
#ifdef HAVE_XRANDR
static void _on_select_resolution (GtkMenuItem *menu_item, gpointer data) /// TODO: put that in the core...
{
CD_APPLET_ENTER;
int iNumRes = GPOINTER_TO_INT (data);
Display *dpy;
Window root;
XRRScreenConfiguration *conf;
short *rates;
int num_rates;
dpy = gdk_x11_get_default_xdisplay ();
root = RootWindow(dpy, 0);
conf = XRRGetScreenInfo(dpy, root);
CD_APPLET_LEAVE_IF_FAIL (conf != NULL);
//g_return_if_fail (conf != NULL);
rates = XRRRates(dpy, 0, iNumRes, &num_rates);
CD_APPLET_LEAVE_IF_FAIL (num_rates > 0);
//g_return_if_fail (num_rates > 0);
cd_debug ("available rates : from %d to %d Hz", rates[0], rates[num_rates-1]);
XRRSetScreenConfigAndRate(dpy, conf, root, iNumRes, RR_Rotate_0, rates[num_rates-1], CurrentTime);
XRRFreeScreenConfigInfo (conf);
// restore original conf : XRRSetScreenConfigAndRate(dpy, conf, root, original_size_id, original_rotation, original_rate, CurrentTime);
CD_APPLET_LEAVE();
}
/*
* @brief sets the current primary output's refresh rate
* @param root window which's primary output will be queried
* @param size_index referencing the size to be set
* @param rate the refresh rate to be set
* @return EINA_TRUE on success else EINA_FALSE
*/
EAPI Eina_Bool
ecore_x_randr_screen_primary_output_refresh_rate_set(
Ecore_X_Window root,
int size_index,
Ecore_X_Randr_Refresh_Rate
rate)
{
#ifdef ECORE_XRANDR
RANDR_CHECK_1_1_RET(EINA_FALSE);
Eina_Bool ret = EINA_FALSE;
XRRScreenConfiguration *sc = NULL;
if (!(sc = XRRGetScreenInfo(_ecore_x_disp, root)))
return ret;
if (!XRRSetScreenConfigAndRate(_ecore_x_disp, sc,
root, size_index,
RR_Rotate_0, rate, CurrentTime))
ret = EINA_TRUE;
XRRFreeScreenConfigInfo(sc);
return ret;
#else /* ifdef ECORE_XRANDR */
return EINA_FALSE;
#endif /* ifdef ECORE_XRANDR */
} /* ecore_x_randr_screen_primary_output_refresh_rate_set */
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;
}
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 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, ¤t_rotation);
XRRSetScreenConfigAndRate(display, screenConfig, rootWnd, size,
current_rotation, mode.refreshRate, CurrentTime);
XRRFreeScreenConfigInfo(screenConfig);
Trace(String("Video mode changed to:") + VideoMode::ToString(mode));
}
}
}
bool QxtScreenPrivate::set(const QSize& reso, int rate, int depth)
{
bool result = false;
Q_UNUSED(reso);
Q_UNUSED(rate);
Q_UNUSED(depth);
#ifdef HAVE_XRANDR
Display* display = XOpenDisplay(NULL);
Window root = RootWindow(display, screen);
XRRScreenConfiguration* config = XRRGetScreenInfo(display, root);
int sizeIndex = 0;
if (reso.isValid())
sizeIndex = availResos.indexOf(reso);
else
sizeIndex = availResos.indexOf(currReso);
Q_ASSERT(sizeIndex != -1);
if (rate == -1)
result = XRRSetScreenConfig(display, config, root, sizeIndex, RR_Rotate_0, CurrentTime);
else
result = XRRSetScreenConfigAndRate(display, config, root, sizeIndex, RR_Rotate_0, rate, CurrentTime);
XRRFreeScreenConfigInfo(config);
XCloseDisplay(display);
#endif // HAVE_XRANDR
return result;
}
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;
}
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, ¤tRotation);
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");
}
}
}
void RestoreScene() {
/* Restore screen resolution */
if(cg_screen_mode == CG_FULLSCREEN) {
XRRSetScreenConfigAndRate(cg_display, cg_screen_conf,
DefaultRootWindow(cg_display), cg_orig_size,
cg_rotation, cg_orig_rate, CurrentTime);
XRRFreeScreenConfigInfo(cg_screen_conf);
}
/* Free resources */
glXMakeCurrent(cg_display, 0, 0);
glXDestroyContext(cg_display, cg_context);
XDestroyWindow(cg_display, cg_window);
XCloseDisplay(cg_display);
}
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()), ¤t_time);
qDebug() << "RotationDaemon::rotate(" << angle << ")";
XRRSetScreenConfigAndRate(QX11Info::display(), config, DefaultRootWindow(QX11Info::display()), size, angle, rate, timestamp);
}
KDE_EXPORT bool RandRScreen::applyProposed()
{
//kdDebug() << k_funcinfo << " size " << (SizeID)proposedSize() << ", rotation " << proposedRotation() << ", refresh " << refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) << endl;
Status status;
if (!d->config) {
d->config = XRRGetScreenInfo(tqt_xdisplay(), RootWindow(tqt_xdisplay(), m_screen));
Q_ASSERT(d->config);
}
if (d->config) {
if (proposedRefreshRate() < 0)
status = XRRSetScreenConfig(tqt_xdisplay(), d->config, DefaultRootWindow(tqt_xdisplay()), (SizeID)proposedSize(), (Rotation)proposedRotation(), CurrentTime);
else {
if( refreshRateIndexToHz(proposedSize(), proposedRefreshRate()) <= 0 ) {
m_proposedRefreshRate = 0;
}
status = XRRSetScreenConfigAndRate(tqt_xdisplay(), d->config, DefaultRootWindow(tqt_xdisplay()), (SizeID)proposedSize(), (Rotation)proposedRotation(), refreshRateIndexToHz(proposedSize(), proposedRefreshRate()), CurrentTime);
}
}
else {
// Great, now we have to set the information manually. Ughh.
// FIXME--this does not work!
ScreenInfo *screeninfo = internal_read_screen_info(tqt_xdisplay());
screeninfo->cur_width = (*m_pixelSizes.at(proposedSize())).width();
screeninfo->cur_height = (*m_pixelSizes.at(proposedSize())).height();
internal_main_low_apply(screeninfo);
status = RRSetConfigSuccess;
}
//kdDebug() << "New size: " << WidthOfScreen(ScreenOfDisplay(TQPaintDevice::x11AppDisplay(), screen)) << ", " << HeightOfScreen(ScreenOfDisplay(TQPaintDevice::x11AppDisplay(), screen)) << endl;
if (status == RRSetConfigSuccess) {
m_currentSize = m_proposedSize;
m_currentRotation = m_proposedRotation;
m_currentRefreshRate = m_proposedRefreshRate;
return true;
}
return false;
}
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);
}
}
}
bool apply(const DisplayMode* mode)
{
if(!_conf) return false;
int sizeIdx = find(mode);
assert(sizeIdx >= 0);
//qDebug() << "calling XRRSetScreenConfig" << _confTime;
Status result = XRRSetScreenConfigAndRate(QX11Info::display(), _conf, QX11Info::appRootWindow(),
sizeIdx, displayRotation, rateFromMode(mode), _confTime);
//qDebug() << "result" << result;
if(result == BadValue)
{
qDebug() << "Failed to apply screen config and rate with Xrandr";
return false;
}
// Update the current mode.
de::currentMode = *mode;
return true;
}
/*
* r_desktop_destroy:
*
*/
void
r_desktop_destroy()
{
XRRScreenConfiguration *sc;
if(self.current_width != self.default_width || self.current_height != self.default_height)
{
sc = XRRGetScreenInfo(game->display, DefaultRootWindow(game->display));
XRRSetScreenConfigAndRate(
game->display,
sc,
DefaultRootWindow(game->display),
self.size,
self.rotation,
self.rate,
CurrentTime
);
XRRFreeScreenConfigInfo(sc);
XSync(game->display, True);
}
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeSetDisplayMode
(JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused)), jint index __attribute__((unused)), jshort rate __attribute__((unused)))
{
#ifdef HAVE_XRANDR
GdkDisplay *display;
XRRScreenConfiguration *config;
Rotation rotation;
display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv);
gdk_threads_enter();
config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW());
/* The rotation is not exposed to the Java API. So we retrieve its current
* value and set it to the same when switching resolution.
*/
XRRConfigCurrentConfiguration (config, &rotation);
XRRSetScreenConfigAndRate (GDK_DISPLAY_XDISPLAY(display),
config,
GDK_ROOT_WINDOW(),
index,
rotation,
rate,
CurrentTime);
XRRFreeScreenConfigInfo(config);
gdk_threads_leave();
#else
JCL_ThrowException(env,
"java/lang/InternalError",
"Method should not have been invoked.");
#endif
}
void _glfwSetVideoModeMODE(int mode, int rate)
{
if (_glfwLibrary.X11.RandR.available)
{
#if defined(_GLFW_HAS_XRANDR)
XRRScreenConfiguration* sc;
Window root;
root = _glfwLibrary.X11.root;
sc = XRRGetScreenInfo(_glfwLibrary.X11.display, root);
// Remember old size and flag that we have changed the mode
if (!_glfwLibrary.X11.FS.modeChanged)
{
_glfwLibrary.X11.FS.oldSizeID = XRRConfigCurrentConfiguration(sc, &_glfwLibrary.X11.FS.oldRotation);
_glfwLibrary.X11.FS.oldWidth = DisplayWidth(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen);
_glfwLibrary.X11.FS.oldHeight = DisplayHeight(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen);
_glfwLibrary.X11.FS.modeChanged = GL_TRUE;
}
if (rate > 0)
{
// Set desired configuration
XRRSetScreenConfigAndRate(_glfwLibrary.X11.display,
sc,
root,
mode,
RR_Rotate_0,
(short) rate,
CurrentTime);
}
else
{
// Set desired configuration
XRRSetScreenConfig(_glfwLibrary.X11.display,
sc,
root,
mode,
RR_Rotate_0,
CurrentTime);
}
XRRFreeScreenConfigInfo(sc);
#endif /*_GLFW_HAS_XRANDR*/
}
else if (_glfwLibrary.X11.VidMode.available)
{
#if defined(_GLFW_HAS_XF86VIDMODE)
XF86VidModeModeInfo **modelist;
int modecount;
// Get a list of all available display modes
XF86VidModeGetAllModeLines(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
&modecount, &modelist);
// Unlock mode switch if necessary
if (_glfwLibrary.X11.FS.modeChanged)
{
XF86VidModeLockModeSwitch(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
0);
}
// Change the video mode to the desired mode
XF86VidModeSwitchToMode(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
modelist[mode]);
// Set viewport to upper left corner (where our window will be)
XF86VidModeSetViewPort(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
0, 0);
// Lock mode switch
XF86VidModeLockModeSwitch(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
1);
// Remember old mode and flag that we have changed the mode
if (!_glfwLibrary.X11.FS.modeChanged)
{
_glfwLibrary.X11.FS.oldMode = *modelist[0];
_glfwLibrary.X11.FS.modeChanged = GL_TRUE;
}
XFree(modelist);
#endif /*_GLFW_HAS_XF86VIDMODE*/
}
}
static int xrandr_resize(int xsz, int ysz, int rate, int just_checking)
{
#ifdef HAVE_X11_EXTENSIONS_XRANDR_H
int event_base, error_base, ver_major, ver_minor, use_rate;
XRRScreenConfiguration *xrr_config = 0;
Status result = -1;
/* must check at runtime for the availability of the extension */
if(!XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) {
return -1;
}
XRRQueryVersion(fgDisplay.Display, &ver_major, &ver_minor);
/* we only heed the rate if we CAN actually use it (Xrandr >= 1.1) and
* the user actually cares about it (rate > 0)
*/
use_rate = ( rate > 0 ) && ( ( ver_major >= 1 ) ||
( ( ver_major == 1 ) && ( ver_minor >= 1 ) ) );
/* this loop is only so that the whole thing will be repeated if someone
* else changes video mode between our query of the current information and
* the attempt to change it.
*/
do {
XRRScreenSize *ssizes;
short *rates;
Rotation rot;
int i, ssizes_count, rates_count, curr, res_idx = -1;
Time timestamp, cfg_timestamp;
if(xrr_config) {
XRRFreeScreenConfigInfo(xrr_config);
}
if(!(xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) {
fgWarning("XRRGetScreenInfo failed");
break;
}
ssizes = XRRConfigSizes(xrr_config, &ssizes_count);
curr = XRRConfigCurrentConfiguration(xrr_config, &rot);
timestamp = XRRConfigTimes(xrr_config, &cfg_timestamp);
/* if either of xsz or ysz are unspecified, use the current values */
if(xsz <= 0)
xsz = fgState.GameModeSize.X = ssizes[curr].width;
if(ysz <= 0)
ysz = fgState.GameModeSize.Y = ssizes[curr].height;
if(xsz == ssizes[curr].width && ysz == ssizes[curr].height) {
/* no need to switch, we're already in the requested resolution */
res_idx = curr;
} else {
for(i=0; i<ssizes_count; i++) {
if(ssizes[i].width == xsz && ssizes[i].height == ysz) {
res_idx = i;
break; /* found it */
}
}
}
if(res_idx == -1)
break; /* no matching resolution */
#if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(use_rate) {
rate = fgState.GameModeRefresh;
/* for the selected resolution, let's find out if there is
* a matching refresh rate available.
*/
rates = XRRConfigRates(xrr_config, res_idx, &rates_count);
for(i=0; i<rates_count; i++) {
if(rates[i] == rate) {
break;
}
}
if(i == rates_count) {
break; /* no matching rate */
}
}
#endif
if(just_checking) {
result = 0;
break;
}
#if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(use_rate)
result = XRRSetScreenConfigAndRate(fgDisplay.Display, xrr_config,
fgDisplay.RootWindow, res_idx, rot, rate, timestamp);
else
#endif
result = XRRSetScreenConfig(fgDisplay.Display, xrr_config,
fgDisplay.RootWindow, res_idx, rot, timestamp);
} while(result == RRSetConfigInvalidTime);
if(xrr_config) {
XRRFreeScreenConfigInfo(xrr_config);
}
if(result == 0) {
return 0;
}
#endif /* HAVE_X11_EXTENSIONS_XRANDR_H */
return -1;
}
/*
* 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);
}
