config.cpp

天使工具,e6手机专用,大家都知道吧,狠狠好地东西,直接编译即可

/*!
  \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.
*/

/*!
  \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.
*/


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

  Reads a string entry stored with \a key, defaulting to \a deflt if there is no entry.
*/

/*
 * ### !LocalTranslator::translate was kept out!
 *
 */

/*!
  \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 qApp->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

  Reads an encrypted string entry stored with \a key, defaulting to \a deflt if there is no entry.
*/

/*!
  \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
  Reads a numeric entry stored with \a key, defaulting to \a deflt if there is no entry.
*/

/*!
  \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
  Reads a bool entry stored with \a key, defaulting to \a deflt if there is no entry.
*/

/*!
  \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
  Reads a string list entry stored with \a key, and with \a sep as the separator.
*/

/*!
  \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.
*/
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 oldGroup = git.key();

    QString strNewFile;
    if ( !fn.isEmpty() )
	filename = fn;
    strNewFile = filename + ".new";

    QFile f( strNewFile );
    if ( !f.open( IO_WriteOnly|IO_Raw ) ) {
	qWarning( "could not open for writing `%s'", strNewFile.latin1() );
	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()) ) {
//	QMessageBox::critical( 0, QObject::tr("Out of Space"),
//			       QObject::tr("There was a problem creating\nConfiguration Information \nfor this program.\n\nPlease free up some space and\ntry again.") );
	RES_ICON_Reader ir;
	ZMessageBox::timerInformation( 0, ir.getIcon(RES_ICON_DLG_ERROR,1), 
		QObject::tr("There was a problem creating\nConfiguration Information \nfor this program.\n\nPlease free up some space and\ntry again."), 
		5, QObject::tr("OK") );
	f.close();
	QFile::remove( strNewFile );
	return;
    }

    f.close();
    // now rename the file...
    if ( rename( strNewFile, filename ) < 0 ) {
	qWarning( "problem renaming the file %s to %s", strNewFile.latin1(),
		  filename.latin1() );
        QFile::remove( strNewFile );
        return;
    }

#ifndef Q_OS_WIN32
    ConfigCache::instance()->insert( filename, groups, d );
    setGroup( oldGroup );
#endif
    changed = FALSE;
}

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

/*!
  \internal
*/
void Config::read()
{
  // AppPath1 = qApp->argv()[0];
	//AppPath1.truncate( AppPath1.findRev("/") + 1 ); 
   changed = FALSE;

    QString readFilename(filename);

    if ( !QFile::exists(filename) ) {
        bool failed = TRUE;
        QFileInfo fi(filename);
        
        
        if (fi.dirPath(TRUE) == "/diska/.preload") {
        
            QString dftlFile = "/diska/.system/etc/default/" + fi.fileName();
           if (QFile::exists(dftlFile)) {
                readFilename = dftlFile;
                failed = FALSE;
            }
        }
        if (failed) {
            git = groups.end();
            return;
        }
    }

#ifndef Q_OS_WIN32

    if (ConfigCache::instance()->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
    ConfigCache::instance()->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;
}



bool Config::hasGroup( const QString& name )const {
    return ( groups. find ( name ) != groups. end ( ));
};

QStringList Config::groupList()const {
    QStringList sl;
    for ( ConfigGroupMap::ConstIterator it = groups. begin ( ); it != groups. end ( ); ++it )
        sl << it.key();

    return sl;
};

/////////////
// Qtopia 2.1 Functions
//
////////////

/*QStringList Config::allGroups()const {
    return groupList();
}*/

/*!
  Returns the time stamp for the config identified by \a name.  The
  time stamp represents the time the config was last committed to storage.
  Returns 0 if there is no time stamp available for the config.

  A \a domain can optionally be specified and defaults to User.
  See \l{Config()} for details.

  First availability: Qtopia 2.0
*/
/*long Config::timeStamp(const QString& name, Domain domain)
{
#ifdef Q_WS_WIN
    // Too slow (many conversions too and from time_t and QDataTime)
    QDateTime epoch;
    epoch.setTime_t(0);
    return epoch.secsTo(QFileInfo(Config::configFilename(name,domain)).lastModified());
#else
    QString fn = Config::configFilename(name,domain);
    struct stat b;
    if (lstat( QFile::encodeName(fn).data(), &b ) == 0)
        return b.st_mtime;
    else
        return 0;
#endif
}*/


/*!
  Removes the current group (and all its entries).

  The current group becomes unset.

  First availability: Qtopia 2.0
*/
/*void Config::removeGroup()
{
    if ( git == groups.end() ) {
        qWarning( "no group set" );
        return;
    }

    groups.remove(git.key());
    git = groups.end();
    changed = TRUE;
}*/

/*!
  Removes the current group (and all its entries).

  The current group becomes unset.

  First availability: Qtopia 2.0
*/
/*void Config::removeGroup(const QString& g)
{
    groups.remove(g);
    git = groups.end();
}*/



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

  The list is
  separated by the two characters "^e", and "^" withing the strings
  is replaced by "^^", such that the strings may contain any character,
  including "^".

  Null strings are also allowed, and are recorded as "^0" in the string.

  First availability: Qtopia 2.0

  \sa readListEntry()
*/
/*void Config::writeEntry( const QString &key, const QStringList &lst )
{
    QString s;
    for (QStringList::ConstIterator it=lst.begin(); it!=lst.end(); ++it) {
        QString el = *it;
        if ( el.isNull() ) {
            el = "^0";
        } else {
            el.replace(QRegExp("\\^"), "^^");
        }
        s+=el;
        s+="^e"; // end of element
    }
    writeEntry(key, s);
}*/

/*!
  Returns the string list entry stored using \a key and with
  the escaped seperator convention described in writeListEntry().

  First availability: Qtopia 2.0
*/
/*QStringList Config::readListEntry( const QString &key ) const
{
    QString value = readEntry( key, QString::null );
    QStringList l;
    QString s;
    bool esc=FALSE;
    for (int i=0; i<(int)value.length(); i++) {
        if ( esc ) {
            if ( value[i] == 'e' ) { // end-of-string
                l.append(s);
                s="";
            } else if ( value[i] == '0' ) { // null string
                s=QString::null;
            } else {
                s.append(value[i]);
            }
            esc = FALSE;
        } else if ( value[i] == '^' ) {
            esc = TRUE;
        } else {
            s.append(value[i]);
            if ( i == (int)value.length()-1 )
                l.append(s);
        }
    }
    return l;
}*/

QString Config::readEntry( const QString &key, const QString &deflt ) const
{ return ((Config*)this)->readEntry(key,deflt); }
QString Config::readEntryCrypt( const QString &key, const QString &deflt ) const
{ return ((Config*)this)->readEntryCrypt(key,deflt); }
QString Config::readEntryDirect( const QString &key, const QString &deflt ) const
{ return ((Config*)this)->readEntryDirect(key,deflt); }
int Config::readNumEntry( const QString &key, int deflt ) const
{ return ((Config*)this)->readNumEntry(key,deflt); }
bool Config::readBoolEntry( const QString &key, bool deflt ) const
{ return ((Config*)this)->readBoolEntry(key,deflt); }
QStringList Config::readListEntry( const QString &key, const QChar &sep ) const
{ return ((Config*)this)->readListEntry(key,sep); }