added connecting dialog; added error code string; added x11 helper; added rdesktop window detection

dialogconnecting.cpp

@@ -0,0 +1,20 @@
+#include "dialogconnecting.h"
+#include "ui_dialogconnecting.h"
+
+DialogConnecting::DialogConnecting(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::DialogConnecting)
+{
+    ui->setupUi(this);
+}
+
+DialogConnecting::~DialogConnecting()
+{
+    delete ui;
+}
+
+void DialogConnecting::on_pushButton_clicked()
+{
+    ui->pushButton->setEnabled(false);
+    emit canceled();
+}

dialogconnecting.h

@@ -0,0 +1,28 @@
+#ifndef DIALOGCONNECTING_H
+#define DIALOGCONNECTING_H
+
+#include <QDialog>
+
+namespace Ui {
+class DialogConnecting;
+}
+
+class DialogConnecting : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit DialogConnecting(QWidget *parent = 0);
+    ~DialogConnecting();
+
+signals:
+    void canceled();
+
+private slots:
+    void on_pushButton_clicked();
+
+private:
+    Ui::DialogConnecting *ui;
+};
+
+#endif // DIALOGCONNECTING_H

dialogconnecting.ui

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>DialogConnecting</class>
+ <widget class="QDialog" name="DialogConnecting">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>607</width>
+    <height>68</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Connexion Bureau à distance</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0">
+    <widget class="QProgressBar" name="progressBar">
+     <property name="maximum">
+      <number>0</number>
+     </property>
+     <property name="value">
+      <number>0</number>
+     </property>
+     <property name="textVisible">
+      <bool>false</bool>
+     </property>
+     <property name="invertedAppearance">
+      <bool>false</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QPushButton" name="pushButton">
+     <property name="text">
+      <string>Annuler</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="2">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Connexion en cours...</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

main.cpp

@@ -1,14 +1,66 @@
 #include "maindialog.h"
 #include <QApplication>
 #include <QTextCodec>
+#include <QWindow>
+#include <QDebug>
+#include <QTimer>
+
 
 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
-    QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
-    QTextCodec::setCodecForTr(QTextCodec::codecForCStrings());
+//    QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
+//    QTextCodec::setCodecForTr(QTextCodec::codecForCStrings());
     MainDialog w;
     w.show();
 
+//    Display *dpy;
+//    Window rootWindow;
+//    Window parent;
+//    Window *children;
+//    Window *child;
+//    unsigned long noOfChildren;
+
+//    dpy = XOpenDisplay(NULL);
+//    if (!dpy) {
+//        return 7;
+//    }
+//    rootWindow = RootWindow(dpy, -1);
+
+
+//    children = (Window*)get_client_list(dpy, &noOfChildren);
+
+////    XQueryTree(dpy, rootWindow, &rootWindow, &parent, &children, &noOfChildren);
+//    for (int i = 0; i < noOfChildren; ++i) {
+//        char* nameStr;
+//        XFetchName(dpy, children[i], &nameStr);
+//        QString name(nameStr);
+//        XFree(nameStr);
+//        if (name.startsWith("rdesktop - ")) {
+////        if (name.startsWith("robin@gigi-lt1: /tmp")) {
+//            qDebug() << name;
+//            QWindow *window = QWindow::fromWinId(children[i]);
+//            window->setFlags(Qt::FramelessWindowHint);
+
+//            QWidget *widget = QWidget::createWindowContainer(window);
+////            QEvent e(QEvent::EmbeddingControl);
+////            QApplication::sendEvent(widget, &e);
+////            widget->show();
+////            QTimer* timer = new QTimer(widget);
+////            QObject::connect(timer, SIGNAL(timeout()), widget, SLOT(update()));
+////            timer->start(100);
+//            break;
+//        }
+//    }
+
+////    QWindow *window = QWindow::fromWinId(0x0340056f);
+////    window->setFlags(Qt::FramelessWindowHint);
+
+////    QWidget *widget = QWidget::createWindowContainer(window);
+
+////    QVBoxLayout *layout = new QVBoxLayout(this);
+////    layout->addWidget(widget);
+////    this->setLayout(layout);
+
     return a.exec();
 }

maindialog.cpp

@@ -1,5 +1,6 @@
 #include <QApplication>
 #include <QDesktopWidget>
+#include <QUuid>
 #include <QDebug>
 #include "maindialog.h"
 #include "ui_maindialog.h"
@@ -8,7 +9,8 @@
 
 MainDialog::MainDialog(QWidget *parent) :
     QDialog(parent),
