explicit Example( storm::Window::Pointer window ) :
_window( std::move(window) ),
_observer( std::make_shared<storm::WindowObserver>() )
{
_window->setWindowedMode( outputWindowDimensions );
_window->addObserver( _observer );
_observer->onShutdownRequested = [] {
outputString( "Shutdown requested" );
};
_observer->onFocusReceived = [] {
outputString( "Focus received" );
};
_observer->onFocusLost = [] {
outputString( "Focus lost" );
};
_observer->onResized = [this] {
outputString(
"The window size is changed. The new size is: " +
std::to_string(_window->getDimensions().width) + ", " +
std::to_string(_window->getDimensions().height) );
};
_observer->onMouseMotion = []( storm::IntVector2d value ) {
outputString(
"The mouse is moved. The delta is: " +
std::to_string(value.x) + ", " +
std::to_string(value.y) );
};
_observer->onMouseButtonPressed = []( storm::MouseButton value ) {
outputString(
"The mouse button is pressed. The value is: " +
std::to_string(static_cast<int>(value)) );
};
_observer->onMouseButtonReleased = []( storm::MouseButton value ) {
outputString(
"The mouse button is released. The value is: " +
std::to_string(static_cast<int>(value)) );
};
_observer->onMouseWheelRotated = []( float value ) {
outputString(
"The mouse wheel is rotated. The delta is: " +
std::to_string(value) );
};
_observer->onPointerMotion = []( storm::IntVector2d value ) {
outputString(
"The mouse pointer is moved. The position is: " +
std::to_string(value.x) + ", " +
std::to_string(value.y) );
};
_observer->onKeyboardKeyPressed = [this]( storm::KeyboardKey value ) {
outputString(
"A keyboard key is pressed. The key is: " +
std::string(getKeyboardKeyName(value)) );
processKeyPress( value );
};
_observer->onKeyboardKeyRepeated = []( storm::KeyboardKey value ) {
outputString(
"A keyboard key is repeated. The key is: " +
std::string(getKeyboardKeyName(value)) );
};
_observer->onKeyboardKeyReleased = []( storm::KeyboardKey value ) {
outputString(
"A keyboard key is released. The key is: " +
std::string(getKeyboardKeyName(value)) );
};
_observer->onCharacterInput = []( char32_t character ) {
std::mbstate_t state = {};
std::string buffer( MB_CUR_MAX, 0 );
std::c32rtomb( buffer.data(), character, &state );
outputString( "Character input: " + buffer +
" (" + std::to_string(character) + ")" );
};
}
void MiningPage::readProcessOutput()
{
QByteArray output;
minerProcess->reset();
output = minerProcess->readAll();
QString outputString(output);
if (!outputString.isEmpty())
{
QStringList list = outputString.split("\n", QString::SkipEmptyParts);
int i;
for (i=0; i<list.size(); i++)
{
QString line = list.at(i);
// Ignore protocol dump
if (!line.startsWith("[") || line.contains("JSON protocol") || line.contains("HTTP hdr"))
continue;
if (ui->debugCheckBox->isChecked())
{
ui->list->addItem(line.trimmed());
ui->list->scrollToBottom();
}
if (line.contains("(yay!!!)"))
reportToList("Share accepted", SHARE_SUCCESS, getTime(line));
else if (line.contains("(booooo)"))
reportToList("Share rejected", SHARE_FAIL, getTime(line));
else if (line.contains("LONGPOLL detected new block"))
reportToList("LONGPOLL detected a new block", LONGPOLL, getTime(line));
else if (line.contains("Supported options:"))
reportToList("Miner didn't start properly. Try checking your settings.", ERROR, NULL);
else if (line.contains("The requested URL returned error: 403"))
reportToList("Couldn't connect. Please check your username and password.", ERROR, NULL);
else if (line.contains("HTTP request failed"))
reportToList("Couldn't connect. Please check pool server and port.", ERROR, NULL);
else if (line.contains("JSON-RPC call failed"))
reportToList("Couldn't communicate with server. Retrying in 30 seconds.", ERROR, NULL);
else if (line.contains("thread ") && line.contains("khash/s"))
{
QString threadIDstr = line.at(line.indexOf("thread ")+7);
int threadID = threadIDstr.toInt();
int threadSpeedindx = line.indexOf(",");
QString threadSpeedstr = line.mid(threadSpeedindx);
threadSpeedstr.chop(8);
threadSpeedstr.remove(", ");
threadSpeedstr.remove(" ");
threadSpeedstr.remove('\n');
double speed=0;
speed = threadSpeedstr.toDouble();
threadSpeed[threadID] = speed;
updateSpeed();
}
}
}
}
void handleTalk(){
outputString("Baldevarth: Good day, my enthusiastic protege. What can I do for you?");
}
void QTestXunitStreamer::output(QTestElement *element) const
{
outputString("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
QTestBasicStreamer::output(element);
}
void ScriptEngine::execute(const std::string path, const std::string arguments, std::shared_ptr<std::vector<char>> output, int32_t* exitCode, bool wait, int32_t threadId)
{
try
{
if(_disposing)
{
setThreadNotRunning(threadId);
return;
}
if(path.empty())
{
//No thread yet
return;
}
if(!output) output.reset(new std::vector<char>());
if(!wait)
{
collectGarbage();
if(!scriptThreadMaxReached())
{
_scriptThreadMutex.lock();
try
{
int32_t threadId = _currentScriptThreadID++;
if(threadId == -1) threadId = _currentScriptThreadID++;
_scriptThreads.insert(std::pair<int32_t, std::pair<std::thread, bool>>(threadId, std::pair<std::thread, bool>(std::thread(&ScriptEngine::execute, this, path, arguments, output, nullptr, true, threadId), true)));
}
catch(const std::exception& ex)
{
GD::out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
GD::out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
_scriptThreadMutex.unlock();
}
if(exitCode) *exitCode = 0;
//No thread yet
return;
}
}
catch(const std::exception& ex)
{
GD::bl->out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
setThreadNotRunning(threadId);
return;
}
catch(BaseLib::Exception& ex)
{
GD::bl->out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
setThreadNotRunning(threadId);
return;
}
catch(...)
{
GD::bl->out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
setThreadNotRunning(threadId);
return;
}
if(exitCode) *exitCode = -1;
if(!GD::bl->io.fileExists(path))
{
GD::out.printError("Error: PHP script \"" + path + "\" does not exist.");
setThreadNotRunning(threadId);
return;
}
ts_resource_ex(0, NULL); //Replaces TSRMLS_FETCH()
try
{
zend_file_handle script;
/* Set up a File Handle structure */
script.type = ZEND_HANDLE_FILENAME;
script.filename = path.c_str();
script.opened_path = NULL;
script.free_filename = 0;
zend_homegear_globals* globals = php_homegear_get_globals();
if(!globals)
{
ts_free_thread();
setThreadNotRunning(threadId);
return;
}
globals->output = output.get();
globals->commandLine = true;
globals->cookiesParsed = true;
if(!tsrm_get_ls_cache() || !((sapi_globals_struct *) (*((void ***) tsrm_get_ls_cache()))[((sapi_globals_id)-1)]) || !((php_core_globals *) (*((void ***) tsrm_get_ls_cache()))[((core_globals_id)-1)]))
{
GD::out.printCritical("Critical: Error in PHP: No thread safe resource exists.");
ts_free_thread();
setThreadNotRunning(threadId);
return;
}
PG(register_argc_argv) = 1;
SG(server_context) = (void*)output.get(); //Must be defined! Otherwise php_homegear_activate is not called.
SG(options) |= SAPI_OPTION_NO_CHDIR;
SG(headers_sent) = 1;
SG(request_info).no_headers = 1;
SG(default_mimetype) = nullptr;
SG(default_charset) = nullptr;
SG(request_info).path_translated = estrndup(path.c_str(), path.size());
if (php_request_startup(TSRMLS_C) == FAILURE) {
GD::bl->out.printError("Error calling php_request_startup...");
ts_free_thread();
setThreadNotRunning(threadId);
return;
}
std::vector<std::string> argv = getArgs(path, arguments);
php_homegear_build_argv(argv);
SG(request_info).argc = argv.size();
SG(request_info).argv = (char**)malloc((argv.size() + 1) * sizeof(char*));
for(uint32_t i = 0; i < argv.size(); ++i)
{
SG(request_info).argv[i] = (char*)argv[i].c_str(); //Value is not modified.
}
SG(request_info).argv[argv.size()] = nullptr;
php_execute_script(&script);
if(exitCode) *exitCode = EG(exit_status);
php_request_shutdown(NULL);
if(output->size() > 0)
{
std::string outputString(&output->at(0), output->size());
if(BaseLib::HelperFunctions::trim(outputString).size() > 0) GD::out.printMessage("Script output:\n" + outputString);
}
}
catch(const std::exception& ex)
{
GD::bl->out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(BaseLib::Exception& ex)
{
GD::bl->out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
GD::bl->out.printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
if(SG(request_info).path_translated)
{
efree(SG(request_info).query_string);
SG(request_info).query_string = nullptr;
}
if(SG(request_info).argv)
{
free(SG(request_info).argv);
SG(request_info).argv = nullptr;
}
SG(request_info).argc = 0;
ts_free_thread();
setThreadNotRunning(threadId);
}
void handleLook(){
outputString("Look there, it's you!");
}
void outputNum(double num, double x, double y, bool window)
{
std::string word = to_string(num);
outputString(word, x, y, window);
}
void QXmlTestLogger::leaveTestFunction()
{
outputString("</TestFunction>\n");
}
void QXmlTestLogger::enterTestFunction(const char *function)
{
char buf[1024];
QTest::qt_snprintf(buf, sizeof(buf), "<TestFunction name=\"%s\">\n", function);
outputString(buf);
}
NS_IMETHODIMP
nsPop3Sink::IncorporateBegin(const char* uidlString,
nsIURI* aURL,
uint32_t flags,
void** closure)
{
#ifdef DEBUG
printf("Incorporate message begin:\n");
if (uidlString)
printf("uidl string: %s\n", uidlString);
#endif
nsCOMPtr<nsIFile> path;
m_folder->GetFilePath(getter_AddRefs(path));
nsresult rv;
nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (pPrefBranch)
{
nsCOMPtr<nsIMsgIncomingServer> server;
m_folder->GetServer(getter_AddRefs(server));
nsCString plugStoreContract;
server->GetCharValue("storeContractID", plugStoreContract);
// Maildir doesn't care about quaranting, but other stores besides berkeley
// mailbox might. We should probably make this an attribute on the pluggable
// store, though.
if (plugStoreContract.Equals(
NS_LITERAL_CSTRING("@mozilla.org/msgstore/berkeleystore;1")))
pPrefBranch->GetBoolPref("mailnews.downloadToTempFile", &m_downloadingToTempFile);
}
nsCOMPtr<nsIMsgDBHdr> newHdr;
nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_popServer);
if (!server)
return NS_ERROR_UNEXPECTED;
if (m_downloadingToTempFile)
{
// need to create an nsIOFileStream from a temp file...
nsCOMPtr<nsIFile> tmpDownloadFile;
rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
"newmsg",
getter_AddRefs(tmpDownloadFile));
NS_ASSERTION(NS_SUCCEEDED(rv),
"writing tmp pop3 download file: failed to append filename");
if (NS_FAILED(rv))
return rv;
if (!m_tmpDownloadFile)
{
//need a unique tmp file to prevent dataloss in multiuser environment
rv = tmpDownloadFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
NS_ENSURE_SUCCESS(rv, rv);
m_tmpDownloadFile = do_QueryInterface(tmpDownloadFile, &rv);
}
if (NS_SUCCEEDED(rv))
{
rv = MsgGetFileStream(m_tmpDownloadFile, getter_AddRefs(m_outFileStream));
NS_ENSURE_SUCCESS(rv, rv);
}
}
else
{
rv = server->GetMsgStore(getter_AddRefs(m_msgStore));
bool reusable;
NS_ENSURE_SUCCESS(rv, rv);
m_msgStore->GetNewMsgOutputStream(m_folder, getter_AddRefs(newHdr),
&reusable, getter_AddRefs(m_outFileStream));
}
// The following (!m_outFileStream etc) was added to make sure that we don't
// write somewhere where for some reason or another we can't write to and
// lose the messages. See bug 62480
if (!m_outFileStream)
return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsISeekableStream> seekableOutStream = do_QueryInterface(m_outFileStream);
// create a new mail parser
if (!m_newMailParser)
m_newMailParser = new nsParseNewMailState;
NS_ENSURE_TRUE(m_newMailParser, NS_ERROR_OUT_OF_MEMORY);
if (m_uidlDownload)
m_newMailParser->DisableFilters();
nsCOMPtr <nsIMsgFolder> serverFolder;
rv = GetServerFolder(getter_AddRefs(serverFolder));
if (NS_FAILED(rv)) return rv;
rv = m_newMailParser->Init(serverFolder, m_folder,
m_window, newHdr, m_outFileStream);
// If we failed to initialize the parser, then just don't use it!!!
// We can still continue without one.
if (NS_FAILED(rv))
{
m_newMailParser = nullptr;
rv = NS_OK;
}
else
{
if (m_downloadingToTempFile)
{
// Tell the parser to use the offset that will be in the dest folder,
// not the temp folder, so that the msg hdr will start off with
// the correct mdb oid
int64_t fileSize;
path->GetFileSize(&fileSize);
m_newMailParser->SetEnvelopePos((uint32_t) fileSize);
}
}
if (closure)
*closure = (void*) this;
nsCString outputString(GetDummyEnvelope());
rv = WriteLineToMailbox(outputString);
NS_ENSURE_SUCCESS(rv, rv);
// Write out account-key before UIDL so the code that looks for
// UIDL will find the account first and know it can stop looking
// once it finds the UIDL line.
if (!m_accountKey.IsEmpty())
{
outputString.AssignLiteral(HEADER_X_MOZILLA_ACCOUNT_KEY ": ");
outputString.Append(m_accountKey);
outputString.AppendLiteral(MSG_LINEBREAK);
rv = WriteLineToMailbox(outputString);
NS_ENSURE_SUCCESS(rv, rv);
}
if (uidlString)
{
outputString.AssignLiteral("X-UIDL: ");
outputString.Append(uidlString);
outputString.AppendLiteral(MSG_LINEBREAK);
rv = WriteLineToMailbox(outputString);
NS_ENSURE_SUCCESS(rv, rv);
}
// WriteLineToMailbox("X-Mozilla-Status: 8000" MSG_LINEBREAK);
char *statusLine = PR_smprintf(X_MOZILLA_STATUS_FORMAT MSG_LINEBREAK, flags);
outputString.Assign(statusLine);
rv = WriteLineToMailbox(outputString);
PR_smprintf_free(statusLine);
NS_ENSURE_SUCCESS(rv, rv);
rv = WriteLineToMailbox(NS_LITERAL_CSTRING("X-Mozilla-Status2: 00000000" MSG_LINEBREAK));
NS_ENSURE_SUCCESS(rv, rv);
// leave space for 60 bytes worth of keys/tags
rv = WriteLineToMailbox(NS_LITERAL_CSTRING(X_MOZILLA_KEYWORDS));
return NS_OK;
}
void TestResultDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
QStyleOptionViewItemV4 opt = option;
initStyleOption(&opt, index);
// make sure we paint the complete delegate instead of keeping an offset
opt.rect.adjust(-opt.rect.x(), 0, 0, 0);
painter->save();
QFontMetrics fm(opt.font);
QColor foreground;
const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(opt.widget);
const bool selected = view->selectionModel()->currentIndex() == index;
if (selected) {
painter->setBrush(opt.palette.highlight().color());
foreground = opt.palette.highlightedText().color();
} else {
painter->setBrush(opt.palette.background().color());
foreground = opt.palette.text().color();
}
painter->setPen(Qt::NoPen);
painter->drawRect(opt.rect);
painter->setPen(foreground);
TestResultFilterModel *resultFilterModel = static_cast<TestResultFilterModel *>(view->model());
LayoutPositions positions(opt, resultFilterModel);
const TestResult &testResult = resultFilterModel->testResult(index);
// draw the indicator by ourself as we paint across it with the delegate
QStyleOptionViewItemV4 indicatorOpt = option;
indicatorOpt.rect = QRect(0, opt.rect.y(), positions.indentation(), opt.rect.height());
opt.widget->style()->drawPrimitive(QStyle::PE_IndicatorBranch, &indicatorOpt, painter);
QIcon icon = index.data(Qt::DecorationRole).value<QIcon>();
if (!icon.isNull())
painter->drawPixmap(positions.left(), positions.top(),
icon.pixmap(positions.iconSize(), positions.iconSize()));
QString typeStr = TestResult::resultToString(testResult.result());
if (selected) {
painter->drawText(positions.typeAreaLeft(), positions.top() + fm.ascent(), typeStr);
} else {
QPen tmp = painter->pen();
painter->setPen(TestResult::colorForType(testResult.result()));
painter->drawText(positions.typeAreaLeft(), positions.top() + fm.ascent(), typeStr);
painter->setPen(tmp);
}
QString output = outputString(testResult, selected);
if (selected) {
output.replace(QLatin1Char('\n'), QChar::LineSeparator);
if (AutotestPlugin::instance()->settings()->limitResultOutput
&& output.length() > outputLimit)
output = output.left(outputLimit).append(QLatin1String("..."));
recalculateTextLayout(index, output, painter->font(), positions.textAreaWidth());
m_lastCalculatedLayout.draw(painter, QPoint(positions.textAreaLeft(), positions.top()));
} else {
painter->setClipRect(positions.textArea());
// cut output before generating elided text as this takes quite long for exhaustive output
painter->drawText(positions.textAreaLeft(), positions.top() + fm.ascent(),
fm.elidedText(output.left(2000), Qt::ElideRight, positions.textAreaWidth()));
}
QString file = testResult.fileName();
const int pos = file.lastIndexOf(QLatin1Char('/'));
if (pos != -1)
file = file.mid(pos + 1);
painter->setClipRect(positions.fileArea());
painter->drawText(positions.fileAreaLeft(), positions.top() + fm.ascent(), file);
if (testResult.line()) {
QString line = QString::number(testResult.line());
painter->setClipRect(positions.lineArea());
painter->drawText(positions.lineAreaLeft(), positions.top() + fm.ascent(), line);
}
painter->setClipRect(opt.rect);
painter->setPen(opt.palette.midlight().color());
painter->drawLine(0, opt.rect.bottom(), opt.rect.right(), opt.rect.bottom());
painter->restore();
}
