← Back to branch summary

~ubuntu-branches/ubuntu/maverick/scribus-ng/maverick-backports

« back to all changes in this revision

Viewing changes to scribus/scimgdataloader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Oleksandr Moskalenko
  • Date: 2009-02-09 09:25:18 UTC
  • mfrom: (5.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090209092518-iqsxmh3pjspgrdyd
Tags: 1.3.5.dfsg~svn20090208-2
debian/control: Use "type-handling -n arm,armel,armeb any" to generate the
list of architectures to build on.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scribus/scimgdataloader.cpp
14
14
void ScImgDataLoader::initialize(void)
15
15
{
16
16
        m_msgType = noMsg;
17
 
        m_message.setLength(0);
 
17
        m_message.resize(0);
18
18
        m_image = QImage();
19
19
        m_imageInfoRecord.init();
20
20
        m_embeddedProfile.resize(0);
29
29
 
30
30
bool ScImgDataLoader::supportFormat(const QString& fmt) 
31
31
{
32
 
        QString format = fmt.lower();
 
32
        QString format = fmt.toLower();
33
33
        return (m_supportedFormats.contains(format));
34
34
}
35
35
 
50
50
                ret += QChar(tmp);
51
51
        }
52
52
        adj = (ret.length()+1) % 2;
53
 
        s.device()->at( s.device()->at() + adj );
 
53
        s.device()->seek( s.device()->pos() + adj );
54
54
        return ret;
55
55
}
56
56
 
90
90
        }
91
91
}
92
92
 
 
93
double ScImgDataLoader::decodePSDfloat(uint data)
 
94
{
 
95
        double ret = 0.0;
 
96
        char man = (data & 0xFF000000) >> 24;
 
97
        if (man >= 0)
 
98
        {
 
99
                ret = (data & 0x00FFFFFF) / 16777215.0;
 
100
                ret = (ret + man);
 
101
        }
 
102
        else
 
103
        {
 
104
                ret = (~data & 0x00FFFFFF) / 16777215.0;
 
105
                ret = (ret + ~man) * -1;
 
106
        }
 
107
        return ret;
 
108
}
 
109
 