-    ui(new Ui::MainDialog)
+    ui(new Ui::MainDialog),
+    m_launcher(0)
 {
     ui->setupUi(this);
     connect(ui->lineComputer->lineEdit(), SIGNAL(returnPressed()), ui->btnConnect, SLOT(animateClick()));
@@ -126,10 +128,25 @@ void MainDialog::loadAll()
 
 void MainDialog::on_btnConnect_clicked()
 {
+    if (m_launcher) {
+        return;
+    }
+
+    ui->lblExitStatus->clear();
+
     RdpOptions opt = getRdpOptions();
     RdpOptionsHelper::save(opt);
-    RDesktopLauncher launcher;
-    launcher.start(opt);
+    opt.setWindowTitle("rdesktop " + QUuid::createUuid().toString());
+
+    m_launcher = new RDesktopLauncher(this);
+    connect(m_launcher, SIGNAL(finished(int)), this, SLOT(onProcessFinished(int)));
+    connect(m_launcher, SIGNAL(windowFound(WId)), this, SLOT(onWindowFound(WId)));
+    m_launcher->start(opt);
+
+    m_dlgConnecting = new DialogConnecting(this);
+    connect(m_dlgConnecting, SIGNAL(canceled()), m_launcher, SLOT(kill()));
+    m_dlgConnecting->setModal(true);
+    m_dlgConnecting->show();
 }
 
 void MainDialog::textChanged(QString)
@@ -189,3 +206,20 @@ void MainDialog::on_btnRemoveSession_clicked()
     RdpOptionsHelper::remove(getRdpOptions());
     loadAll();
 }
+
+void MainDialog::onProcessFinished(int status)
+{
+    ui->lblExitStatus->setText(RDesktopLauncher::getExitStatusString(status));
+    m_launcher->deleteLater();
+    m_launcher = 0;
+    m_dlgConnecting->deleteLater();
+    m_dlgConnecting = 0;
+    show();
+}
+
+void MainDialog::onWindowFound(WId wid)
+{
+    m_dlgConnecting->deleteLater();
+    m_dlgConnecting = 0;
+    hide();
+}

maindialog.h

@@ -3,11 +3,14 @@
 
 #include <QDialog>
 #include "rdpoptions.h"
+#include "dialogconnecting.h"
 
 namespace Ui {
 class MainDialog;
 }
 
+class RDesktopLauncher;
+
 class MainDialog : public QDialog
 {
     Q_OBJECT
@@ -42,12 +45,20 @@ private slots:
 
     void on_btnRemoveSession_clicked();
 
+    void onProcessFinished(int status);
+
+    void onWindowFound(WId wid);
+
 private:
     Ui::MainDialog *ui;
 
     QList<QSize> m_resolutions;
 
     QList<RdpOptions> m_rdpOptions;
+
+    RDesktopLauncher* m_launcher;
+
+    DialogConnecting* m_dlgConnecting;
 };
 
 #endif // MAINDIALOG_H

maindialog.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>467</width>
-    <height>557</height>
+    <width>480</width>
+    <height>560</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -334,6 +334,13 @@
          </property>
         </spacer>
        </item>
+       <item>
+        <widget class="QLabel" name="lblExitStatus">
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+       </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tabDisplay">

rd-launcher.pro

@@ -16,14 +16,21 @@ SOURCES += main.cpp\
         maindialog.cpp \
     rdpoptions.cpp \
     rdesktoplauncher.cpp \
-    rdpoptionshelper.cpp
+    rdpoptionshelper.cpp \
+    dialogconnecting.cpp \
+    x11helper.cpp
 
 HEADERS  += maindialog.h \
     rdpoptions.h \
     rdesktoplauncher.h \
-    rdpoptionshelper.h
+    rdpoptionshelper.h \
+    dialogconnecting.h \
+    x11helper.h
 
-FORMS    += maindialog.ui
+FORMS    += maindialog.ui \
+    dialogconnecting.ui
+
+LIBS += -lX11
 
 RESOURCES += \
     rc.qrc

rdesktoplauncher.cpp

@@ -1,14 +1,21 @@
-#include "rdesktoplauncher.h"
 #include <QStringList>
-#include <QProcess>
+#include "rdesktoplauncher.h"
+#include "x11helper.h"
+
 #include <QDebug>
 
