#include "x.h"
#include <QDebug>
namespace X
{
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
Screen * Screen::_instance = NULL;
Screen::Screen()
{
// Get initial data (to be freed)
_display = XOpenDisplay(NULL);
_screenResources = XRRGetScreenResourcesCurrent(_display, DefaultRootWindow(_display));
/* Get informations about Xserver */
updateScreenResources();
}
//___________________________________________________________________________
void Screen::updateScreenResources()
{
// Create the modemap
_modeMap.clear();
for (int i = 0; i < _screenResources->nmode; ++i)
{
_modeMap.insert(
_screenResources->modes[i].id,
Mode(&_screenResources->modes[i])
);
}
// Create crtcMap
_crtcMap.clear();
for (int i = 0; i < _screenResources->ncrtc; ++i)
{
_crtcMap.insert(
_screenResources->crtcs[i],
Crtc(_screenResources->crtcs[i],this)
);
}
// Create outputMap
_outputMap.clear();
for (int i = 0; i < _screenResources->noutput; ++i)
{
_outputMap.insert(
_screenResources->outputs[i],
new Output(_screenResources->outputs[i], this)
);
}
// Create connectedOutputMap
_connectedOutputList.clear();
for (OutputMap::iterator it = _outputMap.begin();
it != _outputMap.end(); ++it)
if ( (*it)->isConnected() )
_connectedOutputList.push_back((*it)->_id);
}
//___________________________________________________________________________
void Screen::createMode(
unsigned int resX,
unsigned int resY,
unsigned long dotClock,
unsigned int hSyncStart,
unsigned int hSyncEnd,
unsigned int hTotal,
unsigned int vSyncStart,
unsigned int vSyncEnd,
unsigned int vTotal,
QString name)
{
XRRModeInfo m;
m.width = resX;
m.height = resY;
m.dotClock = dotClock;
m.hSyncStart= hSyncStart;
m.hSyncEnd = hSyncEnd;
m.hTotal = hTotal;
m.hSkew = 0;
m.vSyncStart= vSyncStart;
m.vSyncEnd = vSyncEnd;
m.vTotal = vTotal;
QByteArray ba = name.toLocal8Bit();
m.name = ba.data();
XRRCreateMode(const_cast<Display*>(X::Screen::inst()->display()), DefaultRootWindow(X::Screen::inst()->display()), &m);
//XRRAddOutputMode();
}
//___________________________________________________________________________
Screen::~Screen()
{
XCloseDisplay(_display);
XRRFreeScreenResources(_screenResources);
for (int i = 0; i < _outputMap.size(); ++i)
delete _outputMap[i];
}
// //_________________________________________________________________________
//// int Screen::applyChanges()
//// {
//// // First make backup to restore in case of an error or user interaction
//// // Calculate screensize
//// QRect screenSize;
//// for (CrtcMap::iterator i = _crtcMap.begin(); i != _crtcMap.end(); ++i)
//// screenSize = screenSize.united(i->getRect());
//// /* values from xrandr */
//// float dpi = (25.4 * DisplayHeight(_display, 0)) /
//// DisplayHeightMM(_display, 0);
//// int widthMM = (int) ((25.4 * screenSize.width()) / dpi);
//// int heightMM = (int) ((25.4 * screenSize.height()) / dpi);
//// // Set screensize
//// XRRSetScreenSize(_display, DefaultRootWindow(_display),
//// screenSize.width(),
//// screenSize.height(),
//// widthMM, heightMM);
//// // Apply changes of each crtc
//// // Stupid applying here, sanitychecks have to be done before
//// for (CrtcMap::iterator i = _crtcMap.begin(); i != _crtcMap.end(); ++i)
//// {
//// if ( i->applyChanges() )
//// {
//// revertChanges();
//// return EXIT_FAILURE;
//// }
//// }
//// return EXIT_SUCCESS;
//// }
//// //_________________________________________________________________________
//// void Screen::revertChanges()
//// {
//// // TODO
//// }
//// OutputList Screen::getConnectedOutputs() const
//// {
//// OutputList result;
//// for (OutputMap::const_iterator it = _outputMap.begin();
//// it != _outputMap.end(); ++it)
//// if (it->isConnected())
//// result.push_back(it->_id);
//// return result;
//// }
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
XElement::XElement(XID xid)
: _id(xid), _validity(false) {}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
Mode::Mode(XRRModeInfo *info)
{
if ( info == NULL )
return;
_id = info->id;
_dotClock = info->dotClock;
_hSyncStart = info->hSyncStart;
_hSyncEnd = info->hSyncEnd;
_hTotal = info->hTotal;
_hSkew = info->hSkew;
_vSyncStart = info->vSyncStart;
_vSyncEnd = info->vSyncEnd;
_vTotal = info->vTotal;
_name = QString(info->name);
_modeFlags = info->modeFlags;
_resolution.setWidth(info->width);
_resolution.setHeight(info->height);
_validity = true;
// rate = ((float) info->dotClock / ((float) info->hTotal * (float) info->vTotal));
qDebug() << "Mode: " << _id << _resolution.width() << _resolution.height();
}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
Crtc::Crtc(XID id, Screen * parent)
: XElement(id), _parent(parent)
{
// Get the information from XRROutputInfo
XRRCrtcInfo * info = XRRGetCrtcInfo(
const_cast<Display*>(_parent->display()),
const_cast<XRRScreenResources*>(_parent->screenResources()),
id);
// Leave invalid if XID not existent
if ( !info ){
return;
}
_timestamp = info->timestamp;
_crtcRect = QRect(
info->x,
info->y,
info->width,
info->height);
_mode = info->mode;
for (int i = 0; i < info->noutput; ++i)
_outputs.append(info->outputs[i]);
for (int i = 0; i < info->npossible; ++i)
_possible.append(info->possible[i]);
_rotation = info->rotation;
_rotations = info->rotations;
_validity = true;
XRRFreeCrtcInfo(info);
qDebug() << "Crtc: " << _id << _mode << _outputs
<< _crtcRect;
}
//// int Crtc::applyChanges()
//// {
//// return XRRSetCrtcConfig(_parent->display,
//// _parent->screenResources,
//// _id,
//// _timestamp,
//// _crtcRect.x(),
//// _crtcRect.y(),
//// _mode,
//// _rotation,
//// _outputs.toVector().data(),
//// _outputs.size()
//// );
//// }
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
Output::Output(XID id, Screen * parent)
: XElement(id), _parent(parent), _hasReliableEDID(false)
{
// Get the information from XRROutputInfo
XRROutputInfo* info = XRRGetOutputInfo(
const_cast<Display*>(_parent->display()),
const_cast<XRRScreenResources*>(_parent->screenResources()),
id);
// Leave invalid if XID not existent
if ( !info ){
return;
}
_timestamp = info->timestamp;
_crtc = info->crtc;
_name = QString(info->name);
_metricDimension.setWidth(info->mm_width);
_metricDimension.setHeight(info->mm_height);
_connection = (State)info->connection;
//subpixel_order = info->subpixel_order;
for (int i = 0; i < info->ncrtc; ++i)
_crtcs.append(info->crtcs[i]);
for (int i = 0; i < info->nclone; ++i)
_clones.append(info->clones[i]);
// List the supported modes and extract preferred
// This is the point where creating the modemap before the outputmap
// gets a contition.
for (int i = 0; i < info->nmode; ++i){
_modes.insert(info->modes[i]);
if (i < info->npreferred)
_preferred = i;
}
XRRFreeOutputInfo(info);
// Check if this is a beamer
_isProjector = _metricDimension.isEmpty();
// Maybe obsolete, since no preferred mode means no EDID.
// // EDID = ?;
int nprop;
Atom *props = XRRListOutputProperties(
const_cast<Display*>(_parent->display()),
_id,
&nprop);
for (int i = 0; i < nprop; ++i)
{
char *atom_name = XGetAtomName (
const_cast<Display*>(_parent->display()),
props[i]);
if ( strcmp (atom_name, "EDID") == 0)
{
// // Print Stuff
// unsigned long nitems, bytes_after;
// unsigned char *prop;
// int actual_format;
// Atom actual_type;
// int bytes_per_item;
// XRRGetOutputProperty (dpy, ID, props[i],
// 0, 100, False, False,
// AnyPropertyType,
// &actual_type, &actual_format,
// &nitems, &bytes_after, &prop);
// XRRPropertyInfo *propinfo = XRRQueryOutputProperty(dpy, ID, props[i]);
// bytes_per_item = actual_format / 8;
// fprintf (stderr, "\t%s: ", atom_name);
// for (unsigned int k = 0; k < nitems; k++)
// {
// if (k != 0)
// {
// if ((k % 16) == 0)
// {
// fprintf (stderr, "\n\t\t");
// }
// }
// const uint8_t *val = prop + (k * bytes_per_item);
// fprintf (stderr, "%d02", *val);
// }
// free(propinfo);
_hasReliableEDID = true;
}
}
free(props);
qDebug() << "Output: " << _id << _name << _crtc
<< _metricDimension << _clones << _modes;
}
// //_________________________________________________________________________
//// int Screen::Output::changeMode(XID mode)
//// {
//// // Check if this mode is supported
//// if ( ! _modes.contains(mode) )
//// return 1;
//// // Check if this output is connected
//// if ( _connection != Output::Connected )
//// return 2;
//// // If this output is NOT conected to a crtc
//// if ( ! isActive() )
//// {
//// // Try to find a unconnected crtc which
//// // this output can be connected to
//// for (CrtcList::iterator i = _crtcs.begin(); ; ++i)
//// {
//// // If this search reches end no appropriate
//// // crtc has been found
//// if ( i == _crtcs.end() )
//// return 3;
//// // If a free crtc was found connect and apply mode
//// if ( _parent->_crtcMap[*i].getConnectedOutputs().empty() )
//// {
//// _parent->_crtcMap[*i].connect(this, mode);
//// break;
//// }
//// }
//// }
//// //If it is already connected apply mode to the crtc
//// // TODO(Manuel):continue
//// return 0;
//// }
//// //_________________________________________________________________________
//// int Output::changePos()
//// {
//// return 1;
//// }
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
}
//// qDebug() << XRRSetCrtcConfig(display,
//// screenResources,
//// screenResources->crtcs[1],
//// CurrentTime,
//// 0, 0,
//// 597,
//// RR_Rotate_0,
//// &(screenResources->outputs[3]),
//// 1);
//// qDebug() << XRRSetCrtcConfig(display,
//// screenResources,
//// screenResources->crtcs[0],
//// CurrentTime,
//// 1920, 0,
//// 586,
//// RR_Rotate_0,
//// &(screenResources->outputs[1]),
//// 1);
//// HOLY!!
//// XRRSetCrtcConfig(display,
//// screenResources,
//// screenResources->crtcs[1],
//// CurrentTime,
//// 0, 0,
//// 587,
//// RR_Rotate_0,
//// &screenResources->outputs[1],
//// 1);
/////////////////////////////// DBEUG //// DEBUG //////////////////////////////////
//// //SCREEN
//// qDebug() << "ScreenResources: ";
//// qDebug() << "Count of crtcs: " << screenResources->ncrtc;
//// qDebug() << "Count of outputs: " << screenResources->noutput;
//// qDebug() << "Count of modes: " << screenResources->nmode;
//// //MODES
//// for (int i = 0; i < screenResources->nmode; ++i)
//// {
//// qDebug() << screenResources->modes[i].id
//// << screenResources->modes[i].width
//// << screenResources->modes[i].height
////// << screenResources->modes[i].dotClock
////// << screenResources->modes[i].hSyncStart
////// << screenResources->modes[i].hSyncEnd
////// << screenResources->modes[i].hTotal
////// << screenResources->modes[i].hSkew
////// << screenResources->modes[i].vSyncStart
////// << screenResources->modes[i].vSyncEnd
////// << screenResources->modes[i].vTotal
////// << screenResources->modes[i].nameLength
//// << screenResources->modes[i].name;
//// }
//// //CRTCS
//// for (int j = 0; j < screenResources->ncrtc; ++j)
//// {
//// XRRCrtcInfo *CrtcInfo = XRRGetCrtcInfo(display, screenResources, screenResources->crtcs[j]);
//// qDebug() << "\n-------- CrtcInfo";
//// qDebug() << "timestamp: " << CrtcInfo->timestamp;
//// qDebug() << "x: " << CrtcInfo->x;
//// qDebug() << "y: " << CrtcInfo->y;
//// qDebug() << "width: " << CrtcInfo->width;
//// qDebug() << "height: " << CrtcInfo->height;
//// qDebug() << "rotation: " << CrtcInfo->rotation;
//// qDebug() << "noutput: " << CrtcInfo->noutput;
//// qDebug() << "rotations: " << CrtcInfo->rotations;
//// qDebug() << "npossible: " << CrtcInfo->npossible;
//// XRRFreeCrtcInfo(CrtcInfo);
//// }
//// // OUTPUTS
//// for (int nOut = 0; nOut < screenResources->noutput; ++nOut)
//// {
//// XRROutputInfo *OutputInfo = XRRGetOutputInfo (display, screenResources, screenResources->outputs[nOut]);
////// if (OutputInfo->connection == RR_Connected) {
//// qDebug() << "\n--- Output " << nOut;
//// qDebug() << "name " << OutputInfo->name;
//// qDebug() << "mm_width " << OutputInfo->mm_width;
//// qDebug() << "mm_height " << OutputInfo->mm_height;
//// qDebug() << "ncrtc " << OutputInfo->ncrtc;
//// qDebug() << "nclone " << OutputInfo->nclone;
//// qDebug() << "nmode " << OutputInfo->nmode;
//// qDebug() << "npreferred " << OutputInfo->npreferred;
//// for (int j = 0; j < OutputInfo->nmode; j++)
//// {
//// qDebug() << "mode" << j << ": " << OutputInfo->modes[j];
//// }
////// }
//// XRRFreeOutputInfo (OutputInfo);
//// }
///////////////////////////////////////////////////////////////////////////////////
