// Copyright 2013, University of Freiburg,
// Author: Manuel Schneider <ms1144>
#include <iostream>
#include <algorithm>
#include <QDebug>
#include <QtWidgets/QAction>
#include "widget.h"
#include "ui_widget.h"
#include "timeoutdialog.h"
#include "math.h"
//______________________________________________________________________________
Widget::Widget(bool testMode, QWidget *parent) :
QWidget(parent),
_ui(new Ui::Widget)
{
_ui->setupUi(this);
// Get initial data (to be freed)
_display = XOpenDisplay(NULL);
_screenResources = XRRGetScreenResourcesCurrent(
_display,
DefaultRootWindow(_display));
// Get the information about the X elements
updateScreenResources();
if (testMode) {
while (_connectedOutputList.size() > 2) {
_connectedOutputList.pop_front();
}
}
switch ( _connectedOutputList.size() ){
/*************************************************************************/
case 1:// In case of one connected output - xrandr --auto
qDebug() << "One connected output";
exit(0);
break;
case 2: // In case of two connected outputs
qDebug() << "Two connected outputs";
// Check if we are in clone mode
if (testMode || cloneMode()) {
qDebug() << "Dual output with cloned screen!";
// TODO make that mess nice and clean
double_t w0 = _outputMap[_connectedOutputList[0]]->mm_width;
double_t h0 = _outputMap[_connectedOutputList[0]]->mm_height;
double_t w1 = _outputMap[_connectedOutputList[1]]->mm_width;
double_t h1 = _outputMap[_connectedOutputList[1]]->mm_height;
// Get a human readable reference
if (w0 == 0 && h0 == 0) {
_beamer = _connectedOutputList[0];
_monitor = _connectedOutputList[1];
} else if (w1 == 0 && h1 == 0) {
_beamer = _connectedOutputList[1];
_monitor = _connectedOutputList[0];
} else {
double_t d0 = sqrt((pow(w0, 2) + pow(h0, 2)));
double_t d1 = sqrt((pow(w1, 2) + pow(h1, 2)));
if (d0 > d1) {
_beamer = _connectedOutputList[0];
_monitor = _connectedOutputList[1];
} else {
_beamer = _connectedOutputList[1];
_monitor = _connectedOutputList[0];
}
}
// Intersect them by the resolution sorted, dont care about O(n³)
QList<QPair<XRRModeInfo*, XRRModeInfo*> > commonModes;
// Iterate over the modes the monitor supports
for (int i = 0; i < _outputMap[_monitor]->nmode; ++i) {
XRRModeInfo* monitorMode = _modeMap[_outputMap[_monitor]->modes[i]];
// Skip interlace modes
if ( monitorMode->modeFlags & RR_Interlace )
continue;
// Iterate over the modes the beamer supports
for (int j = 0; j < _outputMap[_beamer]->nmode; ++j) {
XRRModeInfo* beamerMode = _modeMap[_outputMap[_beamer]->modes[j]];
// Skip interlace modes
if ( beamerMode->modeFlags & RR_Interlace )
continue;
// Only if the modes have the same size, list them in common modes
if ( monitorMode->height == beamerMode->height
&& monitorMode->width == beamerMode->width ) {
// Build a sorted list of common modes in descending order
QList<QPair<XRRModeInfo*, XRRModeInfo*> >::iterator k
= commonModes.begin();
for (;;++k) {
// If at the end, the mode to insert is the smallest, insert.
// This has to be first to avoid segfaults
if (k == commonModes.end()) {
commonModes.insert(k, qMakePair (monitorMode, beamerMode));
break;
}
// If the mode to insert is larger than k, insert.
if ( monitorMode->width > k->first->width) {
commonModes.insert(k, qMakePair (monitorMode, beamerMode));
break;
}
// If the width is the same ...
if ( monitorMode->width == k->first->width ) {
// ... and the height is the same, the mode already exists
if ( monitorMode->height == k->first->height ) {
break;
}
// ... and the height is larger, insert.
if ( monitorMode->height > k->first->height ) {
commonModes.insert(k, qMakePair (monitorMode, beamerMode));
break;
}
}
}
}
}
}
// Check if the beamer transmitted reliable data.
bool gotEDID = false;
int nprop;
Atom *props = XRRListOutputProperties(_display, _beamer, &nprop);
for (int i = 0; i < nprop; ++i) {
char *atom_name = XGetAtomName (_display, props[i]);
if ( strcmp (atom_name, "EDID") == 0) {
gotEDID = true;
XFree (atom_name);
break;
}
XFree (atom_name);
}
free(props);
// If the beamer transmits no reliable EDID data add modes
#ifdef QT_DEBUG
gotEDID = false;
#endif
if (gotEDID) {
qDebug() << "GOT EDID!";
// Extract the preferred mode of the beamer
RRMode preferredBeamerModeId = 0;
for (int i = 0; i < _outputMap[_beamer]->nmode; ++i) {
if (i < _outputMap[_beamer]->npreferred) {
preferredBeamerModeId = _outputMap[_beamer]->modes[i];
break;
}
}
// Compute the aspect ratio of the beamer
float aspectRatio = (float)_modeMap[preferredBeamerModeId]->width
/ _modeMap[preferredBeamerModeId]->height;
// Fill widget with data
for (QList<QPair<XRRModeInfo*, XRRModeInfo*> >::iterator i
= commonModes.begin(); i != commonModes.end(); ++i ) {
float modeAspectRatio = ((float)i->first->width / i->first->height);
if ( abs(modeAspectRatio - aspectRatio) < 0.05 ) // APPROX
_ui->comboBox->addItem(i->first->name,
QList<QVariant>()
<< QVariant((qulonglong)i->first->id)
<< QVariant((qulonglong)i->second->id));
}
} else {
qDebug() << "NO EDID!";
// Fill widget with data without AR match
// Fill widget with data
for ( QList<QPair<XRRModeInfo*, XRRModeInfo*> >::iterator i
= commonModes.begin(); i != commonModes.end(); ++i ) {
qDebug() << "Insert into QComboBox"
<< i->first->width << "x" << i->first->height
<< "(" << i->first->id << ")";
_ui->comboBox->addItem(i->first->name,
QList<QVariant>()
<< QVariant((qulonglong)i->first->id)
<< QVariant((qulonglong)i->second->id));
}
}
// Set the current resolution highlighted
QString n = _modeMap[_crtcMap[_outputMap[_monitor]->crtc]->mode]->name;
int index = _ui->comboBox->findText(n);
_ui->comboBox->setCurrentIndex(index);
// Remove borders and stuff
setWindowFlags(Qt::Widget | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);
//setStyleSheet("background:transparent;");
//setAttribute(Qt::WA_TranslucentBackground);
// Resize widget to its content
resize(sizeHint());
show();
QTimer *timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(bringToTopTimer()));
timer->start(1000);
// Center dialog on screenbottom
const QRect desktopRect = QApplication::desktop()->screenGeometry();
this->move( desktopRect.width()/2-this->width()/2,
desktopRect.height()-this->height());
// Connect button signal to appropriate slot
connect(_ui->pushButton, SIGNAL(clicked()), this, SLOT(handleButton()));
}
/*********************************************************************/
// If NEITHER of the outputs is a beamer (likely dualscreen setup)
else {
// TODO(manuel): Future feature. Setup dualscreen
qDebug() << "Dual output with extended screen!";
exit(0);
}
break;
/*************************************************************************/
default:
// If there are more than 3 outputs
// its up to the user. Quit.
qDebug() << "More than two outputs. Quit.";
exit(0);
break;
}
/*************************************************************************/
}
void Widget::bringToTopTimer()
{
if (_ui->comboBox->view()->isVisible()) return;
raise();
}
//______________________________________________________________________________
void Widget::updateScreenResources()
{
// Clear the modemap (nothing to be freed, stored in screenResources)
_modeMap.clear();
// Create the modemap
qDebug() << "_MODES_";
for (int i = 0; i < _screenResources->nmode; ++i) {
_modeMap.insert(
_screenResources->modes[i].id,
&_screenResources->modes[i]);
qDebug() << _screenResources->modes[i].id << "\t"
<< _screenResources->modes[i].width << "x"
<< _screenResources->modes[i].height;
}
// Clear the crtmap
for (CrtcMap::iterator it = _crtcMap.begin();
it != _crtcMap.end();) {
XRRFreeCrtcInfo(*it);
it = _crtcMap.erase(it);
}
// Create crtcMap
for (int i = 0; i < _screenResources->ncrtc; ++i) {
XRRCrtcInfo * info = XRRGetCrtcInfo(
_display,
_screenResources,
_screenResources->crtcs[i]);
_crtcMap.insert(
_screenResources->crtcs[i],
info);
}
// Clear the outputmap
for (OutputMap::iterator it = _outputMap.begin();
it != _outputMap.end();) {
XRRFreeOutputInfo(*it);
it = _outputMap.erase(it);
}
// Create outputmap and connectedOutputMap
for (int i = 0; i < _screenResources->noutput; ++i) {
XRROutputInfo* info = XRRGetOutputInfo(
_display,
_screenResources,
_screenResources->outputs[i]);
_outputMap.insert(
_screenResources->outputs[i],
info);
// Store the connected ones separate
if ( info->connection == RR_Connected )
_connectedOutputList.push_back(_screenResources->outputs[i]);
}
}
//______________________________________________________________________________
Widget::~Widget() {
delete _ui;
XCloseDisplay(_display);
XRRFreeScreenResources(_screenResources);
}
//______________________________________________________________________________
void Widget::handleButton(){
/*************************** Backup the crtcinfos ***************************/
qDebug() << "Backup the crtc infos";
CrtcMap backup;
for ( CrtcMap::iterator it = _crtcMap.begin();
it != _crtcMap.end(); ++it ) {
backup[it.key()] = new XRRCrtcInfo;
backup[it.key()]->x = it.value()->x;
backup[it.key()]->y = it.value()->y;
backup[it.key()]->mode = it.value()->mode;
backup[it.key()]->rotation = it.value()->rotation;
backup[it.key()]->noutput = it.value()->noutput;
backup[it.key()]->outputs = new RROutput[it.value()->noutput];
for (int i = 0; i < it.value()->noutput; ++i) {
backup[it.key()]->outputs[i] = it.value()->outputs[i];
}
}
/**************************** Apply the resolution **************************/
// Get the modes which has to be applied from QComboBox
QList<QVariant> modes =
_ui->comboBox->itemData( _ui->comboBox->currentIndex()).toList();
XRRModeInfo* monitorMode = _modeMap[modes[0].toULongLong()];
XRRModeInfo* beamerMode = _modeMap[modes[1].toULongLong()];
// First disconnect all crts to avoid conflicts
for(CrtcMap::iterator it = _crtcMap.begin(); it != _crtcMap.end(); ++it) {
Status st = XRRSetCrtcConfig(_display, _screenResources, it.key(), CurrentTime,
0, 0, None, RR_Rotate_0, NULL, 0);
qDebug() << "Disconnecting" << it.key() << ":" << st;
}
// Set screensize
XRRSetScreenSize(_display, DefaultRootWindow(_display),
monitorMode->width, monitorMode->height,
25.4 * monitorMode->width / 96, // standard dpi that X uses
25.4 * monitorMode->height / 96); // standard dpi that X uses
// Apply the modes
Status stMon = XRRSetCrtcConfig(_display,
_screenResources,
_outputMap[_monitor]->crtc,
CurrentTime,
0, 0, monitorMode->id,
RR_Rotate_0,
&_monitor, 1);
Status stBem = XRRSetCrtcConfig(_display,
_screenResources,
_outputMap[_beamer]->crtc,
CurrentTime,
0, 0, beamerMode->id,
RR_Rotate_0,
&_beamer, 1);
// Sync... whatever...
XSync (_display, False);
qDebug() << "Monitor set:" << stMon << ", beamer set: " << stBem;
// Center widget on screenbottom
this->move( monitorMode->width/2 - this->width()/2,
monitorMode->height - this->height() );
// Set the mouse pointer in the middle of the screen
QCursor::setPos(monitorMode->width/2, monitorMode->height/2);
/*************************** ASK for confirmtion ****************************/
// Show a dialog asking if the res should be kept
TimeOutDialog keepDialog(15, this);
keepDialog.setWindowModality(Qt::ApplicationModal);
keepDialog.setWindowTitle(" ");
keepDialog.setLabelText(trUtf8("Do you want to keep this resolution?"));
keepDialog.setCancelButtonText(trUtf8("Keep"));
keepDialog.move(monitorMode->width/2 - this->width()/2,
monitorMode->height/2 - this->height());
keepDialog.show();
while (keepDialog.isActive()) {
QCoreApplication::processEvents();
}
// If the dialog was not canceled revert the resolution
if ( !keepDialog.wasCanceled()) {
qDebug() << "User did not cancel timeout, reverting!";
/**************************** Apply the backup ****************************/
// First disconnect all crts to avoid conflicts
for(CrtcMap::iterator it = _crtcMap.begin(); it != _crtcMap.end(); ++it) {
XRRSetCrtcConfig(_display, _screenResources, it.key(), CurrentTime,
0, 0, None, RR_Rotate_0, NULL, 0);
}
// Then calc backed up screensize
QSize ScreenSize(0,0);
for ( CrtcMap::iterator it = backup.begin();
it != backup.end(); ++it ) {
// Dangerzone. Only access existing modes!
if ( it.value()->mode != None ) {
ScreenSize.setWidth(
std::max((uint)ScreenSize.width(),
it.value()->x+_modeMap[it.value()->mode]->width));
ScreenSize.setHeight(
std::max((uint)ScreenSize.height(),
it.value()->y+_modeMap[it.value()->mode]->height));
}
}
// Set screensize
XRRSetScreenSize(_display, DefaultRootWindow(_display),
ScreenSize.width(), ScreenSize.height(),
25.4 * ScreenSize.width() / 96, // dpi used by X
25.4 * ScreenSize.height() / 96); // dpi used by X
// Apply the backup
for ( CrtcMap::iterator it = backup.begin();
it != backup.end(); ++it ) {
XRRSetCrtcConfig(_display,
_screenResources,
it.key(),
CurrentTime,
it.value()->x,
it.value()->y,
it.value()->mode,
it.value()->rotation,
it.value()->outputs,
it.value()->noutput);
}
// Sync... whatever...
XSync (_display, False);
// center dialog on screenbottom
qDebug() << "Again center dialog on screenbottom";
this->move( ScreenSize.width()/2 - this->width()/2,
ScreenSize.height() - this->height());
// Set the mouse pointer in the middle of the screen
QCursor::setPos(monitorMode->width/2, monitorMode->height/2);
}
// Delete the backup
for ( CrtcMap::iterator it = backup.begin();
it != backup.end(); ++it ) {
delete[] it.value()->outputs;
delete it.value();
}
// Intenal settings changed. Update!
updateScreenResources();
}
bool Widget::cloneMode()
{
bool cloneMode = true;
for (CrtcMap::iterator it = _crtcMap.begin(); it != _crtcMap.end(); it++) {
XRRCrtcInfo* crtc = it.value();
// check if x starts on upper left corner
if (crtc->x != 0 || crtc->y != 0) {
cloneMode = false;
}
qDebug() << "width: " << crtc->width
<< "height: " << crtc->height
<< "x: " << crtc->x
<< "y: " << crtc->y
<< "mode: " << crtc->mode;
}
return cloneMode;
}
////////////////////////////////////////////////////////////////////////////////
