← Back to branch summary

~ubuntu-branches/ubuntu/vivid/fbreader/vivid-proposed

« back to all changes in this revision

Viewing changes to fbreader/src/formats/fb2/FB2DescriptionReader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Eugene V. Lyubimkin
  • Date: 2008-06-17 23:01:53 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20080617230153-a16c45tq69j8geru
Tags: 0.8.17-11
* debian/control:
  - Enhanced all ZLibrary descriptions, not the main one.
  - Done some renaming to use canonical names of libraries and toolkits in
    decriptions, as suggested by developers-reference:
    'qt' -> 'Qt', 'gtk' -> 'GTK+', 'zlibrary' -> 'ZLibrary'.
  - Bump 'Depends' on quilt to (>= 0.24).
* debian/rules:
  - Included quilt makefile instead of quilt makefile instead
    of copy&paste'ing it.
* debian/fbreader.links:
  - Added this file to relay on dh_link's work instead of using 'ln -sf'
    directly in the debian/rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fbreader/src/formats/fb2/FB2DescriptionReader.cpp
23
23
#include <ZLStringUtil.h>
24
24
 
25
25
#include "FB2DescriptionReader.h"
 
26
#include "FB2TagManager.h"
26
27
 
27
28
FB2DescriptionReader::FB2DescriptionReader(BookDescription &description) : myDescription(description) {
28
29
        myDescription.clearAuthor();
29
30
        myDescription.title().erase();
30
31
        myDescription.language().erase();
 
32
        myDescription.removeAllTags();
31
33
}
32
34
 
