// FIXME: could become a skins2 OS factory function or a vlc core function
std::string ThemeLoader::getTmpDir( )
{
#if defined( _WIN32 )
wchar_t *tmpdir = _wtempnam( NULL, L"vlt" );
if( tmpdir == NULL )
return "";
char* utf8 = FromWide( tmpdir );
free( tmpdir );
std::string tempPath( utf8 ? utf8 : "" );
free( utf8 );
return tempPath;
#elif defined( __OS2__ )
char *tmpdir = tempnam( NULL, "vlt" );
if( tmpdir == NULL )
return "";
std::string tempPath( sFromLocale( tmpdir ));
free( tmpdir );
return tempPath;
#else
char templ[] = "/tmp/vltXXXXXX";
char *tmpdir = mkdtemp( templ );
return std::string( tmpdir ? tmpdir : "");
#endif
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CopyFeatureArrayToElementArray::dataCheck()
{
setErrorCondition(0);
if (getCreatedArrayName().isEmpty() == true)
{
setErrorCondition(-11002);
notifyErrorMessage(getHumanLabel(), "The new Element array name must be set", getErrorCondition());
return;
}
QVector<size_t> cDims(1, 1);
m_FeatureIdsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeatureIdsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
m_InArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getSelectedFeatureArrayPath()); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
DataArrayPath tempPath(getFeatureIdsArrayPath().getDataContainerName(), getFeatureIdsArrayPath().getAttributeMatrixName(), "");
getDataContainerArray()->getPrereqAttributeMatrixFromPath<AbstractFilter>(this, tempPath, -301);
if(getErrorCondition() < 0 ) { return; }
tempPath.update(getFeatureIdsArrayPath().getDataContainerName(), getFeatureIdsArrayPath().getAttributeMatrixName(), getCreatedArrayName());
TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, m_InArrayPtr.lock()->getComponentDimensions(), m_InArrayPtr.lock());
}
/**
* @function smoothPath
*/
void PathPlanner::smoothPath( int _robotId,
const Eigen::VectorXi &_links,
std::list<Eigen::VectorXd> &_path ) {
// =========== YOUR CODE HERE ==================
// HINT: Use whatever technique you like better, first try to shorten a path and then you can try to make it smoother
//////RRT rrt( world, _robotId, _links, _start, stepSize );
//;
if(path.empty() == true || path.size() <= 1)
{return;}
std::list<Eigen::VectorXd>::iterator pathhead, pathend1, pathend2;
////////////////////////////////////////
//
// pathend2 = pathend1 + 1;
// pathend1 = pathhead;
// check whether pathend2 is reachable for pathhead
// if no, (if pathend1 != pathhead, clear(pathhead, pathend1)
// if pathend1 == pathhead, pathhead = pathhead2);
// if yes, pathend1 = pathend2, pathend2++;
//
////////////////////////////////////////
pathhead = pathend1 = pathend2 = path.begin();
pathend2 ++;
while(pathend2 != path.end())
{
if(checkPathSegment(_robotId, _links, (*pathhead), (*pathend2)) == true)
{
pathend1 = pathend2;
pathend2 ++;
}
else
{
std::list<Eigen::VectorXd> tempPath(pathhead,pathend2);
if( tempPath.size() <= 1)
{
pathhead = pathend1 = pathend2;
pathend2 ++;
}
else
{
pathhead ++;
path.erase(pathhead, pathend1);
pathhead = pathend1 = pathend2 = path.begin();
pathend2 ++;
}
}
}
/////////////////////////////////////////////////////////
///
///
///
///
///
///
///
////////////////////////////////////////////////////////
return;
// ========================================
}
CString openTemporaryFile(const char* prefix, PlatformFileHandle& handle)
{
// BREW does not have a system-wide temporary directory,
// use "fs:/~/tmp" as our temporary directory.
String tempPath("fs:/~/tmp");
PlatformRefPtr<IFileMgr> fileMgr = createRefPtrInstance<IFileMgr>(AEECLSID_FILEMGR);
// Create the temporary directory if it does not exist.
IFILEMGR_MkDir(fileMgr.get(), tempPath.utf8().data());
// Loop until we find a temporary filename that does not exist.
int number = static_cast<int>(randomNumber() * 10000);
CString filename;
do {
StringBuilder builder;
builder.append(tempPath);
builder.append('/');
builder.append(prefix);
builder.append(String::number(number));
filename = builder.toString().utf8();
number++;
} while (IFILEMGR_Test(fileMgr.get(), filename.data()) == SUCCESS);
IFile* tempFile = IFILEMGR_OpenFile(fileMgr.get(), filename.data(), _OFM_CREATE);
if (tempFile) {
handle = tempFile;
return filename;
}
return CString();
}
nsresult JRexDirServiceProvider::Initialize(const char* grePath){
nsEmbedCString tempPath(grePath);
nsresult rv=NS_NewNativeLocalFile(tempPath,PR_TRUE,getter_AddRefs(greDirPath));
JREX_RETURN_IF_FAILED(rv,"Initialize()--> **** NS_NewNativeLocalFile ****")
JREX_LOGLN("Initialize()--> **** NS_NewNativeLocalFile Done GOT THE GRE PATH <"<<greDirPath.get()<<"> ****")
return rv;
}
// If this is uninstaller and we're running from installation directory,
// copy uninstaller to temp directory and execute from there, exiting
// ourselves. This is needed so that uninstaller can delete itself
// from installation directory and remove installation directory
// If returns TRUE, this is an installer and we sublaunched ourselves,
// so the caller needs to exit
bool ExecuteUninstallerFromTempDir()
{
// only need to sublaunch if running from installation dir
ScopedMem<WCHAR> ownDir(path::GetDir(GetOwnPath()));
ScopedMem<WCHAR> tempPath(GetTempUninstallerPath());
// no temp directory available?
if (!tempPath)
return false;
// not running from the installation directory?
// (likely a test uninstaller that shouldn't be removed anyway)
if (!path::IsSame(ownDir, gGlobalData.installDir))
return false;
// already running from temp directory?
if (path::IsSame(GetOwnPath(), tempPath))
return false;
if (!CopyFile(GetOwnPath(), tempPath, FALSE)) {
NotifyFailed(L"Failed to copy uninstaller to temp directory");
return false;
}
ScopedMem<WCHAR> args(str::Format(L"/d \"%s\" %s", gGlobalData.installDir, gGlobalData.silent ? L"/s" : L""));
bool ok = CreateProcessHelper(tempPath, args);
// mark the uninstaller for removal at shutdown (note: works only for administrators)
MoveFileEx(tempPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
return ok;
}
bool Deck::importDana(QString fileName)
{
QFileInfo fi(fileName);
QString baseName = fi.baseName().toLower();
QString tempFolder = utils::combinePaths(tempPath(), baseName);
QString deckPath = utils::combinePaths(tempFolder, "deck.xml");
QString iconPath = utils::combinePaths(tempFolder, "icon.png");
utils::createDirectory(tempFolder);
Compressor c;
if(!c.decompressFolder(fileName, tempFolder)) {
return false;
}
///
importFromXml(deckPath);
utils::removeFile(deckPath);
utils::copyDirectory(getDeckPath(), tempFolder);
/// load icon pixmap
loadPixmap( iconPath );
return true;
}
void ThemesDlg::uninstall()
{
ThemeWidget* w = (ThemeWidget*)(tableThemes->selectedItem());
ThemeFile* tf = w->themeFile();
KUrl theme(tf->file());
QString tempPath(tf->path());
karambaApp->closeTheme(tf->name());
if (!tf->isZipTheme()) {
kDebug() << "encountered unpacked theme" ;
//Don't move it to the trash if it is a local theme
if (isDownloaded(tempPath)) {
QFileInfo remPath(tf->path());
QDir remDir(remPath.dir());
remDir.cdUp();
kDebug() << "moving " << remDir.path() << " to the trash" ;
KIO::trash(remDir.path());
}
tableThemes->removeItem((QWidget*)w);
//some themes have multiple .theme files
//find all .themes that could be listed in the dialog for the directory removed
QList<ThemeWidget*> list;
for (uint i = 2; i < tableThemes->count(); ++i) {
ThemeWidget* tempW = (ThemeWidget*)(tableThemes->item(i));
ThemeFile* tempTf = tempW->themeFile();
if (tempTf->path().compare(tempPath) == 0) {
list.append(tempW);
}
}
foreach (ThemeWidget *twPtr, list) {
karambaApp->closeTheme(twPtr->themeFile()->name());
tableThemes->removeItem((QWidget*)twPtr);
}
static std::string
tempFileName(const std::string &ext="") {
#if 0 // [Robb Matzke 2014-06-18]: temp_directory_path and unique_path are not always available
boost::filesystem::path path = boost::filesystem::temp_directory_path().string();
path /= "%%%%-%%%%-%%%%-%%%%" + ext;
return boost::filesystem::unique_path(path).string();
#else
# ifdef BOOST_WINDOWS
char dummy;
size_t size = GetTempPath(0, &dummy); // size includes NUL terminator
if (0==size)
throw std::runtime_error("could not get system temporary directory name");
std::vector<char> buffer(size);
size = GetTempPath(size, &buffer[0]);
ASSERT_require(size==buffer.size());
std::string tempPath(buffer.begin(), buffer.begin()+size); // includes final back-slash according to documentation
# else
std::string tempPath;
if (0!=geteuid()) {
if (char *e = getenv("TMPDIR")) {
struct stat sb;
if (0==stat(e, &sb) && S_ISDIR(sb.st_mode))
tempPath = e;
}
}
if (tempPath.empty()) {
struct stat sb;
if (0==stat(P_tmpdir, &sb) && S_ISDIR(sb.st_mode))
tempPath = P_tmpdir;
}
if (tempPath.empty())
tempPath = _PATH_TMP;
if (tempPath.empty())
tempPath = "/tmp";
if ('/'!=tempPath[tempPath.size()-1])
tempPath += "/";
# endif
while (1) {
std::string basename;
for (int i=0; i<4; ++i) {
if (i!=0)
basename += '-';
for (int j=0; j<4; ++j) {
int k = rand() % 16;
char ch = k < 10 ? '0'+k : 'a'+k-10;
basename += ch;
}
}
std::string path = tempPath + basename + ext;
#ifdef BOOST_WINDOWS
bool exists = PathFileExists(path.c_str());
#else
bool exists = 0 == access(path.c_str(), F_OK);
#endif
if (!exists)
return path;
}
#endif
}
QSqlDatabase QMail::createDatabase()
{
if (!databaseDataInstance()->hasLocalData()) {
databaseDataInstance()->setLocalData(new QDatabaseInstanceData);
}
QDatabaseInstanceData* instance = databaseDataInstance()->localData();
QSqlDatabase db;
if (instance->init) {
db = QSqlDatabase::database("qmailstore_sql_connection");
} else {
qMailLog(Messaging) << "opening database";
db = QSqlDatabase::addDatabase("QSQLITE", "qmailstore_sql_connection");
QDir dbDir(dataPath() + "database");
if (!dbDir.exists()) {
#ifdef Q_OS_UNIX
QString path = dataPath();
if (path.endsWith('/'))
path = path.left(path.length() - 1);
if (!QDir(path).exists() && ::mkdir(QFile::encodeName(path), S_IRWXU) == -1)
qCritical() << "Cannot create database directory: " << errno;
#endif
if (!dbDir.mkpath(dataPath() + "database"))
qCritical() << "Cannot create database path";
}
db.setDatabaseName(dataPath() + "database/qmailstore.db");
#endif
if(!db.open()) {
QSqlError dbError = db.lastError();
qCritical() << "Cannot open database: " << dbError.text();
}
QDir tp(tempPath());
if(!tp.exists())
if(!tp.mkpath(tempPath()))
qCritical() << "Cannot create temp path";
instance->init = true;
}
return db;
}
void ConfigurationManager::processPaths(Files::PathContainer& dataDirs, bool create)
{
std::string path;
for (Files::PathContainer::iterator it = dataDirs.begin(); it != dataDirs.end(); ++it)
{
path = it->string();
boost::erase_all(path, "\"");
*it = boost::filesystem::path(path);
// Check if path contains a token
if (!path.empty() && *path.begin() == '?')
{
std::string::size_type pos = path.find('?', 1);
if (pos != std::string::npos && pos != 0)
{
TokensMappingContainer::iterator tokenIt = mTokensMapping.find(path.substr(0, pos + 1));
if (tokenIt != mTokensMapping.end())
{
boost::filesystem::path tempPath(((mFixedPath).*(tokenIt->second))());
if (pos < path.length() - 1)
{
// There is something after the token, so we should
// append it to the path
tempPath /= path.substr(pos + 1, path.length() - pos);
}
*it = tempPath;
}
else
{
// Clean invalid / unknown token, it will be removed outside the loop
(*it).clear();
}
}
}
if (!boost::filesystem::is_directory(*it))
{
if (create)
{
try
{
boost::filesystem::create_directories (*it);
}
catch (...) {}
if (boost::filesystem::is_directory(*it))
continue;
}
(*it).clear();
}
}
dataDirs.erase(std::remove_if(dataDirs.begin(), dataDirs.end(),
boost::bind(&boost::filesystem::path::empty, _1)), dataDirs.end());
}
QString TempDeck::getDeckPath() const
{
QString deckPath = utils::combinePaths(
tempPath(), QString("tempDeck_%1").arg((quint64)this));
utils::createDirectory(deckPath);
return deckPath;
}
String openTemporaryFile(const String& prefix, PlatformFileHandle& handle)
{
GUniquePtr<gchar> filename(g_strdup_printf("%s%s", prefix.utf8().data(), createCanonicalUUIDString().utf8().data()));
GUniquePtr<gchar> tempPath(g_build_filename(g_get_tmp_dir(), filename.get(), NULL));
GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(tempPath.get()));
handle = g_file_create_readwrite(file.get(), G_FILE_CREATE_NONE, 0, 0);
if (!isHandleValid(handle))
return String();
return String::fromUTF8(tempPath.get());
}
void Filesystem::SetWritePath(const std::string& path)
{
std::unique_ptr<ISearchPath> tempPath(new StdioSearchPath());
if (!tempPath->Init(path))
return;
// Write path is always stdio
writePath = std::move(tempPath);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RemoveComponentFromArray::dataCheck()
{
setErrorCondition(0);
m_InArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getSelectedArrayPath());
if (m_SaveRemovedComponent == true)
{
if (m_NewArrayArrayName.isEmpty() == true)
{
setErrorCondition(-11001);
notifyErrorMessage(getHumanLabel(), "Removed Component array name must be set.", getErrorCondition());
return;
}
}
if (m_ReducedArrayArrayName.isEmpty() == true)
{
setErrorCondition(-11002);
notifyErrorMessage(getHumanLabel(), "Reduced array name must be set.", getErrorCondition());
return;
}
if(getErrorCondition() < 0) { return; }
if (m_InArrayPtr.lock()->getNumberOfComponents() < 2)
{
setErrorCondition(-11003);
QString ss = QObject::tr("Selected array '%1' must have more than 1 component. The number of components is %2").arg(getSelectedArrayPath().getDataArrayName()).arg(m_InArrayPtr.lock()->getNumberOfComponents());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
if(m_CompNumber >= m_InArrayPtr.lock()->getNumberOfComponents())
{
setErrorCondition(-11004);
QString ss = QObject::tr("Component to extract (%1) is larger than the number of components (%2) for array selected: '%1'").arg(m_CompNumber).arg(m_InArrayPtr.lock()->getNumberOfComponents()).arg(getSelectedArrayPath().getDataArrayName());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
QVector<size_t> cDims(1, 1);
if (m_SaveRemovedComponent == true)
{
DataArrayPath tempPath(getSelectedArrayPath().getDataContainerName(), getSelectedArrayPath().getAttributeMatrixName(), getNewArrayArrayName());
m_NewArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, cDims, m_InArrayPtr.lock());
}
cDims[0] = m_InArrayPtr.lock()->getNumberOfComponents() - 1;
DataArrayPath tempPath2(getSelectedArrayPath().getDataContainerName(), getSelectedArrayPath().getAttributeMatrixName(), getReducedArrayArrayName());
m_ReducedArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath2, cDims, m_InArrayPtr.lock());
}
void LogPrefsView::MessageReceived(BMessage* msg)
{
switch (msg->what) {
case M_PREFLOG_CHECKBOX_CHANGED: {
BControl* source(NULL);
msg->FindPointer("source", reinterpret_cast<void**>(&source));
vision_app->SetBool(msg->FindString("setting"), source->Value() == B_CONTROL_ON);
}
break;
case M_PREFLOG_LOGPATH_CHANGED: {
BString tempPath(fLogBaseDir->Text());
if (tempPath.Length() == 0) {
BAlert* emptyPathAlert(
new BAlert(S_PREFLOG_ALERT_TITLE, S_PREFLOG_ALERT_TEXT, S_PREFLOG_ALERT_BUTTON));
emptyPathAlert->Go();
break;
} else {
// remove trailing slash to avoid setting off BPath's normalization
if (tempPath[tempPath.Length() - 1] == '/') tempPath.ReplaceLast('/', '\0');
BPath path(tempPath.String());
if (path.InitCheck() != B_OK) {
BAlert* badPathAlert(new BAlert(S_PREFLOG_ALERT_TITLE, S_PREFLOG_ALERT_TEXT,
S_PREFLOG_ALERT_BUTTON));
badPathAlert->Go();
break;
}
}
vision_app->SetString("logBaseDir", 0, tempPath.String());
}
break;
case M_PREFLOG_TS_FORMAT_CHANGED: {
vision_app->SetString("timestamp_format", 0, fLogStampFormat->Text());
}
break;
case M_PREFLOG_DELETE_LOGS: {
BString path(vision_app->GetString("logBaseDir"));
BEntry entry(path.String());
_DeleteLogs(&entry);
fClearLogs->SetEnabled(false);
}
break;
default:
BView::MessageReceived(msg);
break;
}
}
CLIB_API const boost::filesystem::path & GetTempFolder(boost::filesystem::path & path)
{
DWORD result = ::GetTempPath(0, _T(""));
if (result == 0)
return path;
std::vector<TCHAR> tempPath(result);
result = ::GetTempPath(static_cast<DWORD>(tempPath.size()), &tempPath[0]);
if ((result == 0) || (result > tempPath.size()))
return path;
path = stringToPath(std::_tstring(tempPath.begin(), tempPath.begin() + static_cast<std::size_t>(result)));
return path;
}
BOOL SnapshotWizardPage1::OnInitDialog(CWindow wndFocus, LPARAM lInitParam) {
sourceEdit_ = GetDlgItem(IDC_SOURCE_EDIT);
destinationEdit_ = GetDlgItem(IDC_DEST_EDIT);
sourceEdit_.SetWindowTextW(L"%systemroot%\\NTDS\\ntds.dit");
wchar_t destinationPath[MAX_PATH];
if (::GetModuleFileName(nullptr, destinationPath, MAX_PATH)) {
CPath tempPath(destinationPath);
tempPath.RemoveFileSpec();
tempPath.Append(L"\\ntdsSnapshot.dit");
destinationEdit_.SetWindowTextW(static_cast<const wchar_t*>(tempPath));
}
return TRUE;
}
std::string gettmpdir(void)
{
#ifdef _WIN32
DWORD result = ::GetTempPath(0, _T(""));
if (result == 0)
throw std::runtime_error("Could not get system temp path");
std::vector<TCHAR> tempPath(result + 1);
result = ::GetTempPath(static_cast<DWORD>(tempPath.size()), &tempPath[0]);
if((result == 0) || (result >= tempPath.size()))
throw std::runtime_error("Could not get system temp path");
return std::string(tempPath.begin(), tempPath.begin() + static_cast<std::size_t>(result));
#else
return std::string("/tmp/");
#endif
}
void SetUp() {
samPath_ = tempPath("breakdancer-unit-test", ".sam");
std::ofstream out(samPath_.c_str());
out << samData;
out.close();
reader.reset(openBam(samPath_));
boost::shared_ptr<RawBamEntry> entry(new RawBamEntry);
while (reader->next(*entry) > 0) {
reads.emplace_back(new Alignment(*entry));
rawEntries.push_back(entry);
entry.reset(new RawBamEntry);
}
EXPECT_EQ(6u, reads.size());
}
TEST_F(TestBam, bamWriter) {
std::string tmpOut = tempPath("breakdancer-unit-test", ".sam");
BamWriter writer(tmpOut, reader->header(), true);
for (size_t i = 0; i < rawEntries.size(); ++i) {
writer.write(*rawEntries[i]);
}
writer.close();
std::ifstream in(tmpOut.c_str());
in.seekg(0, std::ios::end);
size_t size = in.tellg();
in.seekg(0, std::ios::beg);
std::vector<char> buf(size);
ASSERT_TRUE(in.read(buf.data(), size));
buf.push_back(0); // make sure buffer is null terminated
EXPECT_STREQ(samData.c_str(), buf.data());
bfs::remove(tmpOut);
}
void FileUtils::removeFile(const char* src) throw (IOException)
{
#ifdef PLATFORM_UNIX
if (unlink(src) != 0)
{
if (errno != ENOENT)
{
throw IOException("Unable to remove file " + std::string(src));
}
}
#else
if (!DeleteFile(src))
{
if (GetLastError() == ERROR_ACCESS_DENIED)
{
// if another process is using the file, try moving it to
// a temporary directory and then
// scheduling it for deletion on reboot
std::string tempDeletePathBase = tempPath();
tempDeletePathBase += '/';
tempDeletePathBase += fileName(src);
int suffix = 0;
std::string tempDeletePath = tempDeletePathBase;
while (fileExists(tempDeletePath.c_str()))
{
++suffix;
tempDeletePath = tempDeletePathBase + '_' + intToStr(suffix);
}
LOG(Warn,"Unable to remove file " + std::string(src) + " - it may be in use. Moving to "
+ tempDeletePath + " and scheduling delete on reboot.");
moveFile(src,tempDeletePath.c_str());
MoveFileEx(tempDeletePath.c_str(),0,MOVEFILE_DELAY_UNTIL_REBOOT);
}
else if (GetLastError() != ERROR_FILE_NOT_FOUND)
{
throw IOException("Unable to remove file " + std::string(src));
}
}
#endif
}
void MeteorShowersMgr::updateFinished(QNetworkReply* reply)
{
if (m_progressBar)
{
m_progressBar->setValue(100);
StelApp::getInstance().removeProgressBar(m_progressBar);
m_progressBar = NULL;
}
if (reply->error() != QNetworkReply::NoError)
{
qWarning() << "MeteorShowersMgr: Failed to download!" << reply->url();
qWarning() << "MeteorShowersMgr: Error " << reply->errorString();
setStatusOfLastUpdate(FAILED);
return;
}
QString tempPath(m_catalogPath + "_new.json");
QFile newCatalog(tempPath);
newCatalog.remove(); // always overwrites
if (!newCatalog.open(QIODevice::ReadWrite | QIODevice::Text))
{
qWarning() << "MeteorShowersMgr: Cannot write the downloaded catalog!";
setStatusOfLastUpdate(FAILED);
return;
}
newCatalog.write(reply->readAll());
newCatalog.close();
if (!loadCatalog(tempPath))
{
setStatusOfLastUpdate(FAILED);
return;
}
QFile(m_catalogPath).remove();
newCatalog.rename(tempPath.remove("_new.json"));
qDebug() << "MeteorShowersMgr: The catalog was updated!";
setStatusOfLastUpdate(UPDATED);
}
bool Deck::exportToDana(QString fileName)
{
QFileInfo fi(fileName);
QString baseName = fi.baseName().toLower();
QString tempFolder = utils::combinePaths(tempPath(), baseName);
QString deckFile = utils::combinePaths(tempFolder, "deck.xml");
utils::removeDirectory(tempFolder);
utils::createDirectory(tempFolder);
if(!exportToXml(deckFile))
return false;
utils::copyDirectory(tempFolder, getDeckPath());
Compressor c;
if(!c.compressFolder(tempFolder, fileName)) {
return false;
}
return true;
}
void ProjectBase::onProblemFinished(Problem* problem,Result* result)
{
if(result)
{
//Results
if(!result->isSuccess())
{
QString msg = "Problem "+ problem->getClassName()+ " has failed";
InfoSender::instance()->send(Info(msg,ListInfo::ERROR2));
delete result;
}
else
{
QString msg = "Problem "+ problem->getClassName()+ " succeeded";
InfoSender::instance()->send(Info(msg,ListInfo::NORMAL2));
if(result->name().isEmpty())
result->setName(result->problem()->name()+" result");
HighTools::checkUniqueResultName(this,result,_results);
// prepare directory (erase content/create folder)
QString storeFolder = resultsFolder()+QDir::separator()+result->name();
LowTools::mkpath(storeFolder,true);
result->store(storeFolder,tempPath());
// result->setParent(this);
addResult(result);
save(result);
}
}
_problemLaunchMutex.unlock();
_problemsThreads.remove(problem);
/// @todo check whether it is really deleted
problem->deleteLater();
}
/**
* Sets the name of the base template for this template.
*
* @param name the base template name
*
* @return 0 on success, error code on error
*/
int TpfTemplate::setBaseTemplateName(const std::string & name)
{
m_baseTemplateName = name;
if (m_parentFile == NULL)
return -1;
// load the base template
if (m_baseTemplateFile != NULL)
{
delete m_baseTemplateFile;
m_baseTemplateFile = NULL;
}
Filename baseTemplateFileName(NULL, NULL, name.c_str(), TEMPLATE_EXTENSION);
Filename sourceTpfPath(NULL, m_parentFile->getTpfPath().c_str(), NULL, NULL);
Filename tempPath(baseTemplateFileName);
tempPath.setPath(sourceTpfPath.getPath().c_str());
tempPath.appendPath(baseTemplateFileName);
tempPath.setDrive(m_parentFile->m_fp.getFilename().getDrive().c_str());
File fp;
int i = 0;
while (!fp.exists(tempPath) && i < MAX_DIRECTORY_DEPTH)
{
sourceTpfPath.appendPath(NEXT_HIGHER_PATH);
tempPath.setPath(sourceTpfPath.getPath().c_str());
tempPath.appendPath(baseTemplateFileName);
++i;
}
if (i == MAX_DIRECTORY_DEPTH)
return -1;
m_baseTemplateFile = new TpfFile;
return m_baseTemplateFile->loadTemplate(tempPath);
} // TpfTemplate::setBaseTemplateName
TEST_F(TrackExporterTest, MungeFilename) {
// Create a track list with a duplicate track in a different location,
// see that the name gets munged.
QFileInfo fileinfo1(m_testDataDir.filePath("cover-test.ogg"));
TrackPointer track1(TrackInfoObject::newTemporary(fileinfo1));
// Create a file with the same name in a different place. Its filename
// should be munged and the file still copied.
QDir tempPath(QDir::tempPath());
QFile file2(tempPath.filePath("cover-test.ogg"));
QFileInfo fileinfo2(file2);
ASSERT_TRUE(file2.open(QIODevice::WriteOnly));
file2.close();
TrackPointer track2(TrackInfoObject::newTemporary(fileinfo2));
// Set up the worker and answerer.
QList<TrackPointer> tracks;
tracks.append(track1);
tracks.append(track2);
TrackExportWorker worker(m_exportDir.canonicalPath(), tracks);
m_answerer.reset(new FakeOverwriteAnswerer(&worker));
worker.run();
EXPECT_TRUE(worker.wait(10000));
EXPECT_EQ(2, m_answerer->currentProgress());
EXPECT_EQ(2, m_answerer->currentProgressCount());
QFileInfo newfile1(m_exportDir.filePath("cover-test.ogg"));
EXPECT_TRUE(newfile1.exists());
QFileInfo newfile2(m_exportDir.filePath("cover-test-0001.ogg"));
EXPECT_TRUE(newfile2.exists());
// Remove the track we created.
tempPath.remove("cover-test.ogg");
}
char *realpath(const char *path, char *resolved_path) {
BPath tempPath(path,NULL,true);
strcpy(resolved_path,tempPath.Path());
return resolved_path;
}
bool Deck::importMnemosyne(QString fileName)
{
QFileInfo fi(fileName);
QString baseName = fi.baseName().toLower();
QString tempFolder = utils::combinePaths(tempPath(), baseName);
QString metadataPath = utils::combinePaths(tempFolder, "METADATA");
QString cardsPath = utils::combinePaths(tempFolder, "cards.xml");
utils::createDirectory(tempFolder);
Compressor c;
if(!c.decompressFolder(fileName, tempFolder)) {
return false;
}
/// import metadata
///
QTextStream s;
QFile metadataFile(metadataPath);
metadataFile.open(QIODevice::ReadOnly | QIODevice::Text);
if(!metadataFile.isOpen())
return false;
s.setDevice(&metadataFile);
s.setCodec("UTF-8");
QStringList sl;
QString l = s.readLine();
while (!s.atEnd()) {
sl = l.split(":");
if(sl.size()>1) {
if(sl[0]=="tags")
setTags(sl[1]);
else if(sl[0]=="notes")
setDesc(sl[1]);
else if(sl[0]=="author_name")
setAuthor(sl[1]);
else if(sl[0]=="card_set_name")
setName(sl[1]);
}
l = s.readLine();
}
/// read cards
QDomDocument domDocument;
QString errorStr;
int errorLine;
int errorColumn;
QString front, back, level;
QFile cardsFile(cardsPath);
cardsFile.open(QIODevice::ReadOnly | QIODevice::Text);
if(!cardsFile.isOpen())
return false;
if (!domDocument.setContent(&cardsFile, true, &errorStr, &errorLine,
&errorColumn)) {
qDebug() << QString("Parse error at line %1, column %2:\n%3")
.arg(errorLine)
.arg(errorColumn)
.arg(errorStr);
return false;
}
QDomElement root = domDocument.documentElement();
QString rootName = root.tagName().toLower();
if (rootName == "opensm2sync") {
QDomNodeList nodes = root.elementsByTagName("log");
QDomNode node;
QDomElement elnode;
int count = nodes.count();
for(int no = 0; no < count; no++) {
node = nodes.at(no);
if(node.attributes().namedItem("type").nodeValue()=="16") {
elnode = node.firstChildElement("f");
front = elnode.text();
elnode = node.firstChildElement("b");
back = elnode.text();
if(!front.isEmpty()) {
Card *card = new Card();
card->updateFront(front);
card->updateBack(back);
addCard(card);
}
}
}
}
metadataFile.close();
cardsFile.close();
utils::removeFile(metadataPath);
utils::removeFile(cardsPath);
utils::copyDirectory(getDeckPath(), tempFolder);
return true;
}
bool ProjectBase::createTempDir()
{
return LowTools::mkpath(tempPath(),true);
}
