qsettings 中文键值 注释 支持

#ifndef SETTINGS_H

#define SETTINGS_H

#include <QString>
#include <QVariant>

class QSettings;

class Settings
{
public:
Settings(const QString & fileName);
~Settings();
void setValue ( const QString & key, const QVariant & value );
QVariant value ( const QString & key, const QVariant & defaultValue = QVariant() ) const;
private:
QSettings *d;
};

#endif // SETTINGS_H

#include "settings.h"
#include <QtGui>

QMap<int, QString> comments;

//#define LZM_DEBUG

bool readIniComment(QString fileName)
{
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly))
{
qDebug()<<"readIniComment open"<<fileName<<"failed!: error"<<file.error();
return false;
}

QTextStream inStream(&file);
inStream.setCodec("UTF-8");

QString data;
bool ok = true;

int line=-1;
while (!inStream.atEnd())
{
data = inStream.readLine();
line++;
QString trimmed = data.trimmed();
if(trimmed.isEmpty())
{
continue;
}
else if(trimmed[0]== QChar('#') || trimmed[0]== QChar(';'))
{
comments[line] = data;
#ifdef LZM_DEBUG
qDebug()<<"line"<<line<<"text"<<data;
#endif

}
else
{
continue;
}
}

return ok;
}

bool WriteIniComment(QString fileName)
{
QFile inFile(fileName);
if (!inFile.open(QIODevice::ReadOnly))
{
qDebug()<<"WriteIniComment open"<<fileName<<"failed!";
return false;
}

QString outFileName = fileName+".out";
QFile outfile(outFileName);
if (!outfile.open(QIODevice::WriteOnly))
{
qDebug()<<"open"<<outFileName<<"failed!";
return false;
}

QTextStream inStream(&inFile);
inStream.setCodec("UTF-8");

QTextStream outStream(&outfile);
outStream.setCodec("UTF-8");

QString data;
bool ok = true;

int line=-1;

while (!inStream.atEnd())
{
data = inStream.readLine();
line++;
QString trimmed = data.trimmed();
//add comments
while(comments.contains(line))
{
outStream <<comments[line]<<"\n";
#ifdef LZM_DEBUG
qDebug()<<"line"<<line<<"text"<<comments[line];
#endif
line++;
}

if(trimmed.isEmpty())
{
outStream <<data<<"\n";
continue;
}
else
{
outStream <<data<<"\n";
}
}

inFile.close();
outfile.close();
//

QFile::remove(fileName);
qDebug()<<"remove"<<fileName;
QFile::rename(outFileName, fileName);
qDebug()<<"rename"<<outFileName<<"to"<<fileName;

return ok;
}

QStringList splitArgs(const QString &s, int idx)
{
int l = s.length();
Q_ASSERT(l > 0);
Q_ASSERT(s.at(idx) == QLatin1Char('('));
Q_ASSERT(s.at(l - 1) == QLatin1Char(')'));

QStringList result;
QString item;

for (++idx; idx < l; ++idx) {
QChar c = s.at(idx);
if (c == QLatin1Char(')')) {
Q_ASSERT(idx == l - 1);
result.append(item);
} else if (c == QLatin1Char(' ')) {
result.append(item);
item.clear();
} else {
item.append(c);
}
}

return result;
}

QVariant stringToVariant(const QString &s)
{
if (s.startsWith(QLatin1Char('@'))) {
if (s.endsWith(QLatin1Char(')'))) {
if (s.startsWith(QLatin1String("@ByteArray("))) {
return QVariant(s.toLatin1().mid(11, s.size() - 12));
} else if (s.startsWith(QLatin1String("@Variant("))) {
#ifndef QT_NO_DATASTREAM
QByteArray a(s.toLatin1().mid(9));
QDataStream stream(&a, QIODevice::ReadOnly);
stream.setVersion(QDataStream::Qt_4_0);
QVariant result;
stream >> result;
return result;
#else
Q_ASSERT(!"QSettings: Cannot load custom types without QDataStream support");
#endif
#ifndef QT_NO_GEOM_VARIANT
} else if (s.startsWith(QLatin1String("@Rect("))) {
QStringList args = ::splitArgs(s, 5);
if (args.size() == 4)
return QVariant(QRect(args[0].toInt(), args[1].toInt(), args[2].toInt(), args[3].toInt()));
} else if (s.startsWith(QLatin1String("@Size("))) {
QStringList args = ::splitArgs(s, 5);
if (args.size() == 2)
return QVariant(QSize(args[0].toInt(), args[1].toInt()));
} else if (s.startsWith(QLatin1String("@Point("))) {
QStringList args = ::splitArgs(s, 6);
if (args.size() == 2)
return QVariant(QPoint(args[0].toInt(), args[1].toInt()));
#endif
} else if (s == QLatin1String("@Invalid()")) {
return QVariant();
}

}
if (s.startsWith(QLatin1String("@@")))
return QVariant(s.mid(1));
}

return QVariant(s);
}

