ZProcess.cpp

Go to the documentation of this file.

#include "ZProcess.h"
#include "ZByteArray.h"
#include <QtQml>


namespace Zbl
{

QVariant ZProcess::m_tags;

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZProcess)

ZProcess::ZProcess(QObject *parent) : QObject(parent)
{
    zDebug() << "ZFile::ZFile";

    createTags();

    m_p = new QProcess(this);

    initZioDevice();

    m_p->setProcessEnvironment(QProcessEnvironment::systemEnvironment());

    connect(m_p, &QProcess::started, this, &ZProcess::started);
    //connect(m_p, SIGNAL(errorOccurred(QProcess::ProcessError)), this, SIGNAL(errorOccurred(QProcess::ProcessError)));

    //connect(m_p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SIGNAL(finished(int,QProcess::ExitStatus)));
    //connect(m_p, SIGNAL(stateChanged(QProcess::ProcessState state)), this, SIGNAL(stateChanged(QProcess::ProcessState state)));
    connect(m_p, SIGNAL(readyReadStandardOutput()), this, SIGNAL(readyReadStandardOutput()));
    connect(m_p, SIGNAL(readyReadStandardError()), this, SIGNAL(readyReadStandardError()));
}

ZProcess::~ZProcess()
{
    zDebug() << "ZProcess::~ZProcess";
    //close();
}

void ZProcess::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterType<ZProcess>("org.zuble.qml", 1, 0, "ZProcess");
}

void ZProcess::initZioDevice()
{
    m_zd = new ZioDevice(this);

    connect(m_zd, SIGNAL(getCurrentDevice(QIODevice**)),
            SLOT(getQDevice(QIODevice**)), Qt::DirectConnection);
}

void ZProcess::createTags()
{
    if(!m_tags.isNull())
        return;

    QVariantMap map;

    map.insert("errorFailedToStart", FailedToStart);
    map.insert("errorCrashed", Crashed);
    map.insert("errorTimedout", Timedout);
    map.insert("errorReadError", ReadError);
    map.insert("errorWriteError", WriteError);
    map.insert("errorUnknownError", UnknownError);
    map.insert("stateNotRunning", NotRunning);
    map.insert("stateStarting", Starting);
    map.insert("stateRunning", Running);
    map.insert("channelStandardOutput", StandardOutput);
    map.insert("channelStandardError", StandardError);
    map.insert("channelModeSeparateChannels", SeparateChannels);
    map.insert("channelModeMergedChannels", MergedChannels);
    map.insert("channelModeForwardedChannels", ForwardedChannels);
    map.insert("channelModeForwardedOutputChannel", ForwardedOutputChannel);
    map.insert("channelModeForwardedErrorChannel", ForwardedErrorChannel);
    map.insert("exitNormalExit", NormalExit);
    map.insert("exitCrashExit", CrashExit);

    m_tags = QVariant::fromValue(map);
}

QVariant ZProcess::getTags()
{
    return m_tags;
}

QObject* ZProcess::getJsDevice()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(m_zd,  NULL,
    Z_FAC_JS, ZProcess::getStatus, getStatus failed)
}

void ZProcess::getQDevice(QIODevice** device)
{
    *device = qobject_cast<QIODevice*>(m_p);
}

#if 0
void ZProcess::release()
{
    ZBL_SLOT_BEGIN_TRY
            m_p.clear();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZProcess::release, release failed)
}
#endif

#if 0
void ZProcess::close()
{
    ZBL_SLOT_BEGIN_TRY

    //validateFile();

   if(m_p)
        m_p->close();

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZProcess::close, close failed)
}
#endif

void ZProcess::start(int mode)
{
    m_p->start(static_cast<QIODevice::OpenMode>(mode));
}

QStringList ZProcess::getArguments()
{
    return m_p->arguments();
}

void ZProcess::setArguments(const QStringList &arguments)
{
    m_p->setArguments(arguments);
}

QString ZProcess::getProgram() const
{
    return m_p->program();
}

void ZProcess::setProgram(const QString &program)
{
    m_p->setProgram(program);
}

void ZProcess::closeWriteChannel()
{
    m_p->closeWriteChannel();
}

void ZProcess::closeReadChannel(int channel)
{
    m_p->closeReadChannel(static_cast<QProcess::ProcessChannel>(channel));
}

qint64 ZProcess::getProcessID() const
{
    return m_p->processId();
}

int ZProcess::getReadChannel() const
{
    return m_p->readChannel();
}

void ZProcess::setReadChannel(int channel)
{
    m_p->setReadChannel(static_cast<QProcess::ProcessChannel>(channel));
}

QObject* ZProcess::readAllStandardError()
{
    QByteArray data = m_p->readAllStandardError();

    return new ZByteArray(data);
}

QObject* ZProcess::readAllStandardOutput()
{
    QByteArray data = m_p->readAllStandardOutput();

    return new ZByteArray(data);
}

int ZProcess::getState() const
{
    return static_cast<int>(m_p->state());
}

int ZProcess::getError() const
{
    return static_cast<int>(m_p->error());
}

void ZProcess::setProcessChannelMode(int mode)
{
    m_p->setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(mode));
}

int ZProcess::getProcessChannelMode() const
{
    return static_cast<int>(m_p->processChannelMode());
}

int ZProcess::exitCode() const
{
    return static_cast<int>(m_p->exitCode());
}

int ZProcess::exitStatus() const
{
    return static_cast<int>(m_p->exitStatus());
}

void ZProcess::envClear()
{
    m_p->setProcessEnvironment(QProcessEnvironment());
}

QStringList ZProcess::envGetList()
{
    return m_p->processEnvironment().toStringList();
}

void ZProcess::envSetValue(const QString& name, const QString& value)
{
    QProcessEnvironment env(m_p->processEnvironment());
    env.insert(name, value);
    m_p->setProcessEnvironment(env);
}

QString ZProcess::envGetValue(const QString& name)
{
    return m_p->processEnvironment().value(name);
}

bool ZProcess::envValueExists(const QString& name)
{
    return m_p->processEnvironment().contains(name);
}


} // Zbl