bool AbstractManager::start()
{
if(!mThread)
{
mThread = new ManagerThread(this,this);
connect(mThread,
SIGNAL(commandFinished()),
this,
SIGNAL(commandFinished()));
}
mThread->start();
return true;
}
void SimpleBackend::tryNextFunction () {
RK_TRACE (PHP);
if ((!busy) && (!command_stack.isEmpty ())) {
// clean up previous command if applicable
if (command_stack.first ()->complete) {
delete command_stack.first ();
command_stack.pop_front ();
if (!command_stack.count ()) return;
}
busy = true;
command_stack.first ()->complete = true;
current_flags = command_stack.first ()->flags;
current_type = command_stack.first ()->type;
current_values.clear ();
template_pos = 0;
if (current_type == Preprocess) current_template = preprocess_template;
else if (current_type == Printout) current_template = printout_template;
else if (current_type == Calculate) current_template = calculate_template;
else if (current_type == Preview) current_template = preview_template;
template_sep = current_template.indexOf ("!!!");
if (template_sep < 0) {
commandFinished ("");
return;
}
processCall ();
}
}
BlinkyPendantUploader::BlinkyPendantUploader(QObject *parent) :
BlinkyUploader(parent)
{
connect(&commandQueue, SIGNAL(error(QString)),
this, SLOT(handleError(QString)));
connect(&commandQueue, SIGNAL(commandFinished(QString, QByteArray)),
this, SLOT(handleCommandFinished(QString, QByteArray)));
}
BlinkyTapeUploader::BlinkyTapeUploader(QObject *parent) :
PatternUploader(parent)
{
bootloaderResetTimer = new QTimer(this);
state = State_Ready;
connect(&programmer,SIGNAL(error(QString)),
this,SLOT(handleProgrammerError(QString)));
connect(&programmer,SIGNAL(commandFinished(QString,QByteArray)),
this,SLOT(handleProgrammerCommandFinished(QString,QByteArray)));
}
void ConversationModel::sendMessage(const QString &text)
{
if (text.isEmpty())
return;
ChatMessageCommand *command = new ChatMessageCommand;
connect(command, SIGNAL(commandFinished()), this, SLOT(messageReply()));
command->send(m_contact->conn(), QDateTime::currentDateTime(), text, lastReceivedId);
beginInsertRows(QModelIndex(), 0, 0);
MessageData message = { text, QDateTime::currentDateTime(), command->identifier(), Sending };
messages.prepend(message);
endInsertRows();
}
void N3GetType0Command::processPacket(const QByteArray &packet)
{
inBuffer.append(packet);
if (inBuffer.size() >= type0Size) {
//Verify the packet received
inBuffer = QByteArray::fromHex(inBuffer);
if (verifyType0Record()) {
setEncryptionKey();
emit userDataAvailable(QSharedPointer<N3GetType0CommandResult>(new N3GetType0CommandResult(inBuffer)));
emit commandFinished();
}
}
}
void ManagerThread::run()
{
while(!bExited)
{
if(bHasCommand && mManager)
{
try
{
ICommand* command = mManager->dequeueCommand();
while(command && !bExited)
{
if(command)
{
mManager->mCurCommand = command;
mManager->doAction(command);
}
if(!bExited)
{
mManager->deleteCommand(command);
command = mManager->dequeueCommand();
}
};
}
catch(QString err)
{
emit errorOccured(err);
}
if(!bExited)
{
mManager->mCurCommand = 0;
bHasCommand = false;
emit commandFinished();
}
}
}
if(bExited)
{
bExitAccepted = true;
}
}
void SimpleBackend::finishCall (const QString &conditions) {
RK_TRACE (PHP);
QString conds = conditions;
int repl = current_values.count();
for (int i = repl; i > 0; --i) {
QString placeholder = "%" + QString::number (i);
QString replacement = current_values[i-1];
conds.replace (placeholder, replacement);
}
QString output;
int pos = 3;
int max = conds.length ();
do {
int cond_end = conds.indexOf ("!?!", pos);
if (cond_end < 0) cond_end = max;
QString condition = conds.mid (pos, cond_end - pos);
int if_end = condition.indexOf ("!:!");
RK_ASSERT (if_end >= 0);
QString if_part = condition.left (if_end);
int if_mid = if_part.indexOf ("!=!");
RK_ASSERT (if_mid >= 0);
QString if_compare = if_part.left (if_mid);
QString if_against = if_part.mid (if_mid + 3);
if ((if_compare.isEmpty() && if_against.isEmpty ()) || (if_compare == if_against)) {
output = condition.mid (if_end + 3);
break;
}
pos = cond_end + 3;
} while (pos < max);
// reached end of template
commandFinished (output);
}
void VVimCmdLineEdit::keyPressEvent(QKeyEvent *p_event)
{
int key = p_event->key();
int modifiers = p_event->modifiers();
if (m_registerPending) {
// Ctrl and Shift may be sent out first.
if (key == Qt::Key_Control || key == Qt::Key_Shift || key == Qt::Key_Meta) {
goto exit;
}
// Expecting a register name.
emit requestRegister(key, modifiers);
p_event->accept();
setRegisterPending(false);
return;
}
if ((key == Qt::Key_Return && modifiers == Qt::NoModifier)
|| (key == Qt::Key_Enter && modifiers == Qt::KeypadModifier)) {
// Enter, complete the command line input.
p_event->accept();
emit commandFinished(m_type, getCommand());
return;
} else if (key == Qt::Key_Escape
|| (key == Qt::Key_BracketLeft && isControlModifier(modifiers))) {
// Exit command line input.
setText(commandLineTypeLeader(m_type));
p_event->accept();
emit commandCancelled();
return;
}
switch (key) {
case Qt::Key_U:
if (isControlModifier(modifiers)) {
// Ctrl+U, delete all user input.
setText(commandLineTypeLeader(m_type));
p_event->accept();
return;
}
break;
case Qt::Key_N:
if (!isControlModifier(modifiers)) {
break;
}
// Ctrl+N, request next command.
// Fall through.
case Qt::Key_Down:
{
emit requestNextCommand(m_type, getCommand());
p_event->accept();
return;
}
case Qt::Key_P:
if (!isControlModifier(modifiers)) {
break;
}
// Ctrl+P, request previous command.
// Fall through.
case Qt::Key_Up:
{
emit requestPreviousCommand(m_type, getCommand());
p_event->accept();
return;
}
case Qt::Key_R:
{
if (isControlModifier(modifiers)) {
// Ctrl+R, insert the content of a register.
setRegisterPending(true);
p_event->accept();
return;
}
}
default:
break;
}
exit:
VLineEdit::keyPressEvent(p_event);
}
void DebuggerDriver::processOutput(const QByteArray& data)
{
// write to log file (do not log delayed output - it would appear twice)
if (m_logFile.isOpen()) {
m_logFile.write(data);
m_logFile.flush();
}
/*
* gdb sometimes produces stray output while it's idle. This happens if
* it receives a signal, most prominently a SIGCONT after a SIGTSTP:
* The user haltet kdbg with Ctrl-Z, then continues it with "fg", which
* also continues gdb, which repeats the prompt!
*/
if (m_activeCmd == 0 && m_state != DSinterrupted) {
// ignore the output
TRACE("ignoring stray output: " + QString(data));
return;
}
ASSERT(m_state == DSrunning || m_state == DSrunningLow || m_state == DSinterrupted);
ASSERT(m_activeCmd != 0 || m_state == DSinterrupted);
// collect output until next prompt string is found
// accumulate it
m_output += data;
// check for a prompt
int promptStart = findPrompt(m_output);
if (promptStart >= 0)
{
// found prompt!
// terminate output before the prompt
m_output.resize(promptStart);
/*
* We've got output for the active command. But if it was
* interrupted, ignore it.
*/
if (m_state != DSinterrupted) {
/*
* m_state shouldn't be DSidle while we are parsing the output
* so that all commands produced by parse() go into the queue
* instead of being written to gdb immediately.
*/
ASSERT(m_state != DSidle);
CmdQueueItem* cmd = m_activeCmd;
m_activeCmd = 0;
commandFinished(cmd);
delete cmd;
}
// empty buffer
m_output.clear();
// also clear delayed output if interrupted
if (m_state == DSinterrupted) {
m_delayedOutput = std::queue<QByteArray>();
}
/*
* We parsed some output successfully. Unless there's more delayed
* output, the debugger must be idle now, so send down the next
* command.
*/
if (m_delayedOutput.empty()) {
if (m_hipriCmdQueue.empty() && m_lopriCmdQueue.empty()) {
// no pending commands
m_state = DSidle;
emit enterIdleState();
} else {
writeCommand();
}
}
}
}
