bool saveState( TQSessionManager&sm) {
TQStringList restartCommand = sm.restartCommand();
if (has_noxft)
restartCommand.append("--noxft");
if (login_shell)
restartCommand.append("--ls");
if (full_script)
restartCommand.append("--script");
if (!auto_close)
restartCommand.append("--noclose");
if (fixed_size)
restartCommand.append("--noresize");
sm.setRestartCommand(restartCommand);
return true;
}
TQStringList IconThemesConfig::findThemeDirs(const TQString &archiveName)
{
TQStringList foundThemes;
KTar archive(archiveName);
archive.open(IO_ReadOnly);
const KArchiveDirectory* themeDir = archive.directory();
KArchiveEntry* possibleDir = 0L;
KArchiveDirectory* subDir = 0L;
// iterate all the dirs looking for an index.theme or index.desktop file
TQStringList entries = themeDir->entries();
for (TQStringList::Iterator it = entries.begin();
it != entries.end();
++it) {
possibleDir = const_cast<KArchiveEntry*>(themeDir->entry(*it));
if (possibleDir->isDirectory()) {
subDir = dynamic_cast<KArchiveDirectory*>( possibleDir );
if (subDir && (subDir->entry("index.theme") != NULL ||
subDir->entry("index.desktop") != NULL))
foundThemes.append(subDir->name());
}
}
archive.close();
return foundThemes;
}
uint CpuConfig::addCpus()
{
#ifdef Q_OS_LINUX
TQStringList output;
TQString parser;
TQFile file("/proc/stat");
if (!file.open(IO_ReadOnly))
return 0;
// Parse the proc file
TQTextStream procStream(&file);
while (!procStream.atEnd()) {
parser = procStream.readLine();
if (TQRegExp("cpu").search(parser, 0) != -1
&& TQRegExp("cpu0").search(parser, 0) == -1) {
output.append(parser);
}
}
return output.count();
#endif
#ifdef Q_OS_BSD4
int mib[] = { CTL_HW, HW_NCPU }; // hw.ncpu
uint cpu;
size_t cpuLen = sizeof(cpu);
if (sysctl(mib, 2, &cpu, &cpuLen, NULL, 0) < 0)
return 0;
return cpu;
#endif
}
/**
* @internal
* Returns a list of certificates as QStrings read from the given file
*/
static TQStringList caReadCerticatesFromFile(TQString filename) {
TQStringList certificates;
TQString certificate, temp;
TQFile file(filename);
if (!file.open(IO_ReadOnly))
return certificates;
while (!file.atEnd()) {
file.readLine(temp, 999);
if (temp.startsWith("-----BEGIN CERTIFICATE-----")) {
certificate = TQString::null;
continue;
}
if (temp.startsWith("-----END CERTIFICATE-----")) {
certificates.append(certificate);
certificate = TQString::null;
continue;
}
certificate += temp.stripWhiteSpace();
}
file.close();
return certificates;
}
TQStringList KURIFilter::pluginNames() const
{
TQStringList list;
for(TQPtrListIterator<KURIFilterPlugin> i = pluginsIterator(); *i; ++i)
list.append((*i)->name());
return list;
}
KPaletteTable::KPaletteTable( TQWidget *parent, int minWidth, int cols)
: TQWidget( parent ), cells(0), mPalette(0), mMinWidth(minWidth), mCols(cols)
{
d = new KPaletteTablePrivate;
i18n_namedColors = i18n("Named Colors");
TQStringList diskPaletteList = KPalette::getPaletteList();
TQStringList paletteList;
// We must replace the untranslated file names by translate names (of course only for KDE's standard palettes)
for ( int i = 0; colorPaletteName[i].m_fileName; ++i )
{
diskPaletteList.remove( colorPaletteName[i].m_fileName );
paletteList.append( i18n( "palette name", colorPaletteName[i].m_displayName ) );
}
paletteList += diskPaletteList;
paletteList.append( i18n_namedColors );
TQVBoxLayout *layout = new TQVBoxLayout( this );
combo = new TQComboBox( false, this );
combo->insertStringList( paletteList );
layout->addWidget(combo);
sv = new TQScrollView( this );
TQSize cellSize = TQSize( mMinWidth, 120);
sv->setHScrollBarMode( TQScrollView::AlwaysOff);
sv->setVScrollBarMode( TQScrollView::AlwaysOn);
TQSize minSize = TQSize(sv->verticalScrollBar()->width(), 0);
minSize += TQSize(sv->frameWidth(), 0);
minSize += TQSize(cellSize);
sv->setFixedSize(minSize);
layout->addWidget(sv);
mNamedColorList = new TDEListBox( this, "namedColorList", 0 );
mNamedColorList->setFixedSize(minSize);
mNamedColorList->hide();
layout->addWidget(mNamedColorList);
connect( mNamedColorList, TQT_SIGNAL(highlighted( const TQString & )),
this, TQT_SLOT( slotColorTextSelected( const TQString & )) );
setFixedSize( sizeHint());
connect( combo, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotSetPalette( const TQString &)));
}
void SevenZipArch::addDir( const TQString & dirName )
{
if ( !dirName.isEmpty() )
{
TQStringList list;
list.append( dirName );
addFile( list );
}
}
void KSim::MemoryPrefs::saveConfig(KSim::Config *config)
{
config->setMemoryItem(m_memCombo->currentItem());
config->setShowMemory(m_memCheck->isChecked());
TQStringList comboItems;
for (int i = 0; i < m_memCombo->count(); i++)
comboItems.append(m_memCombo->text(i));
config->setMemoryFormat(comboItems);
}
TQStringList KIMProxy::onlineContacts()
{
TQStringList value;
PresenceStringMap::iterator it = d->presence_map.begin();
const PresenceStringMap::iterator end= d->presence_map.end();
for ( ; it != end; ++it )
if ( it.data().best().presence > 2 /*Better than Connecting, ie Away or Online*/ )
value.append( it.key() );
return value;
}
void KSim::UptimePrefs::saveConfig(KSim::Config *config)
{
config->setUptimeItem(m_uptimeCombo->currentItem());
config->setShowUptime(m_uptimeCheck->isChecked());
TQStringList comboItems;
for (int i = 0; i < m_uptimeCombo->count(); i++)
comboItems.append(m_uptimeCombo->text(i));
config->setUptimeFormat(comboItems);
}
// static
TQStringList FileProps::createKeyValueList( const KFileMetaInfoGroup& g,
const TQStringList& keys )
{
TQStringList result;
TQStringList::ConstIterator it = keys.begin();
for ( ; it != keys.end(); ++it )
result.append( FileProps::createKeyValue( g, *it ) );
return result;
}
void KSim::SwapPrefs::saveConfig(KSim::Config *config)
{
config->setSwapItem(m_swapCombo->currentItem());
TQStringList comboItems;
for (int i = 0; i < m_swapCombo->count(); i++)
comboItems.append(m_swapCombo->text(i));
config->setSwapFormat(comboItems);
config->setShowSwap(m_swapCheck->isChecked());
}
TQString TDEStorageDevice::determineFileSystemType(TQString path) {
TQStringList mountTable;
TQString prevPath = path;
dev_t prevDev = 0;
int pos;
struct stat directory_info;
if (path.startsWith("/")) {
stat(path.local8Bit(), &directory_info);
prevDev = directory_info.st_dev;
// Walk the directory tree up to the root, checking for any change in st_dev
// If a change is found, the previous value of path is the mount point itself
while (path != "/") {
pos = path.findRev("/", -1, TRUE);
if (pos < 0) {
break;
}
path = path.mid(0, pos);
if (path == "") {
path = "/";
}
stat(path.local8Bit(), &directory_info);
if (directory_info.st_dev != prevDev) {
break;
}
prevPath = path;
prevDev = directory_info.st_dev;
}
}
// Read in mount table
mountTable.clear();
TQFile file( "/proc/mounts" );
if ( file.open( IO_ReadOnly ) ) {
TQTextStream stream( &file );
while ( !stream.atEnd() ) {
mountTable.append(stream.readLine());
}
file.close();
}
// Parse mount table
TQStringList::Iterator it;
for ( it = mountTable.begin(); it != mountTable.end(); ++it ) {
TQStringList mountInfo = TQStringList::split(" ", (*it), true);
if ((*mountInfo.at(1)) == prevPath) {
return (*mountInfo.at(2));
}
}
// Unknown file system type
return TQString::null;
}
TQStringList HSpellDict::suggest( const TQString& word )
{
TQStringList qsug;
struct corlist cl;
int n_sugg;
corlist_init( &cl );
hspell_trycorrect( m_speller, codec->fromUnicode( word ), &cl );
for( n_sugg = 0; n_sugg < corlist_n( &cl ); n_sugg++){
qsug.append( codec->toUnicode( corlist_str( &cl, n_sugg) ) );
}
corlist_free( &cl );
return qsug;
}
//*******************************************************
// Static utility functions
//*******************************************************
static void save_pattern(TQComboBox *obj,
const TQString & group, const TQString & entry)
{
// TQComboBox allows insertion of items more than specified by
// maxCount() (QT bug?). This API call will truncate list if needed.
obj->setMaxCount(15);
// make sure the current item is saved first so it will be the
// default when started next time
TQStringList sl;
TQString cur = obj->currentText();
sl.append(cur);
for (int i = 0; i < obj->count(); i++) {
if( cur != obj->text(i) ) {
sl.append(obj->text(i));
}
}
TDEConfig *conf = TDEGlobal::config();
conf->setGroup(group);
conf->writePathEntry(entry, sl);
}
void ZipArch::addDir( const TQString & _dirName )
{
if ( !_dirName.isEmpty() )
{
bool bOldRecVal = ArkSettings::rarRecurseSubdirs();
// must be true for add directory - otherwise why would user try?
ArkSettings::setRarRecurseSubdirs( true );
TQStringList list;
list.append( _dirName );
addFile( list );
ArkSettings::setRarRecurseSubdirs( bOldRecVal ); // reset to old val
}
}
TQStringList FileProps::availableKeys( const TQString& group ) const
{
KFileMetaInfoGroup g = m_info->group( group );
TQStringList allKeys = g.keys();
TQStringList ret;
TQStringList::ConstIterator it = allKeys.begin();
for ( ; it != allKeys.end(); ++it )
{
if ( g.item( *it ).isValid() )
ret.append( *it );
}
return ret;
}
/* pretty simple algorithm - reads the layout file and
tries to find "xkb_symbols"
also checks whether previous line contains "hidden" to skip it
*/
TQStringList*
X11Helper::getVariants(const TQString& layout, const TQString& x11Dir, bool oldLayouts)
{
TQStringList* result = new TQStringList();
TQString file = x11Dir + "xkb/symbols/";
// workaround for XFree 4.3 new directory for one-group layouts
if( TQDir(file+"pc").exists() && !oldLayouts )
file += "pc/";
file += layout;
// kdDebug() << "reading variants from " << file << endl;
TQFile f(file);
if (f.open(IO_ReadOnly))
{
TQTextStream ts(&f);
TQString line;
TQString prev_line;
while (!ts.eof()) {
prev_line = line;
line = ts.readLine().simplifyWhiteSpace();
if (line[0] == '#' || line.left(2) == "//" || line.isEmpty())
continue;
int pos = line.find("xkb_symbols");
if (pos < 0)
continue;
if( prev_line.find("hidden") >=0 )
continue;
pos = line.find('"', pos) + 1;
int pos2 = line.find('"', pos);
if( pos < 0 || pos2 < 0 )
continue;
result->append(line.mid(pos, pos2-pos));
// kdDebug() << "adding variant " << line.mid(pos, pos2-pos) << endl;
}
f.close();
}
return result;
}
void CpuConfig::saveConfig()
{
config()->setGroup("CpuPlugin");
int cpuNum = 0;
TQStringList enabledCpus;
for (TQListViewItemIterator it(m_listView); it.current(); ++it) {
config()->writeEntry(CPU_NAME(cpuNum), it.current()->text(1));
if (static_cast<TQCheckListItem *>(it.current())->isOn())
enabledCpus.append(it.current()->text(0));
++cpuNum;
}
config()->writeEntry("Cpus", enabledCpus);
}
TQStringList readAreaList()
{
TQStringList lst;
lst.append( "0 (generic)" );
TQString confAreasFile = locate( "config", "kdebug.areas" );
TQFile file( confAreasFile );
if (!file.open(IO_ReadOnly)) {
kdWarning() << "Couldn't open " << confAreasFile << endl;
file.close();
}
else
{
TQString data;
TQTextStream *ts = new TQTextStream(&file);
ts->setEncoding( TQTextStream::Latin1 );
while (!ts->eof()) {
data = ts->readLine().simplifyWhiteSpace();
int pos = data.find("#");
if ( pos != -1 )
data.truncate( pos );
if (data.isEmpty())
continue;
lst.append( data );
}
delete ts;
file.close();
}
return lst;
}
void KateFileSelector::writeConfig(TDEConfig *config, const TQString & name)
{
dir->writeConfig(config,name + ":dir");
config->setGroup( name );
config->writeEntry( "pathcombo history len", cmbPath->maxItems() );
TQStringList l;
for (int i = 0; i < cmbPath->count(); i++) {
l.append( cmbPath->text( i ) );
}
config->writePathEntry( "dir history", l );
config->writePathEntry( "location", cmbPath->currentText() );
config->writeEntry( "filter history len", filter->maxCount() );
config->writeEntry( "filter history", filter->historyItems() );
config->writeEntry( "current filter", filter->currentText() );
config->writeEntry( "last filter", lastFilter );
config->writeEntry( "AutoSyncEvents", autoSyncEvents );
}
//
// Insertion and removal routines
//
TQString KStringHandler::insword( const TQString &text , const TQString &word , uint pos )
{
if ( text.isEmpty() )
return word;
if ( word.isEmpty() )
return text;
// Split words and add into list
TQStringList list = TQStringList::split( " ", text, true );
if ( pos >= list.count() )
list.append( word );
else
list.insert( list.at(pos) , word );
// Rejoin
return list.join( " " );
}
void ExtensionManager::saveContainerConfig()
{
// kdDebug(1210) << "ExtensionManager::saveContainerConfig()" << endl;
TDEConfig *config = TDEGlobal::config();
// build the extension list
TQStringList elist;
ExtensionList::iterator itEnd = _containers.end();
for (ExtensionList::iterator it = _containers.begin(); it != itEnd; ++it)
{
elist.append((*it)->extensionId());
}
// write extension list
config->setGroup("General");
config->writeEntry("Extensions2", elist);
config->sync();
}
TQStringList KSSLD::getKDEKeyByEmail(const TQString &email) {
TQStringList rc;
TQMap<TQString, TQPtrVector<KSSLCertificate> >::iterator it = skEmail.find(email.lower());
kdDebug() << "GETKDEKey " << email.latin1() << endl;
if (it == skEmail.end())
return rc;
TQPtrVector<KSSLCertificate> &elem = *it;
for (unsigned int n = 0; n < elem.size(); n++) {
KSSLCertificate *cert = elem.at(n);
if (cert) {
rc.append(cert->getKDEKey());
}
}
kdDebug() << "ergebnisse: " << rc.size() << " " << elem.size() << endl;
return rc;
}
TQStringList TDECompletion::substringCompletion( const TQString& string ) const
{
// get all items in the tree, possibly in sorted order
bool sorted = (myOrder == Weighted);
TDECompletionMatchesWrapper allItems( sorted );
extractStringsFromNode( myTreeRoot, TQString::null, &allItems, false );
TQStringList list = allItems.list();
// subStringMatches is invoked manually, via a shortcut, so we should
// beep here, if necessary.
if ( list.isEmpty() ) {
doBeep( NoMatch );
return list;
}
if ( string.isEmpty() ) { // shortcut
postProcessMatches( &list );
return list;
}
TQStringList matches;
TQStringList::ConstIterator it = list.begin();
for( ; it != list.end(); ++it ) {
TQString item = *it;
if ( item.find( string, 0, false ) != -1 ) { // always case insensitive
matches.append( item );
}
}
postProcessMatches( &matches );
if ( matches.isEmpty() )
doBeep( NoMatch );
return matches;
}
TQStringList TDERecentDocument::recentDocuments()
{
TQDir d(recentDocumentDirectory(), "*.desktop", TQDir::Time,
TQDir::Files | TQDir::Readable | TQDir::Hidden);
if (!d.exists())
d.mkdir(recentDocumentDirectory());
TQStringList list = d.entryList();
TQStringList fullList;
for (TQStringList::ConstIterator it = list.begin(); it != list.end(); ++it) {
TQString pathDesktop = d.absFilePath( *it );
KDesktopFile tmpDesktopFile( pathDesktop, false);
KURL urlDesktopFile(tmpDesktopFile.readURL());
if( urlDesktopFile.isLocalFile() && !TQFile(urlDesktopFile.path()).exists())
d.remove(pathDesktop);
else
fullList.append( pathDesktop );
}
return fullList;
}
TQString KXEventUtil::getXConfigureRequestEventInfo(XEvent *xevent) {
XConfigureRequestEvent *e = &xevent->xconfigurerequest;
unsigned vm = e->value_mask;
TQStringList vml;
if (vm & CWX) vml.append("CWX");
if (vm & CWY) vml.append("CWY");
if (vm & CWWidth) vml.append("CWWidth");
if (vm & CWHeight) vml.append("CWHeight");
if (vm & CWBorderWidth) vml.append("CWBorderWidth");
if (vm & CWSibling) vml.append("CWSibling");
if (vm & CWStackMode) vml.append("CWStackMode");
TQString vms = vml.join("|");
TQString s("window=%1 x=%2 y=%2 width=%3 height=%4 border_width=%5 above=%6 detail=%7 value_mask=0x%8=%9");
return
s.arg(e->window)
.arg(e->x).arg(e->y)
.arg(e->width).arg(e->height)
.arg(e->border_width)
.arg(e->above)
.arg(e->detail)
.arg(e->value_mask, 0, 16)
.arg(vms);
}
void Security::slotSignFile()
{
if (!m_keysRead || m_gpgRunning)
{
TQTimer::singleShot(5, this, TQT_SLOT(slotSignFile()));
return;
}
TQStringList secretKeys;
for (TQMap<TQString, KeyStruct>::Iterator it = m_keys.begin(); it != m_keys.end(); ++it)
{
if (it.data().secret)
secretKeys.append(it.key());
}
if (secretKeys.count() == 0)
{
emit fileSigned(-1);
return;
}
m_result = 0;
TQFileInfo f(m_fileName);
//create the MD5 sum
TQString md5sum;
const char* c = "";
KMD5 context(c);
TQFile file(m_fileName);
if (file.open(IO_ReadOnly))
{
context.reset();
context.update(TQT_TQIODEVICE_OBJECT(file));
md5sum = context.hexDigest();
file.close();
}
file.setName(f.dirPath() + "/md5sum");
if (file.open(IO_WriteOnly))
{
TQTextStream stream(&file);
stream << md5sum;
m_result |= MD5_OK;
file.close();
}
if (secretKeys.count() > 1)
{
bool ok;
secretKeys = KInputDialog::getItemList(i18n("Select Signing Key"), i18n("Key used for signing:"), secretKeys, secretKeys[0], false, &ok);
if (ok)
m_secretKey = secretKeys[0];
else
{
emit fileSigned(0);
return;
}
} else
m_secretKey = secretKeys[0];
//verify the signature
KProcIO *signProcess=new KProcIO();
*signProcess<<"gpg"<<"--no-secmem-warning"<<"--status-fd=2"<<"--command-fd=0"<<"--no-tty"<<"--detach-sign" << "-u" << m_secretKey << "-o" << f.dirPath() + "/signature" << m_fileName;
connect(signProcess, TQT_SIGNAL(processExited(TDEProcess *)),this, TQT_SLOT(slotProcessExited(TDEProcess *)));
connect(signProcess, TQT_SIGNAL(readReady(KProcIO *)),this, TQT_SLOT(slotDataArrived(KProcIO *)));
m_runMode = Sign;
if (signProcess->start(TDEProcess::NotifyOnExit,true))
m_gpgRunning = true;
else
{
KMessageBox::error(0L, i18n("<qt>Cannot start <i>gpg</i> and sign the file. Make sure that <i>gpg</i> is installed, otherwise signing of the resources will not be possible.</qt>"));
emit fileSigned(0);
delete signProcess;
}
}
TQString TDEStorageDevice::mountDevice(TQString mediaName, TDEStorageMountOptions mountOptions, TQString* errRet, int* retcode) {
int internal_retcode;
if (!retcode) {
retcode = &internal_retcode;
}
TQString ret = mountPath();
// Device is already mounted
if (!ret.isNull()) {
return ret;
}
TQString command;
TQString devNode = deviceNode();
devNode.replace("'", "'\\''");
mediaName.replace("'", "'\\''");
#if defined(WITH_UDISKS2) || defined(WITH_UDISKS)
// Prepare filesystem options for mount
TQStringList udisksOptions;
TQString optionString;
if (mountOptions["ro"] == "true") {
udisksOptions.append("ro");
}
if (mountOptions["atime"] != "true") {
udisksOptions.append("noatime");
}
if (mountOptions["sync"] == "true") {
udisksOptions.append("sync");
}
if( (mountOptions["filesystem"] == "fat")
|| (mountOptions["filesystem"] == "vfat")
|| (mountOptions["filesystem"] == "msdos")
|| (mountOptions["filesystem"] == "umsdos")
) {
if (mountOptions.contains("shortname")) {
udisksOptions.append(TQString("shortname=%1").arg(mountOptions["shortname"]));
}
}
if( (mountOptions["filesystem"] == "jfs")) {
if (mountOptions["utf8"] == "true") {
// udisks/udisks2 for now does not support option iocharset= for jfs
// udisksOptions.append("iocharset=utf8");
}
}
if( (mountOptions["filesystem"] == "ntfs-3g") ) {
if (mountOptions.contains("locale")) {
udisksOptions.append(TQString("locale=%1").arg(mountOptions["locale"]));
}
}
if( (mountOptions["filesystem"] == "ext3")
|| (mountOptions["filesystem"] == "ext4")
) {
if (mountOptions.contains("journaling")) {
// udisks/udisks2 for now does not support option data= for ext3/ext4
// udisksOptions.append(TQString("data=%1").arg(mountOptions["journaling"]));
}
}
for (TQStringList::Iterator it = udisksOptions.begin(); it != udisksOptions.end(); ++it) {
optionString.append(",");
optionString.append(*it);
}
if (!optionString.isEmpty()) {
optionString.remove(0, 1);
}
#endif // defined(WITH_UDISKS2) || defined(WITH_UDISKS)
#ifdef WITH_UDISKS2
if(command.isEmpty()) {
// Try to use UDISKS v2 via DBUS, if available
TQString errorString;
TQString fileSystemType;
if (mountOptions.contains("filesystem") && !mountOptions["filesystem"].isEmpty()) {
fileSystemType = mountOptions["filesystem"];
}
int uDisks2Ret = mountDriveUDisks2(devNode, fileSystemType, optionString, &errorString);
if (uDisks2Ret == 0) {
// Update internal mount data
TDEGlobal::hardwareDevices()->processModifiedMounts();
ret = mountPath();
return ret;
}
else if (uDisks2Ret == -1) {
if (errRet) {
*errRet = errorString;
}
// Update internal mount data
TDEGlobal::hardwareDevices()->processModifiedMounts();
ret = mountPath();
return ret;
}
else {
// The UDISKS v2 DBUS service was either not available or was unusable; try another method...
command = TQString::null;
}
}
#endif // WITH_UDISKS2
#ifdef WITH_UDISKS
if(command.isEmpty()) {
// Try to use UDISKS v1 via DBUS, if available
TQString errorString;
TQString fileSystemType;
if (mountOptions.contains("filesystem") && !mountOptions["filesystem"].isEmpty()) {
fileSystemType = mountOptions["filesystem"];
}
int uDisksRet = mountDriveUDisks(devNode, fileSystemType, udisksOptions, &errorString);
if (uDisksRet == 0) {
// Update internal mount data
TDEGlobal::hardwareDevices()->processModifiedMounts();
ret = mountPath();
return ret;
}
else if (uDisksRet == -1) {
if (errRet) {
*errRet = errorString;
}
// Update internal mount data
TDEGlobal::hardwareDevices()->processModifiedMounts();
ret = mountPath();
return ret;
}
else {
// The UDISKS v1 DBUS service was either not available or was unusable; try another method...
command = TQString::null;
}
}
#endif // WITH_UDISKS
if(command.isEmpty()) {
// Use 'pmount' command, if available
TQString pmountProg = TDEGlobal::dirs()->findExe("pmount");
if (!pmountProg.isEmpty()) {
// Create dummy password file
KTempFile passwordFile(TQString::null, "tmp", 0600);
passwordFile.setAutoDelete(true);
TQString optionString;
if (mountOptions["ro"] == "true") {
optionString.append(" -r");
}
if (mountOptions["atime"] != "true") {
optionString.append(" -A");
}
if (mountOptions["utf8"] == "true") {
optionString.append(" -c utf8");
}
if (mountOptions["sync"] == "true") {
optionString.append(" -s");
}
if (mountOptions.contains("filesystem") && !mountOptions["filesystem"].isEmpty()) {
optionString.append(TQString(" -t %1").arg(mountOptions["filesystem"]));
}
if (mountOptions.contains("locale")) {
optionString.append(TQString(" -c %1").arg(mountOptions["locale"]));
}
TQString passFileName = passwordFile.name();
passFileName.replace("'", "'\\''");
command = TQString("pmount -p '%1' %2 '%3' '%4' 2>&1").arg(passFileName).arg(optionString).arg(devNode).arg(mediaName);
}
}
if(command.isEmpty()) {
if (errRet) {
*errRet = i18n("No supported mounting methods were detected on your system");
}
return ret;
}
FILE *exepipe = popen(command.local8Bit(), "r");
if (exepipe) {
TQString mount_output;
TQTextStream ts(exepipe, IO_ReadOnly);
mount_output = ts.read();
*retcode = pclose(exepipe);
if (errRet) {
*errRet = mount_output;
}
}
// Update internal mount data
TDEGlobal::hardwareDevices()->processModifiedMounts();
ret = mountPath();
return ret;
}
int main( int argc, char **argv )
{
TDEAboutData about(
"tdefile", I18N_NOOP( "tdefile" ), TDEFILEVERSION,
I18N_NOOP("A commandline tool to read and modify metadata of files." ),
TDEAboutData::License_LGPL, "(c) 2002, Carsten Pfeiffer",
0 /*text*/, "http://devel-home.kde.org/~pfeiffer/",
"*****@*****.**" );
about.addAuthor( "Carsten Pfeiffer", 0, "*****@*****.**",
"http://devel-home.kde.org/~pfeiffer/" );
TDECmdLineArgs::init( argc, argv, &about );
TDECmdLineArgs::addCmdLineOptions( options );
TDECmdLineArgs *args = TDECmdLineArgs::parsedArgs();
bool useGUI = args->isSet( "dialog" );
TDEApplication app( useGUI, useGUI );
TQPtrList<FileProps> m_props;
m_props.setAutoDelete( true );
bool quiet = args->isSet( "quiet" );
if ( args->isSet( "supportedMimetypes" ) )
printSupportedMimeTypes();
int files = args->count();
if ( files == 0 )
TDECmdLineArgs::usage( i18n("No files specified") ); // exit()s
if ( args->isSet( "dialog" ) )
{
showPropertiesDialog( args );
return true;
}
TQStringList groupsToUse;
QCStringList suppliedGroups = args->getOptionList( "groups" );
QCStringList::ConstIterator it = suppliedGroups.begin();
for ( ; it != suppliedGroups.end(); ++it )
groupsToUse.append( TQString::fromLocal8Bit( (*it) ) );
TQString mimeType;
for ( int i = 0; i < files; i++ )
{
if ( args->isSet( "mimetype" ) )
printMimeTypes( args );
FileProps *props = new FileProps( args->url(i).path(), groupsToUse );
if ( props->isValid() )
m_props.append( props );
else
{
if ( !quiet )
{
cerr << args->arg(i) << ": " <<
i18n("Cannot determine metadata").local8Bit().data() << endl;
}
delete props;
}
}
processMetaDataOptions( m_props, args );
m_props.clear(); // force destruction/sync of props
cout.flush();
return 0;
}