//=============================================================================
//
// File : KvsObject_process.cpp
// Creation date : Fri Mar 18 21:30:48 CEST 2005
// by Tonino Imbesi(Grifisx) and Alessandro Carbone(Noldor)
//
// This file is part of the KVIrc IRC client distribution
// Copyright (C) 2005-2008 Alessandro Carbone (elfonol at gmail dot com)
//
// 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 "KvsObject_process.h"
#include "KviError.h"
#include "kvi_debug.h"
#include "kvi_settings.h"
#include "KviLocale.h"
#include "QProcess"
/*
@doc: process
@keyterms:
process object class, process
@title:
process class
@type:
class
@short:
A class to manage process.
@inherits:
[class]object[/class]
@description:
The Process class is used to start external programs and to communicate with them.[br]
[b]WARNING! at last you have to close the process![/b]
@functions:
!fn: $addArgument(<process-name:string>)
With this command you give the process name (or more arguments) for communication.
See the next example.
!fn: $startProcess()
Tries to run the process.[br]
[b]e.g.[/b]
[example]
%process=$new(process);[br]
%process->$addArg("cmd.exe");[br]
%process->$start();[br]
[/example]
!fn: <string> $readStdout()
Reads the data that the process has written to standard output.
!fn: <string> $readStderr()
Reads the data that the process has written to standard error.
[b]e.g.[/b]
[example]
class (test,object)
{
slotReadStdout()
{
%stdo = %Process->$readStdout()
#%Aoutput->$append(%stdo);[comment]# coming soon in the new texteditor class[/comment]
%Aoutput->$settext(%stdo);
}
slotReadStderr()
{
%stderr= %Process->$readStderr()
#%Aoutput->$append(%stderr);[comment]# coming soon in the new texteditor class[/comment]
%Aoutput->$settext(%stderr);
}
}
%tt=$new(test)
%A=$new(widget)
%A->$setGeometry(100,100,400,300)
%layoutA=$new(layout,%A)
%Ainput=$new(lineedit,%A)
#%Aoutput=$new(textedit,%A)[comment]# coming soon in the new texteditor class[/commnet]
%Aoutput=$new(label,%A)
%bclosekill=$new(button,%A)
%bclosekill->$settext("&CloseKill ")
%bkill=$new(button,%A)
%bkill->$settext("&Kill ")
%bterminate=$new(button,%A)
%bterminate->$settext("&Ask to Terminate ")
%layoutA->$addwidget(%Ainput,0,0)
%layoutA->$addwidget(%Aoutput,1,0)
%layoutA->$addwidget(%bclosekill,3,0)
%layoutA->$addwidget(%bkill,4,0,)
%layoutA->$addwidget(%bterminate,5,0)
%Process=$new(process)
%Process->$addArgument("cmd.exe")
%Process->$startProcess();
connect %Process readyReadStdout %tt slotReadStdout
connect %Process readyReadStderr %tt slotReadStderr
privateimpl(%Ainput,returnPressedEvent)
{
%command=%Ainput->$text() "\r\n"
%Process->$writeToStdin(%command);
%Ainput->$setText("");
}
privateimpl(%bclosekill,mousepressevent)
{
%Process->$closekill();
delete %A;
}
privateimpl(%bkill,mousepressevent)
{
%Process->$kill();
delete %A;
}
privateimpl(%bterminate,mousepressevent)
{
%Process->$tryTerminate();
delete %A;
}
%A->$show();
[/example]
!fn: $writeToStdin(<command:string>)
With this command you send a command to the process:
!fn: $closekill()
This tries to terminate the process the nice way.[br]
If the process is still running after 5 seconds, it terminates the process the hard way.[br]
(I think that this is the better way.)[br]
[b]e.g.[/b]
[pre]
%Process->close_kill();
[/pre]
!fn: $kill()
Kill the process the hard way (Bad Idea).
!fn: $tryTerminate()
Tries to terminate the process (It could end well, but...).
!fn: $closeStdin()
Close the standard input.
!fn: <boolean> $isRunning()
Return 1 if the process is running, else return 0.
!fn: <boolean> $normalExit()
Returns true if the process has exited normally; otherwise returns false.
!fn: $readyReadStdoutEvent()
This function is invoked by the process when there is new data.[br]
The default implementation emits the [classfnc]$readyReadStdout[/classfnc]() signal.
!fn: $readyReadStderrEvent()
This function is invoked by the process when there are new error messages.[br]
The default implementation emits the [classfnc]$readyReadStderr[/classfnc]() signal.
@signals:
!sg: $readyReadStdout()
This signal is emitted by the default implementation of [classfnc]$readyReadStdoutEvent[/classfnc]().[br]
If you reimplement that function you will have to emit the signal manually (if you still need it).
!sg: $readyReadStderr()
This signal is emitted by the default implementation of [classfnc]$readyReadStderrEvent[/classfnc]().
*/
KVSO_BEGIN_REGISTERCLASS(KvsObject_process, "process", "object")
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, addArgument);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, startProcess);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, readStdout);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, readStderr);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, writeToStdin);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, closekill);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, kill);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, tryTerminate);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, closeStdin);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, isRunning);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, normalExit);
// Events
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, readyReadStdoutEvent);
KVSO_REGISTER_HANDLER_BY_NAME(KvsObject_process, readyReadStderrEvent);
KVSO_END_REGISTERCLASS(KvsObject_process)
KVSO_BEGIN_CONSTRUCTOR(KvsObject_process, KviKvsObject)
m_pProcess = new QProcess();
connect(m_pProcess, SIGNAL(readyReadStandardOutput()), this, SLOT(slotReadStdout()));
connect(m_pProcess, SIGNAL(readyReadStandardError()), this, SLOT(slotReadStderr()));
KVSO_END_CONSTRUCTOR(KvsObject_process)
KVSO_BEGIN_DESTRUCTOR(KvsObject_process)
delete m_pProcess;
KVSO_END_CONSTRUCTOR(KvsObject_process)
KVSO_CLASS_FUNCTION(process, addArgument)
{
QString szArgument;
KVSO_PARAMETERS_BEGIN(c)
KVSO_PARAMETER("argument", KVS_PT_NONEMPTYSTRING, 0, szArgument)
KVSO_PARAMETERS_END(c)
m_szArgs.append(szArgument);
return true;
}
//->Start the process.
KVSO_CLASS_FUNCTION(process, startProcess)
{
CHECK_INTERNAL_POINTER(m_pProcess)
QString szcmd;
szcmd = m_szArgs.takeFirst();
m_pProcess->start(szcmd, m_szArgs);
if(m_pProcess->state() == QProcess::NotRunning)
{
c->warning(__tr2qs_ctx("Process could not be started.", "objects"));
}
return true;
}
//-->Read the standard output.
KVSO_CLASS_FUNCTION(process, readStderr)
{
CHECK_INTERNAL_POINTER(m_pProcess)
QString ng_Process = m_pProcess->readAllStandardError();
c->returnValue()->setString(ng_Process);
return true;
}
//-->Read the standard error.
KVSO_CLASS_FUNCTION(process, readStdout)
{
CHECK_INTERNAL_POINTER(m_pProcess)
QString ng_Process = m_pProcess->readAllStandardOutput();
c->returnValue()->setString(ng_Process);
return true;
}
//-->Signals and slot to manage reading output and error from the process.
KVSO_CLASS_FUNCTION(process, readyReadStdoutEvent)
{
emitSignal("readyReadStdout", c);
return true;
}
KVSO_CLASS_FUNCTION(process, readyReadStderrEvent)
{
emitSignal("readyReadStderr", c);
return true;
}
KVSO_CLASS_FUNCTION(process, writeToStdin)
{
CHECK_INTERNAL_POINTER(m_pProcess)
QString szCommand;
KVSO_PARAMETERS_BEGIN(c)
KVSO_PARAMETER("command", KVS_PT_STRING, 0, szCommand)
KVSO_PARAMETERS_END(c)
if(m_pProcess)
m_pProcess->write(szCommand.toUtf8().data());
return true;
}
//-->The 3 Closing process functions
KVSO_CLASS_FUNCTION(process, closekill)
{
CHECK_INTERNAL_POINTER(m_pProcess)
//I try to to terminate the process the nice way....
m_pProcess->terminate();
//If the process is still running after 5 seconds, I'll terminate the process in the hard way.
QTimer::singleShot(5000, m_pProcess, SLOT(kill()));
return true;
}
KVSO_CLASS_FUNCTION(process, kill)
{
CHECK_INTERNAL_POINTER(m_pProcess)
m_pProcess->kill();
return true;
}
KVSO_CLASS_FUNCTION(process, tryTerminate)
{
CHECK_INTERNAL_POINTER(m_pProcess)
m_pProcess->terminate();
return true;
}
//-->Close the standard input.
KVSO_CLASS_FUNCTION(process, closeStdin)
{
CHECK_INTERNAL_POINTER(m_pProcess)
m_pProcess->closeReadChannel(QProcess::StandardOutput);
return true;
}
//->Returns if the process still runnig
KVSO_CLASS_FUNCTION(process, isRunning)
{
CHECK_INTERNAL_POINTER(m_pProcess)
c->returnValue()->setBoolean(m_pProcess->state() == QProcess::Running);
return true;
}
//->Returns if the process exited.
KVSO_CLASS_FUNCTION(process, normalExit)
{
CHECK_INTERNAL_POINTER(m_pProcess)
c->returnValue()->setBoolean(m_pProcess->state() == QProcess::NotRunning && m_pProcess->exitStatus() == QProcess::NormalExit);
return true;
}
void KvsObject_process::slotReadStdout()
{
KviKvsVariantList * params = nullptr;
callFunction(this, "readyReadStdoutEvent", params);
}
void KvsObject_process::slotReadStderr()
{
KviKvsVariantList * params = nullptr;
callFunction(this, "readyReadStderrEvent", params);
}