93
110
void ScImgDataLoader::parseRessourceData( QDataStream & s, const PSDHeader & header, uint size )
94
111
{
95
112
        uint signature, resSize, offset, resBase, vRes, hRes, adj;
112
129
                        break;
113
130
                s >> resID;
114
131
                offset += 2;
115
 
                adj = s.device()->at();
 
132
                adj = s.device()->pos();
116
133
                resName = getPascalString(s);
117
 
                offset += s.device()->at() - adj;
 
134
                offset += s.device()->pos() - adj;
118
135
                s >> resSize;
119
136
                if(offset + resSize > size)
120
137
                        break;
121
 
                resBase = s.device()->at();
 
138
                resBase = s.device()->pos();
122
139
                if ( (resID >= 0x07d0) && (resID <= 0x0bb6) )
123
140
                {
124
 
                        QString db1, db2;
125
141
                        short type;
126
 
                        uint data1, data2, data3, data4, data5, data6;
 
142
                        uint data;
127
143
                        double frac1, frac2, frac3, frac4, frac5, frac6;
128
 
                        ushort man1, man2, man3, man4, man5, man6;
129
144
                        uint offset2;
130
145
                        offset2 = 0;
131
146
                        first = false;
134
149
                        while (offset2 < resSize)
135
150
                        {
136
151
                                s >> type;
137
 
                                s >> data1;
138
 
                                frac1 = (data1 & 0x00FFFFFF) / 16777215.0;
139
 
                                man1 = (data1 & 0x0F000000) >> 24;
140
 
                                frac1 = (frac1 + man1) * header.height;
141
 
                                s >> data2;
142
 
                                frac2 = (data2 & 0x00FFFFFF) / 16777215.0;
143
 
                                man2 = (data2 & 0x0F000000) >> 24;
144
 
                                frac2 = (frac2 + man2) * header.width;
145
 
                                s >> data3;
146
 
                                frac3 = (data3 & 0x00FFFFFF) / 16777215.0;
147
 
                                man3 = (data3 & 0x0F000000) >> 24;
148
 
                                frac3 = (frac3 + man3) * header.height;
149
 
                                s >> data4;
150
 
                                frac4 = (data4 & 0x00FFFFFF) / 16777215.0;
151
 
                                man4 = (data4 & 0x0F000000) >> 24;
152
 
                                frac4 = (frac4 + man4) * header.width;
153
 
                                s >> data5;
154
 
                                frac5 = (data5 & 0x00FFFFFF) / 16777215.0;
155
 
                                man5 = (data5 & 0x0F000000) >> 24;
156
 
                                frac5 = (frac5 + man5) * header.height;
157
 
                                s >> data6;
158
 
                                frac6 = (data6 & 0x00FFFFFF) / 16777215.0;
159
 
                                man6 = (data6 & 0x0F000000) >> 24;
160
 
                                frac6 = (frac6 + man6) * header.width;
 
152
                                s >> data;
 
153
                                frac1 = decodePSDfloat(data) * header.height;
 
154
                                s >> data;
 
155
                                frac2 = decodePSDfloat(data) * header.width;
 
156
                                s >> data;
 
157
                                frac3 = decodePSDfloat(data) * header.height;
 
158
                                s >> data;
 
159
                                frac4 = decodePSDfloat(data) * header.width;
 
160
                                s >> data;
 
161
                                frac5 = decodePSDfloat(data) * header.height;
 
162
                                s >> data;
 
163
                                frac6 = decodePSDfloat(data) * header.width;
161
164
                                switch (type)
162
165
                                {
163
 
                                case 0:
164
 
                                case 3:
165
 
                                        if (pathOpen)
166
 
                                        {
167
 
                                                clip2.addPoint(firstPoint);
168
 
                                                clip2.addPoint(firstControl);
169
 
                                                clip2.setMarker();
170
 
                                        }
171
 
                                        pathOpen = false;
172
 
                                        first = true;
173
 
                                        break;
174
 
                                case 1:
175
 
                                case 2:
176
 
                                case 4:
177
 
                                case 5:
178
 
                                        if (first)
179
 
                                        {
180
 
                                                firstControl = FPoint(frac2, frac1);
181
 
                                                firstPoint = FPoint(frac4, frac3);
182
 
                                                clip2.addPoint(FPoint(frac4, frac3));
183
 
                                                clip2.addPoint(FPoint(frac6, frac5));
184
 
                                        }
185
 
                                        else
186
 
                                        {
187
 
                                                clip2.addPoint(frac4, frac3);
188
 
                                                clip2.addPoint(frac2, frac1);
189
 
                                                clip2.addPoint(frac4, frac3);
190
 
                                                clip2.addPoint(frac6, frac5);
191
 
                                        }
192
 
                                        pathOpen = true;
193
 
                                        first = false;
194
 
                                        break;
195
 
                                case 6:
196
 
                                        first = true;
197
 
                                        break;
198
 
                                default:
199
 
                                        break;
 
166
                                        case 0:
 
167
                                        case 3:
 
168
                                                if (pathOpen)
 
169
                                                {
 
170
                                                        clip2.addPoint(firstPoint);
 
171
                                                        clip2.addPoint(firstControl);
 
172
                                                        clip2.setMarker();
 
173
                                                }
 
174
                                                pathOpen = false;
 
175
                                                first = true;
 
176
                                                break;
 
177
                                        case 1:
 
178
                                        case 2:
 
179
                                        case 4:
 
180
                                        case 5:
 
181
                                                if (first)
 
182
                                                {
 
183
                                                        firstControl = FPoint(frac2, frac1);
 
184
                                                        firstPoint = FPoint(frac4, frac3);
 
185
                                                        clip2.addPoint(FPoint(frac4, frac3));
 
186
                                                        clip2.addPoint(FPoint(frac6, frac5));
 
187
                                                }
 
188
                                                else
 
189
                                                {
 
190
                                                        clip2.addPoint(frac4, frac3);
 
191
                                                        clip2.addPoint(frac2, frac1);
 
192
                                                        clip2.addPoint(frac4, frac3);
 
193
                                                        clip2.addPoint(frac6, frac5);
 
194
                                                }
 
195
                                                pathOpen = true;
 
196
                                                first = false;
 
197
                                                break;
 
198
                                        case 6:
 
199
                                                first = true;
 
200
                                                break;
 
201
                                        default:
 
202
                                                break;
200
203
                                }
201
204
                                offset2 += 26;
202
205
                        }
210
213
                        switch (resID)
211
214
                        {
212
215
                        case 0x0bb7:
213
 
                                adj = s.device()->at();
 
216
                                adj = s.device()->pos();
214
217
                                m_imageInfoRecord.clipPath = getPascalString(s);
215
 
                                offset += s.device()->at() - adj;
 
218
                                offset += s.device()->pos() - adj;
216
219
                                break;
217
220
                        case 0x03ed:
218
221
                                s >> hRes;
226
229
                                break;
227
230
                        case 0x040f:
228
231
                                m_embeddedProfile.resize(resSize);
229
 
                                s.readRawBytes(m_embeddedProfile.data(), resSize);
 
232
                                s.readRawData(m_embeddedProfile.data(), resSize);
230
233
                                break;
231
234
                        case 0x0409:
232
235
                        case 0x040C:
240
243
                                        s >> thsize;
241
244
                                        s >> thdummy;
242
245
                                        char* buffer = (char*)malloc(thsize);
243
 
                                        s.readRawBytes(buffer, thsize);
 
246
                                        s.readRawData(buffer, thsize);
244
247
                                        QImage imth;
245
248
                                        imth.loadFromData((const uchar*)buffer, thsize, "JPEG");
246
 
                                        imth.convertDepth(32);
 
249
                                        imth.convertToFormat(QImage::Format_ARGB32);
247
250
                                        if (resID == 0x0409)
248
 
                                                m_imageInfoRecord.exifInfo.thumbnail = imth.swapRGB();
 
251
                                                m_imageInfoRecord.exifInfo.thumbnail = imth.rgbSwapped();
249
252
                                        else
250
253
                                                m_imageInfoRecord.exifInfo.thumbnail = imth;
251
254
                                        m_imageInfoRecord.exifInfo.width = imth.width();
258
261
                        }
259
262
                }
260
263
                if (resBase + resSize <= size) {
261
 
                        s.device()->at( resBase + resSize );
 
264
                        s.device()->seek( resBase + resSize );
262
265
                        offset += resSize;
263
266
                }
264
267
                if (resSize & 1)
268
271
                }
269
272
        }
270
273
        if(offset<size)
271
 
                s.device()->at( size );
 
274
                s.device()->seek( size );
272
275
}