Subversion Repositories Scribus

Rev

Rev 455 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
415 Franz 1
/***************************************************************************
2
 *   Copyright (C) 2004 by Riku Leino                                      *
1184 tsoots 3
 *   tsoots@gmail.com                                                      *
415 Franz 4
 *                                                                         *
5
 *   This program is free software; you can redistribute it and/or modify  *
6
 *   it under the terms of the GNU General Public License as published by  *
7
 *   the Free Software Foundation; either version 2 of the License, or     *
8
 *   (at your option) any later version.                                   *
9
 *                                                                         *
10
 *   This program is distributed in the hope that it will be useful,       *
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13
 *   GNU General Public License for more details.                          *
14
 *                                                                         *
15
 *   You should have received a copy of the GNU General Public License     *
16
 *   along with this program; if not, write to the                         *
17
 *   Free Software Foundation, Inc.,                                       *
18
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19
 ***************************************************************************/
20
 
21
#include <qfile.h>
418 Franz 22
#include <qfileinfo.h>
415 Franz 23
#include <qstring.h>
24
#include <qxml.h>
25
#include "prefsfile.h"
26
#include "prefsreader.h"
27
#include "prefstable.h"
28
 
29
PrefsFile::PrefsFile()
30
{
31
        prefsFilePath = "";
32
        ioEnabled = false;
33
}
34
 
418 Franz 35
PrefsFile::PrefsFile(const QString& pFilePath, bool write)
415 Franz 36
{
37
        prefsFilePath = pFilePath;
418 Franz 38
        ioEnabled = write;
39
        if (ioEnabled)
40
                canWrite();
415 Franz 41
        load();
42
}
43
 
44
PrefsContext* PrefsFile::getContext(const QString& contextName, bool persistent)
45
{
46
        if (!contexts.contains(contextName))
47
                contexts[contextName] = new PrefsContext(contextName, persistent);
48
        return contexts[contextName];
49
}
50
 
51
PrefsContext* PrefsFile::getPluginContext(const QString& contextName, bool persistent)
52
{
53
        if (!pluginContexts.contains(contextName))
54
                pluginContexts[contextName] = new PrefsContext(contextName, persistent);
55
        return pluginContexts[contextName];
56
}
57
 
58
void PrefsFile::load()
59
{
60
        PrefsReader* handler = new PrefsReader(&contexts, &pluginContexts);
61
        QFile* rc = new QFile(prefsFilePath);
62
        QXmlInputSource* source = new QXmlInputSource(rc);
63
        QXmlSimpleReader* reader = new QXmlSimpleReader();
64
        reader->setContentHandler(handler);
65
        reader->parse(source);
66
        delete reader;
67
        delete source;
68
        delete rc;
69
        delete handler;
70
}
71
 
72
void PrefsFile::write()
73
{
74
        if ((!ioEnabled) || ((contexts.size() == 0) && (pluginContexts.size() == 0)))
75
                return; // No prefs file path set -> can't write or no prefs to write
76
        QFile* prefsXML = new QFile(prefsFilePath);
77
        if (prefsXML->open(IO_WriteOnly))
78
        {
79
                QTextStream stream(prefsXML);
80
                stream.setEncoding(QTextStream::UnicodeUTF8);
81
                stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
82
                stream << "<preferences>\n";
83
                if (contexts.size() > 0)
84
                {
85
                        stream << "\t<level name=\"application\">\n";
86
                        writeContexts(&contexts, stream);
87
                        stream << "\t</level>\n";
88
                }
89
                if (pluginContexts.size() > 0)
90
                {
91
                        stream << "\t<level name=\"plugin\">\n";
92
                        writeContexts(&pluginContexts, stream);
93
                        stream << "\t</level>\n";
94
                }
95
                stream << "</preferences>\n";
96
 
97
                prefsXML->close();
98
        }
99
        delete prefsXML;
100
}
101
 
102
void PrefsFile::writeContexts(ContextMap* contextMap, QTextStream& stream)
103
{
104
        ContextMap::Iterator it;
105
        for (it = contextMap->begin(); it != contextMap->end(); ++it)
106
        {
107
                if ((it.data()->isPersistent()) && (!it.data()->isEmpty()))
108
                {
418 Franz 109
                        stream << "\t\t<context name=\"" + replaceIllegalChars(it.key()) + "\">\n";
415 Franz 110
                        AttributeMap::Iterator it2;
111
                        PrefsContext* tmpCon = it.data();
112
                        for (it2 = tmpCon->values.begin(); it2 != tmpCon->values.end(); ++it2)
113
                        {
418 Franz 114
                                stream << "\t\t\t<attribute key=\"" + replaceIllegalChars(it2.key()) + "\" ";
415 Franz 115
                                stream << "value=\""  + replaceIllegalChars(it2.data()) + "\"/>\n";
116
                        }
117
                        TableMap::Iterator it3;
118
                        for (it3 = tmpCon->tables.begin(); it3 != tmpCon->tables.end(); ++it3)
119
                        {
418 Franz 120
                                stream << "\t\t\t<table name=\"" + replaceIllegalChars(it3.key()) + "\">\n";
415 Franz 121
                                PrefsTable* t = it3.data();
122
                                for (int i = 0; i < t->height(); ++i)
123
                                {
124
                                        stream << QString("\t\t\t\t<row index=\"%1\">\n").arg(i);
125
                                        for (int j = 0; j < t->width(); ++j)
126
                                        {
127
                                                stream << QString("\t\t\t\t\t<col index=\"%1\">").arg(j);
418 Franz 128
                                                stream << replaceIllegalChars(t->get(i, j, "__NOT__SET__")) << "</col>\n";
415 Franz 129
                                        }
130
                                        stream << "\t\t\t\t</row>\n";
131
                                }
132
                                stream << "\t\t\t</table>\n";
133
                        }
134
                        stream << "\t\t</context>\n";
135
                }
136
        }
137
}
138
 
139
QString PrefsFile::replaceIllegalChars(const QString& text)
140
{
141
        QString s = text;
142
        s.replace("&", "&amp;");
143
        s.replace("<", "&lt;");
144
        s.replace(">", "&gt;");
145
        s.replace("\"", "&quot;");
146
        s.replace("\'", "&apos;");
147
        return s;
148
}
149
 
418 Franz 150
void PrefsFile::canWrite()
151
{
152
        if (ioEnabled)
153
        {
154
                QFile f(prefsFilePath);
155
                QFileInfo fi(f);
156
                if (fi.exists())
157
                        ioEnabled = fi.isWritable();
158
                else
159
                {
160
                        QFile f2(prefsFilePath.left(prefsFilePath.findRev("/")));
161
                        QFileInfo fi2(f2);
162
                        ioEnabled = fi2.isWritable();
163
                }
164
        }
165
}
166
 
415 Franz 167
PrefsFile::~PrefsFile()
168
{
169
        ContextMap::Iterator it;
170
        for (it = contexts.begin(); it != contexts.end(); ++it)
171
                delete it.data();
172
        for (it = pluginContexts.begin(); it != pluginContexts.end(); ++it)
173
                delete it.data();
174
}