bool Brewtarget::ensureDirectoriesExist()
{
bool success;
QDir dir;
QString errTitle(QObject::tr("Directory Problem"));
QString errText(QObject::tr("\"%1\" cannot be read."));
// Check data dir
dir.setPath(getDataDir());
if( ! dir.exists() || ! dir.isReadable() )
{
QMessageBox::information(
0,
errTitle,
errText.arg(dir.path())
);
return false;
}
// Check doc dir
dir.setPath(getDocDir());
if( ! dir.exists() || ! dir.isReadable() )
{
QMessageBox::information(
0,
errTitle,
errText.arg(dir.path())
);
return false;
}
// Check config dir
dir.setPath(getConfigDir(&success));
if( !success || ! dir.exists() || ! dir.isReadable() )
{
QMessageBox::information(
0,
errTitle,
errText.arg(dir.path())
);
return false;
}
// Check/create user data directory
dir.setPath(getUserDataDir());
if( !dir.exists() && !dir.mkpath(".") )
{
QMessageBox::information(
0,
errTitle,
errText.arg(dir.path())
);
return false;
}
return true;
}
void KMSoundTestWidget::openSoundDialog( KURLRequester * )
{
static bool init = true;
if ( !init )
return;
init = false;
KFileDialog *fileDialog = m_urlRequester->fileDialog();
fileDialog->setCaption( i18n("Select Sound File") );
QStringList filters;
filters << "audio/x-wav" << "audio/x-mp3" << "application/x-ogg"
<< "audio/x-adpcm";
fileDialog->setMimeFilter( filters );
QStringList soundDirs = KGlobal::dirs()->resourceDirs( "sound" );
if ( !soundDirs.isEmpty() ) {
KURL soundURL;
QDir dir;
dir.setFilter( QDir::Files | QDir::Readable );
QStringList::ConstIterator it = soundDirs.begin();
while ( it != soundDirs.end() ) {
dir = *it;
if ( dir.isReadable() && dir.count() > 2 ) {
soundURL.setPath( *it );
fileDialog->setURL( soundURL );
break;
}
++it;
}
}
}
void AudioPluginCache::load(const QDir &dir)
{
qDebug() << Q_FUNC_INFO << dir.path();
/* Check that we can access the directory */
if (dir.exists() == false || dir.isReadable() == false)
return;
/* Loop through all files in the directory */
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
/* Attempt to load a plugin from the path */
QString fileName(it.next());
QString path = dir.absoluteFilePath(fileName);
QPluginLoader loader(path, this);
AudioDecoder* ptr = qobject_cast<AudioDecoder*> (loader.instance());
if (ptr != NULL)
{
qDebug() << "Loaded audio decoder plugin from" << fileName;
/* Just append the plugin path to be used at runtime
* for dynamic creation of instances */
ptr->initialize("");
m_pluginsPathList << path;
loader.unload();
}
else
qDebug() << "Failed to load plugin: " << loader.errorString();
}
}
QDir
Configuration::getStorageLocation(const StorageLocation &type) const
{
QDir location;
switch (type)
{
case FaviconStorageLocation:
location = QDir(QStandardPaths::writableLocation(
QStandardPaths::CacheLocation));
break;
case SystemExtensionsLocation:
location = QDir(PlatformDependent::p()->extensionsDir(
PlatformDependent::System));
break;
case UserExtensionsLocation:
location = QDir(PlatformDependent::p()->extensionsDir(
PlatformDependent::User));
break;
case SystemPresetsLocation:
location = QDir(PlatformDependent::p()->presetsDir(
PlatformDependent::System));
break;
case UserPresetsLocation:
location = QDir(PlatformDependent::p()->presetsDir(
PlatformDependent::User));
break;
default:
return QDir();
}
if (! location.isReadable() )
return QDir();
return location;
}
bool Config::copyDir(QDir src, QDir dest) const {
if(!src.isReadable())
return false;
QFileInfoList entries = src.entryInfoList();
QList<QFileInfo>::iterator it;
for(it=entries.begin(); it!=entries.end(); it++) {
QFileInfo &finfo = *it;
if(finfo.fileName()=="." || finfo.fileName()=="..") {
// Nada
} else if(finfo.isDir()) {
dest.mkdir(finfo.fileName());
src.cd(finfo.fileName());
dest.cd(finfo.fileName());
this->copyDir(src, dest);
src.cdUp();
dest.cdUp();
} else if(finfo.isFile()) {
QFile file(finfo.filePath());
file.copy(dest.absoluteFilePath(finfo.fileName()));
}
}
return true;
}
void MidiPlugin::loadMidiTemplates(const QDir& dir)
{
qDebug() << "loadMidiTemplates from " << dir.absolutePath();
if (dir.exists() == false || dir.isReadable() == false)
return;
/* Go thru all found file entries and attempt to load a midi
template from each of them. */
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
QString path = dir.absoluteFilePath(it.next());
qDebug() << "file: " << path;
MidiTemplate* templ;
templ = MidiTemplate::loader(path);
if (templ != NULL)
{
addMidiTemplate(templ);
} else
{
qWarning() << Q_FUNC_INFO << "Unable to load a midi template from" << path;
}
}
}
void InputMap::loadProfiles(const QDir& dir)
{
if (dir.exists() == false || dir.isReadable() == false)
return;
/* Go thru all found file entries and attempt to load an input
profile from each of them. */
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
QLCInputProfile* prof;
QString path;
path = dir.absoluteFilePath(it.next());
prof = QLCInputProfile::loader(path);
if (prof != NULL)
{
/* Check for duplicates */
if (profile(prof->name()) == NULL)
addProfile(prof);
else
delete prof;
}
else
{
qWarning() << Q_FUNC_INFO << "Unable to find an input profile from" << path;
}
}
}
void FileManager::checkExistingReadableDir(QDir dir) {
if (!dir.isReadable()) {
QLOG_FATAL() << "Directory '" + dir.path() + "' does not have read permission. Aborting program.";
exit(16);
}
if (!dir.exists()) {
QLOG_FATAL() << "Directory '" + dir.path() + "' does not exist. Aborting program";
exit(16);
}
}
void QtFileIconView::readDir( const QDir &dir )
{
if ( !dir.isReadable() )
return;
if ( isRoot( dir.absPath() ) )
emit disableUp();
else
emit enableUp();
clear();
emit directoryChanged( dir.absPath() );
const QFileInfoList *filist = dir.entryInfoList( QDir::DefaultFilter, QDir::DirsFirst | QDir::Name );
emit startReadDir( filist->count() );
QFileInfoListIterator it( *filist );
QFileInfo *fi;
bool allowRename = FALSE, allowRenameSet = FALSE;
while ( ( fi = it.current() ) != 0 ) {
++it;
if ( fi && fi->fileName() == ".." && ( fi->dirPath() == "/" || fi->dirPath().isEmpty() ) )
continue;
emit readNextDir();
QtFileIconViewItem *item = new QtFileIconViewItem( this, new QFileInfo( *fi ) );
if ( fi->isDir() )
item->setKey( QString( "000000%1" ).arg( fi->fileName() ) );
else
item->setKey( fi->fileName() );
if ( !allowRenameSet ) {
if ( !QFileInfo( fi->absFilePath() ).isWritable() ||
item->text() == "." || item->text() == ".." )
allowRename = FALSE;
else
allowRename = TRUE;
if ( item->text() == "." || item->text() == ".." )
allowRenameSet = FALSE;
else
allowRenameSet = TRUE;
}
item->setRenameEnabled( allowRename );
}
if ( !QFileInfo( dir.absPath() ).isWritable() )
emit disableMkdir();
else
emit enableMkdir();
emit readDirDone();
}
void IOPluginCache::load(const QDir& dir)
{
qDebug() << Q_FUNC_INFO << dir.path();
/* Check that we can access the directory */
if (dir.exists() == false || dir.isReadable() == false)
return;
/* Loop thru all files in the directory */
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
/* Attempt to load a plugin from the path */
QString fileName(it.next());
QString path = dir.absoluteFilePath(fileName);
QPluginLoader loader(path, this);
QLCIOPlugin* ptr = qobject_cast<QLCIOPlugin*> (loader.instance());
if (ptr != NULL)
{
/* Check for duplicates */
if (plugin(ptr->name()) == NULL)
{
/* New plugin. Append and init. */
qDebug() << "Loaded I/O plugin" << ptr->name() << "from" << fileName;
emit pluginLoaded(ptr->name());
ptr->init();
m_plugins << ptr;
connect(ptr, SIGNAL(configurationChanged()),
this, SLOT(slotConfigurationChanged()));
#if !defined(Q_OS_ANDROID)
HotPlugMonitor::connectListener(ptr);
#endif
// QLCi18n::loadTranslation(p->name().replace(" ", "_"));
}
else
{
/* Duplicate plugin. Unload it. */
qWarning() << Q_FUNC_INFO << "Discarded duplicate I/O plugin"
<< ptr->name() << "in" << path;
loader.unload();
}
}
else
{
qWarning() << Q_FUNC_INFO << fileName << "doesn't contain an I/O plugin:"
<< loader.errorString();
loader.unload();
}
}
}
void FileManager::createDirOrCheckWriteable(QDir dir) {
if (!dir.exists()) {
if (!dir.mkdir(dir.path())) {
QLOG_FATAL() << "Failed to create directory '" << dir.path() << "'. Aborting program.";
exit(16);
}
} else {
if (!dir.isReadable()) {
QLOG_FATAL() << "Directory '" + dir.path() + "' does not have read permission. Aborting program.";
exit(16);
}
}
}
void BtInstallPathDialog::slotAddClicked() {
QString dirname = QFileDialog::getExistingDirectory(this, tr("Choose Folder"), "", QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
if (dirname.isEmpty()) { // if user cancelled the dialog
return;
}
QDir dir = QDir(dirname);
if (dir.isReadable()) {
const QFileInfo fi( dir.canonicalPath() );
if (!fi.exists() || !fi.isWritable()) {
const int result = message::showWarning(this, tr("Use Folder?"), tr("This folder is not writable, so works can not be installed here using BibleTime. Do you still want to add it to the list of bookshelf folders?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
if (result != QMessageBox::Yes) {
return;
}
}
addPathToList(util::directory::convertDirSeparators(dir.canonicalPath()));
updateTopLevelItems();
}
}
bool KTorrentImportPage::GetTorrentSettings (const QString& path,
QMap<QString, QVariant>& settings) const
{
QDir torrentDir (path);
if (!torrentDir.exists () ||
!torrentDir.isReadable())
return false;
QFileInfoList files = torrentDir
.entryInfoList (QDir::Files | QDir::Readable, QDir::Unsorted);
for (int i = 0; i < files.size (); ++i)
{
QFile file (files.at (i).fileName ());
settings.insert (files.at (i).fileName (), file.readAll ());
}
return true;
}
void OutputMap::loadPlugins(const QDir& dir)
{
/* Check that we can access the directory */
if (dir.exists() == false || dir.isReadable() == false)
return;
/* Loop thru all files in the directory */
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
/* Attempt to load a plugin from the path */
QString fileName(it.next());
QString path = dir.absoluteFilePath(fileName);
QPluginLoader loader(path, this);
QLCOutPlugin* p = qobject_cast<QLCOutPlugin*> (loader.instance());
if (p != NULL)
{
/* Check for duplicates */
if (plugin(p->name()) == NULL)
{
/* New plugin. Append and init. */
qDebug() << "Output plugin" << p->name() << "from" << fileName;
p->init();
appendPlugin(p);
QLCi18n::loadTranslation(p->name().replace(" ", "_"));
}
else
{
/* Duplicate plugin. Unload it. */
qWarning() << Q_FUNC_INFO << "Discarded duplicate output plugin"
<< path;
loader.unload();
}
}
else
{
qWarning() << Q_FUNC_INFO << fileName
<< "doesn't contain a QLC output plugin:"
<< loader.errorString();
loader.unload();
}
}
}
QStringList * zEmotIcons::getSmilePackList()
{
QStringList * list = new QStringList();
QDir dir ( ProgDir+"smile/", "", QDir::Name | QDir::DirsFirst | QDir::IgnoreCase );
#ifdef OLD_SDK
dir.setMatchAllDirs ( true );
#endif
dir.setFilter ( QDir::Dirs );
if ( !dir.isReadable() )
return list;
QStringList entries = dir.entryList();
for ( QStringList::ConstIterator it = entries.begin(); it != entries.end(); it++ )
if ( (*it)[0] != "." )
list->append(*it);
return list;
}
void ImageOpenThread::run()
{
if (FUrl.scheme()=="file")
{
int dot=FUrl.path().lastIndexOf('.');
if (dot>0)
{
QString ext=FUrl.path().mid(dot+1);
if (!ext.isEmpty())
{
QStringList validExtensions;
validExtensions << "png" << "gif" << "jpg" << "jpeg" << "ico" << "bmp" << "tif" << "tiff" << "svg";
if (validExtensions.contains(ext, Qt::CaseInsensitive))
{
QDesktopServices::openUrl(FUrl.path());
return;
}
}
}
QDir temp = QDir::temp();
if (temp.isReadable())
{
QString fileName=FUrl.toLocalFile();
QImageReader reader(fileName);
if (reader.canRead())
{
QString type(reader.format());
QString tmpFileName(fileName);
tmpFileName.append('.').append(type);
QFile tmpFile(temp.filePath(tmpFileName));
if (!tmpFile.exists() || tmpFile.size()!=reader.device()->size()) // Exists already
QFile::copy(fileName, tmpFileName);
QDesktopServices::openUrl(QUrl::fromLocalFile(tmpFile.fileName()));
}
else
LOG_WARNING("Reader can't' read!");
}
}
else
QDesktopServices::openUrl(FUrl);
}
void BtInstallPathDialog::slotEditClicked() {
if (QTreeWidgetItem* i = m_swordPathListBox->currentItem()) {
QString dirname = QFileDialog::getExistingDirectory(this, tr("Choose Folder"), i->text(0), QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
if (dirname.isEmpty()) { // if user cancelled the dialog
return;
}
QDir dir = QDir(dirname);
if (dir.isReadable()) {
const QFileInfo fi( dir.canonicalPath() );
if (!fi.exists() || !fi.isWritable()) {
const int result = message::showWarning(this, tr("Use Folder?"), tr("This folder is not writable, so works can not be installed here using BibleTime. Do you want to use this folder instead of the previous value?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
if (result != QMessageBox::Yes) return;
}
//i->setText(0, dir.absolutePath()); // absolute, not canonical
addPathToList(dir.absolutePath());
delete i;
updateTopLevelItems();
}
}
}
void KPrTransEffectDia::slotRequesterClicked( KURLRequester * )
{
QString filter = getSoundFileFilter();
requester->fileDialog()->setFilter( filter );
// find the first "sound"-resource that contains files
QStringList soundDirs = KGlobal::dirs()->resourceDirs( "sound" );
if ( !soundDirs.isEmpty() ) {
KURL soundURL;
QDir dir;
dir.setFilter( QDir::Files | QDir::Readable );
QStringList::ConstIterator it = soundDirs.begin();
while ( it != soundDirs.end() ) {
dir = *it;
if ( dir.isReadable() && dir.count() > 2 ) {
soundURL.setPath( *it );
requester->fileDialog()->setURL( soundURL );
break;
}
++it;
}
}
}
bool QLCFixtureDefCache::load(const QDir& dir)
{
qDebug() << Q_FUNC_INFO << dir.path();
if (dir.exists() == false || dir.isReadable() == false)
return false;
/* Attempt to read all specified files from the given directory */
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
QString path(dir.absoluteFilePath(it.next()));
if (path.toLower().endsWith(KExtFixture) == true)
loadQXF(path);
else if (path.toLower().endsWith(KExtAvolitesFixture) == true)
loadD4(path);
else
qWarning() << Q_FUNC_INFO << "Unrecognized fixture extension:" << path;
}
return true;
}
bool FrmReports::readReportNames ()
{
QDir reportsDir;
reportsDir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
reportsDir.setSorting(QDir::Size | QDir::Reversed);
QStringList filters;
filters << tr("*.bdrt");
reportsDir.setNameFilters(filters);
if (reportsDir.exists(qApp->translate("dir", strReportsDir)))
reportsDir=QDir(qApp->translate("dir", strReportsDir));
else return false;
if (!reportsDir.isReadable()) return false;
QFileInfoList list = reportsDir.entryInfoList(filters,QDir::Files,QDir::Name);
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
listWidget->addItem(fileInfo.baseName());
}
return true;
}
void ModelBaker::initializeOutputDirs() {
// Attempt to make the output folders
// Warn if there is an output directory using the same name, unless we know a parent FST baker created them already
if (QDir(_bakedOutputDir).exists()) {
if (_mappingURL.isEmpty()) {
qWarning() << "Output path" << _bakedOutputDir << "already exists. Continuing.";
}
} else {
qCDebug(model_baking) << "Creating baked output folder" << _bakedOutputDir;
if (!QDir().mkpath(_bakedOutputDir)) {
handleError("Failed to create baked output folder " + _bakedOutputDir);
return;
}
}
QDir originalOutputDir { _originalOutputDir };
if (originalOutputDir.exists()) {
if (_mappingURL.isEmpty()) {
qWarning() << "Output path" << _originalOutputDir << "already exists. Continuing.";
}
} else {
qCDebug(model_baking) << "Creating original output folder" << _originalOutputDir;
if (!QDir().mkpath(_originalOutputDir)) {
handleError("Failed to create original output folder " + _originalOutputDir);
return;
}
}
if (originalOutputDir.isReadable()) {
// The output directory is available. Use that to write/read the original model file
_originalOutputModelPath = originalOutputDir.filePath(_modelURL.fileName());
} else {
handleError("Unable to write to original output folder " + _originalOutputDir);
}
}
QList<IDL::Entry> IDL::load(const QDir &dir, const QString &filename)
{
if (!dir.isReadable())
throw QObject::tr("Could not read directory %1").arg(dir.absolutePath());
QFile f(filename);
if (!f.open(QIODevice::ReadOnly))
throw QObject::tr("Could not open file %1").arg(filename);
// Find all images
QHash<QString, Entry> entries;
foreach (const QString &s, dir.entryList(QStringList() << "*.png"))
{
QString name = s;
name.chop(4);
entries[name] = Entry(name, dir.absoluteFilePath(s), QList<QRect>());
}
QTextStream fin(&f);
while (fin.skipWhiteSpace(), !fin.atEnd())
{
QString item;
int y0, x0, y1, x1;
fin >> item >> y0 >> x0 >> y1 >> x1;
if (fin.status() != QTextStream::Ok)
throw QObject::tr("Error reading file %1").arg(filename);
if (entries.count(item))
entries[item].rects << QRect(x0, y0, x1-x0+1, y1-y0+1);
else
qWarning() << QObject::tr("IDL: warning: file %1.png not found").arg(item);
}
return entries.values();
}
bool myRemovePath(QString dirPath, bool deleteHidden, bool deleteSelf)
{
qDebug()<<"removePath的进程"<<QThread::currentThread ();
QDir entry (dirPath);
if(!entry.exists()||!entry.isReadable())
return false;
entry.setFilter(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden);
QFileInfoList dirList = entry.entryInfoList();
bool bHaveHiddenFile = false;
if(!dirList.isEmpty()) {
for( int i = 0; i < dirList.size() ; ++i) {
QFileInfo info = dirList.at(i);
if(info.isHidden() && !deleteHidden) {
bHaveHiddenFile = true;
continue;
}
QString path = info.absoluteFilePath();
if(info.isDir()) {
if(!myRemovePath(path, deleteHidden, true))
return false;
}else if(info.isFile()) {
if(!QFile::remove(path))
return false;
}else
return false;
}
}
if(deleteSelf && !bHaveHiddenFile) {
if(!entry.rmdir(dirPath)) {
return false;
}
}
return true;
}
/******************************************************************************
* Check whether the specified sound file exists.
* Note that KAudioPlayer::play() can only cope with local files.
*/
bool SoundDlg::checkFile()
{
mFileName = mFileEdit->text();
KURL url;
if(KURL::isRelativeURL(mFileName))
{
// It's not an absolute URL, so check for an absolute path
QFileInfo f(mFileName);
if(!f.isRelative())
url.setPath(mFileName);
}
else
url = KURL::fromPathOrURL(mFileName); // it's an absolute URL
if(!url.isEmpty())
{
// It's an absolute path or URL.
// Only allow local files for KAudioPlayer.
if(url.isLocalFile() && KIO::NetAccess::exists(url, true, this))
{
mFileName = url.path();
return true;
}
}
else
{
// It's a relative path.
// Find the first sound resource that contains files.
QStringList soundDirs = KGlobal::dirs()->resourceDirs("sound");
if(!soundDirs.isEmpty())
{
QDir dir;
dir.setFilter(QDir::Files | QDir::Readable);
for(QStringList::ConstIterator it = soundDirs.begin(); it != soundDirs.end(); ++it)
{
dir = *it;
if(dir.isReadable() && dir.count() > 2)
{
url.setPath(*it);
url.addPath(mFileName);
if(KIO::NetAccess::exists(url, true, this))
{
mFileName = url.path();
return true;
}
}
}
}
url.setPath(QDir::homeDirPath());
url.addPath(mFileName);
if(KIO::NetAccess::exists(url, true, this))
{
mFileName = url.path();
return true;
}
}
KMessageBox::sorry(this, i18n("File not found"));
mFileName = QString::null;
return false;
}
bool QLCFixtureDefCache::loadMap(const QDir &dir)
{
qDebug() << Q_FUNC_INFO << dir.path();
if (dir.exists() == false || dir.isReadable() == false)
return false;
QString mapPath(dir.absoluteFilePath(FIXTURES_MAP_NAME));
if (mapPath.isEmpty() == true)
return false;
// cache the map path to be used when composing the fixture
// definition absolute path
m_mapAbsolutePath = dir.absolutePath();
QXmlStreamReader *doc = QLCFile::getXMLReader(mapPath);
if (doc == NULL || doc->device() == NULL || doc->hasError())
{
qWarning() << Q_FUNC_INFO << "Unable to read from" << mapPath;
return false;
}
while (!doc->atEnd())
{
if (doc->readNext() == QXmlStreamReader::DTD)
break;
}
if (doc->hasError())
{
QLCFile::releaseXMLReader(doc);
return false;
}
// make sure the doc type is FixtureMap
if (doc->dtdName() != KXMLQLCFixtureMap)
{
qWarning() << Q_FUNC_INFO << mapPath << "is not a fixture map file";
QLCFile::releaseXMLReader(doc);
return false;
}
if (doc->readNextStartElement() == false)
{
QLCFile::releaseXMLReader(doc);
return false;
}
// make sure the root tag is FixtureMap
if (doc->name() != KXMLQLCFixtureMap)
{
qWarning() << Q_FUNC_INFO << mapPath << "is not a fixture map file";
QLCFile::releaseXMLReader(doc);
return false;
}
int fxCount = 0;
QString manufacturer = "";
while (doc->readNextStartElement())
{
if (doc->name() == "M")
{
if (doc->attributes().hasAttribute("n"))
{
manufacturer = doc->attributes().value("n").toString();
fxCount += loadMapManufacturer(doc, manufacturer);
}
}
else
{
qWarning() << Q_FUNC_INFO << "Unknown Fixture Map tag: " << doc->name();
doc->skipCurrentElement();
}
}
qDebug() << fxCount << "fixtures found in map";
#if 0
/* Attempt to read all files not in FixtureMap */
QStringList definitionPaths;
// Gather a list of manufacturers
QListIterator <QLCFixtureDef*> mfit(m_defs);
while (mfit.hasNext() == true)
definitionPaths << mfit.next()->definitionSourceFile();
QStringListIterator it(dir.entryList());
while (it.hasNext() == true)
{
QString path(dir.absoluteFilePath(it.next()));
if (definitionPaths.contains(path))
continue;
qWarning() << path << "not in" << FIXTURES_MAP_NAME;
if (path.toLower().endsWith(KExtFixture) == true)
loadQXF(path);
else if (path.toLower().endsWith(KExtAvolitesFixture) == true)
loadD4(path);
else
qWarning() << Q_FUNC_INFO << "Unrecognized fixture extension:" << path;
}
#endif
return true;
}
int main(int argc, char *argv[])
{
// apply default settings
QucsSettings.x = 60;
QucsSettings.y = 30;
QucsSettings.dx = 640;
QucsSettings.dy = 400;
QucsSettings.font = QFont("Helvetica", 12);
// is application relocated?
char * var = getenv ("QUCSDIR");
if (var != NULL) {
QDir QucsDir = QDir (var);
QString QucsDirStr = QucsDir.canonicalPath ();
QucsSettings.DocDir =
QDir::convertSeparators (QucsDirStr + "/share/qucs/docs/");
QucsSettings.BitmapDir =
QDir::convertSeparators (QucsDirStr + "/share/qucs/bitmaps/");
QucsSettings.LangDir =
QDir::convertSeparators (QucsDirStr + "/share/qucs/lang/");
} else {
QucsSettings.DocDir = DOCDIR;
QucsSettings.BitmapDir = BITMAPDIR;
QucsSettings.LangDir = LANGUAGEDIR;
}
loadSettings();
QApplication a(argc, argv);
a.setFont(QucsSettings.font);
QTranslator tor( 0 );
QString locale = QucsSettings.Language;
if(locale.isEmpty())
locale = QTextCodec::locale();
tor.load( QString("qucs_") + locale, QucsSettings.LangDir);
a.installTranslator( &tor );
QucsHelpDir = QucsSettings.DocDir + locale;
if (!QucsHelpDir.exists () || !QucsHelpDir.isReadable ()) {
int p = locale.find ('_');
if (p != -1) {
QucsHelpDir = QucsSettings.DocDir + locale.left (p);
if (!QucsHelpDir.exists () || !QucsHelpDir.isReadable ()) {
QucsHelpDir = QucsSettings.DocDir + "en";
}
}
else QucsHelpDir = QucsSettings.DocDir + "en";
}
QString Page;
if(argc > 1) Page = argv[1];
QucsHelp *qucs = new QucsHelp(Page);
a.setMainWidget(qucs);
qucs->resize(QucsSettings.dx, QucsSettings.dy); // size and position ...
qucs->move(QucsSettings.x, QucsSettings.y); // ... before "show" !!!
qucs->show();
int result = a.exec();
saveApplSettings(qucs);
return result;
}
RideImportWizard::RideImportWizard(RideAutoImportConfig *dirs, Context *context, QWidget *parent) : QDialog(parent), context(context), importConfig(dirs)
{
_importInProcess = true;
autoImportMode = true;
autoImportStealth = true;
if (autoImportStealth) hide();
QList<QString> files;
// get the directories & rules
QList<RideAutoImportRule> rules = importConfig->getConfig();
// prepare the widget to show the status of the directory
directoryWidget = new QTableWidget(rules.count(), 3, this);
directoryWidget->verticalHeader()->setDefaultSectionSize(20);
QTableWidgetItem *directoryHeading = new QTableWidgetItem;
directoryHeading->setText(tr("Directory"));
directoryWidget->setHorizontalHeaderItem(0, directoryHeading);
QTableWidgetItem *importRuleHeading = new QTableWidgetItem;
importRuleHeading->setText(tr("Import Rule"));
directoryWidget->setHorizontalHeaderItem(1, importRuleHeading);
QTableWidgetItem *statusHeading = new QTableWidgetItem;
statusHeading->setText(tr("Directory Status"));
directoryWidget->setHorizontalHeaderItem(2, statusHeading);
// and get the allowed files formats
const RideFileFactory &rff = RideFileFactory::instance();
QStringList suffixList = rff.suffixes();
suffixList.replaceInStrings(QRegExp("^"), "*.");
QStringList allFormats;
foreach(QString suffix, rff.suffixes())
allFormats << QString("*.%1").arg(suffix);
// Fill in the directory names and importRuleStatus
int i=-1;
foreach (RideAutoImportRule rule, rules){
i++; // do it here to allow "continue" - and start with "0"
QTableWidgetItem *t;
// Directory
t = new QTableWidgetItem();
t->setText(rule.getDirectory());
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
directoryWidget->setItem(i,0,t);
// Import Rule
QList<QString> descriptions = rule.getRuleDescriptions();
t = new QTableWidgetItem();
t->setText(descriptions.at(rule.getImportRule()));
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
directoryWidget->setItem(i,1,t);
// Import Status
t = new QTableWidgetItem();
t->setText(tr(""));
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
directoryWidget->setItem(i,2,t);
// only add files if configured to do so
if (rule.getImportRule() == RideAutoImportRule::noImport) {
directoryWidget->item(i,2)->setText(tr("No import"));
continue;
}
// do some checks on the directory first
QString currentImportDirectory = rule.getDirectory();
if (currentImportDirectory == "") {
directoryWidget->item(i,2)->setText(tr("No directory"));
continue;
}
QDir *importDir = new QDir (currentImportDirectory);
if (!importDir->exists()) { // directory might not be available (USB,..)
directoryWidget->item(i,2)->setText(tr("Directory not available"));
continue;
}
if (!importDir->isReadable()) {
directoryWidget->item(i,2)->setText(tr("Directory not readable"));
continue;
}
// determine timerange in the past which should considerd in import
QDate selectAfter = QDate::currentDate();
switch(rule.getImportRule()) {
case RideAutoImportRule::importLast90days:
case RideAutoImportRule::importBackground90:
selectAfter = selectAfter.addDays(Q_INT64_C(-90));
break;
case RideAutoImportRule::importLast180days:
case RideAutoImportRule::importBackground180:
selectAfter = selectAfter.addDays(Q_INT64_C(-180));
break;
case RideAutoImportRule::importLast360days:
case RideAutoImportRule::importBackground360:
selectAfter = selectAfter.addDays(Q_INT64_C(-360));
break;
}
// if any of the rules says "with Dialog" then we keep the dialog - if not it's stealth
switch (rule.getImportRule()) {
case RideAutoImportRule::importAll:
case RideAutoImportRule::importLast90days:
case RideAutoImportRule::importLast180days:
case RideAutoImportRule::importLast360days:
autoImportStealth = false;
break;
}
// now get the files with their full names
QFileInfoList fileInfos = importDir->entryInfoList(allFormats, QDir::Files, QDir::NoSort);
if (!fileInfos.isEmpty()) {
int j = 0;
foreach(QFileInfo f, fileInfos) {
// append following the import rules
switch (rule.getImportRule()) {
case RideAutoImportRule::importAll:
case RideAutoImportRule::importBackgroundAll:
files.append(f.absoluteFilePath());
j++;
break;
case RideAutoImportRule::importLast90days:
case RideAutoImportRule::importLast180days:
case RideAutoImportRule::importLast360days:
case RideAutoImportRule::importBackground90:
case RideAutoImportRule::importBackground180:
case RideAutoImportRule::importBackground360:
if (f.created().date() >= selectAfter || f.lastModified().date() >= selectAfter) {
files.append(f.absoluteFilePath());
j++;
};
break;
}
}
if (j > 0) {
directoryWidget->item(i,2)->setText(tr("%1 files for import selected").arg(QString::number(j)));
} else {
directoryWidget->item(i,2)->setText(tr("No files in requested time range"));
}
} else {
//-----------------------------------------------------------------------------
int main(int argc, char * argv[])
{
QCoreApplication app(argc, argv);
ctkCommandLineParser parser;
// Use Unix-style argument names
parser.setArgumentPrefix("--", "-");
// Add command line argument names
parser.addArgument("help", "h", QVariant::Bool, "Print usage information and exit.");
parser.addArgument("verbose", "v", QVariant::Bool, "Enable verbose output.");
parser.addArgument("wrapping-namespace", "wns", QVariant::String, "Wrapping namespace.", QVariant("org.commontk.foo"));
parser.addArgument("target-name", "p", QVariant::String, "Target name.");
parser.addArgument("check-only", "c", QVariant::Bool, "Return 1 (or 0) indicating if the file"
"could be successfully wrapped.");
parser.addArgument("output-dir", "o", QVariant::String, "Output directory");
// Parse the command line arguments
bool ok = false;
QHash<QString, QVariant> parsedArgs = parser.parseArguments(QCoreApplication::arguments(), &ok);
if (!ok)
{
std::cerr << "Error parsing arguments: " << qPrintable(parser.errorString()) << std::endl;
printHelpUsage();
return EXIT_FAILURE;
}
// Show help message
if (parsedArgs.contains("help"))
{
printHelp(parser);
return EXIT_SUCCESS;
}
QString wrappingNamespace = parsedArgs.value("wrapping-namespace").toString();
if (wrappingNamespace.isEmpty())
{
std::cerr << "error: Wrapping namespace not specified" << std::endl;
printHelpUsage();
return EXIT_FAILURE;
}
if (!QRegExp("[a-zA-Z0-9]+(\\.[a-zA-Z0-9]+)*").exactMatch(wrappingNamespace))
{
std::cerr << "error: Invalid wrapping namespace. Should match: [a-zA-Z0-9]+(.[a-zA-Z0-9]+)*" << std::endl;
printHelpUsage();
return EXIT_FAILURE;
}
QString outputDir = parsedArgs.value("output-dir").toString();
if (outputDir.isEmpty())
{
std::cerr << "error: Output directory not specified" << std::endl;
printHelpUsage();
return EXIT_FAILURE;
}
QDir dir = QDir(outputDir);
if (!dir.exists() || !dir.isReadable())
{
std::cerr << "error: Output directory non existent or non readable ["
<< qPrintable(outputDir) << "]" << std::endl;
return EXIT_FAILURE;
}
if (parser.unparsedArguments().count() == 0)
{
std::cerr << "error: <path-to-cpp-header-file> not specified" << std::endl;
printHelpUsage();
return EXIT_FAILURE;
}
ctkPythonQtWrapper wrapper;
wrapper.setVerbose(parsedArgs.contains("verbose"));
wrapper.setWrappingNamespace(wrappingNamespace);
if (!wrapper.setOutput(outputDir))
{
std::cerr << "error: Failed to set output" << std::endl;
return EXIT_FAILURE;
}
if (!wrapper.setInput(parser.unparsedArguments()))
{
std::cerr << "error: Failed to set input" << std::endl;
return EXIT_FAILURE;
}
int rejectedHeaders = wrapper.validateInputFiles();
if (parsedArgs.contains("check-only"))
{
return rejectedHeaders;
}
if (rejectedHeaders == parser.unparsedArguments().count())
{
std::cerr << "error: All specified headers have been rejected" << std::endl;
return EXIT_FAILURE;
}
QString targetName = parsedArgs.value("target-name").toString();
if (parser.unparsedArguments().count() == 1)
{
if (targetName.isEmpty())
{
QFileInfo fileInfo(parser.unparsedArguments().value(0));
targetName = fileInfo.baseName();
}
}
else
{
if (targetName.isEmpty())
{
std::cerr << "error: Target name hasn't been specified" << std::endl;
printHelpUsage();
return EXIT_FAILURE;
}
}
wrapper.setTargetName(targetName);
wrapper.generateOutputs();
return EXIT_SUCCESS;
}
RideImportWizard::RideImportWizard(RideAutoImportConfig *dirs, Context *context, QWidget *parent) : QDialog(parent), context(context), importConfig(dirs)
{
autoImportMode = true;
QList<QString> files;
// get the directories
QList<RideAutoImportRule> rules = importConfig->getConfig();
// prepare the widget to show the status of the directory
directoryWidget = new QTableWidget(rules.count(), 3, this);
directoryWidget->verticalHeader()->setDefaultSectionSize(20);
QTableWidgetItem *directoryHeading = new QTableWidgetItem;
directoryHeading->setText(tr("Directory"));
directoryWidget->setHorizontalHeaderItem(0, directoryHeading);
QTableWidgetItem *importRuleHeading = new QTableWidgetItem;
importRuleHeading->setText(tr("Import Rule"));
directoryWidget->setHorizontalHeaderItem(1, importRuleHeading);
QTableWidgetItem *statusHeading = new QTableWidgetItem;
statusHeading->setText(tr("Directory Status"));
directoryWidget->setHorizontalHeaderItem(2, statusHeading);
// and get the allowed files formats
const RideFileFactory &rff = RideFileFactory::instance();
QStringList suffixList = rff.suffixes();
suffixList.replaceInStrings(QRegExp("^"), "*.");
QStringList allFormats;
foreach(QString suffix, rff.suffixes())
allFormats << QString("*.%1").arg(suffix);
// Fill in the directory names and importRuleStatus
int i=-1;
foreach (RideAutoImportRule rule, rules){
i++; // do it here to allow "continue" - and start with "0"
QTableWidgetItem *t;
// Directory
t = new QTableWidgetItem();
t->setText(rule.getDirectory());
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
directoryWidget->setItem(i,0,t);
// Import Rule
QList<QString> descriptions = rule.getRuleDescriptions();
t = new QTableWidgetItem();
t->setText(descriptions.at(rule.getImportRule()));
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
directoryWidget->setItem(i,1,t);
// Import Status
t = new QTableWidgetItem();
t->setText(tr(""));
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
directoryWidget->setItem(i,2,t);
// only add files if configured to do so
if (rule.getImportRule() == 0) {
directoryWidget->item(i,2)->setText(tr("No import"));
continue;
}
// do some checks on the directory first
QString currentImportDirectory = rule.getDirectory();
if (currentImportDirectory == "") {
directoryWidget->item(i,2)->setText(tr("No directory"));
continue;
}
QDir *importDir = new QDir (currentImportDirectory);
if (!importDir->exists()) { // directory might not be available (USB,..)
directoryWidget->item(i,2)->setText(tr("Directory not available"));
continue;
}
if (!importDir->isReadable()) {
directoryWidget->item(i,2)->setText(tr("Directory not readable"));
continue;
}
// now get the files with their full names
QFileInfoList fileInfos = importDir->entryInfoList(allFormats, QDir::Files, QDir::NoSort);
if (!fileInfos.isEmpty()) {
int j = 0;
foreach(QFileInfo f, fileInfos) {
files.append(f.absoluteFilePath());
j++;
}
void ZFileOpenDialog::CargarBrowser(QString direccion)
{
browser->clear();
QDir dir ( direccion, "*" );
sPath = direccion;
dir.setMatchAllDirs ( true );
dir.setFilter ( QDir::Dirs | QDir::Hidden );
if ( !dir.isReadable() )
return;
QStringList entries = dir.entryList();
entries.sort();
QStringList::ConstIterator it = entries.begin();
QPixmap pixmap;
if ( (sPath != "") && (sPath != "/") && (sPath != "//") )
{
pixmap=QPixmap( iconReader2.getIcon("gen_back_to_arrw_thb", false) );
if ( pixmap.height() > 19 ) { QImage image; image = pixmap.convertToImage();
image = image.smoothScale( 19, 19 ); pixmap.convertFromImage(image); }
ZListBoxItem* Item;
Item = new ZListBoxItem ( browser, QString ( "%I%M" ) );
Item->setPixmap ( 0, pixmap ); Item->appendSubItem ( 1, "..", false, NULL );
browser->insertItem ( Item,-1,true );
}
while ( it != entries.end() ) {
if ( ( *it != "." ) && ( *it != ".." ) )
{
pixmap=QPixmap( iconReader2.getIcon("fm_folder_small", false) );
if ( pixmap.height() > 19 ) { QImage image; image = pixmap.convertToImage();
image = image.smoothScale( 19, 19 ); pixmap.convertFromImage(image); }
ZListBoxItem* Item;
Item = new ZListBoxItem ( browser, QString ( "%I%M" ) );
Item->setPixmap ( 0, pixmap );
Item->appendSubItem ( 1, *it, false, NULL );
browser->insertItem ( Item,-1,true );
}
++it;
}
dir.setFilter ( QDir::Files | QDir::Hidden );
entries = dir.entryList();
entries.sort();
it = entries.begin();
while ( it != entries.end() ) {
pixmap=QPixmap( iconReader2.getIcon("msg_receipt_request_small", false) );
if ( pixmap.height() > 19 ) { QImage image; image = pixmap.convertToImage();
image = image.smoothScale( 19, 19 ); pixmap.convertFromImage(image); }
ZListBoxItem* Item;
Item = new ZListBoxItem ( browser, QString ( "%I%M" ) );
Item->setPixmap ( 0, pixmap );
Item->appendSubItem ( 1, *it, false, NULL );
browser->insertItem ( Item,-1,true );
++it;
}
}
