config.cpp

Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3.10平台上编译为嵌入式图形界面操作系统。

    return cipher;
}

static QString decipher(const QString& cipher)
{
    QString plain;
    int mix=28730492;
    for (int i=0; i<(int)cipher.length();) {
	int l = cipher[i].unicode()-'a';
	QString x = cipher.mid(i+1,l); i+=l+1;
	int u = x.toInt(0,36) ^ mix;
	plain.append(QChar(u));
	mix *= u;
    }
    return plain;
}

/*!
  Writes a weakly encrypted (\a key, \a value) entry to the current group.

  Note that the degree of protection offered by the encryption is
  only sufficient to avoid the most casual observation of the configuration
  files.

  \sa readEntryCrypt()
*/
void Config::writeEntryCrypt( const QString &key, const QString &value )
{
    if ( git == groups.end() ) {
	qWarning( "no group set" );
	return;
    }
    QString evalue = encipher(value);
    if ( (*git)[key] != evalue ) {
	( *git ).insert( key, evalue );
	changed = TRUE;
    }
}

/*!
  Writes a (\a key, \a num) entry to the current group.

  \sa readNumEntry() readBoolEntry()
*/
void Config::writeEntry( const QString &key, int num )
{
    QString s;
    s.setNum( num );
    writeEntry( key, s );
}

#ifdef Q_HAS_BOOL_TYPE
/*!
  Writes a (\a key, \a b) entry to the current group. This is equivalent
  to writing a 0 or 1 as an integer entry.

  \sa readBoolEntry()
*/
void Config::writeEntry( const QString &key, bool b )
{
    QString s;
    s.setNum( ( int )b );
    writeEntry( key, s );
}
#endif

/*!
  Writes a (\a key, \a lst) entry to the current group. The list is
  separated by \a sep, so the strings must not contain that character.

  \sa readListEntry()
*/
void Config::writeEntry( const QString &key, const QStringList &lst, const QChar &sep )
{
    QString s;
    QStringList::ConstIterator it = lst.begin();
    for ( ; it != lst.end(); ++it )
	s += *it + sep;
    writeEntry( key, s );
}

/*!
  Removes the \a key entry from the current group. Does nothing if
  there is no such entry.

  \sa writeEntry() clearGroup()
*/

void Config::removeEntry( const QString &key )
{
    if ( git == groups.end() ) {
	qWarning( "no group set" );
	return;
    }
    ( *git ).remove( key );
    changed = TRUE;
}

/*!
  \fn bool Config::operator == ( const Config & other ) const

  Tests for equality with \a other. Config objects are equal if they
  refer to the same filename.

  \sa operator!=()
*/

/*!
  \fn bool Config::operator != ( const Config & other ) const

  Tests for inequality with \a other. Config objects are equal if they
  refer to the same filename.

  \sa operator==()
*/

/*!
  \fn QString Config::readEntry( const QString &key, const QString &deflt ) const

  Returns the string entry for \a key, defaulting to \a deflt if there
  is no entry for the given \a key.

  \sa writeEntry()
*/

/*!
  \internal
  For compatibility, non-const version.
*/
QString Config::readEntry( const QString &key, const QString &deflt )
{
    QString r;
    if ( d && !d->trcontext.isNull() ) {
	// Still try untranslated first, becuase:
	//  1. It's the common case
	//  2. That way the value can be WRITTEN (becoming untranslated)
	r = readEntryDirect( key );
	if ( !r.isNull() )
	    return r;
	r = readEntryDirect( key + "[]" );
	if ( !r.isNull() )
	    return LocalTranslator::translate(d->trfile,d->trcontext,r);
    } else if ( d && d->multilang ) {
	// For compatibilitity
	r = readEntryDirect( key + "["+lang+"]" );
	if ( !r.isNull() )
	    return r;
	if ( !glang.isEmpty() ) {
	    r = readEntryDirect( key + "["+glang+"]" );
	    if ( !r.isNull() )
		return r;
	}
    }
    r = readEntryDirect( key, deflt );
    return r;
}