bool myReadFunc(QIODevice &device, QSettings::SettingsMap &settingsMap)
{
QString currentSection;
QTextStream stream(&device);
stream.setCodec("UTF-8");
QString data;
bool ok = true;
while (!stream.atEnd())
{

data = stream.readLine();
if (data.trimmed().isEmpty())
{
continue;
}
if (data[0] == QChar('['))
{
QString iniSection;
int inx = data.indexOf(QChar(']'));
if (inx == -1){
ok = false;
iniSection = data.mid(1);
}
else
{
iniSection = data.mid(1, inx - 1);
}
iniSection = iniSection.trimmed();
if (iniSection.compare(QString("general"), Qt::CaseInsensitive) == 0)
{
currentSection.clear();
}
else
{
if (iniSection.compare(QString("%general"), Qt::CaseInsensitive) == 0)
{
currentSection = QString("general");
}
else
{
currentSection = iniSection;
}
currentSection += QChar('/');

}
}
else
{
bool inQuotes = false;
int equalsPos = -1;
QList<int> commaPos;
int i = 0;
while (i < data.size())
{
QChar ch = data.at(i);
if (ch == QChar('='))
{
if (!inQuotes && equalsPos == -1)
{
equalsPos = i;
}
}
else if (ch == QChar('"'))
{
inQuotes = !inQuotes;
}
else if (ch == QChar(','))
{
if (!inQuotes && equalsPos != -1)
{
commaPos.append(i);
}
}
else if (ch == QChar(';') || ch == QChar('#'))
{
if (!inQuotes)
{
data.resize(i);
break;
}
}
else if (ch == QChar('\\'))
{
if (++i < data.size())
{
}
else
{
ok = false;
break;
}
}
i++;
}
if (equalsPos == -1)
{
break;
}
else
{
QString key = data.mid(0, equalsPos).trimmed();
if (key.isEmpty())
{
break;
}
else
{
key = currentSection + key;
}
if (commaPos.isEmpty())
{
//value
QString v = data.mid(equalsPos+1).trimmed();
if (v.startsWith("\"") && v.endsWith("\"") && v.length()>1)
{
v = v.mid(1, v.length()-2);
}
settingsMap[key] = stringToVariant(v);
}
else
{ //value list
commaPos.prepend(equalsPos);
commaPos.append(-1);
QVariantList vals;
for (int i=1; i<commaPos.size(); ++i)
{
QString d = data.mid(commaPos.at(i-1)+1, commaPos.at(i)-commaPos.at(i-1)-1);
QString v = d.trimmed();
if (v.startsWith("\"") && v.endsWith("\"") && v.length()>1)
{
v = v.mid(1, v.length()-2);
}
vals.append(stringToVariant(v) /*stringToVariant(unescapedString(v))*/);
}
settingsMap[key] = vals;
}
}
}
}

return ok;
}

