void OsmPbfWriterPrivate::writeHeaderFileblock(const QString &writingProgram, const QStringList &requiredFeatures, const QStringList &optionalFeatures)
{
OSMPBF::HeaderBlock headerBlockParsed;
if (!writingProgram.isNull())
headerBlockParsed.set_writingprogram(writingProgram.toUtf8().constData(), writingProgram.toUtf8().length());
for (QStringList::const_iterator iFeature = requiredFeatures.constBegin() ; iFeature != requiredFeatures.constEnd() ; ++iFeature)
headerBlockParsed.add_required_features(iFeature->toUtf8().constData(), iFeature->toUtf8().length());
for (QStringList::const_iterator iFeature = optionalFeatures.constBegin() ; iFeature != optionalFeatures.constEnd() ; ++iFeature)
headerBlockParsed.add_optional_features(iFeature->toUtf8().constData(), iFeature->toUtf8().length());
QByteArray headerBlockPacked = packPbfMessageToArray(headerBlockParsed);
writeFileblock("OSMHeader", headerBlockPacked);
}
QT_BEGIN_NAMESPACE
static QList<QByteArray> stringListToByteArray(const QStringList &l)
{
if (l.empty())
return QList<QByteArray>();
QList<QByteArray> rc;
const QStringList::const_iterator cend = l.constEnd();
for (QStringList::const_iterator it = l.constBegin(); it != cend; ++it)
rc += it->toUtf8();
return rc;
}
QStringList CMntRes::resources()
{
QStringList result;
mntent *ptr = 0;
while(ptr = getmntent(f)) {
QString str = QString::fromUtf8(ptr->mnt_dir);
if(str.startsWith(QLatin1String("/mnt/stb")))
result << str;
}
#ifndef NDEBUG
QStringList::const_iterator it = result.constBegin();
while(it != result.constEnd()) {
std::cout << it->toUtf8().constData() << std::endl;
++it;
}
#endif
return result;
}
RecollModel::RecollModel(const QStringList fields, QObject *parent)
: QAbstractTableModel(parent), m_ignoreSort(false)
{
// Initialize the translated map for column headers
o_displayableFields["abstract"] = tr("Abstract");
o_displayableFields["author"] = tr("Author");
o_displayableFields["dbytes"] = tr("Document size");
o_displayableFields["dmtime"] = tr("Document date");
o_displayableFields["fbytes"] = tr("File size");
o_displayableFields["filename"] = tr("File name");
o_displayableFields["fmtime"] = tr("File date");
o_displayableFields["ipath"] = tr("Ipath");
o_displayableFields["keywords"] = tr("Keywords");
o_displayableFields["mtype"] = tr("MIME type");
o_displayableFields["origcharset"] = tr("Original character set");
o_displayableFields["relevancyrating"] = tr("Relevancy rating");
o_displayableFields["title"] = tr("Title");
o_displayableFields["url"] = tr("URL");
o_displayableFields["mtime"] = tr("Mtime");
o_displayableFields["date"] = tr("Date");
o_displayableFields["datetime"] = tr("Date and time");
// Add dynamic "stored" fields to the full column list. This
// could be protected to be done only once, but it's no real
// problem
if (theconfig) {
const set<string>& stored = theconfig->getStoredFields();
for (set<string>::const_iterator it = stored.begin();
it != stored.end(); it++) {
if (o_displayableFields.find(*it) == o_displayableFields.end()) {
o_displayableFields[*it] = QString::fromUtf8(it->c_str());
}
}
}
// Construct the actual list of column names
for (QStringList::const_iterator it = fields.begin();
it != fields.end(); it++) {
m_fields.push_back((const char *)(it->toUtf8()));
m_getters.push_back(chooseGetter(m_fields.back()));
}
g_hiliter.set_inputhtml(false);
}
void RegexpMatcherManager::HandleItem (const Item_ptr& item) const
{
std::deque<RegexpItem> matchingTitles;
LeechCraft::Util::copy_if (Items_.begin (), Items_.end (),
std::back_inserter (matchingTitles),
IfTitleMatches (item->Title_));
QStringList links = std::for_each (matchingTitles.begin (),
matchingTitles.end (),
HandleBody (item)).GetLinks ();
for (QStringList::const_iterator i = links.begin (),
end = links.end (); i != end; ++i)
{
LeechCraft::DownloadEntity e;
e.Entity_ = i->toUtf8 ();
emit gotLink (e);
}
}
void CelestiaAppWindow::init(const QString& qConfigFileName,
const QStringList& qExtrasDirectories)
{
QString celestia_data_dir = QString::fromLocal8Bit(::getenv("CELESTIA_DATA_DIR"));
if (celestia_data_dir.isEmpty()) {
QString celestia_data_dir = CONFIG_DATA_DIR;
QDir::setCurrent(celestia_data_dir);
} else if (QDir(celestia_data_dir).isReadable()) {
QDir::setCurrent(celestia_data_dir);
} else {
QMessageBox::critical(0, "Celestia",
_("Celestia is unable to run because the data directroy was not "
"found, probably due to improper installation."));
exit(1);
}
// Get the config file name
string configFileName;
if (qConfigFileName.isEmpty())
configFileName = DEFAULT_CONFIG_FILE.toUtf8().data();
else
configFileName = qConfigFileName.toUtf8().data();
// Translate extras directories from QString -> std::string
vector<string> extrasDirectories;
for (QStringList::const_iterator iter = qExtrasDirectories.begin();
iter != qExtrasDirectories.end(); iter++)
{
extrasDirectories.push_back(iter->toUtf8().data());
}
#ifdef TARGET_OS_MAC
static short domains[] = { kUserDomain, kLocalDomain, kNetworkDomain };
int domain = 0;
int domainCount = (sizeof domains / sizeof(short));
QString resourceDir = QDir::currentPath();
while (!QDir::setCurrent(resourceDir+"/CelestiaResources") && domain < domainCount)
{
FSRef folder;
CFURLRef url;
UInt8 fullPath[PATH_MAX];
if (noErr == FSFindFolder(domains[domain++], kApplicationSupportFolderType, FALSE, &folder))
{
url = CFURLCreateFromFSRef(nil, &folder);
if (CFURLGetFileSystemRepresentation(url, TRUE, fullPath, PATH_MAX))
resourceDir = (const char *)fullPath;
CFRelease(url);
}
}
if (domain >= domainCount)
{
QMessageBox::critical(0, "Celestia",
_("Celestia is unable to run because the CelestiaResources folder was not "
"found, probably due to improper installation."));
exit(1);
}
#endif
initAppDataDirectory();
m_appCore = new CelestiaCore();
AppProgressNotifier* progress = new AppProgressNotifier(this);
alerter = new AppAlerter(this);
m_appCore->setAlerter(alerter);
setWindowIcon(QIcon(":/icons/celestia.png"));
m_appCore->initSimulation(&configFileName,
&extrasDirectories,
progress);
delete progress;
// Enable antialiasing if requested in the config file.
// TODO: Make this settable via the GUI
QGLFormat glformat = QGLFormat::defaultFormat();
if (m_appCore->getConfig()->aaSamples > 1)
{
glformat.setSampleBuffers(true);
glformat.setSamples(m_appCore->getConfig()->aaSamples);
QGLFormat::setDefaultFormat(glformat);
}
glWidget = new CelestiaGlWidget(NULL, "Celestia", m_appCore);
glWidget->makeCurrent();
GLenum glewErr = glewInit();
if (glewErr != GLEW_OK)
{
QMessageBox::critical(0, "Celestia",
QString(_("Celestia was unable to initialize OpenGL extensions (error %1). Graphics quality will be reduced.")).arg(glewErr));
}
m_appCore->setCursorHandler(glWidget);
m_appCore->setContextMenuCallback(ContextMenu);
MainWindowInstance = this; // TODO: Fix context menu callback
setCentralWidget(glWidget);
setWindowTitle("Celestia");
actions = new CelestiaActions(this, m_appCore);
createMenus();
QTabWidget* tabWidget = new QTabWidget(this);
tabWidget->setObjectName("celestia-tabbed-browser");
toolsDock = new QDockWidget(_("Celestial Browser"), this);
toolsDock->setObjectName("celestia-tools-dock");
toolsDock->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
// Create the various browser widgets
celestialBrowser = new CelestialBrowser(m_appCore, NULL);
celestialBrowser->setObjectName("celestia-browser");
connect(celestialBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
QWidget* deepSkyBrowser = new DeepSkyBrowser(m_appCore, NULL);
deepSkyBrowser->setObjectName("deepsky-browser");
connect(deepSkyBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
SolarSystemBrowser* solarSystemBrowser = new SolarSystemBrowser(m_appCore, NULL);
solarSystemBrowser->setObjectName("ssys-browser");
connect(solarSystemBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
// Set up the browser tabs
tabWidget->addTab(solarSystemBrowser, _("Solar System"));
tabWidget->addTab(celestialBrowser, _("Stars"));
tabWidget->addTab(deepSkyBrowser, _("Deep Sky Objects"));
toolsDock->setWidget(tabWidget);
addDockWidget(Qt::LeftDockWidgetArea, toolsDock);
infoPanel = new InfoPanel(_("Info Browser"), this);
infoPanel->setObjectName("info-panel");
infoPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, infoPanel);
infoPanel->setVisible(false);
eventFinder = new EventFinder(m_appCore, _("Event Finder"), this);
eventFinder->setObjectName("event-finder");
eventFinder->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
addDockWidget(Qt::LeftDockWidgetArea, eventFinder);
eventFinder->setVisible(false);
//addDockWidget(Qt::DockWidgetArea, eventFinder);
// Create the time toolbar
TimeToolBar* timeToolBar = new TimeToolBar(m_appCore, _("Time"));
timeToolBar->setObjectName("time-toolbar");
timeToolBar->setFloatable(true);
timeToolBar->setMovable(true);
addToolBar(Qt::TopToolBarArea, timeToolBar);
// Create the guides toolbar
QToolBar* guidesToolBar = new QToolBar(_("Guides"));
guidesToolBar->setObjectName("guides-toolbar");
guidesToolBar->setFloatable(true);
guidesToolBar->setMovable(true);
guidesToolBar->setToolButtonStyle(Qt::ToolButtonTextOnly);
guidesToolBar->addAction(actions->equatorialGridAction);
guidesToolBar->addAction(actions->galacticGridAction);
guidesToolBar->addAction(actions->eclipticGridAction);
guidesToolBar->addAction(actions->horizonGridAction);
guidesToolBar->addAction(actions->eclipticAction);
guidesToolBar->addAction(actions->markersAction);
guidesToolBar->addAction(actions->constellationsAction);
guidesToolBar->addAction(actions->boundariesAction);
guidesToolBar->addAction(actions->orbitsAction);
guidesToolBar->addAction(actions->labelsAction);
addToolBar(Qt::TopToolBarArea, guidesToolBar);
// Give keyboard focus to the 3D view
glWidget->setFocus();
m_bookmarkManager = new BookmarkManager(this);
// Load the bookmarks file and nitialize the bookmarks menu
if (!loadBookmarks())
m_bookmarkManager->initializeBookmarks();
populateBookmarkMenu();
connect(m_bookmarkManager, SIGNAL(bookmarkTriggered(const QString&)),
this, SLOT(slotBookmarkTriggered(const QString&)));
m_bookmarkToolBar = new BookmarkToolBar(m_bookmarkManager, this);
m_bookmarkToolBar->setObjectName("bookmark-toolbar");
m_bookmarkToolBar->rebuild();
addToolBar(Qt::TopToolBarArea, m_bookmarkToolBar);
// Read saved window preferences
readSettings();
// Build the view menu
// Add dockable panels and toolbars to the view menu
viewMenu->addAction(timeToolBar->toggleViewAction());
viewMenu->addAction(guidesToolBar->toggleViewAction());
viewMenu->addAction(m_bookmarkToolBar->toggleViewAction());
viewMenu->addSeparator();
viewMenu->addAction(toolsDock->toggleViewAction());
viewMenu->addAction(infoPanel->toggleViewAction());
viewMenu->addAction(eventFinder->toggleViewAction());
viewMenu->addSeparator();
QAction* fullScreenAction = new QAction(_("Full screen"), this);
fullScreenAction->setCheckable(true);
fullScreenAction->setShortcut(QString(_("Shift+F11")));
// Set the full screen check state only after reading settings
fullScreenAction->setChecked(isFullScreen());
connect(fullScreenAction, SIGNAL(triggered()), this, SLOT(slotToggleFullScreen()));
viewMenu->addAction(fullScreenAction);
// We use a timer with a null timeout value
// to add m_appCore->tick to Qt's event loop
QTimer *t = new QTimer(dynamic_cast<QObject *>(this));
QObject::connect(t, SIGNAL(timeout()), SLOT(celestia_tick()));
t->start(0);
}
void ImportCsvDialog::accept()
{
// save settings
QSettings settings(QApplication::organizationName(), QApplication::organizationName());
settings.beginGroup("importcsv");
settings.setValue("firstrowheader", ui->checkboxHeader->isChecked());
settings.setValue("separator", currentSeparatorChar());
settings.setValue("quotecharacter", currentQuoteChar());
settings.setValue("trimfields", ui->checkBoxTrimFields->isChecked());
settings.setValue("encoding", currentEncoding());
settings.endGroup();
// Parse all csv data
QFile file(csvFilename);
file.open(QIODevice::ReadOnly);
CSVParser csv(ui->checkBoxTrimFields->isChecked(), currentSeparatorChar(), currentQuoteChar());
csv.setCSVProgress(new CSVImportProgress(file.size()));
QTextStream tstream(&file);
tstream.setCodec(currentEncoding().toUtf8());
csv.parse(tstream);
file.close();
if(csv.csv().size() == 0)
return;
// Generate field names. These are either taken from the first CSV row or are generated in the format of "fieldXY" depending on the user input
sqlb::FieldVector fieldList;
CSVParser::TCSVResult::const_iterator itBegin = csv.csv().begin();
if(ui->checkboxHeader->isChecked())
{
++itBegin;
for(QStringList::const_iterator it = csv.csv().at(0).begin();
it != csv.csv().at(0).end();
++it)
{
// Remove invalid characters
QString thisfield = *it;
thisfield.replace("`", "");
thisfield.replace(" ", "");
thisfield.replace('"', "");
thisfield.replace("'","");
thisfield.replace(",","");
thisfield.replace(";","");
// Avoid empty field names
if(thisfield.isEmpty())
thisfield = QString("field%1").arg(std::distance(csv.csv().at(0).begin(), it) + 1);
fieldList.push_back(sqlb::FieldPtr(new sqlb::Field(thisfield, "")));
}
} else {
for(size_t i=0; i < csv.columns(); ++i)
fieldList.push_back(sqlb::FieldPtr(new sqlb::Field(QString("field%1").arg(i+1), "")));
}
// Show progress dialog
QProgressDialog progress(tr("Inserting data..."), tr("Cancel"), 0, csv.csv().size());
progress.setWindowModality(Qt::ApplicationModal);
progress.show();
// Are we importing into an existing table?
bool importToExistingTable = false;
objectMap objects = pdb->getBrowsableObjects();
for(objectMap::ConstIterator i=objects.begin();i!=objects.end();++i)
{
if(i.value().gettype() == "table" && i.value().getname() == ui->editName->text())
{
if((size_t)i.value().table.fields().size() != csv.columns())
{
QMessageBox::warning(this, QApplication::applicationName(),
tr("There is already a table of that name and an import into an existing table is only possible if the number of columns match."));
return;
} else {
if(QMessageBox::question(this, QApplication::applicationName(), tr("There is already a table of that name. Do you want to import the data into it?"), QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
{
importToExistingTable = true;
break;
} else {
return;
}
}
}
}
// Create a savepoint, so we can rollback in case of any errors during importing
// db needs to be saved or an error will occur
QString restorepointName = QString("CSVIMPORT_%1").arg(QDateTime::currentMSecsSinceEpoch());
if(!pdb->setSavepoint(restorepointName))
return rollback(this, pdb, progress, restorepointName, 0, tr("Creating restore point failed: %1").arg(pdb->lastErrorMessage));
// Create table
if(!importToExistingTable)
{
if(!pdb->createTable(ui->editName->text(), fieldList))
return rollback(this, pdb, progress, restorepointName, 0, tr("Creating the table failed: %1").arg(pdb->lastErrorMessage));
}
// now lets import all data, one row at a time
for(CSVParser::TCSVResult::const_iterator it = itBegin;
it != csv.csv().end();
++it)
{
QString sql = QString("INSERT INTO `%1` VALUES(").arg(ui->editName->text());
QStringList insertlist;
for(QStringList::const_iterator jt = it->begin(); jt != it->end(); ++jt)
{
// need to mprintf here
char* formSQL = sqlite3_mprintf("%Q", (const char*)jt->toUtf8());
insertlist << formSQL;
if(formSQL)
sqlite3_free(formSQL);
}
// add missing fields with empty values
for(unsigned int i = insertlist.size(); i < csv.columns(); ++i)
{
qWarning() << "ImportCSV" << tr("Missing field for record %1").arg(std::distance(itBegin, it) + 1);
insertlist << "NULL";
}
sql.append(insertlist.join(QChar(',')));
sql.append(");");
if(!pdb->executeSQL(sql, false, false))
return rollback(this, pdb, progress, restorepointName, std::distance(itBegin, it) + 1, tr("Inserting row failed: %1").arg(pdb->lastErrorMessage));
// Update progress bar and check if cancel button was clicked
unsigned int prog = std::distance(csv.csv().begin(), it);
if(prog % 100 == 0)
progress.setValue(prog);
if(progress.wasCanceled())
return rollback(this, pdb, progress, restorepointName, std::distance(itBegin, it) + 1, "");
}
QApplication::restoreOverrideCursor(); // restore original cursor
QDialog::accept();
}
void MythSystemUnix::Fork(time_t timeout)
{
QString LOC_ERR = QString("myth_system('%1'): Error: ").arg(GetLogCmd());
// For use in the child
char locerr[MAX_BUFLEN];
strncpy(locerr, (const char *)LOC_ERR.toUtf8().constData(), MAX_BUFLEN);
locerr[MAX_BUFLEN-1] = '\0';
LOG(VB_SYSTEM, LOG_DEBUG, QString("Launching: %1").arg(GetLogCmd()));
GetBuffer(0)->setBuffer(0);
GetBuffer(1)->setBuffer(0);
GetBuffer(2)->setBuffer(0);
int p_stdin[] = {-1,-1};
int p_stdout[] = {-1,-1};
int p_stderr[] = {-1,-1};
/* set up pipes */
if( GetSetting("UseStdin") )
{
if( pipe(p_stdin) == -1 )
{
LOG(VB_SYSTEM, LOG_ERR, LOC_ERR + "stdin pipe() failed");
SetStatus( GENERIC_EXIT_NOT_OK );
}
else
fcntl(p_stdin[1], F_SETFL, O_NONBLOCK);
}
if( GetSetting("UseStdout") )
{
if( pipe(p_stdout) == -1 )
{
LOG(VB_SYSTEM, LOG_ERR, LOC_ERR + "stdout pipe() failed");
SetStatus( GENERIC_EXIT_NOT_OK );
}
else
fcntl(p_stdout[0], F_SETFL, O_NONBLOCK);
}
if( GetSetting("UseStderr") )
{
if( pipe(p_stderr) == -1 )
{
LOG(VB_SYSTEM, LOG_ERR, LOC_ERR + "stderr pipe() failed");
SetStatus( GENERIC_EXIT_NOT_OK );
}
else
fcntl(p_stderr[0], F_SETFL, O_NONBLOCK);
}
// set up command args
if (GetSetting("UseShell"))
{
QStringList args = QStringList("-c");
args << GetCommand() + " " + GetArgs().join(" ");
SetArgs( args );
QString cmd = "/bin/sh";
SetCommand( cmd );
}
QStringList args = GetArgs();
args.prepend(GetCommand().split('/').last());
SetArgs( args );
QByteArray cmdUTF8 = GetCommand().toUtf8();
const char *command = strdup(cmdUTF8.constData());
char **cmdargs = (char **)malloc((args.size() + 1) * sizeof(char *));
int i;
QStringList::const_iterator it;
for( i = 0, it = args.constBegin(); it != args.constEnd(); it++, i++ )
{
cmdargs[i] = strdup( it->toUtf8().constData() );
}
cmdargs[i] = NULL;
const char *directory = NULL;
QString dir = GetDirectory();
if (GetSetting("SetDirectory") && !dir.isEmpty())
directory = strdup(dir.toUtf8().constData());
// check before fork to avoid QString use in child
bool setpgidsetting = GetSetting("SetPGID");
/* Do this before forking in case the child miserably fails */
m_timeout = timeout;
if( timeout )
m_timeout += time(NULL);
pid_t child = fork();
if (child < 0)
{
/* Fork failed, still in parent */
LOG(VB_SYSTEM, LOG_ERR, "fork() failed: " + ENO);
SetStatus( GENERIC_EXIT_NOT_OK );
}
else if( child > 0 )
{
/* parent */
m_pid = child;
SetStatus( GENERIC_EXIT_RUNNING );
LOG(VB_SYSTEM, LOG_INFO,
QString("Managed child (PID: %1) has started! "
"%2%3 command=%4, timeout=%5")
.arg(m_pid) .arg(GetSetting("UseShell") ? "*" : "")
.arg(GetSetting("RunInBackground") ? "&" : "")
.arg(GetLogCmd()) .arg(timeout));
/* close unused pipe ends */
CLOSE(p_stdin[0]);
CLOSE(p_stdout[1]);
CLOSE(p_stderr[1]);
// store the rest
m_stdpipe[0] = p_stdin[1];
m_stdpipe[1] = p_stdout[0];
m_stdpipe[2] = p_stderr[0];
}
else if (child == 0)
{
/* Child - NOTE: it is not safe to use LOG or QString between the
* fork and execv calls in the child. It causes occasional locking
* issues that cause deadlocked child processes. */
/* handle standard input */
if( p_stdin[0] >= 0 )
{
/* try to attach stdin to input pipe - failure is fatal */
if( dup2(p_stdin[0], 0) < 0 )
{
cerr << locerr
<< "Cannot redirect input pipe to standard input: "
<< strerror(errno) << endl;
_exit(GENERIC_EXIT_PIPE_FAILURE);
}
}
else
{
/* try to attach stdin to /dev/null */
int fd = open("/dev/null", O_RDONLY);
if( fd >= 0 )
{
if( dup2(fd, 0) < 0)
{
cerr << locerr
<< "Cannot redirect /dev/null to standard input,"
"\n\t\t\tfailed to duplicate file descriptor: "
<< strerror(errno) << endl;
}
}
else
{
cerr << locerr
<< "Cannot redirect /dev/null to standard input, "
"failed to open: "
<< strerror(errno) << endl;
}
}
/* handle standard output */
if( p_stdout[1] >= 0 )
{
/* try to attach stdout to output pipe - failure is fatal */
if( dup2(p_stdout[1], 1) < 0)
{
cerr << locerr
<< "Cannot redirect output pipe to standard output: "
<< strerror(errno) << endl;
_exit(GENERIC_EXIT_PIPE_FAILURE);
}
}
/* handle standard err */
if( p_stderr[1] >= 0 )
{
/* try to attach stderr to error pipe - failure is fatal */
if( dup2(p_stderr[1], 2) < 0)
{
cerr << locerr
<< "Cannot redirect error pipe to standard error: "
<< strerror(errno) << endl;
_exit(GENERIC_EXIT_PIPE_FAILURE);
}
}
/* Close all open file descriptors except stdin/stdout/stderr */
for( int i = sysconf(_SC_OPEN_MAX) - 1; i > 2; i-- )
close(i);
/* set directory */
if( directory && chdir(directory) < 0 )
{
cerr << locerr
<< "chdir() failed: "
<< strerror(errno) << endl;
}
/* Set the process group id to be the same as the pid of this child
* process. This ensures that any subprocesses launched by this
* process can be killed along with the process itself. */
if (setpgidsetting && setpgid(0,0) < 0 )
{
cerr << locerr
<< "setpgid() failed: "
<< strerror(errno) << endl;
}
/* run command */
if( execv(command, cmdargs) < 0 )
{
// Can't use LOG due to locking fun.
cerr << locerr
<< "execv() failed: "
<< strerror(errno) << endl;
}
/* Failed to exec */
_exit(GENERIC_EXIT_DAEMONIZING_ERROR); // this exit is ok
}
/* Parent */
// clean up the memory use
if( command )
free((void *)command);
if( directory )
free((void *)directory);
if( cmdargs )
{
for (i = 0; cmdargs[i]; i++)
free( cmdargs[i] );
free( cmdargs );
}
if( GetStatus() != GENERIC_EXIT_RUNNING )
{
CLOSE(p_stdin[0]);
CLOSE(p_stdin[1]);
CLOSE(p_stdout[0]);
CLOSE(p_stdout[1]);
CLOSE(p_stderr[0]);
CLOSE(p_stderr[1]);
}
}
void tvalue2json(rapidjson::Value & output, const QVariant & input, rapidjson::Value::AllocatorType & allocator)
{
switch(input.type())
{
case QVariant::Invalid:
{
output.SetNull();
break;
}
case QVariant::Bool:
{
output.SetBool(input.toBool());
break;
}
case QVariant::Int:
{
output.SetInt64(input.toInt());
break;
}
case QVariant::LongLong:
{
output.SetInt64(input.toLongLong());
break;
}
case QVariant::Double:
{
output.SetDouble(input.toDouble());
break;
}
case QVariant::String:
{
QByteArray str = input.toString().toUtf8();
output.SetString(str.data(), str.size(), allocator);
break;
}
case QVariant::StringList:
{
QStringList list = input.toStringList();
output.SetArray();
output.Reserve(list.size(), allocator);
rapidjson::Value temp;
for(QStringList::const_iterator it = list.begin(); it != list.end(); ++it)
{
QByteArray str = it->toUtf8();
temp.SetString(str.data(), str.size(), allocator);
output.PushBack(temp, allocator);
}
break;
}
case QVariant::List:
{
QList<QVariant> list = input.toList();
output.SetArray();
output.Reserve(list.size(), allocator);
rapidjson::Value temp;
for(QList<QVariant>::const_iterator it = list.begin(); it != list.end(); ++it)
{
tvalue2json(temp, *it, allocator);
output.PushBack(temp, allocator);
}
break;
}
case QVariant::Map:
{
output.SetObject();
rapidjson::Value tempK, tempV;
QMap<QString, QVariant> qmap = input.toMap();
for(QMap<QString, QVariant>::const_iterator it = qmap.begin(); it != qmap.end(); ++it)
{
tvalue2json(tempK, it.key(), allocator);
tvalue2json(tempV, it.value(), allocator);
output.AddMember(tempK, tempV, allocator);
}
break;
}
case QVariant::Point:
{
QPoint pt = input.toPoint();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
break;
}
case QVariant::PointF:
{
QPointF pt = input.toPointF();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
break;
}
case QVariant::Size:
{
QSize pt = input.toSize();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::SizeF:
{
QSizeF pt = input.toSizeF();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::Rect:
{
QRect pt = input.toRect();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::RectF:
{
QRectF pt = input.toRectF();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.width(), allocator);
output.PushBack(pt.height(), allocator);
break;
}
case QVariant::Vector2D:
{
QVector2D pt = input.value<QVector2D>();
output.SetArray();
output.Reserve(2, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
break;
}
case QVariant::Vector3D:
{
QVector3D pt = input.value<QVector3D>();
output.SetArray();
output.Reserve(3, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.z(), allocator);
break;
}
case QVariant::Vector4D:
{
QVector4D pt = input.value<QVector4D>();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.x(), allocator);
output.PushBack(pt.y(), allocator);
output.PushBack(pt.z(), allocator);
output.PushBack(pt.w(), allocator);
break;
}
case QVariant::Color:
{
QColor pt = input.value<QColor>();
output.SetArray();
output.Reserve(4, allocator);
output.PushBack(pt.red(), allocator);
output.PushBack(pt.green(), allocator);
output.PushBack(pt.blue(), allocator);
output.PushBack(pt.alpha(), allocator);
break;
}
default:
{
output.SetNull();
assert(false && "shuldn't execute to here.");
}
}
}