-RDesktopLauncher::RDesktopLauncher()
+RDesktopLauncher::RDesktopLauncher(QObject *parent)
+    : QObject(parent)
+    , m_process(0)
+    , m_windowLookUpTimer(0)
 {
 }
 
 void RDesktopLauncher::start(RdpOptions options)
 {
+    if (m_process) {
+        return;
+    }
     QStringList args;
     args.append("-u");
     args.append(options.username());
@@ -54,7 +61,130 @@ void RDesktopLauncher::start(RdpOptions options)
     args.append("-r");
     args.append("sound:local:alsa");
 
+    if (!options.windowTitle().isEmpty()) {
+        args.append("-T");
+        args.append(options.windowTitle());
+    }
+
     args.append(options.host());
 
-    QProcess::startDetached("rdesktop", args);
+    m_options = options;
+
+    m_process = new QProcess(this);
+    connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(onProcessFinished(int, QProcess::ExitStatus)));
+    m_process->start("rdesktop", args);
+
+    m_windowLookUpTimer = new QTimer(this);
+    connect(m_windowLookUpTimer, SIGNAL(timeout()), this, SLOT(lookUpWindow()));
+    m_windowLookUpTimer->start(500);
+}
+
+QString RDesktopLauncher::getExitStatusString(int status)
+{
+    switch (status) {
+    case 0:
+        return tr("RDP session terminated normally");
+    case 1:
+        return tr("Server initiated disconnect (also returned for logoff by XP joined to a domain)");
+    case 2:
+        return tr("Server initiated logoff");
+    case 3:
+        return tr("Server idle timeout reached");
+    case 4:
+        return tr("Server logon timeout reached");
+    case 5:
+        return tr("The session was replaced");
+    case 6:
+        return tr("The server is out of memory");
+    case 7:
+        return tr("The server denied the connection");
+    case 8:
+        return tr("The server denied the connection for security reason");
+    case 9:
+        return tr("The user cannot connect to the server due to insufficient access privileges");
+    case 10:
+        return tr("The server does not accept saved user credentials and requires that the user enter their credentials for each connection");
+    case 11:
+        return tr("Disconnect initiated by administration tool");
+    case 12:
+        return tr("Disconnect initiated by user");
+    case 16:
+        return tr("Internal licensing error");
+    case 17:
+        return tr("No license server available");
+    case 18:
+        return tr("No valid license available");
+    case 19:
+        return tr("Invalid licensing message");
+    case 20:
+        return tr("Hardware id doesn't match software license");
+    case 21:
+        return tr("Client license error");
+    case 22:
+        return tr("Network error during licensing protocol");
+    case 23:
+        return tr("Licensing protocol was not completed");
+    case 24:
+        return tr("Incorrect client license enryption");
+    case 25:
+        return tr("Can't upgrade license");
+    case 26:
+        return tr("The server is not licensed to accept remote connections");
+    case 62:
+        return tr("The local client window was closed");
+    case 63:
+        return tr("Some other, unknown error occured");
+    case 64:
+        return tr("Command line usage error");
+    case 69:
+        return tr("A service or resource (such as memory) is unavailable");
+    case 70:
+        return tr("An internal software error has been detected");
+    case 71:
+        return tr("Operating system error");
+    case 76:
+        return tr("Protocol error or unable to connect to remote host");
+    default:
+        return tr("Unknown error");
+    }
+}
+
+void RDesktopLauncher::kill()
+{
+    clearWindowLookUpTimer();
+    if (m_process) {
+        m_process->kill();
+    }
+}
+
+void RDesktopLauncher::onProcessFinished(int exitCode, QProcess::ExitStatus exitStatus)
+{
+    clearWindowLookUpTimer();
+    m_process->deleteLater();
+    m_process = 0;
+    emit finished(exitCode);
+}
+
+void RDesktopLauncher::lookUpWindow()
+{
+    QMap<WId, QString> windows = X11Helper::getRootWindows();
+    QList<WId> keys = windows.keys();
+    for (int i = 0; i < keys.size(); ++i) {
+        WId key = keys[i];
+        QString name = windows[key];
+        if (name.startsWith(m_options.windowTitle())) {
+            clearWindowLookUpTimer();
+            emit windowFound(key);
+            return;
+        }
+    }
+}
+
+void RDesktopLauncher::clearWindowLookUpTimer()
+{
+    if (m_windowLookUpTimer) {
+        m_windowLookUpTimer->stop();
+        m_windowLookUpTimer->deleteLater();
+        m_windowLookUpTimer = 0;
+    }
 }

rdesktoplauncher.h

@@ -1,15 +1,42 @@
 #ifndef RDESKTOPLAUNCHER_H
 #define RDESKTOPLAUNCHER_H
 
+#include <QProcess>
+#include <QWidget>
+#include <QTimer>
 #include "rdpoptions.h"
 
-class RDesktopLauncher
+class RDesktopLauncher : public QObject
 {
+    Q_OBJECT
 public:
-    RDesktopLauncher();
+    RDesktopLauncher(QObject* parent = 0);
 
-public:
     void start(RdpOptions options);
+
+    static QString getExitStatusString(int status);
+
+signals:
+    void finished(int status);
+
+    void windowFound(WId);
+
+public slots:
+    void kill();
+
+private slots:
+    void onProcessFinished(int, QProcess::ExitStatus);
+
+    void lookUpWindow();
+
+    void clearWindowLookUpTimer();
+
+private:
+    QProcess* m_process;
+
+    QTimer* m_windowLookUpTimer;
+
+    RdpOptions m_options;
 };
 
 #endif // RDESKTOPLAUNCHER_H