/*!
  \fn QString Config::readEntryCrypt( const QString &key, const QString &deflt ) const

  Returns the unencrypted string entry for the encrypted entry stored
  using \a key, defaulting to \a deflt if there is no entry for the
  given \a key.

  \sa writeEntryCrypt()
*/

/*!
  \internal
  For compatibility, non-const version.
*/
QString Config::readEntryCrypt( const QString &key, const QString &deflt )
{
    QString res = readEntry( key );
    if ( res.isNull() )
	return deflt;
    return decipher(res);
}

/*!
  \fn QString Config::readEntryDirect( const QString &key, const QString &deflt ) const
  \internal
*/

/*!
  \internal
  For compatibility, non-const version.
*/
QString Config::readEntryDirect( const QString &key, const QString &deflt )
{
    if ( git == groups.end() ) {
	//qWarning( "no group set" );
	return deflt;
    }
    ConfigGroup::ConstIterator it = ( *git ).find( key );
    if ( it != ( *git ).end() )
	return *it;
    else
	return deflt;
}

/*!
  \fn int Config::readNumEntry( const QString &key, int deflt ) const

  Returns the integer entry stored using \a key, defaulting to \a
  deflt if there is no entry for the given \a key.

  \sa writeEntry()
*/

/*!
  \internal
  For compatibility, non-const version.
*/
int Config::readNumEntry( const QString &key, int deflt )
{
    QString s = readEntry( key );
    if ( s.isEmpty() )
	return deflt;
    else
	return s.toInt();
}

/*!
  \fn bool Config::readBoolEntry( const QString &key, bool deflt ) const

  Returns the boolean entry stored (as an integer) using \a key,
  defaulting to \a deflt if there is no entry for the given \a key.

  \sa writeEntry()
*/

/*!
  \internal
  For compatibility, non-const version.
*/
bool Config::readBoolEntry( const QString &key, bool deflt )
{
    QString s = readEntry( key );
    if ( s.isEmpty() )
	return deflt;
    else
	return (bool)s.toInt();
}

/*!
  \fn QStringList Config::readListEntry( const QString &key, const QChar &sep ) const

  Returns the string list entry stored using \a key and with \a sep as
  the separator.

  These entries are stored as a single string, with each element
  separated by \a sep.

  \sa writeEntry()
*/

/*!
  \internal
  For compatibility, non-const version.
*/
QStringList Config::readListEntry( const QString &key, const QChar &sep )
{
    QString s = readEntry( key );
    if ( s.isEmpty() )
	return QStringList();
    else
	return QStringList::split( sep, s );
}

/*!
  Removes all entries from the current group.

  \sa removeEntry() removeGroup()
*/
void Config::clearGroup()
{
    if ( git == groups.end() ) {
	qWarning( "no group set" );
	return;
    }
    if ( !(*git).isEmpty() ) {
	( *git ).clear();
	changed = TRUE;
    }
}

/*!
  \internal
*/
void Config::write( const QString &fn )
{
    QString strNewFile;
    if ( !fn.isEmpty() )
	filename = fn;
    strNewFile = qtopia_tempName( filename );
    QFile f( strNewFile );
    if ( !f.open( IO_WriteOnly|IO_Raw ) ) {
	qWarning( "could not open for writing `%s'", strNewFile.latin1() );
#ifndef QT_NO_COP
        //send this msg to make sure user is notified if it is
        //"out of disk space" problem
        QCopEnvelope e("QPE/System", "checkDiskSpace()");
#endif
	git = groups.end();
	return;
    }

    QString str;
    QCString cstr;
    QMap< QString, ConfigGroup >::Iterator g_it = groups.begin();

    for ( ; g_it != groups.end(); ++g_it ) {
 	str += "[" + g_it.key() + "]\n";
 	ConfigGroup::Iterator e_it = ( *g_it ).begin();
 	for ( ; e_it != ( *g_it ).end(); ++e_it )
 	    str += e_it.key() + " = " + *e_it + "\n";
    }
    cstr = str.utf8();

    int total_length;
    total_length = f.writeBlock( cstr.data(), cstr.length() );
    if ( total_length != int(cstr.length()) ) {
        QString msg = qApp->translate( "Config", "<qt>There was a problem creating "
				                "Configuration Information for this program."
						"<br>Please free up some space and try again.</qt>");
	qWarning( "unable to write configuration information" );
#ifndef QT_NO_COP
        QCopEnvelope e("QPE/System", "outOfDiskSpace(QString)");
        e << msg;
#endif
        f.close();
	QFile::remove( strNewFile );
	return;
    }

    f.close();
    qtopia_renameFile( strNewFile, filename );
#ifndef Q_OS_WIN32
    if (qpe_configCache)
	qpe_configCache->insert(filename, groups, d);
#endif
    changed = FALSE;
}

