aboutsummaryrefslogtreecommitdiff
path: root/src/qt/rpcconsole.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/qt/rpcconsole.cpp')
-rw-r--r--src/qt/rpcconsole.cpp316
1 files changed, 316 insertions, 0 deletions
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
new file mode 100644
index 0000000000..d59f5c6a38
--- /dev/null
+++ b/src/qt/rpcconsole.cpp
@@ -0,0 +1,316 @@
+#include "rpcconsole.h"
+#include "ui_rpcconsole.h"
+
+#include "clientmodel.h"
+#include "bitcoinrpc.h"
+#include "guiutil.h"
+
+#include <QTime>
+#include <QTimer>
+#include <QThread>
+#include <QTextEdit>
+#include <QKeyEvent>
+
+#include <boost/tokenizer.hpp>
+
+// TODO: make it possible to filter out categories (esp debug messages when implemented)
+// TODO: receive errors and debug messages through ClientModel
+
+const int CONSOLE_SCROLLBACK = 50;
+const int CONSOLE_HISTORY = 50;
+
+/* Object for executing console RPC commands in a separate thread.
+*/
+class RPCExecutor: public QObject
+{
+ Q_OBJECT
+public slots:
+ void start();
+ void request(const QString &command);
+signals:
+ void reply(int category, const QString &command);
+};
+
+#include "rpcconsole.moc"
+
+void RPCExecutor::start()
+{
+ // Nothing to do
+}
+
+void RPCExecutor::request(const QString &command)
+{
+ // Parse shell-like command line into separate arguments
+ boost::escaped_list_separator<char> els('\\',' ','\"');
+ std::string strCommand = command.toStdString();
+ boost::tokenizer<boost::escaped_list_separator<char> > tok(strCommand, els);
+
+ std::string strMethod;
+ std::vector<std::string> strParams;
+ int n = 0;
+ for(boost::tokenizer<boost::escaped_list_separator<char> >::iterator beg=tok.begin(); beg!=tok.end();++beg,++n)
+ {
+ if(n == 0) // First parameter is the command
+ strMethod = *beg;
+ else
+ strParams.push_back(*beg);
+ }
+
+ try {
+ std::string strPrint;
+ json_spirit::Value result = tableRPC.execute(strMethod, RPCConvertValues(strMethod, strParams));
+
+ // Format result reply
+ if (result.type() == json_spirit::null_type)
+ strPrint = "";
+ else if (result.type() == json_spirit::str_type)
+ strPrint = result.get_str();
+ else
+ strPrint = write_string(result, true);
+
+ emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
+ }
+ catch (json_spirit::Object& objError)
+ {
+ emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), false)));
+ }
+ catch (std::exception& e)
+ {
+ emit reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
+ }
+}
+
+RPCConsole::RPCConsole(QWidget *parent) :
+ QDialog(parent),
+ ui(new Ui::RPCConsole),
+ firstLayout(true),
+ historyPtr(0)
+{
+ ui->setupUi(this);
+ ui->messagesWidget->horizontalHeader()->setResizeMode(1, QHeaderView::Stretch);
+ ui->messagesWidget->setContextMenuPolicy(Qt::ActionsContextMenu);
+
+ // Install event filter for up and down arrow
+ ui->lineEdit->installEventFilter(this);
+
+ // Add "Copy message" to context menu explicitly
+ QAction *copyMessageAction = new QAction(tr("&Copy"), this);
+ copyMessageAction->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_C));
+ copyMessageAction->setShortcutContext(Qt::WidgetShortcut);
+ connect(copyMessageAction, SIGNAL(triggered()), this, SLOT(copyMessage()));
+ ui->messagesWidget->addAction(copyMessageAction);
+
+ connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
+
+ startExecutor();
+
+ clear();
+}
+
+RPCConsole::~RPCConsole()
+{
+ emit stopExecutor();
+ delete ui;
+}
+
+bool RPCConsole::event(QEvent *event)
+{
+ int returnValue = QWidget::event(event);
+
+ if (event->type() == QEvent::LayoutRequest && firstLayout)
+ {
+ // Work around QTableWidget issue:
+ // Call resizeRowsToContents on first Layout request with widget visible,
+ // to make sure multiline messages that were added before the console was shown
+ // have the right height.
+ if(ui->messagesWidget->isVisible())
+ {
+ firstLayout = false;
+ ui->messagesWidget->resizeRowsToContents();
+ }
+ return true;
+ }
+
+ return returnValue;
+}
+
+bool RPCConsole::eventFilter(QObject* obj, QEvent *event)
+{
+ if(obj == ui->lineEdit)
+ {
+ if(event->type() == QEvent::KeyPress)
+ {
+ QKeyEvent *key = static_cast<QKeyEvent*>(event);
+ switch(key->key())
+ {
+ case Qt::Key_Up: browseHistory(-1); return true;
+ case Qt::Key_Down: browseHistory(1); return true;
+ }
+ }
+ }
+ return QDialog::eventFilter(obj, event);
+}
+
+void RPCConsole::setClientModel(ClientModel *model)
+{
+ this->clientModel = model;
+ if(model)
+ {
+ // Subscribe to information, replies, messages, errors
+ connect(model, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));
+ connect(model, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));
+
+ // Provide initial values
+ ui->clientVersion->setText(model->formatFullVersion());
+ ui->clientName->setText(model->clientName());
+ ui->buildDate->setText(model->formatBuildDate());
+
+ setNumConnections(model->getNumConnections());
+ ui->isTestNet->setChecked(model->isTestNet());
+
+ setNumBlocks(model->getNumBlocks());
+ }
+}
+
+static QColor categoryColor(int category)
+{
+ switch(category)
+ {
+ case RPCConsole::MC_ERROR: return QColor(255,0,0); break;
+ case RPCConsole::MC_DEBUG: return QColor(192,192,192); break;
+ case RPCConsole::CMD_REQUEST: return QColor(128,128,128); break;
+ case RPCConsole::CMD_REPLY: return QColor(128,255,128); break;
+ case RPCConsole::CMD_ERROR: return QColor(255,128,128); break;
+ default: return QColor(0,0,0);
+ }
+}
+
+void RPCConsole::clear()
+{
+ ui->messagesWidget->clear();
+ ui->messagesWidget->setRowCount(0);
+ ui->lineEdit->clear();
+ ui->lineEdit->setFocus();
+
+ message(CMD_REPLY, tr("Welcome to the bitcoin RPC console.")+"\n"+
+ tr("Use up and down arrows to navigate history, and Ctrl-L to clear screen.")+"\n"+
+ tr("Type \"help\" for an overview of available commands."));
+}
+
+void RPCConsole::message(int category, const QString &message)
+{
+ // Add row to messages widget
+ int row = ui->messagesWidget->rowCount();
+ ui->messagesWidget->setRowCount(row+1);
+
+ QTime time = QTime::currentTime();
+ QTableWidgetItem *newTime = new QTableWidgetItem(time.toString());
+ newTime->setData(Qt::DecorationRole, categoryColor(category));
+ newTime->setForeground(QColor(128,128,128));
+ newTime->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled); // make non-editable
+
+ int numLines = message.count("\n") + 1;
+ // As Qt doesn't like very tall cells (they break scrolling) keep only short messages in
+ // the cell text, longer messages trigger a display widget with scroll bar
+ if(numLines < 5)
+ {
+ QTableWidgetItem *newItem = new QTableWidgetItem(message);
+ newItem->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled); // make non-editable
+ if(category == CMD_ERROR) // Coloring error messages in red
+ newItem->setForeground(QColor(255,16,16));
+ ui->messagesWidget->setItem(row, 1, newItem);
+ } else {
+ QTextEdit *newWidget = new QTextEdit;
+ newWidget->setText(message);
+ newWidget->setMaximumHeight(100);
+ newWidget->setReadOnly(true);
+ ui->messagesWidget->setCellWidget(row, 1, newWidget);
+ }
+
+ ui->messagesWidget->setItem(row, 0, newTime);
+ ui->messagesWidget->resizeRowToContents(row);
+ // Preserve only limited scrollback buffer
+ while(ui->messagesWidget->rowCount() > CONSOLE_SCROLLBACK)
+ ui->messagesWidget->removeRow(0);
+ // Scroll to bottom after table is updated
+ QTimer::singleShot(0, ui->messagesWidget, SLOT(scrollToBottom()));
+}
+
+void RPCConsole::setNumConnections(int count)
+{
+ ui->numberOfConnections->setText(QString::number(count));
+}
+
+void RPCConsole::setNumBlocks(int count)
+{
+ ui->numberOfBlocks->setText(QString::number(count));
+ if(clientModel)
+ {
+ ui->totalBlocks->setText(QString::number(clientModel->getNumBlocksOfPeers()));
+ ui->lastBlockTime->setText(clientModel->getLastBlockDate().toString());
+ }
+}
+
+void RPCConsole::on_lineEdit_returnPressed()
+{
+ QString cmd = ui->lineEdit->text();
+ ui->lineEdit->clear();
+
+ if(!cmd.isEmpty())
+ {
+ message(CMD_REQUEST, cmd);
+ emit cmdRequest(cmd);
+ // Truncate history from current position
+ history.erase(history.begin() + historyPtr, history.end());
+ // Append command to history
+ history.append(cmd);
+ // Enforce maximum history size
+ while(history.size() > CONSOLE_HISTORY)
+ history.removeFirst();
+ // Set pointer to end of history
+ historyPtr = history.size();
+ }
+}
+
+void RPCConsole::browseHistory(int offset)
+{
+ historyPtr += offset;
+ if(historyPtr < 0)
+ historyPtr = 0;
+ if(historyPtr > history.size())
+ historyPtr = history.size();
+ QString cmd;
+ if(historyPtr < history.size())
+ cmd = history.at(historyPtr);
+ ui->lineEdit->setText(cmd);
+}
+
+void RPCConsole::startExecutor()
+{
+ QThread* thread = new QThread;
+ RPCExecutor *executor = new RPCExecutor();
+ executor->moveToThread(thread);
+
+ // Notify executor when thread started (in executor thread)
+ connect(thread, SIGNAL(started()), executor, SLOT(start()));
+ // Replies from executor object must go to this object
+ connect(executor, SIGNAL(reply(int,QString)), this, SLOT(message(int,QString)));
+ // Requests from this object must go to executor
+ connect(this, SIGNAL(cmdRequest(QString)), executor, SLOT(request(QString)));
+ // On stopExecutor signal
+ // - queue executor for deletion (in execution thread)
+ // - quit the Qt event loop in the execution thread
+ connect(this, SIGNAL(stopExecutor()), executor, SLOT(deleteLater()));
+ connect(this, SIGNAL(stopExecutor()), thread, SLOT(quit()));
+ // Queue the thread for deletion (in this thread) when it is finished
+ connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
+ // Default implementation of QThread::run() simply spins up an event loop in the thread,
+ // which is what we want.
+ thread->start();
+}
+
+void RPCConsole::copyMessage()
+{
+ GUIUtil::copyEntryData(ui->messagesWidget, 1, Qt::EditRole);
+}