rdpoptions.cpp

@@ -174,6 +174,16 @@ QString RdpOptions::visibleName() const
     return str;
 }
 
+QString RdpOptions::windowTitle() const
+{
+    return m_windowTitle;
+}
+
+void RdpOptions::setWindowTitle(const QString &windowTitle)
+{
+    m_windowTitle = windowTitle;
+}
+
 
 
 

rdpoptions.h

@@ -76,6 +76,9 @@ public:
     QString keymap() const;
     void setKeymap(const QString &keymap);
 
+    QString windowTitle() const;
+    void setWindowTitle(const QString &windowTitle);
+
     QString visibleName() const;
 
 private:
@@ -110,6 +113,8 @@ private:
     bool m_autoReconnect;
 
     QString m_keymap;
+
+    QString m_windowTitle;
 };
 
 #endif // RDPOPTIONS_H

x11helper.cpp

@@ -0,0 +1,99 @@
+#include "x11helper.h"
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/Xresource.h>
+
+static char *get_property (Display *disp, Window win,
+        Atom xa_prop_type, char *prop_name, unsigned long *size) {
+    Atom xa_prop_name;
+    Atom xa_ret_type;
+    int ret_format;
+    unsigned long ret_nitems;
+    unsigned long ret_bytes_after;
+    unsigned long tmp_size;
+    unsigned char *ret_prop;
+    char *ret;
+
+    xa_prop_name = XInternAtom(disp, prop_name, False);
+
+    if (XGetWindowProperty(disp, win, xa_prop_name, 0, 200 / 4, False,
+            xa_prop_type, &xa_ret_type, &ret_format,
+            &ret_nitems, &ret_bytes_after, &ret_prop) != Success) {
+        return NULL;
+    }
+
+    if (xa_ret_type != xa_prop_type) {
+        XFree(ret_prop);
+        return NULL;
+    }
+
+    /* null terminate the result to make string handling easier */
+    tmp_size = (ret_format / 8) * ret_nitems;
+    /* Correct 64 Architecture implementation of 32 bit data */
+    if(ret_format==32) tmp_size *= sizeof(long)/4;
+    ret = (char*)malloc(tmp_size + 1);
+    memcpy(ret, ret_prop, tmp_size);
+    ret[tmp_size] = '\0';
+
+    if (size) {
+        *size = tmp_size;
+    }
+
+    XFree(ret_prop);
+    return ret;
+}
+
+static Window *get_client_list (Display *disp, unsigned long *size) {
+    Window *client_list;
+
+    if ((client_list = (Window *)get_property(disp, DefaultRootWindow(disp),
+                    XA_WINDOW, (char*)"_NET_CLIENT_LIST", size)) == NULL) {
+        if ((client_list = (Window *)get_property(disp, DefaultRootWindow(disp),
+                        XA_CARDINAL, (char*)"_WIN_CLIENT_LIST", size)) == NULL) {
+            return NULL;
+        }
+    }
+
+    return client_list;
+}
+
+QMap<WId, QString> X11Helper::getRootWindows()
+{
+    QMap<WId, QString> windows;
+    Display *dpy;
+    Window *children;
+    unsigned long noOfChildren;
+
+    dpy = XOpenDisplay(NULL);
+    if (!dpy) {
+        return windows;
+    }
+
+    children = (Window*)get_client_list(dpy, &noOfChildren);
+    if (!children) {
+        return windows;
+    }
+    for (unsigned long i = 0; i < noOfChildren; ++i) {
+        char* nameStr;
+        XFetchName(dpy, children[i], &nameStr);
+        QString name(nameStr);
+        XFree(nameStr);
+        if (!name.isEmpty()) {
+            windows.insert(children[i], name);
+//        if (name.startsWith("robin@gigi-lt1: /tmp")) {
+//            qDebug() << name;
+//            QWindow *window = QWindow::fromWinId(children[i]);
+//            window->setFlags(Qt::FramelessWindowHint);
+
+//            QWidget *widget = QWidget::createWindowContainer(window);
+//            QEvent e(QEvent::EmbeddingControl);
+//            QApplication::sendEvent(widget, &e);
+//            widget->show();
+//            QTimer* timer = new QTimer(widget);
+//            QObject::connect(timer, SIGNAL(timeout()), widget, SLOT(update()));
+//            timer->start(100);
+        }
+    }
+    return windows;
+}

x11helper.h

@@ -0,0 +1,13 @@
+#ifndef X11HELPER_H
+#define X11HELPER_H
+
+#include <QMap>
+#include <QWidget>
+
+class X11Helper
+{
+public:
+    static QMap<WId, QString> getRootWindows();
+};
+
+#endif // X11HELPER_H