/*!
  Returns TRUE if the Config is in a valid state; otherwise returns
  FALSE.
*/
bool Config::isValid() const
{
    return groups.end() != git;
}

/*!
  \internal
*/
void Config::read()
{
    changed = FALSE;

    QString readFilename(filename);

    if ( !QFile::exists(filename) ) {
	bool failed = TRUE;
	QFileInfo fi(filename);
	QString settingsDir = QDir::homeDirPath() + "/Settings";
	if (fi.dirPath(TRUE) == settingsDir) {
	    // User setting - see if there is a default in $QPEDIR/etc/default/
	    QString dftlFile = QPEApplication::qpeDir() + "/etc/default/" + fi.fileName();
	    if (QFile::exists(dftlFile)) {
		readFilename = dftlFile;
		failed = FALSE;
	    }
	}
	if (failed) {
	    git = groups.end();
	    return;
	}
    }

#ifndef Q_OS_WIN32
    if (!qpe_configCache)
	qpe_configCache = new ConfigCache;

    if (qpe_configCache->find(readFilename, groups, d)) {
	if ( d && d->multilang ) {
	    QStringList l = Global::languageList();
	    lang = l[0];
	    glang = l[1];
	}
	git = groups.begin();
	return;
    }
#endif

    QFile f( readFilename );
    if ( !f.open( IO_ReadOnly ) ) {
	git = groups.end();
	return;
    }

    if (f.getch()!='[') {
	git = groups.end();
	return;
    }
    f.ungetch('[');

    QTextStream s( &f );
    read( s );
    f.close();

#ifndef Q_OS_WIN32
    qpe_configCache->insert(readFilename, groups, d);
#endif
}

/*!
  \internal
*/
bool Config::parse( const QString &l )
{
    QString line = l.stripWhiteSpace();
    if ( line[ 0 ] == QChar( '[' ) ) {
	QString gname = line;
	gname = gname.remove( 0, 1 );
	if ( gname[ (int)gname.length() - 1 ] == QChar( ']' ) )
	    gname = gname.remove( gname.length() - 1, 1 );
	git = groups.insert( gname, ConfigGroup() );
    } else if ( !line.isEmpty() ) {
	if ( git == groups.end() )
	    return FALSE;
	int eq = line.find( '=' );
	if ( eq == -1 )
	    return FALSE;
	QString key = line.left(eq).stripWhiteSpace();
	QString value = line.mid(eq+1).stripWhiteSpace();

	if ( git.key() == "Translation" ) {
	    if ( key == "File" ) {
		if ( !d )
		    d = new ConfigPrivate;
		d->trfile = value;
	    } else if ( key == "Context" ) {
		if ( !d )
		    d = new ConfigPrivate;
		d->trcontext = value.latin1();
            } else if ( key.startsWith("Comment") ) {
                return TRUE; // ignore comment for ts file
	    } else {
		return FALSE; // Unrecognized
	    }
	}

	int kl = key.length();
	if ( kl > 1 && key[kl-1] == ']' && key[kl-2] != '[' ) {
	    // Old-style translation (inefficient)
	    if ( !d )
		d = new ConfigPrivate;
	    if ( !d->multilang ) {
	        QStringList l = Global::languageList();
		lang = l[0];
		glang = l[1];
		d->multilang = TRUE;
	    }
	}

	( *git ).insert( key, value );
    }
    return TRUE;
}