Rename a number of libraries and executables to avoid conflicts with KDE4

12 files changed, 4440 insertions, 0 deletions

diff --git a/tderandr/CMakeLists.txt b/tderandr/CMakeLists.txt
new file mode 100644
index 000000000..efcd8519d
--- /dev/null
+++ b/tderandr/CMakeLists.txt
@@ -0,0 +1,48 @@
+#################################################
+#
+#  (C) 2010 Serghei Amelian
+#  serghei (DOT) amelian (AT) gmail.com
+#
+#  Improvements and feedback are welcome
+#
+#  This file is released under GPL >= 2
+#
+#################################################
+
+include_directories(
+  ${TQT_INCLUDE_DIRS}
+  ${XRANDR_INCLUDE_DIRS}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_BINARY_DIR}/tdecore
+  ${CMAKE_SOURCE_DIR}/dcop
+  ${CMAKE_SOURCE_DIR}/tdecore
+  ${CMAKE_SOURCE_DIR}/tdeui
+)
+
+link_directories(
+  ${TQT_LIBRARY_DIRS}
+  ${XRANDR_LIBRARY_DIRS}
+)
+
+
+##### headers ###################################
+
+install( FILES
+    randr.h lowlevel_randr.h ktimerdialog.h libtderandr.h
+  DESTINATION ${INCLUDE_INSTALL_DIR}/libtderandr )
+
+
+##### tderandr ####################################
+
+set( target tderandr )
+
+set( ${target}_SRCS
+  randr.cpp lowlevel_randr.c ktimerdialog.cpp libtderandr.cc
+)
+
+tde_add_library( ${target} SHARED AUTOMOC
+  SOURCES ${${target}_SRCS}
+  VERSION 0.0.95
+  LINK tdeui-shared ${XRANDR_LIBRARIES} Xext
+  DESTINATION ${LIB_INSTALL_DIR}
+)
diff --git a/tderandr/Mainpage.dox b/tderandr/Mainpage.dox
new file mode 100644
index 000000000..c173d52aa
--- /dev/null
+++ b/tderandr/Mainpage.dox
@@ -0,0 +1,18 @@
+/** \mainpage XRandr Interface for Trinity Applications
+
+The \b KRandr library adds the ability for %Trinity applications to easily configure an Xorg display via XRandr.
+
+@authors
+Timothy Pearson \<kb9vqf@pearsoncomputing.net\>
+
+@maintainers
+Timothy Pearson \<kb9vqf@pearsoncomputing.net\>
+
+@licenses
+@gpl
+
+*/
+
+// DOXYGEN_REFERENCES = tdecore tdeui
+// DOXYGEN_SET_PROJECT_NAME = KRandr
+// vim:ts=4:sw=4:expandtab:filetype=doxygen
diff --git a/tderandr/Makefile.am b/tderandr/Makefile.am
new file mode 100644
index 000000000..7818014df
--- /dev/null
+++ b/tderandr/Makefile.am
@@ -0,0 +1,19 @@
+
+INCLUDES =  -I$(srcdir)/.. $(all_includes)
+
+# For the future: examine if condensing the tons of *_LDFLAGS variables
+# into $(all_libraries) isn't better
+AM_LDFLAGS = $(LDFLAGS_AS_NEEDED) $(LDFLAGS_NEW_DTAGS)
+
+libtderandrincludedir = $(includedir)/libtderandr
+libtderandrinclude_HEADERS = randr.h lowlevel_randr.h ktimerdialog.h libtderandr.h
+
+lib_LTLIBRARIES = libtderandr.la
+libtderandr_la_SOURCES  = randr.cpp lowlevel_randr.c ktimerdialog.cpp libtderandr.cc
+METASOURCES = AUTO
+
+libtderandr_la_LDFLAGS = $(KDE_MT_LDFLAGS) -version-info 0:95  -no-undefined
+libtderandr_la_LIBADD = $(LIBASOUND) ../tdecore/libtdecore.la $(LIB_QT) $(LIB_XRANDR)
+
+DOXYGEN_REFERENCES = tdecore
+include ../admin/Doxyfile.am
diff --git a/tderandr/configure.in.in b/tderandr/configure.in.in
new file mode 100644
index 000000000..3dd4a9319
--- /dev/null
+++ b/tderandr/configure.in.in
@@ -0,0 +1,21 @@
+dnl -----------------------------------------------------
+dnl X Resize and Rotate extension library check
+dnl -----------------------------------------------------
+
+KDE_CHECK_HEADERS(X11/extensions/Xrandr.h, [xrandr_h=yes], [xrandr_h=no], [#include <X11/Xlib.h>])
+if test "$xrandr_h" = yes; then
+  KDE_CHECK_LIB(Xrandr, XRRSetScreenConfigAndRate, [
+    LIB_XRANDR=-lXrandr
+    AC_DEFINE_UNQUOTED(XRANDR_SUPPORT, 1, [Defined if your system has XRandR support])
+    RANDR_SUBDIR="randr"
+  ], [
+    RANDR_SUBDIR=""
+  ], -lXrender -lXext $X_EXTRA_LIBS)
+else
+  LIB_XRANDR=
+fi
+AC_SUBST(LIB_XRANDR)
+AM_CONDITIONAL(system_has_xrandr, test -n "$RANDR_SUBDIR")
+if test $system_has_xrandr = no; then
+  DO_NOT_COMPILE="$DO_NOT_COMPILE libtderandr"
+fi
diff --git a/tderandr/ktimerdialog.cpp b/tderandr/ktimerdialog.cpp
new file mode 100644
index 000000000..0be416be7
--- /dev/null
+++ b/tderandr/ktimerdialog.cpp
@@ -0,0 +1,205 @@
+/*
+ *  This file is part of the KDE Libraries
+ *  Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include <tqhbox.h>
+#include <tqlayout.h>
+#include <tqvbox.h>
+#include <tqtimer.h>
+#include <tqprogressbar.h>
+#include <tqlabel.h>
+
+#include <twin.h>
+#include <kiconloader.h>
+
+#include <klocale.h>
+#include <kdebug.h>
+
+#include "ktimerdialog.h"
+#include "ktimerdialog.moc"
+
+KTimerDialog::KTimerDialog( int msec, TimerStyle style, TQWidget *parent,
+                 const char *name, bool modal,
+                 const TQString &caption,
+                 int buttonMask, ButtonCode defaultButton,
+                 bool separator,
+                 const KGuiItem &user1,
+                 const KGuiItem &user2,
+                 const KGuiItem &user3 )
+    : KDialogBase(parent, name, modal, caption, buttonMask, defaultButton,
+                 separator, user1, user2, user3 )
+{
+    totalTimer = new TQTimer( this );
+    updateTimer = new TQTimer( this );
+    msecTotal = msecRemaining = msec;
+    updateInterval = 1000;
+    tStyle = style;
+	KWin::setIcons( winId(), DesktopIcon("randr"), SmallIcon("randr") );
+    // default to cancelling the dialog on timeout
+    if ( buttonMask & Cancel )
+        buttonOnTimeout = Cancel;
+
+    connect( totalTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( slotInternalTimeout() ) );
+    connect( updateTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( slotUpdateTime() ) );
+
+    // create the widgets
+    mainWidget = new TQVBox( this, "mainWidget" );
+    timerWidget = new TQHBox( mainWidget, "timerWidget" );
+    timerLabel = new TQLabel( timerWidget );
+    timerProgress = new TQProgressBar( timerWidget );
+    timerProgress->setTotalSteps( msecTotal );
+    timerProgress->setPercentageVisible( false );
+
+    KDialogBase::setMainWidget( mainWidget );
+
+    slotUpdateTime( false );
+}
+
+KTimerDialog::~KTimerDialog()
+{
+}
+
+void KTimerDialog::show()
+{
+    KDialogBase::show();
+    totalTimer->start( msecTotal, true );
+    updateTimer->start( updateInterval, false );
+}
+
+int KTimerDialog::exec()
+{
+    totalTimer->start( msecTotal, true );
+    updateTimer->start( updateInterval, false );
+    return KDialogBase::exec();
+}
+
+void KTimerDialog::setMainWidget( TQWidget *widget )
+{
+    // yuck, here goes.
+    TQVBox *newWidget = new TQVBox( this );
+
+    if ( widget->parentWidget() != mainWidget ) {
+        widget->reparent( newWidget, 0, TQPoint(0,0) );
+    } else {
+        newWidget->insertChild( TQT_TQOBJECT(widget) );
+    }
+
+    timerWidget->reparent( newWidget, 0, TQPoint(0, 0) );
+
+    delete mainWidget;
+    mainWidget = newWidget;
+    KDialogBase::setMainWidget( mainWidget );
+}
+
+void KTimerDialog::setRefreshInterval( int msec )
+{
+    updateInterval = msec;
+    if ( updateTimer->isActive() )
+        updateTimer->changeInterval( updateInterval );
+}
+
+int KTimerDialog::timeoutButton() const
+{
+    return buttonOnTimeout;
+}
+
+void KTimerDialog::setTimeoutButton( const ButtonCode newButton )
+{
+    buttonOnTimeout = newButton;
+}
+
+int KTimerDialog::timerStyle() const
+{
+    return tStyle;
+}
+
+void KTimerDialog::setTimerStyle( const TimerStyle newStyle )
+{
+    tStyle = newStyle;
+}
+
+void KTimerDialog::slotUpdateTime( bool update )
+{
+    if ( update )
+        switch ( tStyle ) {
+            case CountDown:
+                msecRemaining -= updateInterval;
+                break;
+            case CountUp:
+                msecRemaining += updateInterval;
+                break;
+            case Manual:
+                break;
+        }
+    
+    timerProgress->setProgress( msecRemaining );
+
+    timerLabel->setText( i18n("1 second remaining:","%n seconds remaining:",msecRemaining/1000) );
+}
+
+void KTimerDialog::slotInternalTimeout()
+{
+    emit timerTimeout();
+    switch ( buttonOnTimeout ) {
+        case Help:
+            slotHelp();
+            break;
+        case Default:
+            slotDefault();
+            break;
+        case Ok:
+            slotOk();
+            break;
+        case Apply:
+            applyPressed();
+            break;
+        case Try:
+            slotTry();
+            break;
+        case Cancel:
+            slotCancel();
+            break;
+        case Close:
+            slotClose();
+            break;
+        /*case User1:
+            slotUser1();
+            break;
+        case User2:
+            slotUser2();
+            break;*/
+        case User3:
+            slotUser3();
+            break;
+        case No:
+            slotNo();
+            break;
+        case Yes:
+            slotCancel();
+            break;
+        case Details:
+            slotDetails();
+            break;
+        case Filler:
+        case Stretch:
+            kdDebug() << "Cannot execute button code " << buttonOnTimeout << endl;
+            break;
+    }
+}
diff --git a/tderandr/ktimerdialog.h b/tderandr/ktimerdialog.h
new file mode 100644
index 000000000..965a72393
--- /dev/null
+++ b/tderandr/ktimerdialog.h
@@ -0,0 +1,170 @@
+/*
+ *  This file is part of the KDE Libraries
+ *  Copyright (C) 2002 Hamish Rodda <rodda@kde.org>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
+ *
+ */
+#ifndef _KTIMERDIALOG_H_
+#define _KTIMERDIALOG_H_
+
+#include <kdialogbase.h>
+
+class TQTimer;
+class TQHBox;
+class TQProgressBar;
+class TQLabel;
+
+/**
+ * Provides a dialog that is only available for a specified amount
+ * of time, and reports the time remaining to the user.
+ *
+ * The timer is capable of counting up or down, for any number of milliseconds.
+ * 
+ * The button which is activated upon timeout can be specified, as can the
+ * update interval for the dialog box.
+ *
+ * In addition, this class retains all of the functionality of @see KDialogBase .
+ *
+ * @short A dialog with a time limit and corresponding UI features.
+ * @author Hamish Rodda <rodda@kde.org>
+ */
+class KTimerDialog : public KDialogBase
+{
+  Q_OBJECT
+
+  public:
+
+    /**
+     * @li @p CountDown - The timer counts downwards from the seconds given.
+     * @li @p CountUp - The timer counts up to the number of seconds given.
+     * @li @p Manual - The timer is not invoked; the caller must update the
+     * progress.
+     */
+    enum TimerStyle
+    {
+        CountDown,
+        CountUp,
+        Manual
+    };
+
+    /**
+     * Constructor for the standard mode where you must specify the main
+     * widget with @ref setMainWidget() . See @see KDialogBase for further details.
+     *
+     * For the rest of the arguments, See @see KDialogBase .
+     */
+    KTimerDialog( int msec, TimerStyle style=CountDown, TQWidget *parent=0,
+                 const char *name=0, bool modal=true,
+                 const TQString &caption=TQString::null,
+                 int buttonMask=Ok|Apply|Cancel, ButtonCode defaultButton=Ok,
+                 bool separator=false,
+                 const KGuiItem &user1=KGuiItem(),
+                 const KGuiItem &user2=KGuiItem(),
+                 const KGuiItem &user3=KGuiItem() );
+
+    /**
+     * Destructor.
+     */
+    ~KTimerDialog();
+
+    /**
+     * Execute the dialog modelessly - see @see TQDialog .
+     */
+    virtual void show();
+
+    /**
+     * Set the refresh interval for the timer progress. Defaults to one second.
+     */
+    void setRefreshInterval( int msec );
+
+    /**
+     * Retrieves the @ref ButtonCode which will be activated once the timer
+     * times out. @see setTimeoutButton
+     */
+    int timeoutButton() const;
+
+    /**
+     * Sets the @ref ButtonCode to determine which button will be activated
+     * once the timer times out. @see timeoutButton
+     */
+    void setTimeoutButton( ButtonCode newButton );
+
+    /**
+     * Retrieves the current @ref TimerStyle. @see setTimerStyle
+     */
+    int timerStyle() const;
+
+    /**
+     * Sets the @ref TimerStyle. @see timerStyle
+     */
+    void setTimerStyle( TimerStyle newStyle );
+
+    /**
+     * Overridden function which is used to set the main widget of the dialog.
+     * @see KDialogBase::setMainWidget.
+     */
+    void setMainWidget( TQWidget *widget );
+
+  signals:
+    /**
+     * Signal which is emitted once the timer has timed out.
+     */
+    void timerTimeout();
+
+  public slots:
+    /**
+     * Execute the dialog modally - see @see TQDialog .
+     */
+    int exec();
+
+  private slots:
+    /**
+     * Updates the dialog with the current progress levels.
+     */
+    void slotUpdateTime( bool update = true );
+
+    /**
+     * The internal
+     */
+    void slotInternalTimeout();
+
+  private:
+    /**
+     * Prepares the layout that manages the widgets of the dialog
+     */
+    void setupLayout();
+
+    TQTimer *totalTimer;
+    TQTimer *updateTimer;
+    int msecRemaining, updateInterval, msecTotal;
+
+    ButtonCode buttonOnTimeout;
+    TimerStyle tStyle;
+    
+    TQHBox *timerWidget;
+    TQProgressBar *timerProgress;
+    TQLabel *timerLabel;
+    TQVBox *mainWidget;
+
+    class KTimerDialogPrivate;
+    KTimerDialogPrivate *d;
+};
+
+#endif
+
+
+
diff --git a/tderandr/libtderandr.cc b/tderandr/libtderandr.cc
new file mode 100644
index 000000000..65005f91e
--- /dev/null
+++ b/tderandr/libtderandr.cc
@@ -0,0 +1,1634 @@
+/*  libtderandr.cc     - class KRandr that makes it easy to use XRandr in KDE
+    This file is part of KRandr 0.9.5
+    Copyright (C) 2010  Timothy Pearson
+    LibKRandr's homepage : http://www.trinitydesktop.org
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+
+    Send comments and bug fixes to Timothy Pearson <kb9vqf@pearsoncomputing.net>
+
+***************************************************************************/
+
+#include <tqdir.h>
+#include <tqtimer.h>
+#include <tqstringlist.h>
+
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kapplication.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <cmath>
+
+#include "libtderandr.h"
+
+#include <X11/extensions/dpms.h>
+
+// FIXME
+// For now, just use the standalone xrandr program to apply the display settings
+#define USE_XRANDR_PROGRAM
+
+// This routine is courtsey of an answer on "Stack Overflow"
+// It takes an LSB-first int and makes it an MSB-first int (or vice versa)
+unsigned int reverse_bits(register unsigned int x)
+{
+    x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
+    x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
+    x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
+    x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
+    return((x >> 16) | (x << 16));
+}
+
+// This routine returns the output of an arbitrary Bash command
+TQString exec(const char * cmd) {
+	TQString bashcommand = cmd;
+	bashcommand = bashcommand.replace("\"", "\\\"");
+	bashcommand = TQString("/bin/bash -c \"%1\" 2>&1").arg(bashcommand);
+	FILE* pipe = popen(bashcommand.ascii(), "r");
+	if (!pipe) return "ERROR";
+	char buffer[128];
+	TQString result = "";
+	while(!feof(pipe)) {
+		if(fgets(buffer, 128, pipe) != NULL) {
+			result += buffer;
+		}
+	}
+	pclose(pipe);
+	result.remove(result.length(), 1);
+	return result;
+}
+
+TQString capitalizeString(TQString in) {
+	return in.left(1).upper() + in.right(in.length()-1);
+}
+
+TQString KRandrSimpleAPI::getIccFileName(TQString profileName, TQString screenName, TQString kde_confdir) {
+	KSimpleConfig *t_config = NULL;
+	KSimpleConfig *t_systemconfig = NULL;
+	int t_numberOfProfiles;
+	TQStringList t_cfgProfiles;
+	TQString retval;
+
+	if (profileName != NULL) {
+		t_config = new KSimpleConfig( TQString::fromLatin1( "kiccconfigrc" ));
+	}
+	else {
+		t_systemconfig = new KSimpleConfig( kde_confdir + TQString("/kicc/kiccconfigrc") );
+	}
+
+	if (profileName != NULL) {
+		t_config->setGroup(NULL);
+		if (t_config->readBoolEntry("EnableICC", false) == true) {
+			t_config->setGroup(profileName);
+			retval = t_config->readEntry(screenName);
+		}
+		else {
+			retval = "";
+		}
+	}
+	else {
+		t_systemconfig->setGroup(NULL);
+		if (t_systemconfig->readBoolEntry("EnableICC", false) == true) {
+			retval = t_systemconfig->readEntry("ICCFile");
+		}
+		else {
+			retval = "";
+		}
+	}
+
+	if (profileName != "") {
+		if (t_config) {
+			delete t_config;
+		}
+	}
+	else {
+		if (t_systemconfig) {
+			delete t_systemconfig;
+		}
+	}
+
+	return retval;
+}
+
+TQString KRandrSimpleAPI::applyIccFile(TQString screenName, TQString fileName) {
+	int i;
+	int j;
+	Display *randr_display;
+	ScreenInfo *randr_screen_info;
+	XRROutputInfo *output_info;
+
+	int screenNumber = 0;
+
+	if (fileName != "") {
+		// FIXME
+		// This should use the RRSetCrtcGamma function when available
+		// That is the only way to get proper setting when two output are active at the same time
+		// (otherwise in clone mode only one screen is available)
+
+		// HACK
+		// For now, simply exit with no changes if screenName is not an active output
+
+		if (isValid() == true) {
+			screenNumber = -1;
+			randr_display = tqt_xdisplay();
+			randr_screen_info = read_screen_info(randr_display);
+			if (randr_screen_info == NULL) {
+				return "";
+			}
+			j=0;
+			for (i = 0; i < randr_screen_info->n_output; i++) {
+				output_info = randr_screen_info->outputs[i]->info;
+				// Look for ON outputs...
+				if (!randr_screen_info->outputs[i]->cur_crtc) {
+					continue;
+				}
+				// ...that are connected
+				if (RR_Disconnected == randr_screen_info->outputs[i]->info->connection) {
+					continue;
+				}
+				if (output_info->name == screenName) {
+					screenNumber = j;
+				}
+				j++;
+			}
+			freeScreenInfoStructure(randr_screen_info);
+		}
+
+		if (screenNumber >= 0) {
+			// Apply ICC settings with XCalib
+			TQString icc_command;
+			FILE *pipe_xcalib;
+			char xcalib_result[2048];
+			int i;
+			xcalib_result[0]=0;
+
+			icc_command = TQString("xcalib \"%1\"").arg(fileName);
+			if ((pipe_xcalib = popen(icc_command.ascii(), "r")) == NULL)
+			{
+				printf("Xcalib pipe error\n\r [xcalib apply]");
+			}
+			else {
+				if (fgets(xcalib_result, 2048, pipe_xcalib)) {
+					pclose(pipe_xcalib);
+					for (i=1;i<2048;i++) {
+						if (xcalib_result[i] == 0) {
+							xcalib_result[i-1]=0;
+							i=2048;
+						}
+					}
+					if (strlen(xcalib_result) > 2) {
+						return xcalib_result;
+					}
+				}
+				else {
+					return "";
+				}
+			}
+		}
+	}
+	else {
+		// Reset ICC profile on this screen
+
+		// FIXME
+		// This should use the RRSetCrtcGamma function when available
+		// That is the only way to get proper setting when two output are active at the same time
+		// (otherwise in clone mode only one screen is available)
+
+		// HACK
+		// For now, simply exit with no changes if screenName is not an active output
+
+		if (isValid() == true) {
+			screenNumber = -1;
+			randr_display = tqt_xdisplay();
+			randr_screen_info = read_screen_info(randr_display);
+			if (randr_screen_info == NULL) {
+				return "";
+			}
+			j=0;
+			for (i = 0; i < randr_screen_info->n_output; i++) {
+				output_info = randr_screen_info->outputs[i]->info;
+				// Look for ON outputs...
+				if (!randr_screen_info->outputs[i]->cur_crtc) {
+					continue;
+				}
+				// ...that are connected
+				if (RR_Disconnected == randr_screen_info->outputs[i]->info->connection) {
+					continue;
+				}
+				if (output_info->name == screenName) {
+					screenNumber = j;
+				}
+				j++;
+			}
+			freeScreenInfoStructure(randr_screen_info);
+		}
+
+		if (screenNumber >= 0) {
+			// Apply ICC settings with XCalib
+			TQString icc_command;
+			FILE *pipe_xcalib;
+			char xcalib_result[2048];
+			int i;
+			xcalib_result[0]=0;
+
+			icc_command = TQString("xcalib -c");
+			if ((pipe_xcalib = popen(icc_command.ascii(), "r")) == NULL)
+			{
+				printf("Xcalib pipe error\n\r [xcalib clear]");
+			}
+			else {
+				if (fgets(xcalib_result, 2048, pipe_xcalib)) {
+					pclose(pipe_xcalib);
+					for (i=1;i<2048;i++) {
+						if (xcalib_result[i] == 0) {
+							xcalib_result[i-1]=0;
+							i=2048;
+						}
+					}
+					if (strlen(xcalib_result) > 2) {
+						return xcalib_result;
+					}
+				}
+				else {
+					return "";
+				}
+			}
+		}
+	}
+	return "";
+}
+
+TQString KRandrSimpleAPI::applyIccConfiguration(TQString profileName, TQString kde_confdir) {
+	int i;
+	Display *randr_display;
+	ScreenInfo *randr_screen_info;
+	XRROutputInfo *output_info;
+	KSimpleConfig *t_config;
+
+	int screenNumber = 0;
+	TQString errorstr = "";
+
+	t_config = new KSimpleConfig( TQString::fromLatin1( "kiccconfigrc" ));
+
+	// Find all screens
+	if (isValid() == true) {
+		randr_display = tqt_xdisplay();
+		randr_screen_info = read_screen_info(randr_display);
+		if (randr_screen_info == NULL) {
+			return "";
+		}
+		for (i = 0; i < randr_screen_info->n_output; i++) {
+			output_info = randr_screen_info->outputs[i]->info;
+			errorstr = applyIccFile(output_info->name, getIccFileName(profileName, output_info->name, kde_confdir));
+			if (errorstr != "") {
+				return errorstr;
+			}
+		}
+		freeScreenInfoStructure(randr_screen_info);
+	}
+	else {
+		return applyIccFile(getIccFileName(profileName, "Default", kde_confdir), "Default");
+	}
+
+	t_config->writeEntry("CurrentProfile", profileName);
+	t_config->sync();
+	delete t_config;
+
+	return "";
+}
+
+TQString KRandrSimpleAPI::getEDIDMonitorName(int card, TQString displayname) {
+	TQString edid;
+	TQByteArray binaryedid = getEDID(card, displayname);
+	if (binaryedid.isNull())
+		return TQString();
+
+	// Get the manufacturer ID
+	unsigned char letter_1 = ((binaryedid[8]>>2) & 0x1F) + 0x40;
+	unsigned char letter_2 = (((binaryedid[8] & 0x03) << 3) | ((binaryedid[9]>>5) & 0x07)) + 0x40;
+	unsigned char letter_3 = (binaryedid[9] & 0x1F) + 0x40;
+	TQChar qletter_1 = TQChar(letter_1);
+	TQChar qletter_2 = TQChar(letter_2);
+	TQChar qletter_3 = TQChar(letter_3);
+	TQString manufacturer_id = TQString("%1%2%3").arg(qletter_1).arg(qletter_2).arg(qletter_3);
+
+	// Get the model ID
+	unsigned int raw_model_id = (((binaryedid[10] << 8) | binaryedid[11]) << 16) & 0xFFFF0000;
+	// Reverse the bit order
+	unsigned int model_id = reverse_bits(raw_model_id);
+
+	// Try to get the model name
+	bool has_friendly_name = false;
+	unsigned char descriptor_block[18];
+	int i;
+	for (i=72;i<90;i++) {
+		descriptor_block[i-72] = binaryedid[i] & 0xFF;
+	}
+	if ((descriptor_block[0] != 0) || (descriptor_block[1] != 0) || (descriptor_block[3] != 0xFC)) {
+		for (i=90;i<108;i++) {
+			descriptor_block[i-90] = binaryedid[i] & 0xFF;
+		}
+		if ((descriptor_block[0] != 0) || (descriptor_block[1] != 0) || (descriptor_block[3] != 0xFC)) {
+			for (i=108;i<126;i++) {
+				descriptor_block[i-108] = binaryedid[i] & 0xFF;
+			}
+		}
+	}
+
+	TQString monitor_name;
+	if ((descriptor_block[0] == 0) && (descriptor_block[1] == 0) && (descriptor_block[3] == 0xFC)) {
+		char* pos = strchr((char *)(descriptor_block+5), '\n');
+		if (pos) {
+			*pos = 0;
+			has_friendly_name = true;
+			monitor_name = TQString((char *)(descriptor_block+5));
+		}
+		else {
+			has_friendly_name = false;
+		}
+	}
+
+	// [FIXME]
+	// Look up manudacturer names if possible!
+
+	if (has_friendly_name)
+		edid = TQString("%1 %2").arg(manufacturer_id).arg(monitor_name);
+	else
+		edid = TQString("%1 0x%2").arg(manufacturer_id).arg(model_id, 0, 16);
+
+	return edid;
+}
+
+TQByteArray KRandrSimpleAPI::getEDID(int card, TQString displayname) {
+	TQFile file(TQString("/sys/class/drm/card%1-%2/edid").arg(card).arg(displayname));
+	if (!file.open (IO_ReadOnly))
+		return TQByteArray();
+	TQByteArray binaryedid = file.readAll();
+	file.close();
+	return binaryedid;
+}
+
+TQString KRandrSimpleAPI::getCurrentProfile () {
+	TQString profileName;
+	KSimpleConfig *t_config;
+
+	t_config = new KSimpleConfig( TQString::fromLatin1( "kiccconfigrc" ));
+	profileName = t_config->readEntry("CurrentProfile");
+	delete t_config;
+	return profileName;
+}
+
+TQString KRandrSimpleAPI::applySystemWideIccConfiguration(TQString kde_confdir) {
+	// Apply ICC settings with XCalib
+	TQString icc_command;
+	FILE *pipe_xcalib;
+	char xcalib_result[2048];
+	int i;
+	xcalib_result[0]=0;
+
+	icc_command = TQString("xcalib \"%1\"").arg(getIccFileName(NULL, "Default", kde_confdir));
+	if ((pipe_xcalib = popen(icc_command.ascii(), "r")) == NULL)
+	{
+		printf("Xcalib pipe error [xcalib apply]\n\r");
+	}
+	else {
+		if (fgets(xcalib_result, 2048, pipe_xcalib)) {
+			pclose(pipe_xcalib);
+			for (i=1;i<2048;i++) {
+				if (xcalib_result[i] == 0) {
+					xcalib_result[i-1]=0;
+					i=2048;
+				}
+			}
+			if (strlen(xcalib_result) > 2) {
+				return xcalib_result;
+			}
+		}
+		else {
+			return "";
+		}
+	}
+	return "";
+}
+
+TQStringList KRandrSimpleAPI::getDisplayConfigurationProfiles(TQString kde_confdir) {
+	TQStringList ret;
+
+	TQDir d(kde_confdir + "/displayconfig/");
+	d.setFilter(TQDir::Files);
+	d.setSorting(TQDir::Name);
+
+	const TQFileInfoList *list = d.entryInfoList();
+	if (list) {
+		TQFileInfoListIterator it(*list);
+		TQFileInfo *fi;
+
+		while ((fi = it.current()) != 0) {
+			if (fi->fileName() != "default") {
+				ret.append(fi->fileName());
+			}
+			++it;
+		}
+	}
+
+	return ret;
+}
+
+bool KRandrSimpleAPI::deleteDisplayConfiguration(TQString profilename, TQString kde_confdir) {
+	TQString fileName = kde_confdir + "/displayconfig/";
+	fileName.append(profilename);
+	return (!unlink(fileName.ascii()));
+}
+
+bool KRandrSimpleAPI::renameDisplayConfiguration(TQString profilename, TQString newprofilename, TQString kde_confdir) {
+	TQString fileName = kde_confdir + "/displayconfig/";
+	TQString newFileName = fileName;
+	fileName.append(profilename);
+	newFileName.append(newprofilename);
+	TQDir d(kde_confdir + "/displayconfig/");
+	return (d.rename(fileName, newFileName));
+}
+
+void KRandrSimpleAPI::saveDisplayConfiguration(bool enable, bool applyonstart, TQString profilename, TQString defaultprofilename, TQString kde_confdir, TQPtrList<SingleScreenData> screenInfoArray) {
+	int i;
+
+	TQString filename;
+
+	filename = "displayglobals";
+	filename.prepend(kde_confdir.append("/"));
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+	display_config->setGroup("General");
+	display_config->writeEntry("EnableDisplayControl", enable);
+	display_config->writeEntry("ApplySettingsOnStart", applyonstart);
+	display_config->writeEntry("StartupProfileName", defaultprofilename);
+	display_config->sync();
+	delete display_config;
+
+	filename = profilename;
+	if (filename == "") {
+		filename = "default";
+	}
+	filename.prepend(kde_confdir.append("/displayconfig/"));
+
+	display_config = new KSimpleConfig( filename );
+
+	i=0;
+	SingleScreenData *screendata;
+	for ( screendata=screenInfoArray.first(); screendata; screendata=screenInfoArray.next() ) {
+		display_config->setGroup(TQString("SCREEN %1").arg(i));
+		display_config->writeEntry("ScreenUniqueName", screendata->screenUniqueName);
+		display_config->writeEntry("ScreenFriendlyName", screendata->screenFriendlyName);
+		display_config->writeEntry("GenericScreenDetected", screendata->generic_screen_detected);
+		display_config->writeEntry("ScreenConnected", screendata->screen_connected);
+		display_config->writeEntry("Resolutions", screendata->resolutions);
+		display_config->writeEntry("RefreshRates", screendata->refresh_rates);
+		display_config->writeEntry("ColorDepths", screendata->color_depths);
+		display_config->writeEntry("AvailableRotations", screendata->rotations);
+		display_config->writeEntry("CurrentResolution", screendata->current_resolution_index);
+		display_config->writeEntry("CurrentRefreshRate", screendata->current_refresh_rate_index);
+		display_config->writeEntry("CurrentColorDepth", screendata->current_color_depth_index);
+		display_config->writeEntry("CurrentRotation", screendata->current_rotation_index);
+		display_config->writeEntry("CurrentOrientiation", screendata->current_orientation_mask);
+		display_config->writeEntry("GammaRed", screendata->gamma_red);
+		display_config->writeEntry("GammaGreen", screendata->gamma_green);
+		display_config->writeEntry("GammaBlue", screendata->gamma_blue);
+		display_config->writeEntry("CurrentXFlip", screendata->has_x_flip);
+		display_config->writeEntry("CurrentYFlip", screendata->has_y_flip);
+		display_config->writeEntry("SupportsTransformation", screendata->supports_transformations);
+		display_config->writeEntry("IsPrimary", screendata->is_primary);
+		display_config->writeEntry("IsExtended", screendata->is_extended);
+		display_config->writeEntry("AbsXPos", screendata->absolute_x_position);
+		display_config->writeEntry("AbsYPos", screendata->absolute_y_position);
+		display_config->writeEntry("CurrentXPixelCount", screendata->current_x_pixel_count);
+		display_config->writeEntry("CurrentYPixelCount", screendata->current_y_pixel_count);
+		display_config->writeEntry("HasDPMS", screendata->has_dpms);
+		display_config->writeEntry("EnableDPMS", screendata->enable_dpms);
+		display_config->writeEntry("DPMSStandbyDelay", screendata->dpms_standby_delay);
+		display_config->writeEntry("DPMSSuspendDelay", screendata->dpms_suspend_delay);
+		display_config->writeEntry("DPMSPowerDownDelay", screendata->dpms_off_delay);
+		i++;
+	}
+
+	display_config->sync();
+	delete display_config;
+}
+
+TQPoint KRandrSimpleAPI::applyStartupDisplayConfiguration(TQString kde_confdir) {
+	bool applyonstart = getDisplayConfigurationStartupAutoApplyEnabled(kde_confdir);
+	if (applyonstart) {
+		TQString profilename = getDisplayConfigurationStartupAutoApplyName(kde_confdir);
+		return applyDisplayConfiguration(profilename, kde_confdir);
+	}
+	else {
+		return TQPoint();
+	}
+}
+
+TQPoint KRandrSimpleAPI::applyDisplayConfiguration(TQString profilename, TQString kde_confdir) {
+	TQPoint ret;
+
+	bool enabled = getDisplayConfigurationEnabled(kde_confdir);
+	if (profilename == "") {
+		profilename = "default";
+	}
+
+	if (enabled) {
+		TQPtrList<SingleScreenData> screenInfoArray;
+		screenInfoArray = loadDisplayConfiguration(profilename, kde_confdir);
+		if (screenInfoArray.count() > 0) {
+			applyDisplayConfiguration(screenInfoArray, FALSE, kde_confdir);
+		}
+		destroyScreenInformationObject(screenInfoArray);
+		screenInfoArray = readCurrentDisplayConfiguration();
+		ensureMonitorDataConsistency(screenInfoArray);
+		ret = primaryScreenOffsetFromTLC(screenInfoArray);
+		destroyScreenInformationObject(screenInfoArray);
+	}
+
+	return ret;
+}
+
+TQPtrList<SingleScreenData> KRandrSimpleAPI::loadDisplayConfiguration(TQString profilename, TQString kde_confdir) {
+	int i;
+
+	TQString filename;
+	filename = profilename;
+	if (filename == "") {
+		filename = "default";
+	}
+	filename.prepend(kde_confdir.append("/displayconfig/"));
+
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+
+	TQStringList grouplist = display_config->groupList();
+	SingleScreenData *screendata;
+	TQPtrList<SingleScreenData> screenInfoArray;
+	for ( TQStringList::Iterator it = grouplist.begin(); it != grouplist.end(); ++it ) {
+		if ((*it).startsWith("SCREEN ")) {
+			display_config->setGroup(*it);
+			i = ((*it).remove("SCREEN ")).toInt();
+			screendata = new SingleScreenData;
+			screenInfoArray.append(screendata);
+			screendata->screenUniqueName = display_config->readEntry("ScreenUniqueName");
+			screendata->screenFriendlyName = display_config->readEntry("ScreenFriendlyName");
+			screendata->generic_screen_detected = display_config->readBoolEntry("GenericScreenDetected");
+			screendata->screen_connected = display_config->readBoolEntry("ScreenConnected");
+			screendata->resolutions = display_config->readListEntry("Resolutions");
+			screendata->refresh_rates = display_config->readListEntry("RefreshRates");
+			screendata->color_depths = display_config->readListEntry("ColorDepths");
+			screendata->rotations = display_config->readListEntry("AvailableRotations");
+			screendata->current_resolution_index = display_config->readNumEntry("CurrentResolution");
+			screendata->current_refresh_rate_index = display_config->readNumEntry("CurrentRefreshRate");
+			screendata->current_color_depth_index = display_config->readNumEntry("CurrentColorDepth");
+			screendata->current_rotation_index = display_config->readNumEntry("CurrentRotation");
+			screendata->current_orientation_mask = display_config->readNumEntry("CurrentOrientiation");
+			screendata->gamma_red = display_config->readDoubleNumEntry("GammaRed");
+			screendata->gamma_green = display_config->readDoubleNumEntry("GammaGreen");
+			screendata->gamma_blue = display_config->readDoubleNumEntry("GammaBlue");
+			screendata->has_x_flip = display_config->readBoolEntry("CurrentXFlip");
+			screendata->has_y_flip = display_config->readBoolEntry("CurrentYFlip");
+			screendata->supports_transformations = display_config->readBoolEntry("SupportsTransformation");
+			screendata->is_primary = display_config->readBoolEntry("IsPrimary");
+			screendata->is_extended = display_config->readBoolEntry("IsExtended");
+			screendata->absolute_x_position = display_config->readNumEntry("AbsXPos");
+			screendata->absolute_y_position = display_config->readNumEntry("AbsYPos");
+			screendata->current_x_pixel_count = display_config->readNumEntry("CurrentXPixelCount");
+			screendata->current_y_pixel_count = display_config->readNumEntry("CurrentYPixelCount");
+			screendata->has_dpms = display_config->readBoolEntry("HasDPMS");
+			screendata->enable_dpms = display_config->readBoolEntry("EnableDPMS");
+			screendata->dpms_standby_delay = display_config->readNumEntry("DPMSStandbyDelay");
+			screendata->dpms_suspend_delay = display_config->readNumEntry("DPMSSuspendDelay");
+			screendata->dpms_off_delay = display_config->readNumEntry("DPMSPowerDownDelay");
+		}
+	}
+
+	delete display_config;
+
+	return screenInfoArray;
+}
+
+int KRandrSimpleAPI::getHardwareRotationFlags(SingleScreenData* screendata) {
+	int rotationFlags = 0;
+	TQString rotationDesired = *screendata->rotations.at(screendata->current_rotation_index);
+	if (rotationDesired == ROTATION_0_DEGREES_STRING) {
+		rotationFlags = rotationFlags | RandRScreen::Rotate0;
+	}
+	else if (rotationDesired == ROTATION_90_DEGREES_STRING) {
+		rotationFlags = rotationFlags | RandRScreen::Rotate90;
+	}
+	else if (rotationDesired == ROTATION_180_DEGREES_STRING) {
+		rotationFlags = rotationFlags | RandRScreen::Rotate180;
+	}
+	else if (rotationDesired == ROTATION_270_DEGREES_STRING) {
+		rotationFlags = rotationFlags | RandRScreen::Rotate270;
+	}
+	if (screendata->has_x_flip) {
+		rotationFlags = rotationFlags | RandRScreen::ReflectX;
+	}
+	if (screendata->has_y_flip) {
+		rotationFlags = rotationFlags | RandRScreen::ReflectY;
+	}
+	return rotationFlags;
+}
+
+#define USE_XRANDR_PROGRAM
+
+bool KRandrSimpleAPI::applyDisplayConfiguration(TQPtrList<SingleScreenData> screenInfoArray, bool test, TQString kde_confdir) {
+	int i;
+	int j;
+	bool accepted = true;
+	Display *randr_display;
+	XRROutputInfo *output_info;
+	ScreenInfo *randr_screen_info;
+
+	SingleScreenData *screendata;
+
+	TQPtrList<SingleScreenData> oldconfig;
+	if (test == TRUE) {
+		oldconfig = readCurrentDisplayConfiguration();
+	}
+
+	if (isValid() == true) {
+#ifdef USE_XRANDR_PROGRAM
+		// Assemble the command string for xrandr
+		TQString command;
+		command = "xrandr";
+
+		randr_display = tqt_xdisplay();
+		randr_screen_info = read_screen_info(randr_display);
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			if (screendata) {
+				output_info = randr_screen_info->outputs[i]->info;
+				command.append(" --output ").append(output_info->name);
+				if (screendata->is_primary || screendata->is_extended) {
+					command.append(TQString(" --mode %1x%2").arg(screendata->current_x_pixel_count).arg(screendata->current_y_pixel_count));
+					command.append(TQString(" --pos %1x%2").arg(screendata->absolute_x_position).arg(screendata->absolute_y_position));
+					command.append(TQString(" --refresh %1").arg((*screendata->refresh_rates.at(screendata->current_refresh_rate_index)).replace("Hz", "")));
+					command.append(TQString(" --gamma %1:%2:%3").arg(screendata->gamma_red).arg(screendata->gamma_green).arg(screendata->gamma_blue));
+					if (screendata->current_rotation_index == 0) command.append(" --rotate ").append("normal");
+					if (screendata->current_rotation_index == 1) command.append(" --rotate ").append("left");
+					if (screendata->current_rotation_index == 2) command.append(" --rotate ").append("inverted");
+					if (screendata->current_rotation_index == 3) command.append(" --rotate ").append("right");
+					if ((screendata->has_x_flip == 0) && (screendata->has_y_flip == 0)) command.append(" --reflect ").append("normal");
+					if ((screendata->has_x_flip == 1) && (screendata->has_y_flip == 0)) command.append(" --reflect ").append("x");
+					if ((screendata->has_x_flip == 0) && (screendata->has_y_flip == 1)) command.append(" --reflect ").append("y");
+					if ((screendata->has_x_flip == 1) && (screendata->has_y_flip == 1)) command.append(" --reflect ").append("xy");
+					if (screendata->is_primary) {
+						command.append(" --primary");
+					}
+				}
+				else {
+					command.append(" --off");
+				}
+			}
+			else {
+				printf("[WARNING] Unable to find configuration for monitor %d; settings may not be correctly applied...\n\r", i); fflush(stdout);
+			}
+		}
+		freeScreenInfoStructure(randr_screen_info);
+
+		TQString xrandr_command_output = exec(command.ascii());
+		xrandr_command_output = xrandr_command_output.stripWhiteSpace();
+		if (test) {
+			if (xrandr_command_output != "") {
+				applyDisplayConfiguration(oldconfig, FALSE, kde_confdir);
+				accepted = false;
+				destroyScreenInformationObject(oldconfig);
+				KMessageBox::sorry(0, xrandr_command_output, i18n("XRandR encountered a problem"));
+				return accepted;
+			}
+		}
+#else
+		randr_display = tqt_xdisplay();
+		randr_screen_info = read_screen_info(randr_display);
+		// Turn off all displays
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			output_info = randr_screen_info->outputs[i]->info;
+
+			randr_screen_info->cur_crtc = randr_screen_info->outputs[i]->cur_crtc;
+			randr_screen_info->cur_output = randr_screen_info->outputs[i];
+			randr_screen_info->cur_output->auto_set = 0;
+			randr_screen_info->cur_output->off_set = 1;
+			output_off (randr_screen_info, randr_screen_info->cur_output);
+			j=main_low_apply(randr_screen_info);
+		}
+		freeScreenInfoStructure(randr_screen_info);
+		randr_screen_info = read_screen_info(randr_display);
+		// Turn on the primary display
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			output_info = randr_screen_info->outputs[i]->info;
+
+			if (screendata->is_primary == true) {
+				randr_screen_info->cur_crtc = randr_screen_info->outputs[i]->cur_crtc;
+				randr_screen_info->cur_output = randr_screen_info->outputs[i];
+				randr_screen_info->cur_output->auto_set = 1;
+				randr_screen_info->cur_output->off_set = 0;
+				output_auto (randr_screen_info, randr_screen_info->cur_output);
+				j=main_low_apply(randr_screen_info);
+			}
+		}
+		freeScreenInfoStructure(randr_screen_info);
+		// Handle the remaining displays
+		randr_screen_info = read_screen_info(randr_display);
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			output_info = randr_screen_info->outputs[i]->info;
+
+			// Activate or deactivate the screens as necessary
+			randr_screen_info->cur_crtc = randr_screen_info->outputs[i]->cur_crtc;
+			randr_screen_info->cur_output = randr_screen_info->outputs[i];
+			if (screendata->is_primary == false) {
+				if (screendata->is_primary || screendata->is_extended) {
+					randr_screen_info->cur_output->auto_set = 1;
+					randr_screen_info->cur_output->off_set = 0;
+					output_auto (randr_screen_info, randr_screen_info->cur_output);
+					j=main_low_apply(randr_screen_info);
+				}
+				else {
+					randr_screen_info->cur_output->auto_set = 0;
+					randr_screen_info->cur_output->off_set = 1;
+					output_off (randr_screen_info, randr_screen_info->cur_output);
+					j=main_low_apply(randr_screen_info);
+				}
+			}
+		}
+		freeScreenInfoStructure(randr_screen_info);
+		randr_screen_info = read_screen_info(randr_display);
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			output_info = randr_screen_info->outputs[i]->info;
+
+			if (screendata->is_primary || screendata->is_extended) {
+				// Set rotation, refresh rate, and size
+				RandRScreen *cur_screen = new RandRScreen(i);
+				cur_screen->proposeSize(screendata->current_resolution_index);
+				cur_screen->proposeRefreshRate(screendata->current_refresh_rate_index);
+				cur_screen->proposeRotation(getHardwareRotationFlags(screendata));
+				cur_screen->applyProposed();
+				delete cur_screen;
+
+				// Force data reload
+				randr_screen_info = read_screen_info(randr_display);
+				output_info = randr_screen_info->outputs[i]->info;
+
+				// Finally, set the screen's position
+				randr_screen_info->cur_crtc = randr_screen_info->outputs[i]->cur_crtc;
+				if (randr_screen_info->cur_crtc) {
+					randr_screen_info->cur_crtc->cur_x = screendata->absolute_x_position;
+					randr_screen_info->cur_crtc->cur_y = screendata->absolute_y_position;
+					j=main_low_apply(randr_screen_info);
+				}
+			}
+		}
+		freeScreenInfoStructure(randr_screen_info);
+#endif
+	}
+
+	applyDisplayGamma(screenInfoArray);
+	applyDisplayDPMS(screenInfoArray);
+	TQString current_icc_profile = getCurrentProfile();
+	applySystemWideIccConfiguration(kde_confdir);
+	applyIccConfiguration(current_icc_profile, kde_confdir);
+
+	if (test == TRUE) {
+		int ret = showTestConfigurationDialog();
+		if (!ret) {
+			applyDisplayConfiguration(oldconfig, FALSE, kde_confdir);
+			accepted = false;
+		}
+		destroyScreenInformationObject(oldconfig);
+	}
+
+	return accepted;
+}
+
+TQPtrList<SingleScreenData> KRandrSimpleAPI::copyScreenInformationObject(TQPtrList<SingleScreenData> screenInfoArray) {
+	SingleScreenData *origscreendata;
+	SingleScreenData *copyscreendata;
+	TQPtrList<SingleScreenData> retArray;
+	for ( origscreendata = screenInfoArray.first(); origscreendata; origscreendata = screenInfoArray.next() ) {
+		copyscreendata = new SingleScreenData;
+		*copyscreendata = *origscreendata;
+		retArray.append(copyscreendata);
+	}
+	return retArray;
+}
+
+void KRandrSimpleAPI::destroyScreenInformationObject(TQPtrList<SingleScreenData> screenInfoArray) {
+	SingleScreenData *screendata;
+	for ( screendata = screenInfoArray.first(); screendata; screendata = screenInfoArray.next() ) {
+		screenInfoArray.remove(screendata);
+		delete screendata;
+	}
+}
+
+void KRandrSimpleAPI::ensureMonitorDataConsistency(TQPtrList<SingleScreenData> screenInfoArray) {
+	int i;
+	SingleScreenData *screendata;
+
+	int numberOfScreens = screenInfoArray.count();
+
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		if (!screendata->screen_connected) {
+			screendata->is_primary = false;
+			screendata->is_extended = false;
+		}
+	}
+
+	bool has_primary_monitor = false;
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		if (screendata->is_primary) {
+			has_primary_monitor = true;
+		}
+	}
+	if (!has_primary_monitor) {
+		for (i=0;i<numberOfScreens;i++) {
+			screendata = screenInfoArray.at(i);
+			if (!has_primary_monitor) {
+				if (screendata->screen_connected && screendata->is_extended) {
+					screendata->is_primary = true;
+					screendata->is_extended = true;
+					has_primary_monitor = true;
+				}
+			}
+		}
+	}
+	if (!has_primary_monitor) {
+		for (i=0;i<numberOfScreens;i++) {
+			screendata = screenInfoArray.at(i);
+			if (!has_primary_monitor) {
+				if (screendata->screen_connected) {
+					screendata->is_primary = true;
+					screendata->is_extended = true;
+					has_primary_monitor = true;
+				}
+			}
+		}
+	}
+
+	bool found_first_primary_monitor = false;
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		if (screendata->is_primary) {
+			if (!found_first_primary_monitor) {
+				found_first_primary_monitor = true;
+			}
+			else {
+				screendata->is_primary = false;
+			}
+		}
+	}
+
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		if (screendata->is_primary) {
+			screendata->is_extended = true;
+		}
+	}
+
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		TQString resolutionstring = screendata->resolutions[screendata->current_resolution_index];
+		int separator_pos = resolutionstring.find(" x ");
+		TQString x_res_string = resolutionstring.left(separator_pos);
+		TQString y_res_string = resolutionstring.right(resolutionstring.length()-separator_pos-3);
+		screendata->current_x_pixel_count = x_res_string.toInt();
+		screendata->current_y_pixel_count = y_res_string.toInt();
+		screendata->current_orientation_mask = getHardwareRotationFlags(screendata);
+	}
+
+	// Each screen's absolute position is given relative to the primary monitor
+	// Fix up the absolute positions
+	int primary_offset_x = 0;
+	int primary_offset_y = 0;
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		if (screendata->is_primary) {
+			primary_offset_x = screendata->absolute_x_position;
+			primary_offset_y = screendata->absolute_y_position;
+			primary_offset_x = primary_offset_x * (-1);
+			primary_offset_y = primary_offset_y * (-1);
+		}
+	}
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		screendata->absolute_x_position = screendata->absolute_x_position + primary_offset_x;
+		screendata->absolute_y_position = screendata->absolute_y_position + primary_offset_y;
+	}
+}
+
+TQPoint KRandrSimpleAPI::primaryScreenOffsetFromTLC(TQPtrList<SingleScreenData> screenInfoArray) {
+	int i;
+	SingleScreenData *screendata;
+	int numberOfScreens = screenInfoArray.count();
+
+	int primary_offset_x = 0;
+	int primary_offset_y = 0;
+	for (i=0;i<numberOfScreens;i++) {
+		screendata = screenInfoArray.at(i);
+		if (screendata->absolute_x_position < primary_offset_x) {
+			primary_offset_x = screendata->absolute_x_position;
+		}
+		if (screendata->absolute_y_position < primary_offset_y) {
+			primary_offset_y = screendata->absolute_y_position;
+		}
+	}
+	primary_offset_x = primary_offset_x * (-1);
+	primary_offset_y = primary_offset_y * (-1);
+
+	return TQPoint(primary_offset_x, primary_offset_y);
+}
+
+HotPlugRulesList KRandrSimpleAPI::getHotplugRules(TQString kde_confdir) {
+	int i;
+	TQString filename;
+	HotPlugRulesList ret;
+
+	filename = "displayglobals";
+	filename.prepend(kde_confdir.append("/"));
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+
+	TQStringList grouplist = display_config->groupList();
+	for ( TQStringList::Iterator it = grouplist.begin(); it != grouplist.end(); ++it ) {
+		if (!(*it).startsWith("Hotplug-Rule")) {
+			continue;
+		}
+		HotPlugRule rule;
+		display_config->setGroup(*it);
+		rule.outputs = display_config->readListEntry("Outputs");
+		rule.states = display_config->readIntListEntry("States");
+		rule.profileName = display_config->readEntry("Profile");
+		ret.append(rule);
+	}
+	delete display_config;
+
+	return ret;
+}
+
+void KRandrSimpleAPI::saveHotplugRules(HotPlugRulesList rules, TQString kde_confdir) {
+	int i;
+	TQString filename;
+
+	filename = "displayglobals";
+	filename.prepend(kde_confdir.append("/"));
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+	TQStringList grouplist = display_config->groupList();
+	for ( TQStringList::Iterator it = grouplist.begin(); it != grouplist.end(); ++it ) {
+		if (!(*it).startsWith("Hotplug-Rule")) {
+			continue;
+		}
+		display_config->deleteGroup(*it, true, false);
+	}
+	HotPlugRulesList::Iterator it;
+	i=0;
+	for (it=rules.begin(); it != rules.end(); ++it) {
+		display_config->setGroup(TQString("Hotplug-Rule%1").arg(i));
+		display_config->writeEntry("Outputs", (*it).outputs);
+		display_config->writeEntry("States", (*it).states);
+		display_config->writeEntry("Profile", (*it).profileName);
+		i++;
+	}
+	display_config->sync();
+	delete display_config;
+}
+
+bool KRandrSimpleAPI::getDisplayConfigurationEnabled(TQString kde_confdir) {
+	TQString filename = "displayglobals";
+	filename.prepend(kde_confdir.append("/"));
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+	display_config->setGroup("General");
+	bool enabled = display_config->readBoolEntry("EnableDisplayControl", false);
+	delete display_config;
+
+	return enabled;
+}
+
+bool KRandrSimpleAPI::getDisplayConfigurationStartupAutoApplyEnabled(TQString kde_confdir) {
+	TQString filename = "displayglobals";
+	filename.prepend(kde_confdir.append("/"));
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+	display_config->setGroup("General");
+	bool applyonstart = display_config->readBoolEntry("ApplySettingsOnStart", false);
+	delete display_config;
+
+	return applyonstart;
+}
+
+TQString KRandrSimpleAPI::getDisplayConfigurationStartupAutoApplyName(TQString kde_confdir) {
+	TQString filename = "displayglobals";
+	filename.prepend(kde_confdir.append("/"));
+	KSimpleConfig* display_config = new KSimpleConfig( filename );
+	display_config->setGroup("General");
+	TQString profilename = display_config->readEntry("StartupProfileName", "");
+	delete display_config;
+
+	return profilename;
+}
+
+void KRandrSimpleAPI::applyHotplugRules(TQString kde_confdir) {
+	bool enabled = getDisplayConfigurationEnabled(kde_confdir);
+	if (!enabled) {
+		return;
+	}
+
+	HotPlugRulesList rules = getHotplugRules(kde_confdir);
+	TQPtrList<SingleScreenData> screenInfoArray = readCurrentDisplayConfiguration();
+
+	int i;
+	int j;
+	TQString bestRule;
+	int bestRuleMatchCount = 0;
+	SingleScreenData *screendata = NULL;
+	HotPlugRulesList::Iterator it;
+	for (it=rules.begin(); it != rules.end(); ++it) {
+		// Compare each rule against the current display configuration
+		// It an output matches the state given in the rule, increment matchCount
+		HotPlugRule rule = *it;
+		int matchCount = 0;
+		int numberOfScreens = screenInfoArray.count();
+		for (i=0;i<numberOfScreens;i++) {
+			screendata = screenInfoArray.at(i);
+			for (j=0; j<(*it).outputs.count(); j++) {
+				if ((*it).outputs[j] != screendata->screenUniqueName) {
+					continue;
+				}
+				if ((*it).states[j] == HotPlugRule::Connected) {
+					if (screendata->screen_connected) {
+						matchCount++;
+					}
+				}
+				else if ((*it).states[j] == HotPlugRule::Disconnected) {
+					if (!screendata->screen_connected) {
+						matchCount++;
+					}
+				}
+			}
+		}
+
+		if (matchCount > bestRuleMatchCount) {
+			bestRuleMatchCount = matchCount;
+			bestRule = rule.profileName;
+		}
+	}
+
+	destroyScreenInformationObject(screenInfoArray);
+
+	if (bestRuleMatchCount > 0) {
+		// At least one rule matched...
+		// Apply the profile name in bestRule to the display hardware
+		applyDisplayConfiguration(bestRule, kde_confdir);
+	}
+}
+
+void KRandrSimpleAPI::applyDisplayGamma(TQPtrList<SingleScreenData> screenInfoArray) {
+	int i;
+	Display *randr_display;
+	XRROutputInfo *output_info;
+	ScreenInfo *randr_screen_info;
+	XRRCrtcGamma *gamma;
+
+	SingleScreenData *screendata;
+
+	if (isValid() == true) {
+		randr_display = tqt_xdisplay();
+		randr_screen_info = read_screen_info(randr_display);
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			output_info = randr_screen_info->outputs[i]->info;
+			CrtcInfo *current_crtc = randr_screen_info->outputs[i]->cur_crtc;
+			if (!current_crtc) {
+				continue;
+			}
+			// vvvvvvvvv This chunk of code is borrowed from xrandr vvvvvvvvvv
+			int size = XRRGetCrtcGammaSize(randr_display, current_crtc->id);
+			if (!size) {
+				continue;
+			}
+			gamma = XRRAllocGamma(size);
+			if (!gamma) {
+				continue;
+			}
+			for (i = 0; i < size; i++) {
+				if (screendata->gamma_red == 1.0)
+					gamma->red[i] = i << 8;
+				else
+					gamma->red[i] = (pow((double)i/(double)(size-1), (double)screendata->gamma_red) * (double)(size-1)*256);
+
+				if (screendata->gamma_green == 1.0)
+					gamma->green[i] = i << 8;
+				else
+					gamma->green[i] = (pow((double)i/(double)(size-1), (double)screendata->gamma_green) * (double)(size-1)*256);
+
+				if (screendata->gamma_blue == 1.0)
+					gamma->blue[i] = i << 8;
+				else
+					gamma->blue[i] = (pow((double)i/(double)(size-1), (double)screendata->gamma_blue) * (double)(size-1)*256);
+			}
+			XRRSetCrtcGamma(randr_display, current_crtc->id, gamma);
+			free(gamma);
+			// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+		}
+		freeScreenInfoStructure(randr_screen_info);
+	}
+}
+
+void KRandrSimpleAPI::applyDisplayDPMS(TQPtrList<SingleScreenData> screenInfoArray) {
+	int i;
+	Display *randr_display;
+	XRROutputInfo *output_info;
+	ScreenInfo *randr_screen_info;
+	XRRCrtcGamma *gamma;
+
+	SingleScreenData *screendata;
+
+	if (isValid() == true) {
+		randr_display = tqt_xdisplay();
+		randr_screen_info = read_screen_info(randr_display);
+		for (i = 0; i < screenInfoArray.count(); i++) {
+			screendata = screenInfoArray.at(i);
+			output_info = randr_screen_info->outputs[i]->info;
+			CrtcInfo *current_crtc = randr_screen_info->outputs[i]->cur_crtc;
+			if (!current_crtc) {
+				continue;
+			}
+			if (!screendata->has_dpms) {
+				continue;
+			}
+			if (screendata->enable_dpms) {
+				DPMSSetTimeouts(randr_display, screendata->dpms_standby_delay, screendata->dpms_suspend_delay, screendata->dpms_off_delay);
+				DPMSEnable(randr_display);
+			}
+			else {
+				DPMSDisable(randr_display);
+			}
+		}
+		freeScreenInfoStructure(randr_screen_info);
+	}
+}
+
+void KRandrSimpleAPI::freeScreenInfoStructure(ScreenInfo* screen_info) {
+	int i;
+
+	for (i=0; i<screen_info->n_crtc; i++) {
+		free(screen_info->crtcs[i]);
+	}
+	for (i=0; i<screen_info->n_output; i++) {
+		free(screen_info->outputs[i]);
+	}
+	free(screen_info->outputs);
+	free(screen_info->crtcs);
+	free(screen_info);
+}
+
+TQPtrList<SingleScreenData> KRandrSimpleAPI::readCurrentDisplayConfiguration() {
+	// Discover display information
+	int i;
+	int j;
+
+	XRROutputInfo *output_info;
+	SingleScreenData *screendata;
+	TQPtrList<SingleScreenData> screenInfoArray;
+
+	Display *randr_display;
+	ScreenInfo *randr_screen_info;
+
+	// Clear existing info
+	destroyScreenInformationObject(screenInfoArray);
+
+	int numberOfScreens = 0;
+	if (isValid() == true) {
+		randr_display = tqt_xdisplay();
+		randr_screen_info = read_screen_info(randr_display);
+		for (i = 0; i < randr_screen_info->n_output; i++) {
+			output_info = randr_screen_info->outputs[i]->info;
+			CrtcInfo *current_crtc = randr_screen_info->outputs[i]->cur_crtc;
+
+			// Create new data object
+			screendata = new SingleScreenData;
+			screenInfoArray.append(screendata);
+			screendata->screenUniqueName = TQString(i18n("%1:%2")).arg(":0").arg(capitalizeString(output_info->name));	// [FIXME] How can I get the name of the Xorg graphics driver currently in use?
+			screendata->screenFriendlyName = TQString(i18n("%1. %2 output on %3")).arg(i+1).arg(capitalizeString(output_info->name)).arg(":0");	// [FIXME] How can I get the name of the Xorg graphics driver currently in use?
+			screendata->generic_screen_detected = false;
+
+			// Attempt to use KMS to find screen EDID and name
+			TQString edid = getEDIDMonitorName(0, output_info->name);	// [FIXME] Don't hardwire to card 0!
+			if (!edid.isNull()) {
+				screendata->screenFriendlyName = TQString(i18n("%1. %2 on %3 on card %4")).arg(i+1).arg(edid).arg(capitalizeString(output_info->name)).arg("0");	// [FIXME] How can I get the name of the Xorg graphics driver currently in use?
+			}
+
+			// Get resolutions
+			bool screen_active;
+			RandRScreen *cur_screen = 0;
+			if (RR_Disconnected == randr_screen_info->outputs[i]->info->connection) {
+				// Output DISCONNECTED
+				screen_active = false;
+			}
+			else {
+				if (randr_screen_info->outputs[i]->cur_crtc) {
+					// Output CONNECTED and ON
+					screen_active = true;
+					cur_screen = new RandRScreen(i);
+				}
+				else {
+					// Output CONNECTED and OFF
+					screen_active = false;
+					cur_screen = new RandRScreen(i);
+				}
+			}
+
+			// Get DPMS information
+			screendata->has_dpms = 1;	// [FIXME] Master Xorg check for global DPMS support should go here if possible
+			if (screendata->has_dpms) {
+				CARD16 dpms_standby_delay;
+				CARD16 dpms_suspend_delay;
+				CARD16 dpms_off_delay;
+				screendata->has_dpms = DPMSGetTimeouts(randr_display, &dpms_standby_delay, &dpms_suspend_delay, &dpms_off_delay);
+				screendata->dpms_standby_delay = dpms_standby_delay;
+				screendata->dpms_suspend_delay = dpms_suspend_delay;
+				screendata->dpms_off_delay = dpms_off_delay;
+				if (screendata->has_dpms) {
+					CARD16 power_level;
+					BOOL enable_dpms;
+					screendata->has_dpms = DPMSInfo(randr_display, &power_level, &enable_dpms);
+					screendata->enable_dpms = enable_dpms;
+				}
+			}
+			if (!screendata->has_dpms) {
+				screendata->enable_dpms = false;
+				screendata->dpms_standby_delay = 0;
+				screendata->dpms_suspend_delay = 0;
+				screendata->dpms_off_delay = 0;
+			}
+
+			if (cur_screen) {
+				screendata->screen_connected = true;
+				for (int j = 0; j < cur_screen->numSizes(); j++) {
+					screendata->resolutions.append(i18n("%1 x %2").arg(cur_screen->pixelSize(j).width()).arg(cur_screen->pixelSize(j).height()));
+				}
+				screendata->current_resolution_index = 0;
+				if (current_crtc) {
+					screendata->current_resolution_index = screendata->resolutions.findIndex(i18n("%1 x %2").arg(current_crtc->info->width).arg(current_crtc->info->height));
+				}
+				if (screendata->current_resolution_index < 0) {
+					screendata->current_resolution_index = cur_screen->proposedSize();
+				}
+
+				// Get refresh rates
+				TQStringList rr = cur_screen->refreshRates(screendata->current_resolution_index);
+				for (TQStringList::Iterator it = rr.begin(); it != rr.end(); ++it) {
+					screendata->refresh_rates.append(*it);
+				}
+				screendata->current_refresh_rate_index = cur_screen->proposedRefreshRate();
+
+				// Get color depths
+				// [FIXME]
+				screendata->color_depths.append(i18n("Default"));
+				screendata->current_color_depth_index = 0;
+
+				// Get orientation flags
+				// RandRScreen::Rotate0
+				// RandRScreen::Rotate90
+				// RandRScreen::Rotate180
+				// RandRScreen::Rotate270
+				// RandRScreen::ReflectX
+				// RandRScreen::ReflectY
+
+				screendata->rotations.append(i18n(ROTATION_0_DEGREES_STRING));
+				screendata->rotations.append(i18n(ROTATION_90_DEGREES_STRING));
+				screendata->rotations.append(i18n(ROTATION_180_DEGREES_STRING));
+				screendata->rotations.append(i18n(ROTATION_270_DEGREES_STRING));
+				screendata->supports_transformations = (cur_screen->rotations() != RandRScreen::Rotate0);
+				if (screendata->supports_transformations) {
+					screendata->current_orientation_mask = cur_screen->proposedRotation();
+					switch (screendata->current_orientation_mask & RandRScreen::RotateMask) {
+						case RandRScreen::Rotate0:
+							screendata->current_rotation_index = 0;
+							break;
+						case RandRScreen::Rotate90:
+							screendata->current_rotation_index = 1;
+							break;
+						case RandRScreen::Rotate180:
+							screendata->current_rotation_index = 2;
+							break;
+						case RandRScreen::Rotate270:
+							screendata->current_rotation_index = 3;
+							break;
+						default:
+							// Shouldn't hit this one
+							Q_ASSERT(screendata->current_orientation_mask & RandRScreen::RotateMask);
+							screendata->current_rotation_index = 0;
+							break;
+					}
+					screendata->has_x_flip = (screendata->current_orientation_mask & RandRScreen::ReflectX);
+					screendata->has_y_flip = (screendata->current_orientation_mask & RandRScreen::ReflectY);
+				}
+				else {
+					screendata->has_x_flip = false;
+					screendata->has_y_flip = false;
+					screendata->current_rotation_index = 0;
+				}
+
+				// Determine if this display is primary and/or extended
+				RROutput primaryoutput = XRRGetOutputPrimary(tqt_xdisplay(), DefaultRootWindow(tqt_xdisplay()));
+				if (primaryoutput == randr_screen_info->outputs[i]->id) {
+					screendata->is_primary = false;
+				}
+				else {
+					screendata->is_primary = true;
+				}
+				screendata->is_extended = screen_active;
+				if (!screendata->is_extended) {
+					screendata->is_primary = false;
+				}
+
+				// Get this screen's absolute position
+				screendata->absolute_x_position = 0;
+				screendata->absolute_y_position = 0;
+				if (current_crtc) {
+					screendata->absolute_x_position = current_crtc->info->x;
+					screendata->absolute_y_position = current_crtc->info->y;
+				}
+
+				// Get this screen's current resolution
+				screendata->current_x_pixel_count = cur_screen->pixelSize(screendata->current_resolution_index).width();
+				screendata->current_y_pixel_count = cur_screen->pixelSize(screendata->current_resolution_index).height();
+
+				// Get this screen's current gamma values
+				// [FIXME]
+				// This attempts to guess a gamma value based on the LUT settings at 50%
+				// It may not always be 100% correct, or even anywhere close...
+				// Essentially it "undoes" the LUT gamma calculation from xrandr
+				// lut_gamma->green[i] = (pow(i/(size - 1), desired_gamma.green) * (size - 1) * 256);
+				if (current_crtc) {
+					//int slot = 127;
+					int slot = 7;
+					int size = XRRGetCrtcGammaSize(randr_display, current_crtc->id);
+					XRRCrtcGamma *gammastruct = XRRGetCrtcGamma (randr_display, current_crtc->id);
+					screendata->gamma_red = log(gammastruct->red[slot]/((size-1.0)*256.0))/log(slot/(size-1.0));
+					screendata->gamma_green = log(gammastruct->green[slot]/((size-1.0)*256.0))/log(slot/(size-1.0));
+					screendata->gamma_blue = log(gammastruct->blue[slot]/((size-1.0)*256.0))/log(slot/(size-1.0));
+				}
+				else {
+					screendata->gamma_red = 2.2;
+					screendata->gamma_green = 2.2;
+					screendata->gamma_blue = 2.2;
+				}
+				// Round off the gamma to one decimal place
+				screendata->gamma_red = floorf(screendata->gamma_red * 10 + 0.5) / 10;
+				screendata->gamma_green = floorf(screendata->gamma_green * 10 + 0.5) / 10;
+				screendata->gamma_blue = floorf(screendata->gamma_blue * 10 + 0.5) / 10;
+
+				delete cur_screen;
+			}
+			else {
+				// Fill in generic data for this disconnected output
+				screendata->screenFriendlyName = screendata->screenFriendlyName + TQString(" (") + i18n("disconnected") + TQString(")");
+				screendata->screen_connected = false;
+
+				screendata->resolutions = i18n("Default");
+				screendata->refresh_rates = i18n("Default");
+				screendata->color_depths = i18n("Default");
+				screendata->rotations = i18n("N/A");
+
+				screendata->current_resolution_index = 0;
+				screendata->current_refresh_rate_index = 0;
+				screendata->current_color_depth_index = 0;
+
+				screendata->gamma_red = 2.2;
+				screendata->gamma_green = 2.2;
+				screendata->gamma_blue = 2.2;
+
+				screendata->current_rotation_index = 0;
+				screendata->current_orientation_mask = 0;
+				screendata->has_x_flip = false;
+				screendata->has_y_flip = false;
+				screendata->supports_transformations = false;
+
+				screendata->is_primary = false;
+				screendata->is_extended = false;
+				screendata->absolute_x_position = 0;
+				screendata->absolute_y_position = 0;
+				screendata->current_x_pixel_count = 640;
+				screendata->current_y_pixel_count = 480;
+			}
+
+			// Check for more screens...
+			numberOfScreens++;
+		}
+
+		freeScreenInfoStructure(randr_screen_info);
+	}
+	else {
+		screendata = new SingleScreenData;
+		screenInfoArray.append(screendata);
+
+		// Fill in a bunch of generic data
+		screendata->screenFriendlyName = i18n("Default output on generic video card");
+		screendata->generic_screen_detected = true;
+		screendata->screen_connected = true;
+
+		screendata->resolutions = i18n("Default");
+		screendata->refresh_rates = i18n("Default");
+		screendata->color_depths = i18n("Default");
+		screendata->rotations = i18n("N/A");
+
+		screendata->current_resolution_index = 0;
+		screendata->current_refresh_rate_index = 0;
+		screendata->current_color_depth_index = 0;
+
+		screendata->gamma_red = 2.2;
+		screendata->gamma_green = 2.2;
+		screendata->gamma_blue = 2.2;
+
+		screendata->current_rotation_index = 0;
+		screendata->current_orientation_mask = 0;
+		screendata->has_x_flip = false;
+		screendata->has_y_flip = false;
+		screendata->supports_transformations = false;
+
+		screendata->is_primary = true;
+		screendata->is_extended = true;
+		screendata->absolute_x_position = 0;
+		screendata->absolute_y_position = 0;
+		screendata->current_x_pixel_count = 640;
+		screendata->current_y_pixel_count = 480;
+
+		numberOfScreens++;
+	}
+
+	bool primary_set = false;
+	for ( screendata=screenInfoArray.first(); screendata; screendata=screenInfoArray.next() ) {
+		if (screendata->is_primary) {
+			primary_set = true;
+			break;
+		}
+	}
+	// If there is no primary monitor set, xrandr is probably not functioning correctly!
+	Q_ASSERT(primary_set);
+	if (!primary_set) {
+		// [FIXME]
+		// Set this on the real primary monitor only!
+		screendata = screenInfoArray.at(0);
+		screendata->is_primary = true;
+	}
+
+	return screenInfoArray;
+}
+
+TQString KRandrSimpleAPI::clearIccConfiguration() {
+	// Clear ICC settings with XCalib
+	TQString icc_command;
+	FILE *pipe_xcalib;
+	char xcalib_result[2048];
+	int i;
+	xcalib_result[0]=0;
+
+	icc_command = TQString("xcalib -c");
+	if ((pipe_xcalib = popen(icc_command.ascii(), "r")) == NULL)
+	{
+		printf("Xcalib pipe error [xcalib clear]\n\r");
+	}
+	else {
+		if (fgets(xcalib_result, 2048, pipe_xcalib)) {
+			pclose(pipe_xcalib);
+			for (i=1;i<2048;i++) {
+				if (xcalib_result[i] == 0) {
+					xcalib_result[i-1]=0;
+					i=2048;
+				}
+			}
+			if (strlen(xcalib_result) > 2) {
+				return xcalib_result;
+			}
+		}
+		else {
+			return "";
+		}
+	}
+	return "";
+}
+
+ScreenInfo* KRandrSimpleAPI::read_screen_info (Display *display)
+{
+    return internal_read_screen_info(display);
+}
+
+int KRandrSimpleAPI::set_screen_size (ScreenInfo *screen_info)
+{
+    return internal_set_screen_size(screen_info);
+}
+
+void KRandrSimpleAPI::output_auto (ScreenInfo *screen_info, OutputInfo *output_info)
+{
+    internal_output_auto (screen_info, output_info);
+}
+
+void KRandrSimpleAPI::output_off(ScreenInfo *screen_info, OutputInfo *output)
+{
+    internal_output_off(screen_info, output);
+}
+
+CrtcInfo* KRandrSimpleAPI::auto_find_crtc (ScreenInfo *screen_info, OutputInfo *output_info)
+{
+    return internal_auto_find_crtc (screen_info, output_info);
+}
+
+XRRModeInfo *KRandrSimpleAPI::find_mode_by_xid (ScreenInfo *screen_info, RRMode mode_id)
+{
+    return internal_find_mode_by_xid (screen_info, mode_id);
+}
+
+int KRandrSimpleAPI::mode_height (XRRModeInfo *mode_info, Rotation rotation)
+{
+    return internal_mode_height (mode_info, rotation);
+}
+
+int KRandrSimpleAPI::mode_width (XRRModeInfo *mode_info, Rotation rotation)
+{
+    return internal_mode_width (mode_info, rotation);
+}
+
+int KRandrSimpleAPI::get_width_by_output_id (ScreenInfo *screen_info, RROutput output_id)
+{
+    return internal_get_width_by_output_id (screen_info, output_id);
+}
+
+int KRandrSimpleAPI::get_height_by_output_id (ScreenInfo *screen_info, RROutput output_id)
+{
+    return internal_get_height_by_output_id (screen_info, output_id);
+}
+
+char *KRandrSimpleAPI::get_output_name (ScreenInfo *screen_info, RROutput id)
+{
+    return internal_get_output_name (screen_info, id);
+}
+
+Status KRandrSimpleAPI::crtc_apply (CrtcInfo *crtc_info)
+{
+    return internal_crtc_apply (crtc_info);
+}
+
+Status KRandrSimpleAPI::crtc_disable (CrtcInfo *crtc)
+{
+    return internal_crtc_disable (crtc);
+}
+
+int KRandrSimpleAPI::main_low_apply (ScreenInfo *screen_info)
+{
+    return internal_main_low_apply (screen_info);
+}
+
+void KRandrSimpleAPI::set_primary_output (ScreenInfo *screen_info, RROutput output_id)
+{
+    internal_output_set_primary(screen_info, output_id);
+}
+
+bool KRandrSimpleAPI::kRandrHasRandr(void)
+{
+    return isValid();
+}
+
+const char *KRandrSimpleAPI::kRandrVersion(void)
+{
+    return "0.9.5";
+}
+
+const char *KRandrSimpleAPI::kRandrCopyright(void)
+{
+   return "LibKRandr 0.9.5 (C)2010 Timothy Pearson <kb9vqf@pearsoncomputing.net>. U.S.A.";
+}
+
+/* * * * * *
+
+ Under this line (------) there's only a C wrapper for the KRandrSimpleAPI class
+
+* * * * * */
+const char *kRandrVersion(void)
+{
+  return KRandrSimpleAPI::kRandrVersion();
+}
+
+const char *kRandrCopyright(void)
+{
+  return KRandrSimpleAPI::kRandrCopyright();
+}
+
diff --git a/tderandr/libtderandr.h b/tderandr/libtderandr.h
new file mode 100644
index 000000000..b2b362a90
--- /dev/null
+++ b/tderandr/libtderandr.h
@@ -0,0 +1,359 @@
+/*  libtderandr.h     - class KRandr that makes it easy to use XRandr in KDE
+    This file is part of KRandr 0.9.5
+    Copyright (C) 2010  Timothy Pearson
+    LibKRandr's homepage : http://www.trinitydesktop.org
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+
+    Send comments and bug fixes to Timothy Pearson <kb9vqf@pearsoncomputing.net>
+
+***************************************************************************/
+#ifndef _LIBKRANDR_H
+#define _LIBKRANDR_H
+
+#include "randr.h"
+#include "lowlevel_randr.h"
+
+#ifdef __cplusplus
+
+#include <tqfile.h>
+
+#include <kconfig.h>
+#include <ksimpleconfig.h>
+#include <tdelibs_export.h>
+
+#define ROTATION_0_DEGREES_STRING "0 degrees"
+#define ROTATION_90_DEGREES_STRING "90 degrees"
+#define ROTATION_180_DEGREES_STRING "180 degrees"
+#define ROTATION_270_DEGREES_STRING "270 degrees"
+
+/**
+ * Simple API covering most of the uses of libtderandr.
+ *
+ * You can use the members of this class in pure C applications, just by using
+ * the same name as the corresponding function member.
+ *
+ * @short A simple API around the rest of libtderandr.
+ * @version 0.9.5 27/04/2010
+ * @author Timothy Pearson <kb9vqf@pearsoncomputing.net>
+ */
+class KRANDR_EXPORT KRandrSimpleAPI : public RandRDisplay
+{
+  private:
+
+  public:
+    /**
+     * Retrieves the specificed ICC profile filename from the configuration database
+     */
+    TQString getIccFileName(TQString profileName, TQString screenName, TQString kde_confdir);
+
+    /**
+     * Applies the specificed ICC profile filename to the specified RandR output
+     * If RandR is not available, the specified file is applied to the current display
+     */
+    TQString applyIccFile(TQString screenName, TQString fileName);
+
+    /**
+     * Applies all saved ICC profile settings to all RandR outputs
+     * If RandR is not available, the settings are applied to the current display
+     */
+    TQString applyIccConfiguration(TQString profileName, TQString kde_confdir);
+
+    /**
+     * Applies saved system wide settings to the current display
+     */
+    TQString applySystemWideIccConfiguration(TQString kde_confdir);
+
+    /**
+     * Resets the current display
+     */
+    TQString clearIccConfiguration(void);
+
+    /**
+     * Retrieves current profile name
+     */
+    TQString getCurrentProfile(void);
+
+    /**
+     * Reads current screen information.
+     * NOTE: The caller is responsible for calling freeScreenInfoStructure() when done
+     */
+    ScreenInfo* read_screen_info(Display *display);
+
+    /**
+     * Frees the ScreenInfo structure
+     */
+    void freeScreenInfoStructure(ScreenInfo* screen_info);
+
+    /**
+     * Sets the screen size.
+     */
+    int set_screen_size (ScreenInfo *screen_info);
+
+    /**
+     * Automatically selects an output port.
+     */
+    void output_auto (ScreenInfo *screen_info, OutputInfo *output_info);
+
+    /**
+     * Turns off a specified output on a specified screen.
+     */
+    void output_off(ScreenInfo *screen_info, OutputInfo *output);
+
+    /**
+     * Automatically finds the CRTC structure.
+     */
+    CrtcInfo* auto_find_crtc (ScreenInfo *screen_info, OutputInfo *output_info);
+
+    /**
+     * Finds a mode by XID.
+     */
+    XRRModeInfo *find_mode_by_xid (ScreenInfo *screen_info, RRMode mode_id);
+
+    /**
+     * Returns specified mode height in pixels.
+     */
+    int mode_height (XRRModeInfo *mode_info, Rotation rotation);
+
+    /**
+     * Returns specified mode width in pixels.
+     */
+    int mode_width (XRRModeInfo *mode_info, Rotation rotation);
+
+    /**
+     * Returns specified output width in pixels.
+     */
+    int get_width_by_output_id (ScreenInfo *screen_info, RROutput output_id);
+
+    /**
+     * Returns specified output height in pixels.
+     */
+    int get_height_by_output_id (ScreenInfo *screen_info, RROutput output_id);
+
+    /**
+     * Returns output name.
+     */
+    char *get_output_name (ScreenInfo *screen_info, RROutput id);
+
+    /**
+     * Applies specified CRTC.
+     */
+    Status crtc_apply (CrtcInfo *crtc_info);
+
+    /**
+     * Disables specificed CRTC
+     */
+    Status crtc_disable (CrtcInfo *crtc);
+
+    /**
+     * Applies all previously configured settings to the specified screen.
+     */
+    int main_low_apply (ScreenInfo *screen_info);
+
+    /**
+     * Sets the primary output device to the specified output_id
+     */
+    void set_primary_output (ScreenInfo *screen_info, RROutput output_id);
+
+    /**
+    * Gets the binary monitor EDID for the specified card and display
+    */
+    TQByteArray getEDID(int card, TQString displayname);
+
+    /**
+    * Gets the monitor EDID name for the specified card and display
+    */
+    TQString getEDIDMonitorName(int card, TQString displayname);
+
+    /**
+    * Returns true if the specified configuration directory has enabled display configuration
+    */
+    bool getDisplayConfigurationEnabled(TQString kde_confdir);
+
+    /**
+    * Returns true if the specified configuration directory has enabled automatic profile application on startup
+    */
+    bool getDisplayConfigurationStartupAutoApplyEnabled(TQString kde_confdir);
+
+    /**
+    * Returns the name of the automatically applied startup profile in the specified configuration directory
+    */
+    TQString getDisplayConfigurationStartupAutoApplyName(TQString kde_confdir);
+
+    /**
+    * Returns a HotPlugRulesList containing all hotplug rules from the specified configuration directory
+    */
+    HotPlugRulesList getHotplugRules(TQString kde_confdir);
+
+    /**
+    * Saves a HotPlugRulesList containing all hotplug rules to the specified configuration directory
+    */
+    void saveHotplugRules(HotPlugRulesList rules, TQString kde_confdir);
+
+    /**
+    * Applies all hotplug rules in the specified configuration directory to the current display configuration
+    */
+    void applyHotplugRules(TQString kde_confdir);
+
+    /**
+    * Returns a list of all profiles available in the specified configuration directory
+    * This list does not include the default ("") profile
+    */
+    TQStringList getDisplayConfigurationProfiles(TQString kde_confdir);
+
+    /**
+    * Deletes the specified profile from the specified configuration directory
+    * Returns true on success, false on failure
+    */
+    bool deleteDisplayConfiguration(TQString profilename, TQString kde_confdir);
+
+    /**
+    * Renames the specified profile in the specified configuration directory
+    * Returns true on success, false on failure
+    */
+    bool renameDisplayConfiguration(TQString profilename, TQString newprofilename, TQString kde_confdir);
+
+    /**
+    * Saves the systemwide display configuration screenInfoArray to the specified profile
+    * If profilename is empty, the default profile is utilized
+    * If enable is set to true, the default profile will be applied at system startup
+    */
+    void saveDisplayConfiguration(bool enable, bool applyonstart, TQString profilename, TQString defaultprofilename, TQString kde_confdir, TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Reads the systemwide display configuration screenInfoArray from the specified profile
+    * If profilename is empty, the default profile is utilized
+    * WARNING: The calling application must free the returned objects when it is done using them
+    */
+    TQPtrList<SingleScreenData> loadDisplayConfiguration(TQString profilename, TQString kde_confdir);
+
+    /**
+    * Applies the startup display configuration profile if enabled
+    * Returns the offset of the primary screen's top left corner
+    */
+    TQPoint applyStartupDisplayConfiguration(TQString kde_confdir);
+
+    /**
+    * Applies the systemwide display configuration screenInfoArray from the specified profile
+    * If profilename is empty, the default profile is utilized
+    * Returns the offset of the primary screen's top left corner
+    */
+    TQPoint applyDisplayConfiguration(TQString profilename, TQString kde_confdir);
+
+    /**
+    * Applies the systemwide display configuration screenInfoArray to the hardware
+    * If test is true, the new configuration will be loaded for a short period of time, then reverted automatically
+    * Returns true if configuration was accepted; false if not
+    */
+    bool applyDisplayConfiguration(TQPtrList<SingleScreenData> screenInfoArray, bool test=TRUE, TQString kde_confdir="");
+
+    /**
+    * Applies the gamma contained within the systemwide display configuration screenInfoArray to the hardware
+    */
+    void applyDisplayGamma(TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Applies the DPMS settings contained within the systemwide display configuration screenInfoArray to the hardware
+    */
+    void applyDisplayDPMS(TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Copies a screen information object
+    */
+    TQPtrList<SingleScreenData> copyScreenInformationObject(TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Destroys a screen information object
+    */
+    void destroyScreenInformationObject(TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Returns the offset of the primary screen's Top Left Corner
+    */
+    TQPoint primaryScreenOffsetFromTLC(TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Ensures that the data contained within screenInfoArray is self consistent
+    */
+    void ensureMonitorDataConsistency(TQPtrList<SingleScreenData> screenInfoArray);
+
+    /**
+    * Reads the current display configuration screenInfoArray from the hardware
+    */
+    TQPtrList<SingleScreenData> readCurrentDisplayConfiguration();
+
+    /**
+    * Returns the hardware rotation flags given a valid SingleScreenData structure
+    */
+    int getHardwareRotationFlags(SingleScreenData*);
+
+    /**
+     * Returns whether or not the system supports XRandR
+     */
+    bool kRandrHasRandr();
+
+    /**
+     * Returns the version number of libtderandr, i.e. "0.9.5" or "1.0 Beta"
+     */
+    static const char *kRandrVersion(void);
+
+    /**
+     * Returns the copyright notice that applications using libtderandr should print
+     * to the user in an about box or somewhere visible.
+     * I.e.
+     *
+     * "LibKRandr 0.9.5 (C) 2010 Timothy Pearson <kb9vqf@pearsoncomputing.net>. U.S.A."
+     */
+    static const char *kRandrCopyright(void);
+
+};
+
+
+
+extern "C" {
+
+#else
+#define KRANDR_EXPORT
+#endif
+
+// KRANDR_EXPORT ScreenInfo* read_screen_info(Display *);
+// KRANDR_EXPORT int         set_screen_size (ScreenInfo *screen_info);
+// KRANDR_EXPORT void        output_auto (ScreenInfo *screen_info, OutputInfo *output_info);
+// KRANDR_EXPORT void        output_off(ScreenInfo *screen_info, OutputInfo *output);
+// KRANDR_EXPORT CrtcInfo*   auto_find_crtc (ScreenInfo *screen_info, OutputInfo *output_info);
+// KRANDR_EXPORT XRRModeInfo *find_mode_by_xid (ScreenInfo *screen_info, RRMode mode_id);
+// KRANDR_EXPORT int         mode_height (XRRModeInfo *mode_info, Rotation rotation);
+// KRANDR_EXPORT int         mode_width (XRRModeInfo *mode_info, Rotation rotation);
+// KRANDR_EXPORT int         get_width_by_output_id (ScreenInfo *screen_info, RROutput output_id);
+// KRANDR_EXPORT int         get_height_by_output_id (ScreenInfo *screen_info, RROutput output_id);
+// KRANDR_EXPORT char        *get_output_name (ScreenInfo *screen_info, RROutput id);
+// KRANDR_EXPORT Status      crtc_apply (CrtcInfo *crtc_info);
+// KRANDR_EXPORT Status      crtc_disable (CrtcInfo *crtc);
+// KRANDR_EXPORT int         main_low_apply (ScreenInfo *screen_info);
+// KRANDR_EXPORT bool        kRandrHasRandr();
+
+KRANDR_EXPORT const char  *kRandrVersion(void);
+KRANDR_EXPORT const char  *kRandrCopyright(void);
+
+#ifdef __cplusplus
+
+}
+
+
+#endif
+
+
+#endif
diff --git a/tderandr/lowlevel_randr.c b/tderandr/lowlevel_randr.c
new file mode 100644
index 000000000..c7a2edc2a
--- /dev/null
+++ b/tderandr/lowlevel_randr.c
@@ -0,0 +1,680 @@
+/*
+ * Copyright © 2010 Raptor Engineering
+ * Copyright © 2007 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include "lowlevel_randr.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+Status internal_crtc_disable (struct CrtcInfo *crtc);
+
+char * internal_get_output_name (struct ScreenInfo *screen_info, RROutput id)
+{
+	char *output_name = NULL;
+	int i;
+
+	for (i = 0; i < screen_info->n_output; i++) {
+		if (id == screen_info->outputs[i]->id) {
+			output_name = screen_info->outputs[i]->info->name;
+		}
+	}
+
+	if (!output_name) {
+		output_name = "Unknown";
+	}
+
+	return output_name;
+}
+
+XRRModeInfo * internal_find_mode_by_xid (struct ScreenInfo *screen_info, RRMode mode_id)
+{
+	XRRModeInfo *mode_info = NULL;
+	XRRScreenResources *res;
+	int i;
+
+	res = screen_info->res;
+	for (i = 0; i < res->nmode; i++) {
+		if (mode_id == res->modes[i].id) {
+			mode_info = &res->modes[i];
+			break;
+		}
+	}
+
+	return mode_info;
+}
+
+static XRRCrtcInfo * internal_find_crtc_by_xid (struct ScreenInfo *screen_info, RRCrtc crtc_id)
+{
+	XRRCrtcInfo *crtc_info;
+	Display *dpy;
+	XRRScreenResources *res;
+
+	dpy = screen_info->dpy;
+	res = screen_info->res;
+
+	crtc_info = XRRGetCrtcInfo (dpy, res, crtc_id);
+
+	return crtc_info;
+}
+
+int internal_get_width_by_output_id (struct ScreenInfo *screen_info, RROutput output_id)
+{
+	struct OutputInfo *output_info;
+	struct CrtcInfo *crtc_info;
+	RRMode mode_id;
+	XRRModeInfo *mode_info;
+	int i;
+	int width = -1;
+
+	for (i = 0; i < screen_info->n_output; i++) {
+		if (output_id == screen_info->outputs[i]->id) {
+			crtc_info = screen_info->outputs[i]->cur_crtc;
+			if (!crtc_info) {
+				width = 0;
+				break;
+			}
+			mode_id = crtc_info->cur_mode_id;
+			mode_info = internal_find_mode_by_xid (screen_info, mode_id);
+
+			width = internal_mode_width (mode_info, crtc_info->cur_rotation);
+
+			break;
+		}
+	}
+
+	return width;
+}
+
+int internal_get_height_by_output_id (struct ScreenInfo *screen_info, RROutput output_id)
+{
+	struct OutputInfo *output_info;
+	struct CrtcInfo *crtc_info;
+	RRMode mode_id;
+	XRRModeInfo *mode_info;
+	int i;
+	int height = -1;
+
+	for (i = 0; i < screen_info->n_output; i++) {
+		if (output_id == screen_info->outputs[i]->id) {
+			crtc_info = screen_info->outputs[i]->cur_crtc;
+			if (!crtc_info) {
+				height = 0;
+				break;
+			}
+			mode_id = crtc_info->cur_mode_id;
+			mode_info = internal_find_mode_by_xid (screen_info, mode_id);
+
+			height = internal_mode_height (mode_info, crtc_info->cur_rotation);
+
+			break;
+		}
+	}
+
+	return height;
+}
+
+int internal_mode_height (XRRModeInfo *mode_info, Rotation rotation)
+{
+    switch (rotation & 0xf) {
+    case RR_Rotate_0:
+    case RR_Rotate_180:
+        return mode_info->height;
+    case RR_Rotate_90:
+    case RR_Rotate_270:
+        return mode_info->width;
+    default:
+        return 0;
+    }
+}
+
+int internal_mode_width (XRRModeInfo *mode_info, Rotation rotation)
+{
+    switch (rotation & 0xf) {
+    case RR_Rotate_0:
+    case RR_Rotate_180:
+        return mode_info->width;
+    case RR_Rotate_90:
+    case RR_Rotate_270:
+        return mode_info->height;
+    default:
+        return 0;
+    }
+}
+
+
+static struct CrtcInfo * internal_find_crtc (struct ScreenInfo *screen_info, XRROutputInfo *output)
+{
+	struct CrtcInfo *crtc_info = NULL;
+	int i;
+
+	for (i = 0; i < screen_info->n_crtc; i++) {
+		if (screen_info->crtcs[i]->id == output->crtc) {
+			crtc_info = screen_info->crtcs[i];
+			break;
+		}
+	}
+
+	return crtc_info;
+}
+
+struct CrtcInfo * internal_auto_find_crtc (struct ScreenInfo *screen_info, struct OutputInfo *output_info)
+{
+	struct CrtcInfo *crtc_info = NULL;
+	int i;
+
+	for (i = 0; i < screen_info->n_crtc; i++) {
+		if (0 == screen_info->crtcs[i]->cur_noutput) {
+			crtc_info = screen_info->crtcs[i];
+			break;
+		}
+	}
+
+	if (NULL == crtc_info) {
+		crtc_info = screen_info->crtcs[0];
+	}
+
+	return crtc_info;
+}
+
+int internal_set_screen_size (struct ScreenInfo *screen_info)
+{
+	Display *dpy;
+	int screen;
+	struct CrtcInfo *crtc;
+	XRRModeInfo *mode_info;
+	int cur_x = 0, cur_y = 0;
+	int w = 0, h = 0;
+	int mmW, mmH;
+	int max_width = 0, max_height = 0;
+	int i;
+
+	dpy = screen_info->dpy;
+	screen = DefaultScreen (dpy);
+
+	for (i = 0; i < screen_info->n_crtc; i++) {
+		crtc = screen_info->crtcs[i];
+		if (!crtc->cur_mode_id) {
+			continue;
+		}
+		mode_info = internal_find_mode_by_xid (screen_info, crtc->cur_mode_id);
+		cur_x = crtc->cur_x;
+		cur_y = crtc->cur_y;
+
+		w = internal_mode_width (mode_info, crtc->cur_rotation);
+		h = internal_mode_height (mode_info, crtc->cur_rotation);
+
+		if (cur_x + w > max_width) {
+			max_width = cur_x + w;
+		}
+		if (cur_y + h > max_height) {
+			max_height = cur_y + h;
+		}
+	}
+
+		if (max_width > screen_info->max_width) {
+	#if RANDR_GUI_DEBUG
+			fprintf (stderr, "user set screen width %d, larger than max width %d, set to max width\n",
+						cur_x + w, screen_info->max_width);
+	#endif
+			return 0;
+		} else if (max_width < screen_info->min_width) {
+			screen_info->cur_width = screen_info->min_width;
+		} else {
+			screen_info->cur_width = max_width;
+		}
+
+		if (max_height > screen_info->max_height) {
+	#if RANDR_GUI_DEBUG
+			fprintf (stderr, "user set screen height %d, larger than max height %d, set to max height\n",
+						cur_y + h, screen_info->max_height);
+	#endif
+			return 0;
+		} else if (max_height < screen_info->min_height) {
+			screen_info->cur_height = screen_info->min_height;
+		} else {
+			screen_info->cur_height = max_height;
+		}
+
+	/* calculate mmWidth, mmHeight */
+	if (screen_info->cur_width != DisplayWidth (dpy, screen) ||
+		 screen_info->cur_height != DisplayHeight (dpy, screen) ) {
+		double dpi;
+
+		dpi = (25.4 * DisplayHeight (dpy, screen)) / DisplayHeightMM(dpy, screen);
+		mmW = (25.4 * screen_info->cur_width) / dpi;
+		mmH = (25.4 * screen_info->cur_height) / dpi;
+	} else {
+		mmW = DisplayWidthMM (dpy, screen);
+		mmH = DisplayHeightMM (dpy, screen);
+	}
+
+	screen_info->cur_mmWidth = mmW;
+	screen_info->cur_mmHeight = mmH;
+
+	return 1;
+}
+
+void internal_screen_apply (struct ScreenInfo *screen_info)
+{
+	int width, height;
+	int mmWidth, mmHeight;
+	Display *dpy, *cur_dpy;
+	Window window;
+	int screen;
+	static int first = 1;
+
+	width = screen_info->cur_width;
+	height = screen_info->cur_height;
+	mmWidth = screen_info->cur_mmWidth;
+	mmHeight = screen_info->cur_mmHeight;
+	dpy = screen_info->dpy;
+	window = screen_info->window;
+	screen = DefaultScreen (dpy);
+
+	cur_dpy = XOpenDisplay (NULL);
+
+	if (width == DisplayWidth (cur_dpy, screen) &&
+			height == DisplayHeight (cur_dpy, screen) &&
+			mmWidth == DisplayWidthMM (cur_dpy, screen) &&
+			mmHeight == DisplayHeightMM (cur_dpy, screen) ) {
+		return;
+	} else {
+		XRRSetScreenSize (dpy, window, width, height, mmWidth, mmHeight);
+	}
+}
+
+Status internal_crtc_apply (struct CrtcInfo *crtc_info)
+{
+	struct ScreenInfo *screen_info;
+	XRRCrtcInfo *rr_crtc_info;
+	Display *dpy;
+	XRRScreenResources *res;
+	RRCrtc crtc_id;
+	int x, y;
+	RRMode mode_id;
+	Rotation rotation;
+	RROutput *outputs;
+	int noutput;
+	Status s;
+	int i;
+
+	/*if (!crtc_info->changed) {
+		return RRSetConfigSuccess;
+	}*/
+
+	screen_info = crtc_info->screen_info;
+	dpy = screen_info->dpy;
+	res = screen_info->res;
+	crtc_id = crtc_info->id;
+	x = crtc_info->cur_x;
+	y = crtc_info->cur_y;
+
+	mode_id = crtc_info->cur_mode_id;
+	rotation = crtc_info->cur_rotation;
+
+	noutput = crtc_info->cur_noutput;
+
+	if (0 == noutput) {
+		return internal_crtc_disable (crtc_info);
+	}
+
+	outputs = malloc (sizeof (RROutput) * noutput);
+	noutput = 0;
+	for (i = 0; i < screen_info->n_output; i++) {
+		struct OutputInfo *output_info = screen_info->outputs[i];
+
+		if (output_info->cur_crtc && crtc_id == output_info->cur_crtc->id) {
+			outputs[noutput++] = output_info->id;
+		}
+	}
+
+
+	s = XRRSetCrtcConfig (dpy, res, crtc_id, CurrentTime,
+                              x, y, mode_id, rotation,
+                              outputs, noutput);
+
+	if (RRSetConfigSuccess == s) {
+		crtc_info->changed = 0;
+	}
+
+	free (outputs);
+
+	return s;
+}
+
+Status internal_crtc_disable (struct CrtcInfo *crtc)
+{
+	struct ScreenInfo *screen_info;
+
+	screen_info = crtc->screen_info;
+
+	return XRRSetCrtcConfig (screen_info->dpy, screen_info->res, crtc->id, CurrentTime,
+                             0, 0, None, RR_Rotate_0, NULL, 0);
+}
+
+struct ScreenInfo* internal_read_screen_info (Display *display)
+{
+	struct ScreenInfo *screen_info;
+	int screen_num;
+	Window root_window;
+	XRRScreenResources *sr;
+	int i;
+
+	screen_num = DefaultScreen (display);
+	root_window = RootWindow (display, screen_num);
+
+	sr = XRRGetScreenResources (display, root_window);
+
+	if (sr == NULL) {
+		return NULL;
+	}
+
+	screen_info = malloc (sizeof (struct ScreenInfo));
+	screen_info->dpy = display;
+	screen_info->window = root_window;
+	screen_info->res = sr;
+	screen_info->cur_width = DisplayWidth (display, screen_num);
+	screen_info->cur_height = DisplayHeight (display, screen_num);
+	screen_info->cur_mmWidth = DisplayWidthMM (display, screen_num);
+	screen_info->cur_mmHeight = DisplayHeightMM (display, screen_num);
+	screen_info->n_output = sr->noutput;
+	screen_info->n_crtc = sr->ncrtc;
+	screen_info->outputs = malloc (sizeof (struct OutputInfo *) * sr->noutput);
+	screen_info->crtcs = malloc (sizeof (struct CrtcInfo *) * sr->ncrtc);
+	screen_info->clone = 0;
+
+	XRRGetScreenSizeRange (display, root_window, &screen_info->min_width, &screen_info->min_height, &screen_info->max_width, &screen_info->max_height);
+
+	/* get crtc */
+	for (i = 0; i < sr->ncrtc; i++) {
+		struct CrtcInfo *crtc_info;
+		screen_info->crtcs[i] = malloc (sizeof (struct CrtcInfo));
+		crtc_info = screen_info->crtcs[i];
+		XRRCrtcInfo *xrr_crtc_info = XRRGetCrtcInfo (display, sr, sr->crtcs[i]);
+
+		crtc_info->id = sr->crtcs[i];
+		crtc_info->info = xrr_crtc_info;
+		crtc_info->cur_x = xrr_crtc_info->x;
+		crtc_info->cur_y = xrr_crtc_info->y;
+		crtc_info->cur_mode_id = xrr_crtc_info->mode;
+		crtc_info->cur_rotation = xrr_crtc_info->rotation;
+		crtc_info->rotations = xrr_crtc_info->rotations;
+		crtc_info->cur_noutput = xrr_crtc_info->noutput;
+
+		crtc_info->changed = 0;
+		crtc_info->screen_info = screen_info;
+	}
+
+
+	/* get output */
+	for (i = 0; i < sr->noutput; i++) {
+		struct OutputInfo *output;
+		screen_info->outputs[i] = malloc (sizeof (struct OutputInfo));
+		output = screen_info->outputs[i];
+
+		output->id = sr->outputs[i];
+		output->info = XRRGetOutputInfo (display, sr, sr->outputs[i]);
+		output->cur_crtc = internal_find_crtc (screen_info, output->info);
+		output->auto_set = 0;
+		if (output->cur_crtc) {
+			output->off_set = 0;
+		} else {
+			output->off_set = 1;
+		}
+
+	}
+
+	/* set current crtc */
+	screen_info->cur_crtc = screen_info->outputs[0]->cur_crtc;
+	screen_info->primary_crtc = screen_info->cur_crtc;
+	screen_info->cur_output = screen_info->outputs[0];
+
+	return screen_info;
+}
+
+void internal_free_screen_info (struct ScreenInfo *screen_info)
+{
+	free (screen_info->outputs);
+	free (screen_info->crtcs);
+	free (screen_info);
+}
+
+
+
+/*check if other outputs that connected to the same crtc support this mode*/
+static int internal_check_mode (struct ScreenInfo *screen_info, struct OutputInfo *output, RRMode mode_id)
+{
+	XRRCrtcInfo *crtc_info;
+	/* XRR */
+	int i, j;
+	int mode_ok = 1;
+
+	if (!output->cur_crtc) {
+		return 1;
+	}
+
+	crtc_info = output->cur_crtc->info;
+	for (i = 0; i < crtc_info->noutput; i++) {
+		XRROutputInfo *output_info;
+		int nmode;
+
+		if (output->id == crtc_info->outputs[i]) {
+			continue;
+		}
+
+		mode_ok = 0;
+		output_info = XRRGetOutputInfo (screen_info->dpy, screen_info->res, crtc_info->outputs[i]);
+		nmode = output_info->nmode;
+		for (j = 0; j < nmode; j++) {
+			if (mode_id == output_info->modes[j]) {
+				mode_ok = 1;
+				break;
+			}
+		}
+		if (!mode_ok) {
+			break;
+		}
+	}
+
+	return mode_ok;
+}
+
+static RRCrtc internal_get_crtc_id_by_output_id (struct ScreenInfo *screen_info, RROutput output_id)
+{
+	int i;
+	RRCrtc crtc_id = -1;
+
+	for (i = 0; i < screen_info->n_output; i++) {
+		if (output_id == screen_info->outputs[i]->id) {
+			if (screen_info->outputs[i]->cur_crtc) {
+				crtc_id = screen_info->outputs[i]->cur_crtc->id;
+			} else {
+				crtc_id = 0;	/* this output is off */
+			}
+			break;
+		}
+	}
+
+	return crtc_id;
+}
+
+static struct CrtcInfo *
+internal_get_crtc_info_by_xid (struct ScreenInfo *screen_info, RRCrtc crtc_id)
+{
+	struct CrtcInfo *crtc_info = NULL;
+	int i;
+
+	for (i = 0; i < screen_info->n_crtc; i++) {
+		if (crtc_id == screen_info->crtcs[i]->id) {
+			crtc_info = screen_info->crtcs[i];
+			break;
+		}
+	}
+
+	return crtc_info;
+}
+
+static XRRModeInfo *
+internal_preferred_mode (struct ScreenInfo *screen_info, struct OutputInfo *output)
+{
+    XRROutputInfo   *output_info = output->info;
+    Display *dpy;
+    int screen;
+    int             m;
+    XRRModeInfo     *best;
+    int             bestDist;
+
+	 dpy = screen_info->dpy;
+	 screen = DefaultScreen (dpy);
+    best = NULL;
+    bestDist = 0;
+    for (m = 0; m < output_info->nmode; m++) {
+        XRRModeInfo *mode_info = internal_find_mode_by_xid (screen_info, output_info->modes[m]);
+        int         dist;
+
+        if (m < output_info->npreferred)
+            dist = 0;
+        else if (output_info->mm_height)
+            dist = (1000 * DisplayHeight(dpy, screen) / DisplayHeightMM(dpy, screen) -
+                    1000 * mode_info->height / output_info->mm_height);
+        else
+            dist = DisplayHeight(dpy, screen) - mode_info->height;
+
+        if (dist < 0) dist = -dist;
+        if (!best || dist < bestDist) {
+            best = mode_info;
+            bestDist = dist;
+        	   }
+    	}
+    return best;
+}
+
+int internal_main_low_apply (struct ScreenInfo *screen_info)
+{
+	int i;
+	struct CrtcInfo *crtc_info;
+
+	/* set_positions (screen_info); */
+
+	if (!internal_set_screen_size (screen_info)) {
+		printf("Screen Size FAILURE\n\r");
+		return 0;
+	}
+
+	for (i = 0; i < screen_info->n_crtc; i++) {
+		int old_x, old_y, old_w, old_h;
+
+		XRRCrtcInfo *crtc_info = XRRGetCrtcInfo (screen_info->dpy, screen_info->res, screen_info->crtcs[i]->id);
+		XRRModeInfo *old_mode = internal_find_mode_by_xid (screen_info, crtc_info->mode);
+
+		if (crtc_info->mode == None) {
+			continue;
+		}
+
+		old_x = crtc_info->x;
+		old_y = crtc_info->y;
+		old_w = internal_mode_width (old_mode, crtc_info->rotation);
+		old_h = internal_mode_height (old_mode, crtc_info->rotation);
+
+		if (old_x + old_w <= screen_info->cur_width &&
+			 old_y + old_h <= screen_info->cur_height ) {
+			continue;
+		} else {
+			internal_crtc_disable (screen_info->crtcs[i]);
+		}
+	}
+
+	internal_screen_apply (screen_info);
+
+	for (i = 0; i < screen_info->n_crtc; i++) {
+		Status s;
+		crtc_info = screen_info->crtcs[i];
+
+			s = internal_crtc_apply (crtc_info);
+			if (RRSetConfigSuccess != s) {
+				fprintf (stderr, "crtc apply error\n");
+			}
+	}
+
+	return 1;
+}
+
+void internal_output_auto (struct ScreenInfo *screen_info, struct OutputInfo *output_info)
+{
+	XRRModeInfo *mode_info;
+	RRMode mode_id;
+	struct CrtcInfo *crtc_info;
+	XRROutputInfo *probe_output_info;
+
+	if (RR_Disconnected == output_info->info->connection) {
+		XRRScreenResources *cur_res;
+
+		cur_res = XRRGetScreenResources (screen_info->dpy, screen_info->window);
+		probe_output_info = XRRGetOutputInfo (screen_info->dpy, cur_res, output_info->id);
+		if (RR_Disconnected != probe_output_info->connection) {
+			output_info->info = probe_output_info;
+			output_info->cur_crtc = internal_auto_find_crtc (screen_info, output_info);
+		}
+	}
+
+	mode_info = internal_preferred_mode (screen_info, output_info);
+	if (!mode_info) {
+		return;
+	}
+	mode_id = mode_info->id;
+
+	crtc_info = output_info->cur_crtc;
+	if (crtc_info) {
+		crtc_info->cur_mode_id = mode_id;
+	} else {
+		crtc_info = internal_auto_find_crtc (screen_info, output_info);
+		if (!crtc_info) {
+#if RANDR_GUI_DEBUG
+			fprintf (stderr, "Can not find usable CRTC\n");
+#endif
+			return;
+		} else {
+			screen_info->cur_output->cur_crtc = crtc_info;
+			screen_info->cur_crtc = crtc_info;
+			screen_info->cur_crtc->cur_noutput++;
+			fprintf (stderr, "n output: %d\n", screen_info->cur_crtc->cur_noutput);
+			screen_info->cur_crtc->cur_mode_id = mode_id;
+			screen_info->cur_crtc->changed = 1;
+		}
+	}
+
+}
+
+void internal_output_off (struct ScreenInfo *screen_info, struct OutputInfo *output)
+{
+	if (output->cur_crtc) {
+		output->cur_crtc->cur_noutput--;
+	}
+	output->cur_crtc = NULL;
+	screen_info->cur_crtc = NULL;
+	output->off_set = 1;
+}
+
+void internal_output_set_primary (struct ScreenInfo *screen_info, RROutput output_id)
+{
+	XRRSetOutputPrimary(screen_info->dpy, screen_info->window, output_id);
+}
\ No newline at end of file
diff --git a/tderandr/lowlevel_randr.h b/tderandr/lowlevel_randr.h
new file mode 100644
index 000000000..b5825e450
--- /dev/null
+++ b/tderandr/lowlevel_randr.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright © 2007 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
+
+struct ScreenInfo;
+
+struct CrtcInfo {
+	RRCrtc id;
+	XRRCrtcInfo *info;
+	int cur_x;
+	int cur_y;
+	RRMode cur_mode_id;
+	Rotation cur_rotation;
+	Rotation rotations;
+	int cur_noutput;
+
+	int changed;
+
+	struct ScreenInfo *screen_info;
+};
+
+struct OutputInfo {
+	RROutput id;
+	XRROutputInfo *info;
+	struct CrtcInfo *cur_crtc;
+
+	int auto_set;
+	int off_set;
+};
+
+struct ScreenInfo {
+	Display *dpy;
+	Window window;
+	XRRScreenResources *res;
+	int min_width, min_height;
+	int max_width, max_height;
+	int cur_width;
+	int cur_height;
+	int cur_mmWidth;
+	int cur_mmHeight;
+
+  	int n_output;
+  	int n_crtc;
+  	struct OutputInfo **outputs;
+  	struct CrtcInfo **crtcs;
+
+  	int clone;
+  	struct CrtcInfo *primary_crtc;
+
+  	struct CrtcInfo *cur_crtc;
+  	struct OutputInfo *cur_output;
+};
+
+extern struct ScreenInfo *screen_info;
+extern const uint big_pixbuf[], small_pixbuf[];
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void free_screen_info (struct ScreenInfo *screen_info);
+
+struct ScreenInfo* internal_read_screen_info (Display *);
+
+int internal_set_screen_size (struct ScreenInfo *screen_info);
+void internal_output_auto (struct ScreenInfo *screen_info, struct OutputInfo *output_info);
+void internal_output_off (struct ScreenInfo *screen_info, struct OutputInfo *output);
+void internal_output_set_primary (struct ScreenInfo *screen_info, RROutput output_id);
+struct CrtcInfo* internal_auto_find_crtc (struct ScreenInfo *screen_info, struct OutputInfo *output_info);
+
+XRRModeInfo *internal_find_mode_by_xid (struct ScreenInfo *screen_info, RRMode mode_id);
+int internal_mode_height (XRRModeInfo *mode_info, Rotation rotation);
+int internal_mode_width (XRRModeInfo *mode_info, Rotation rotation);
+int internal_get_width_by_output_id (struct ScreenInfo *screen_info, RROutput output_id);
+int internal_get_height_by_output_id (struct ScreenInfo *screen_info, RROutput output_id);
+char *internal_get_output_name (struct ScreenInfo *screen_info, RROutput id);
+Status internal_crtc_apply (struct CrtcInfo *crtc_info);
+Status internal_crtc_disable (struct CrtcInfo *crtc);
+int internal_main_low_apply (struct ScreenInfo *screen_info);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/tderandr/randr.cpp b/tderandr/randr.cpp
new file mode 100644
index 000000000..334da5a79
--- /dev/null
+++ b/tderandr/randr.cpp
@@ -0,0 +1,881 @@
+/*
+ * Copyright (c) 2002,2003 Hamish Rodda <rodda@kde.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "randr.h"
+#include "lowlevel_randr.h"
+
+#include <tqtimer.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kglobal.h>
+#include <kapplication.h>
+#include <kiconloader.h>
+#include <dcopclient.h>
+#include <kipc.h>
+#include <kactivelabel.h>
+
+#include "ktimerdialog.h"
+
+#include <X11/Xlib.h>
+#define INT8 _X11INT8
+#define INT32 _X11INT32
+#include <X11/Xproto.h>
+#undef INT8
+#undef INT32
+#include <X11/extensions/Xrandr.h>
+
+HotPlugRule::HotPlugRule()
+{
+	//
+}
+
+HotPlugRule::~HotPlugRule()
+{
+	//
+}
+
+SingleScreenData::SingleScreenData()
+{
+	generic_screen_detected = false;
+	screen_connected = false;
+
+	current_resolution_index = 0;
+	current_refresh_rate_index = 0;
+	current_color_depth_index = 0;
+
+	gamma_red = 0.0;
+	gamma_green = 0.0;
+	gamma_blue = 0.0;
+
+	current_rotation_index = 0;
+	current_orientation_mask = 0;
+	has_x_flip = false;
+	has_y_flip = false;
+	supports_transformations = false;
+
+	is_primary = false;
+	is_extended = false;
+	absolute_x_position = 0;
+	absolute_y_position = 0;
+	current_x_pixel_count = 0;
+	current_y_pixel_count = 0;
+
+	has_dpms = false;
+	enable_dpms = false;
+	dpms_standby_delay = 0;
+	dpms_suspend_delay = 0;
+	dpms_off_delay = 0;
+}
+
+SingleScreenData::~SingleScreenData()
+{
+	//
+}
+
+class RandRScreenPrivate
+{
+public:
+	RandRScreenPrivate() : config(0L) {};
+	~RandRScreenPrivate()
+	{
+		if (config) {
+			XRRFreeScreenConfigInfo(config);
+		}
+	}
+
+	XRRScreenConfiguration* config;
+};
+
+KDE_EXPORT RandRScreen::RandRScreen(int screenIndex)
+	: d(new RandRScreenPrivate())
+	, m_screen(screenIndex)
+	, m_shownDialog(NULL)
+{
+	loadSettings();
+	setOriginal();
+}
+
+KDE_EXPORT RandRScreen::~RandRScreen()
+{
+	delete d;
+}
+
+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;
+	}
+}
+
+KDE_EXPORT void RandRScreen::setOriginal()
+{
+	m_originalSize = m_currentSize;
+	m_originalRotation = m_currentRotation;
+	m_originalRefreshRate = m_currentRefreshRate;
+}
+
+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;
+}
+
+KDE_EXPORT bool RandRScreen::applyProposedAndConfirm()
+{
+	if (proposedChanged()) {
+		setOriginal();
+
+		if (applyProposed()) {
+			if (!confirm()) {
+				proposeOriginal();
+				applyProposed();
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+KDE_EXPORT bool RandRScreen::confirm()
+{
+	// uncomment the line below and edit out the KTimerDialog stuff to get
+	// a version which works on today's tdelibs (no accept dialog is presented)
+
+	// FIXME remember to put the dialog on the right screen
+
+	KTimerDialog acceptDialog ( 15000, KTimerDialog::CountDown,
+                TDEApplication::kApplication()->mainWidget(),
+											"mainKTimerDialog",
+											true,
+											i18n("Confirm Display Setting Change"),
+											KTimerDialog::Ok|KTimerDialog::Cancel,
+											KTimerDialog::Cancel);
+
+	acceptDialog.setButtonOK(KGuiItem(i18n("&Accept Configuration"), "button_ok"));
+	acceptDialog.setButtonCancel(KGuiItem(i18n("&Return to Previous Configuration"), "button_cancel"));
+
+	KActiveLabel *label = new KActiveLabel(i18n("Your screen orientation, size and refresh rate "
+                    "have been changed to the requested settings. Please indicate whether you wish to "
+                    "keep this configuration. In 15 seconds the display will revert to your previous "
+                    "settings."), &acceptDialog, "userSpecifiedLabel");
+
+	acceptDialog.setMainWidget(label);
+
+	KDialog::centerOnScreen(&acceptDialog, m_screen);
+
+	m_shownDialog = &acceptDialog;
+	connect( m_shownDialog, TQT_SIGNAL( destroyed()), this, TQT_SLOT( shownDialogDestroyed()));
+	connect( kapp->desktop(), TQT_SIGNAL( resized(int)), this, TQT_SLOT( desktopResized()));
+
+        return acceptDialog.exec();
+}
+
+KDE_EXPORT void RandRScreen::shownDialogDestroyed()
+{
+    m_shownDialog = NULL;
+    disconnect( kapp->desktop(), TQT_SIGNAL( resized(int)), this, TQT_SLOT( desktopResized()));
+}
+
+KDE_EXPORT void RandRScreen::desktopResized()
+{
+	if( m_shownDialog != NULL )
+		KDialog::centerOnScreen(m_shownDialog, m_screen);
+}
+
+KDE_EXPORT TQString RandRScreen::changedMessage() const
+{
+	if (currentRefreshRate() == -1)
+		return i18n("New configuration:\nResolution: %1 x %2\nOrientation: %3")
+			.arg(currentPixelWidth())
+			.arg(currentPixelHeight())
+			.arg(currentRotationDescription());
+	else
+		return i18n("New configuration:\nResolution: %1 x %2\nOrientation: %3\nRefresh rate: %4")
+			.arg(currentPixelWidth())
+			.arg(currentPixelHeight())
+			.arg(currentRotationDescription())
+			.arg(currentRefreshRateDescription());
+}
+
+KDE_EXPORT bool RandRScreen::changedFromOriginal() const
+{
+	return m_currentSize != m_originalSize || m_currentRotation != m_originalRotation || m_currentRefreshRate != m_originalRefreshRate;
+}
+
+KDE_EXPORT void RandRScreen::proposeOriginal()
+{
+	m_proposedSize = m_originalSize;
+	m_proposedRotation = m_originalRotation;
+	m_proposedRefreshRate = m_originalRefreshRate;
+}
+
+KDE_EXPORT bool RandRScreen::proposedChanged() const
+{
+	return m_currentSize != m_proposedSize || m_currentRotation != m_proposedRotation || m_currentRefreshRate != m_proposedRefreshRate;
+}
+
+KDE_EXPORT TQString RandRScreen::rotationName(int rotation, bool pastTense, bool capitalised)
+{
+	if (!pastTense)
+		switch (rotation) {
+			case RR_Rotate_0:
+				return i18n("Normal");
+			case RR_Rotate_90:
+				return i18n("Left (90 degrees)");
+			case RR_Rotate_180:
+				return i18n("Upside-down (180 degrees)");
+			case RR_Rotate_270:
+				return i18n("Right (270 degrees)");
+			case RR_Reflect_X:
+				return i18n("Mirror horizontally");
+			case RR_Reflect_Y:
+				return i18n("Mirror vertically");
+			default:
+				return i18n("Unknown orientation");
+		}
+
+	switch (rotation) {
+		case RR_Rotate_0:
+			return i18n("Normal");
+		case RR_Rotate_90:
+			return i18n("Rotated 90 degrees counterclockwise");
+		case RR_Rotate_180:
+			return i18n("Rotated 180 degrees counterclockwise");
+		case RR_Rotate_270:
+			return i18n("Rotated 270 degrees counterclockwise");
+		default:
+			if (rotation & RR_Reflect_X)
+				if (rotation & RR_Reflect_Y)
+					if (capitalised)
+						return i18n("Mirrored horizontally and vertically");
+					else
+						return i18n("mirrored horizontally and vertically");
+				else
+					if (capitalised)
+						return i18n("Mirrored horizontally");
+					else
+						return i18n("mirrored horizontally");
+			else if (rotation & RR_Reflect_Y)
+				if (capitalised)
+					return i18n("Mirrored vertically");
+				else
+					return i18n("mirrored vertically");
+			else
+				if (capitalised)
+					return i18n("Unknown orientation");
+				else
+					return i18n("unknown orientation");
+	}
+}
+
+KDE_EXPORT TQPixmap RandRScreen::rotationIcon(int rotation) const
+{
+	// Adjust icons for current screen orientation
+	if (!(m_currentRotation & RR_Rotate_0) && rotation & (RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270)) {
+		int currentAngle = m_currentRotation & (RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270);
+		switch (currentAngle) {
+			case RR_Rotate_90:
+				rotation <<= 3;
+				break;
+			case RR_Rotate_180:
+				rotation <<= 2;
+				break;
+			case RR_Rotate_270:
+				rotation <<= 1;
+				break;
+		}
+
+		// Fix overflow
+		if (rotation > RR_Rotate_270) {
+			rotation >>= 4;
+		}
+	}
+
+	switch (rotation) {
+		case RR_Rotate_0:
+			return SmallIcon("up");
+		case RR_Rotate_90:
+			return SmallIcon("back");
+		case RR_Rotate_180:
+			return SmallIcon("down");
+		case RR_Rotate_270:
+			return SmallIcon("forward");
+		case RR_Reflect_X:
+		case RR_Reflect_Y:
+		default:
+			return SmallIcon("stop");
+	}
+}
+
+KDE_EXPORT TQString RandRScreen::currentRotationDescription() const
+{
+	TQString ret = rotationName(m_currentRotation & RotateMask);
+
+	if (m_currentRotation != (m_currentRotation & RotateMask)) {
+		if (m_currentRotation & RR_Rotate_0) {
+			ret = rotationName(m_currentRotation & (RR_Reflect_X + RR_Reflect_X), true, true);
+		}
+		else {
+			ret += ", " + rotationName(m_currentRotation & (RR_Reflect_X + RR_Reflect_X), true, false);
+		}
+	}
+
+	return ret;
+}
+
+KDE_EXPORT int RandRScreen::rotationIndexToDegree(int rotation) const
+{
+	switch (rotation & RotateMask) {
+		case RR_Rotate_90:
+			return 90;
+
+		case RR_Rotate_180:
+			return 180;
+
+		case RR_Rotate_270:
+			return 270;
+
+		default:
+			return 0;
+	}
+}
+
+KDE_EXPORT int RandRScreen::rotationDegreeToIndex(int degree) const
+{
+	switch (degree) {
+		case 90:
+			return RR_Rotate_90;
+
+		case 180:
+			return RR_Rotate_180;
+
+		case 270:
+			return RR_Rotate_270;
+
+		default:
+			return RR_Rotate_0;
+	}
+}
+
+KDE_EXPORT int RandRScreen::currentPixelWidth() const
+{
+	return m_pixelSizes[m_currentSize].width();
+}
+
+KDE_EXPORT int RandRScreen::currentPixelHeight() const
+{
+	return m_pixelSizes[m_currentSize].height();
+}
+
+KDE_EXPORT int RandRScreen::currentMMWidth() const
+{
+	return m_pixelSizes[m_currentSize].width();
+}
+
+KDE_EXPORT int RandRScreen::currentMMHeight() const
+{
+	return m_pixelSizes[m_currentSize].height();
+}
+
+KDE_EXPORT TQStringList RandRScreen::refreshRates(int size) const
+{
+	int nrates;
+	TQStringList ret;
+
+	if (d->config) {
+		short* rates = XRRRates(tqt_xdisplay(), m_screen, (SizeID)size, &nrates);
+
+		for (int i = 0; i < nrates; i++)
+			ret << refreshRateDirectDescription(rates[i]);
+	}
+	else {
+		// Great, now we have to go after the information manually.  Ughh.
+		ScreenInfo *screeninfo = internal_read_screen_info(tqt_xdisplay());
+		int numSizes = screeninfo->res->nmode;
+		for (int i = 0; i < numSizes; i++) {
+			int refresh_rate = ((screeninfo->res->modes[i].dotClock*1.0)/((screeninfo->res->modes[i].hTotal)*(screeninfo->res->modes[i].vTotal)*1.0));
+			TQString newRate = refreshRateDirectDescription(refresh_rate);
+			if (!ret.contains(newRate)) {
+				ret.append(newRate);
+			}
+		}
+	}
+
+	return ret;
+}
+
+KDE_EXPORT TQString RandRScreen::refreshRateDirectDescription(int rate) const
+{
+	return i18n("Refresh rate in Hertz (Hz)", "%1 Hz").arg(rate);
+}
+
+KDE_EXPORT TQString RandRScreen::refreshRateIndirectDescription(int size, int index) const
+{
+	return i18n("Refresh rate in Hertz (Hz)", "%1 Hz").arg(refreshRateIndexToHz(size, index));
+}
+
+KDE_EXPORT TQString RandRScreen::refreshRateDescription(int size, int index) const
+{
+	return refreshRates(size)[index];
+}
+
+KDE_EXPORT bool RandRScreen::proposeRefreshRate(int index)
+{
+	if (index >= 0 && (int)refreshRates(proposedSize()).count() > index) {
+		m_proposedRefreshRate = index;
+		return true;
+	}
+
+	return false;
+}
+
+KDE_EXPORT int RandRScreen::currentRefreshRate() const
+{
+	return m_currentRefreshRate;
+}
+
+KDE_EXPORT TQString RandRScreen::currentRefreshRateDescription() const
+{
+	return refreshRateIndirectDescription(m_currentSize, m_currentRefreshRate);
+}
+
+KDE_EXPORT int RandRScreen::proposedRefreshRate() const
+{
+	return m_proposedRefreshRate;
+}
+
+KDE_EXPORT int RandRScreen::refreshRateHzToIndex(int size, int hz) const
+{
+	int nrates;
+	short* rates = XRRRates(tqt_xdisplay(), m_screen, (SizeID)size, &nrates);
+
+	for (int i = 0; i < nrates; i++)
+		if (hz == rates[i])
+			return i;
+
+	if (nrates != 0)
+		// Wrong input Hz!
+		Q_ASSERT(false);
+
+	return -1;
+}
+
+KDE_EXPORT int RandRScreen::refreshRateIndexToHz(int size, int index) const
+{
+	int nrates;
+	short* rates = XRRRates(tqt_xdisplay(), m_screen, (SizeID)size, &nrates);
+
+	if (nrates == 0 || index < 0)
+		return 0;
+
+	// Wrong input Hz!
+	if(index >= nrates)
+		return 0;
+
+	return rates[index];
+}
+
+KDE_EXPORT int RandRScreen::numSizes() const
+{
+	return m_pixelSizes.count();
+}
+
+KDE_EXPORT const TQSize& RandRScreen::pixelSize(int index) const
+{
+	return m_pixelSizes[index];
+}
+
+KDE_EXPORT const TQSize& RandRScreen::mmSize(int index) const
+{
+	return m_mmSizes[index];
+}
+
+KDE_EXPORT int RandRScreen::sizeIndex(TQSize pixelSize) const
+{
+	for (uint i = 0; i < m_pixelSizes.count(); i++)
+		if (m_pixelSizes[i] == pixelSize)
+			return i;
+
+	return -1;
+}
+
+KDE_EXPORT int RandRScreen::rotations() const
+{
+	return m_rotations;
+}
+
+KDE_EXPORT int RandRScreen::currentRotation() const
+{
+	return m_currentRotation;
+}
+
+KDE_EXPORT int RandRScreen::currentSize() const
+{
+	return m_currentSize;
+}
+
+KDE_EXPORT int RandRScreen::proposedRotation() const
+{
+	return m_proposedRotation;
+}
+
+KDE_EXPORT void RandRScreen::proposeRotation(int newRotation)
+{
+	m_proposedRotation = newRotation & OrientationMask;
+}
+
+KDE_EXPORT int RandRScreen::proposedSize() const
+{
+	return m_proposedSize;
+}
+
+KDE_EXPORT bool RandRScreen::proposeSize(int newSize)
+{
+	if ((int)m_pixelSizes.count() > newSize) {
+		m_proposedSize = newSize;
+		return true;
+	}
+
+	return false;
+}
+
+KDE_EXPORT void RandRScreen::load(TDEConfig& config)
+{
+	config.setGroup(TQString("Screen%1").arg(m_screen));
+
+	if (proposeSize(sizeIndex(TQSize(config.readNumEntry("width", currentPixelWidth()), config.readNumEntry("height", currentPixelHeight())))))
+		proposeRefreshRate(refreshRateHzToIndex(proposedSize(), config.readNumEntry("refresh", currentRefreshRate())));
+
+	proposeRotation(rotationDegreeToIndex(config.readNumEntry("rotation", 0)) + (config.readBoolEntry("reflectX") ? ReflectX : 0) + (config.readBoolEntry("reflectY") ? ReflectY : 0));
+}
+
+KDE_EXPORT void RandRScreen::save(TDEConfig& config) const
+{
+	config.setGroup(TQString("Screen%1").arg(m_screen));
+	config.writeEntry("width", currentPixelWidth());
+	config.writeEntry("height", currentPixelHeight());
+	config.writeEntry("refresh", refreshRateIndexToHz(currentSize(), currentRefreshRate()));
+	config.writeEntry("rotation", rotationIndexToDegree(currentRotation()));
+	config.writeEntry("reflectX", (bool)(currentRotation() & ReflectMask) == ReflectX);
+	config.writeEntry("reflectY", (bool)(currentRotation() & ReflectMask) == ReflectY);
+}
+
+KDE_EXPORT RandRDisplay::RandRDisplay()
+	: m_valid(true)
+{
+	// Check extension
+	Status s = XRRQueryExtension(tqt_xdisplay(), &m_eventBase, &m_errorBase);
+	if (!s) {
+		m_errorCode = TQString("%1, base %1").arg(s).arg(m_errorBase);
+		m_valid = false;
+		return;
+	}
+
+	// Sometimes the extension is available but does not return any screens (!)
+	// Check for that case
+	Display *randr_display = XOpenDisplay(NULL);
+	int screen_num;
+	Window root_window;
+
+	screen_num = DefaultScreen (randr_display);
+	root_window = RootWindow (randr_display, screen_num);
+	if (XRRGetScreenResources (randr_display, root_window) == NULL) {
+		m_errorCode = i18n("No screens detected");
+		m_valid = false;
+		return;
+	}
+
+	int major_version, minor_version;
+	XRRQueryVersion(tqt_xdisplay(), &major_version, &minor_version);
+
+	m_version = TQString("X Resize and Rotate extension version %1.%1").arg(major_version).arg(minor_version);
+
+	m_numScreens = ScreenCount(tqt_xdisplay());
+
+	// This assumption is WRONG with Xinerama
+	// Q_ASSERT(TQApplication::desktop()->numScreens() == ScreenCount(tqt_xdisplay()));
+
+	m_screens.setAutoDelete(true);
+	for (int i = 0; i < m_numScreens; i++) {
+		m_screens.append(new RandRScreen(i));
+	}
+
+	setCurrentScreen(TQApplication::desktop()->primaryScreen());
+}
+
+KDE_EXPORT bool RandRDisplay::isValid() const
+{
+	return m_valid;
+}
+
+KDE_EXPORT const TQString& RandRDisplay::errorCode() const
+{
+	return m_errorCode;
+}
+
+KDE_EXPORT int RandRDisplay::eventBase() const
+{
+	return m_eventBase;
+}
+
+KDE_EXPORT int RandRDisplay::screenChangeNotifyEvent() const
+{
+	return m_eventBase + RRScreenChangeNotify;
+}
+
+KDE_EXPORT int RandRDisplay::errorBase() const
+{
+	return m_errorBase;
+}
+
+KDE_EXPORT const TQString& RandRDisplay::version() const
+{
+	return m_version;
+}
+
+KDE_EXPORT void RandRDisplay::setCurrentScreen(int index)
+{
+	m_currentScreenIndex = index;
+	m_currentScreen = m_screens.at(m_currentScreenIndex);
+	Q_ASSERT(m_currentScreen);
+}
+
+KDE_EXPORT int RandRDisplay::screenIndexOfWidget(TQWidget* widget)
+{
+	int ret = TQApplication::desktop()->screenNumber(widget);
+	return ret != -1 ? ret : TQApplication::desktop()->primaryScreen();
+}
+
+KDE_EXPORT int RandRDisplay::currentScreenIndex() const
+{
+	return m_currentScreenIndex;
+}
+
+KDE_EXPORT void RandRDisplay::refresh()
+{
+	for (RandRScreen* s = m_screens.first(); s; s = m_screens.next())
+		s->loadSettings();
+}
+
+KDE_EXPORT int RandRDisplay::numScreens() const
+{
+	return m_numScreens;
+}
+
+KDE_EXPORT RandRScreen* RandRDisplay::screen(int index)
+{
+	return m_screens.at(index);
+}
+
+KDE_EXPORT RandRScreen* RandRDisplay::currentScreen()
+{
+	return m_currentScreen;
+}
+
+KDE_EXPORT bool RandRDisplay::loadDisplay(TDEConfig& config, bool loadScreens)
+{
+	if (loadScreens)
+		for (RandRScreen* s = m_screens.first(); s; s = m_screens.next())
+			s->load(config);
+
+	return applyOnStartup(config);
+}
+
+KDE_EXPORT bool RandRDisplay::applyOnStartup(TDEConfig& config)
+{
+	config.setGroup("Display");
+	return config.readBoolEntry("ApplyOnStartup", false);
+}
+
+KDE_EXPORT bool RandRDisplay::syncTrayApp(TDEConfig& config)
+{
+	config.setGroup("Display");
+	return config.readBoolEntry("SyncTrayApp", false);
+}
+
+KDE_EXPORT void RandRDisplay::saveDisplay(TDEConfig& config, bool applyOnStartup, bool syncTrayApp)
+{
+	Q_ASSERT(!config.isReadOnly());
+
+	config.setGroup("Display");
+	config.writeEntry("ApplyOnStartup", applyOnStartup);
+	config.writeEntry("SyncTrayApp", syncTrayApp);
+
+	for (RandRScreen* s = m_screens.first(); s; s = m_screens.next())
+		s->save(config);
+}
+
+KDE_EXPORT void RandRDisplay::applyProposed(bool confirm)
+{
+	for (int screenIndex = 0; screenIndex < numScreens(); screenIndex++) {
+		if (screen(screenIndex)->proposedChanged()) {
+			if (confirm)
+					screen(screenIndex)->applyProposedAndConfirm();
+			else
+					screen(screenIndex)->applyProposed();
+		}
+	}
+}
+
+KDE_EXPORT bool RandRDisplay::showTestConfigurationDialog()
+{
+	RandRScreen* firstScreen = screen(0);
+	if (firstScreen) {
+		return firstScreen->showTestConfigurationDialog();
+	}
+	else {
+		return false;
+	}
+}
+
+KDE_EXPORT bool RandRScreen::showTestConfigurationDialog()
+{
+	// uncomment the line below and edit out the KTimerDialog stuff to get
+	// a version which works on today's tdelibs (no accept dialog is presented)
+
+	// FIXME remember to put the dialog on the right screen
+
+	KTimerDialog acceptDialog ( 15000, KTimerDialog::CountDown,
+                TDEApplication::kApplication()->mainWidget(),
+											"mainKTimerDialog",
+											true,
+											i18n("Confirm Display Settings"),
+											KTimerDialog::Ok|KTimerDialog::Cancel,
+											KTimerDialog::Cancel);
+
+	acceptDialog.setButtonOK(KGuiItem(i18n("&Accept Configuration"), "button_ok"));
+	acceptDialog.setButtonCancel(KGuiItem(i18n("&Return to Previous Configuration"), "button_cancel"));
+
+	KActiveLabel *label = new KActiveLabel(i18n("Your display devices has been configured "
+                    "to match the settings shown above. Please indicate whether you wish to "
+                    "keep this configuration. In 15 seconds the display will revert to your previous "
+                    "settings."), &acceptDialog, "userSpecifiedLabel");
+
+	acceptDialog.setMainWidget(label);
+
+	KDialog::centerOnScreen(&acceptDialog, 0);
+
+	m_shownDialog = &acceptDialog;
+	connect( m_shownDialog, TQT_SIGNAL( destroyed()), this, TQT_SLOT( shownDialogDestroyed()));
+	connect( kapp->desktop(), TQT_SIGNAL( resized(int)), this, TQT_SLOT( desktopResized()));
+
+        return acceptDialog.exec();
+}
+
+KDE_EXPORT int RandRScreen::pixelCount( int index ) const
+{
+	TQSize sz = pixelSize(index);
+	return sz.width() * sz.height();
+}
+
+#include "randr.moc"
diff --git a/tderandr/randr.h b/tderandr/randr.h
new file mode 100644
index 000000000..af3712e71
--- /dev/null
+++ b/tderandr/randr.h
@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) 2002,2003 Hamish Rodda <rodda@kde.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef __RANDR_H__
+#define __RANDR_H__
+
+#include <tqobject.h>
+#include <tqstringlist.h>
+#include <tqptrlist.h>
+
+#include <tdecmodule.h>
+#include <kconfig.h>
+
+class KTimerDialog;
+class RandRScreenPrivate;
+
+class KRANDR_EXPORT HotPlugRule {
+	public:
+		enum states {
+			AnyState		= 0,
+			Connected		= 1,
+			Disconnected		= 2
+		};
+
+	public:
+		HotPlugRule();
+		virtual ~HotPlugRule();
+
+	public:
+		TQStringList outputs;
+		TQValueList< int > states;
+		TQString profileName;
+};
+
+typedef TQValueList< HotPlugRule > HotPlugRulesList;
+
+class KRANDR_EXPORT SingleScreenData {
+	public:
+		SingleScreenData();
+		virtual ~SingleScreenData();
+	
+	public:
+		TQString screenUniqueName;
+		TQString screenFriendlyName;
+		bool generic_screen_detected;
+		bool screen_connected;
+	
+		TQStringList resolutions;
+		TQStringList refresh_rates;
+		TQStringList color_depths;
+		TQStringList rotations;
+	
+		int current_resolution_index;
+		int current_refresh_rate_index;
+		int current_color_depth_index;
+	
+		float gamma_red;
+		float gamma_green;
+		float gamma_blue;
+	
+		int current_rotation_index;
+		int current_orientation_mask;
+		bool has_x_flip;
+		bool has_y_flip;
+		bool supports_transformations;
+	
+		bool is_primary;
+		bool is_extended;
+		int absolute_x_position;
+		int absolute_y_position;
+		int current_x_pixel_count;
+		int current_y_pixel_count;
+	
+		bool has_dpms;
+		bool enable_dpms;
+		unsigned int dpms_standby_delay;
+		unsigned int dpms_suspend_delay;
+		unsigned int dpms_off_delay;
+};
+
+class RandRScreen : public TQObject
+{
+	Q_OBJECT
+
+public:
+	enum orientations {
+		Rotate0			= 0x1,
+		Rotate90		= 0x2,
+		Rotate180		= 0x4,
+		Rotate270		= 0x8,
+		RotateMask		= 15,
+		RotationCount	= 4,
+		ReflectX		= 0x10,
+		ReflectY		= 0x20,
+		ReflectMask		= 48,
+		OrientationMask	= 63,
+		OrientationCount = 6
+	};
+
+	RandRScreen(int screenIndex);
+	~RandRScreen();
+
+	void		loadSettings();
+	void		setOriginal();
+
+	bool		applyProposed();
+
+	/**
+	 * @returns false if the user did not confirm in time, or cancelled, or the change failed
+	 */
+	bool		applyProposedAndConfirm();
+
+public slots:
+	bool		confirm();
+	bool		showTestConfigurationDialog();
+
+public:
+	TQString		changedMessage() const;
+
+	bool		changedFromOriginal() const;
+	void		proposeOriginal();
+
+	bool		proposedChanged() const;
+
+	static TQString	rotationName(int rotation, bool pastTense = false, bool capitalised = true);
+	TQPixmap	        rotationIcon(int rotation) const;
+	TQString			currentRotationDescription() const;
+
+	int				rotationIndexToDegree(int rotation) const;
+	int				rotationDegreeToIndex(int degree) const;
+
+	/**
+	 * Refresh rate functions.
+	 */
+	TQStringList refreshRates(int size) const;
+
+	TQString		refreshRateDirectDescription(int rate) const;
+	TQString		refreshRateIndirectDescription(int size, int index) const;
+	TQString		refreshRateDescription(int size, int index) const;
+
+	int			currentRefreshRate() const;
+	TQString		currentRefreshRateDescription() const;
+
+	// Refresh rate hz <==> index conversion
+	int			refreshRateHzToIndex(int size, int hz) const;
+	int			refreshRateIndexToHz(int size, int index) const;
+
+	/**
+	 * Screen size functions.
+	 */
+	int				numSizes() const;
+	const TQSize&	pixelSize(int index) const;
+	const TQSize&	mmSize(int index) const;
+	int				pixelCount(int index) const;
+
+	/**
+	 * Retrieve the index of a screen size with a specified pixel size.
+	 *
+	 * @param pixelSize dimensions of the screen in pixels
+	 * @returns the index of the requested screen size
+	 */
+	int				sizeIndex(TQSize pixelSize) const;
+
+	int			rotations() const;
+
+	/**
+	 * Current setting functions.
+	 */
+	int			currentPixelWidth() const;
+	int			currentPixelHeight() const;
+	int			currentMMWidth() const;
+	int			currentMMHeight() const;
+
+	int			currentRotation() const;
+	int			currentSize() const;
+
+	/**
+	 * Proposed setting functions.
+	 */
+	int			proposedSize() const;
+	bool		proposeSize(int newSize);
+
+	int			proposedRotation() const;
+	void		proposeRotation(int newRotation);
+
+	int			proposedRefreshRate() const;
+	/**
+	 * Propose a refresh rate.
+	 * Please note that you must propose the target size first for this to work.
+	 *
+	 * @param index the index of the refresh rate (not a refresh rate in hz!)
+	 * @returns true if successful, false otherwise.
+	 */
+	bool		proposeRefreshRate(int index);
+
+	/**
+	 * Configuration functions.
+	 */
+	void		load(TDEConfig& config);
+	void		save(TDEConfig& config) const;
+
+private:
+	RandRScreenPrivate*	d;
+
+	int			m_screen;
+
+	TQValueList<TQSize>	m_pixelSizes;
+	TQValueList<TQSize>	m_mmSizes;
+	int					m_rotations;
+
+	int			m_originalRotation;
+	int			m_originalSize;
+	int			m_originalRefreshRate;
+
+	int			m_currentRotation;
+	int			m_currentSize;
+	int			m_currentRefreshRate;
+
+	int			m_proposedRotation;
+	int			m_proposedSize;
+	int			m_proposedRefreshRate;
+
+	KTimerDialog*	m_shownDialog;
+
+private slots:
+	void		desktopResized();
+	void		shownDialogDestroyed();
+};
+
+typedef TQPtrList<RandRScreen> ScreenList;
+
+class RandRDisplay
+{
+public:
+	RandRDisplay();
+
+	bool			isValid() const;
+	const TQString&	errorCode() const;
+	const TQString&	version() const;
+
+	int		eventBase() const;
+	int		screenChangeNotifyEvent() const;
+	int		errorBase() const;
+
+	int		screenIndexOfWidget(TQWidget* widget);
+
+	int				numScreens() const;
+	RandRScreen*	screen(int index);
+
+	void			setCurrentScreen(int index);
+	int				currentScreenIndex() const;
+	RandRScreen*	currentScreen();
+
+	void	refresh();
+
+	/**
+	 * Loads saved settings.
+	 *
+	 * @param config the TDEConfig object to load from
+	 * @param loadScreens whether to call RandRScreen::load() for each screen
+	 * @retuns true if the settings should be applied on KDE startup.
+	 */
+	bool	loadDisplay(TDEConfig& config, bool loadScreens = true);
+	void	saveDisplay(TDEConfig& config, bool applyOnStartup, bool syncTrayApp);
+
+	static bool		applyOnStartup(TDEConfig& config);
+	static bool		syncTrayApp(TDEConfig& config);
+
+	void	applyProposed(bool confirm = true);
+
+	bool showTestConfigurationDialog();
+
+private:
+	int				m_numScreens;
+	int				m_currentScreenIndex;
+	RandRScreen*	m_currentScreen;
+	ScreenList		m_screens;
+
+	bool			m_valid;
+	QString			m_errorCode;
+	QString			m_version;
+
+	int				m_eventBase;
+	int				m_errorBase;
+};
+
+#endif