QString variantToString(const QVariant &v)
{
QString result;

switch (v.type()) {
case QVariant::Invalid:
result = QLatin1String("@Invalid()");
break;

case QVariant::ByteArray: {
QByteArray a = v.toByteArray();
result = QLatin1String("@ByteArray(");
result += QString::fromLatin1(a.constData(), a.size());
result += QLatin1Char(')');
break;
}

case QVariant::String:
case QVariant::LongLong:
case QVariant::ULongLong:
case QVariant::Int:
case QVariant::UInt:
case QVariant::Bool:
case QVariant::Double:
case QVariant::KeySequence: {
result = v.toString();
if (result.startsWith(QLatin1Char('@')))
result.prepend(QLatin1Char('@'));
break;
}
#ifndef QT_NO_GEOM_VARIANT
case QVariant::Rect: {
QRect r = qvariant_cast<QRect>(v);
result += QLatin1String("@Rect(");
result += QString::number(r.x());
result += QLatin1Char(' ');
result += QString::number(r.y());
result += QLatin1Char(' ');
result += QString::number(r.width());
result += QLatin1Char(' ');
result += QString::number(r.height());
result += QLatin1Char(')');
break;
}
case QVariant::Size: {
QSize s = qvariant_cast<QSize>(v);
result += QLatin1String("@Size(");
result += QString::number(s.width());
result += QLatin1Char(' ');
result += QString::number(s.height());
result += QLatin1Char(')');
break;
}
case QVariant::Point: {
QPoint p = qvariant_cast<QPoint>(v);
result += QLatin1String("@Point(");
result += QString::number(p.x());
result += QLatin1Char(' ');
result += QString::number(p.y());
result += QLatin1Char(')');
break;
}
#endif // !QT_NO_GEOM_VARIANT

default: {
#ifndef QT_NO_DATASTREAM
QByteArray a;
{
QDataStream s(&a, QIODevice::WriteOnly);
s.setVersion(QDataStream::Qt_4_0);
s << v;
}

result = QLatin1String("@Variant(");
result += QString::fromLatin1(a.constData(), a.size());
result += QLatin1Char(')');
#else
Q_ASSERT(!"QSettings: Cannot save custom types without QDataStream support");
#endif
break;
}
}

return result;
}

bool myWriteFunc(QIODevice &device, const QSettings::SettingsMap &settingsMap)
{
#ifdef Q_OS_WIN
const char * const eol = "\r\n";
#else
const char *eol = "\n";
#endif
bool writeError = false;
QString lastSection;
QMapIterator<QString,QVariant> it(settingsMap);
while(it.hasNext() && !writeError)
{
it.next();
QString key = it.key();
QString section;
qDebug()<<"key: "<<key;
int idx = key.lastIndexOf(QChar('/'));
if (idx == -1)
{
section = QString("[General]");
}
else
{
section = key.left(idx);
key = key.mid(idx+1);
if (section.compare(QString("General"), Qt::CaseInsensitive) == 0)
{
section = QString("[%General]");
}
else
{
section.prepend(QChar('['));
section.append(QChar(']'));
}
}
if (section.compare(lastSection, Qt::CaseInsensitive))
{
if (!lastSection.isEmpty())
{
device.write(eol);
}
lastSection = section;
if (device.write(section.toUtf8() + eol) == -1)
{
writeError = true;
}
}
QByteArray block = key.toUtf8();
block += " = ";
if (it.value().type() == QVariant::StringList)
{
// foreach (QString s, it.value().toStringList())
// {
// block += /*escapedString(s)*/ s;
// block += ", ";
// }
// if (block.endsWith(", "))
// {
// block.chop(2);
// }
qDebug()<< "no support QVariant::StringList";
}
else if (it.value().type() == QVariant::List)
{
// foreach (QVariant v, it.value().toList())
// {
// block += /*escapedString(variantToString(v))*/ v.toString();
// block += ", ";
// }
// if (block.endsWith(", "))
// {
// block.chop(2);
// }
qDebug()<< "no support QVariant::List";
}
else
{
// block += /*escapedString*/(variantToString(it.value()));
// block += it.value().toString();
block += variantToString(it.value());
}
block += eol;
if (device.write(block) == -1)
{
writeError = true;
}
}
return writeError;

}

Settings::Settings(const QString & fileName)
{
readIniComment(fileName);
const QSettings::Format MyIniFormat = QSettings::registerFormat("ini", myReadFunc, myWriteFunc);
d= new QSettings(fileName, MyIniFormat);
d->setIniCodec("UTF-8");
}

Settings::~Settings()
{
if(d)
{
QString fileName = d->fileName();

delete d;
WriteIniComment(fileName);
}

}

void Settings::setValue(const QString &key, const QVariant &value)
{
d->setValue(key, value);
}

QVariant Settings::value(const QString &key, const QVariant &defaultValue) const
{
return d->value(key, defaultValue);
}