Asynchronously Run Console Output and GUI in Qt

I am wor开发者_开发百科king on building a GUI around a console application. I would like to be able to click a button to run the console app and show the console output inside of the GUI itself. How might I accomplish this? I am working in Linux.

You could also try QProcess. It provides a Qt interface to launching external processes, reading their I/O and waiting, or not, on their completion.

For your purpose, it sounds like you want the process to run asynchronously, so code might look like :

myprocessstarter.h :

#include <QObject>
#include <QProcess>
#include <QDebug>


class MyProcessStarter : public QObject
{
    Q_OBJECT
public:
    MyProcessStarter() : QObject() {};
    void StartProcess();
private slots:
    void readStandardOutput();
private:
    QProcess *myProcess;
};

main.cpp:

#include "myprocessstarter.h"

void MyProcessStarter::StartProcess()
{
    QString program = "dir";
    QStringList arguments;
    // Add any arguments you want to be passed

    myProcess = new QProcess(this);
    connect(myProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(readStandardOutput()));
    myProcess->start(program, arguments);
}

void MyProcessStarter::readStandardOutput()
{
    QByteArray processOutput;
    processOutput = myProcess->readAllStandardOutput();

    qDebug() << "Output was " << QString(processOutput);
}

void main(int argc, char** argv)
{
    MyProcessStarter s;
    s.StartProcess();
}

I wanted to do something similar in one of my applications. I redirected all output from the standard stream (cout) to my console window. To periodically read out the stream contents I use a timer loop. Works fine for me.

StdRedirector.cpp

#include "StdRedirector.h"

QMutex coutMutex;

void outcallback(const char* ptr, std::streamsize count, void* bufferString)
{
    string *b = (string *) bufferString;    
    string t;

    for (int i=0; i < count; i++)
    {
        if (ptr[i] == '\n')
        {
            t = t + "\n";
        } else {
            t = t + ptr[i];
        }
    }       

    coutMutex.lock();
    *b = *b + t;
    coutMutex.unlock();
}

void ConsoleWindow::updateTimer(void)
{   
    coutMutex.lock();
    if (bufferString.size() > 0)
    {
        consoleBox->insertPlainText(QString(bufferString.c_str()));
        bufferString.clear();

        QScrollBar *sb = consoleBox->verticalScrollBar();
        sb->setValue(sb->maximum());        
    }
    coutMutex.unlock();
}

ConsoleWindow::ConsoleWindow(QWidget *parent) : QWidget(parent)
{
    consoleBox = new QTextEdit(this);
    consoleBox->setReadOnly(true);

    stdRedirector = new StdRedirector<>(std::cout, outcallback, &bufferString);

    QVBoxLayout *vb = new QVBoxLayout();
    vb->addWidget(consoleBox);
    vb->setMargin(0);
    vb->setSpacing(0);  

    setLayout(vb);

    QTimer *timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(updateTimer()));
    timer->start(100);
}

ConsoleWindow::~ConsoleWindow()
{
    delete stdRedirector;
}

StdRedirector.h

#ifndef STD_REDIRECTOR
#define STD_REDIRECTOR

#include <QWidget>
#include <QTextEdit>
#include <QString>
#include <QVBoxLayout>
#include <QTimer.h>
#include <QMutex>
#include <QScrollBar>

#include <iostream>
#include <string>

using namespace std;

template<class Elem = char, class Tr = std::char_traits<Elem>>

class StdRedirector : public std::basic_streambuf<Elem, Tr>
{
    typedef void (*pfncb) ( const Elem*, std::streamsize _Count, void* pUsrData );

    public:
        StdRedirector(std::ostream& a_Stream, pfncb a_Cb, void* a_pUsrData) :
            m_Stream(a_Stream),
            m_pCbFunc(a_Cb),
            m_pUserData(a_pUsrData)
        {
            m_pBuf = m_Stream.rdbuf(this);
        }

        ~StdRedirector()
        {
            m_Stream.rdbuf(m_pBuf);
        }

        std::streamsize xsputn(const Elem* _Ptr, std::streamsize _Count)
        {
            m_pCbFunc(_Ptr, _Count, m_pUserData);
            return _Count;
        }

        typename Tr::int_type overflow(typename Tr::int_type v)
        {
            Elem ch = Tr::to_char_type(v);
            m_pCbFunc(&ch, 1, m_pUserData);
            return Tr::not_eof(v);
        }

    protected:
        std::basic_ostream<Elem, Tr>& m_Stream;
        std::streambuf* m_pBuf;
        pfncb m_pCbFunc;
        void* m_pUserData;
};

class ConsoleWindow : public QWidget
{
Q_OBJECT

    public:
        ConsoleWindow(QWidget *parent = 0);
        ~ConsoleWindow();

    public slots:
        void updateTimer(void);

    public:
        QTextEdit *consoleBox;
        StdRedirector<> *stdRedirector;
        string bufferString;
};

#endif

The StdRedirector class is based on code from this forum post: http://www.qtforum.org/article/24554/displaying-std-cout-in-a-text-box.html

Take a look at the popen() function, it might do what you need.

Then you could pass the FILE * to a QTextStream and work in Qt style with it.

I suggest, rather than showing stdout in GUI, having own console output, which essentially means all messages you want to show to users you are sending to your own output.

This way you can have debug messages and such still available from console, wtih potential errors with connections and whatever that can happen and have fully controlled console output in GUI application. Of course this output can also be outputted to stdout so it is visible in console, but it also allows you to append a prefixs like WARNING LOG NOTICE NO_THIS_WENT_WRONG or whatever you want to show to users as your console entry.