33
35
void FB2DescriptionReader::characterDataHandler(const char *text, int len) {
34
 
        if (myReadSomething) {
35
 
                if (myReadTitle) {
 
36
        switch (myReadState) {
 
37
                case READ_TITLE:
36
38
                        myDescription.title().append(text, len);
37
 
                } else if (myReadLanguage) {
 
39
                        break;
 
40
                case READ_LANGUAGE:
38
41
                        myDescription.language().append(text, len);
39
 
                } else {
40
 
                        for (int i = 0; i < 3; ++i) {
41
 
                                if (myReadAuthorName[i]) {
42
 
                                        myAuthorNames[i].append(text, len);
43
 
                                        break;
44
 
                                }
45
 
                        }
46
 
                }
 
42
                        break;
 
43
                case READ_AUTHOR_NAME_0:
 
44
                        myAuthorNames[0].append(text, len);
 
45
                        break;
 
46
                case READ_AUTHOR_NAME_1:
 
47
                        myAuthorNames[1].append(text, len);
 
48
                        break;
 
49
                case READ_AUTHOR_NAME_2:
 
50
                        myAuthorNames[2].append(text, len);
 
51
                        break;
 
52
                case READ_GENRE:
 
53
                        myGenreBuffer.append(text, len);
 
54
                        break;
 
55
                default:
 
56
                        break;
47
57
        }
48
58
}
49
59
 
54
64
                        interrupt();
55
65
                        break;
56
66
                case _TITLE_INFO:
57
 
                        myReadSomething = true;
 
67
                        myReadState = READ_SOMETHING;
58
68
                        break;
59
69
                case _BOOK_TITLE:
60
 
                        myReadTitle = true;
 
70
                        if (myReadState == READ_SOMETHING) {
 
71
                                myReadState = READ_TITLE;
 
72
                        }
 
73
                        break;
 
74
                case _GENRE:
 
75
                        if (myReadState == READ_SOMETHING) {
 
76
                                myReadState = READ_GENRE;
 
77
                        }
61
78
                        break;
62
79
                case _AUTHOR:
63
 
                        myReadAuthor = true;
 
80
                        if (myReadState == READ_SOMETHING) {
 
81
                                myReadState = READ_AUTHOR;
 
82
                        }
64
83
                        break;
65
84
                case _LANG:
66
 
                        myReadLanguage = true;
 
85
                        if (myReadState == READ_SOMETHING) {
 
86
                                myReadState = READ_LANGUAGE;
 
87
                        }
67
88
                        break;
68
89
                case _FIRST_NAME:
69
 
                        if (myReadAuthor) {
70
 
                                myReadAuthorName[0] = true;
 
90
                        if (myReadState == READ_AUTHOR) {
 
91
                                myReadState = READ_AUTHOR_NAME_0;
71
92
                        }
72
93
                        break;
73
94
                case _MIDDLE_NAME:
74
 
                        if (myReadAuthor) {
75
 
                                myReadAuthorName[1] = true;
 
95
                        if (myReadState == READ_AUTHOR) {
 
96
                                myReadState = READ_AUTHOR_NAME_1;
76
97
                        }
77
98
                        break;
78
99
                case _LAST_NAME:
79
 
                        if (myReadAuthor) {
80
 
                                myReadAuthorName[2] = true;
 
100
                        if (myReadState == READ_AUTHOR) {
 
101
                                myReadState = READ_AUTHOR_NAME_2;
81
102
                        }
82
103
                        break;
83
104
                case _SEQUENCE:
84
 
                        if (myReadSomething) {
 
105
                        if (myReadState == READ_SOMETHING) {
85
106
                                const char *name = attributeValue(attributes, "name");
86
107
                                if (name != 0) {
87
 
                                        std::string sequenceName = name;
88
 
                                        ZLStringUtil::stripWhiteSpaces(sequenceName);
89
 
                                        myDescription.sequenceName() = sequenceName;
 
108
                                        std::string seriesName = name;
 
109
                                        ZLStringUtil::stripWhiteSpaces(seriesName);
 
110
                                        myDescription.seriesName() = seriesName;
90
111
                                        const char *number = attributeValue(attributes, "number");
91
 
                                        myDescription.numberInSequence() = (number != 0) ? atoi(number) : 0;
 
112
                                        myDescription.numberInSeries() = (number != 0) ? atoi(number) : 0;
92
113
                                }
93
114
                        }
94
115
                        break;
100
121
void FB2DescriptionReader::endElementHandler(int tag) {
101
122
        switch (tag) {
102
123
                case _TITLE_INFO:
103
 
                        myReadSomething = false;
 
124
                        myReadState = READ_NOTHING;
104
125
                        break;
105
126
                case _BOOK_TITLE:
106
 
                        myReadTitle = false;
 
127
                        if (myReadState == READ_TITLE) {
 
128
                                myReadState = READ_SOMETHING;
 
129
                        }
 
130
                        break;
 
131
                case _GENRE:
 
132
                        if (myReadState == READ_GENRE) {
 
133
                                ZLStringUtil::stripWhiteSpaces(myGenreBuffer);
 
134
                                if (!myGenreBuffer.empty()) {
 
135
                                        const std::vector<std::string> &tags =
 
136
                                                FB2TagManager::instance().humanReadableTags(myGenreBuffer);
 
137
                                        if (!tags.empty()) {
 
138
                                                for (std::vector<std::string>::const_iterator it = tags.begin(); it != tags.end(); ++it) {
 
139
                                                        myDescription.addTag(*it, false);
 
140
                                                }
 
141
                                        } else {
 
142
                                                myDescription.addTag(myGenreBuffer);
 
143
                                        }
 
144
                                        myGenreBuffer.erase();
 
145
                                }
 
146
                                myReadState = READ_SOMETHING;
 
147
                        }
107
148
                        break;
108
149
                case _AUTHOR:
109
 
                        if (myReadSomething) {
 
150
                        if (myReadState == READ_AUTHOR) {
110
151
                                ZLStringUtil::stripWhiteSpaces(myAuthorNames[0]);
111
152
                                ZLStringUtil::stripWhiteSpaces(myAuthorNames[1]);
112
153
                                ZLStringUtil::stripWhiteSpaces(myAuthorNames[2]);
123
164
                                myAuthorNames[0].erase();
124
165
                                myAuthorNames[1].erase();
125
166
                                myAuthorNames[2].erase();
126
 
                                myReadAuthor = false;
 
167
                                myReadState = READ_SOMETHING;
127
168
                        }
128
169
                        break;
129
170
                case _LANG:
130
 
                        myReadLanguage = false;
 
171
                        if (myReadState == READ_LANGUAGE) {
 
172
                                myReadState = READ_SOMETHING;
 
173
                        }
131
174
                        break;
132
175
                case _FIRST_NAME:
133
 
                        myReadAuthorName[0] = false;
 
176
                        if (myReadState == READ_AUTHOR_NAME_0) {
 
177
                                myReadState = READ_AUTHOR;
 
178
                        }
134
179
                        break;
135
180
                case _MIDDLE_NAME:
136
 
                        myReadAuthorName[1] = false;
 
181
                        if (myReadState == READ_AUTHOR_NAME_1) {
 
182
                                myReadState = READ_AUTHOR;
 
183
                        }
137
184
                        break;
138
185
                case _LAST_NAME:
139
 
                        myReadAuthorName[2] = false;
 
186
                        if (myReadState == READ_AUTHOR_NAME_2) {
 
187
                                myReadState = READ_AUTHOR;
 
188
                        }
140
189
                        break;
141
190
                default:
142
191
                        break;
144
193
}
145
194
 
146
195
bool FB2DescriptionReader::readDescription(const std::string &fileName) {
147
 
        myReadSomething = false;
148
 
        myReadTitle = false;
149
 
        myReadAuthor = false;
150
 
        myReadLanguage = false;
 
196
        myReadState = READ_NOTHING;
151
197
        for (int i = 0; i < 3; ++i) {
152
 
                myReadAuthorName[i] = false;
 
198
                myAuthorNames[i].erase();
153
199
        }
 
200
        myGenreBuffer.erase();
154
201
        return readDocument(fileName);
155
202
}