Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : :
30 : : #include <string.h>
31 : : #include <osl/endian.h>
32 : : #include <tools/stream.hxx>
33 : : #include <vcl/gdimtf.hxx>
34 : : #include <tools/color.hxx>
35 : : #include <vcl/virdev.hxx>
36 : : #include "sgffilt.hxx"
37 : : #include "sgfbram.hxx"
38 : :
39 : : /*************************************************************************
40 : : |*
41 : : |* operator>>( SvStream&, SgfHeader& )
42 : : |*
43 : : *************************************************************************/
44 : 12 : SvStream& operator>>(SvStream& rIStream, SgfHeader& rHead)
45 : : {
46 : 12 : rIStream.Read((char*)&rHead.Magic,SgfHeaderSize);
47 : : #if defined OSL_BIGENDIAN
48 : : rHead.Magic =OSL_SWAPWORD(rHead.Magic );
49 : : rHead.Version=OSL_SWAPWORD(rHead.Version);
50 : : rHead.Typ =OSL_SWAPWORD(rHead.Typ );
51 : : rHead.Xsize =OSL_SWAPWORD(rHead.Xsize );
52 : : rHead.Ysize =OSL_SWAPWORD(rHead.Ysize );
53 : : rHead.Xoffs =OSL_SWAPWORD(rHead.Xoffs );
54 : : rHead.Yoffs =OSL_SWAPWORD(rHead.Yoffs );
55 : : rHead.Planes =OSL_SWAPWORD(rHead.Planes );
56 : : rHead.SwGrCol=OSL_SWAPWORD(rHead.SwGrCol);
57 : : rHead.OfsLo =OSL_SWAPWORD(rHead.OfsLo );
58 : : rHead.OfsHi =OSL_SWAPWORD(rHead.OfsHi );
59 : : #endif
60 : 12 : return rIStream;
61 : : }
62 : :
63 : :
64 : : /*************************************************************************
65 : : |*
66 : : |* SgfHeader::ChkMagic()
67 : : |*
68 : : *************************************************************************/
69 : 12 : sal_Bool SgfHeader::ChkMagic()
70 : 12 : { return Magic=='J'*256+'J'; }
71 : :
72 : 6 : sal_uInt32 SgfHeader::GetOffset()
73 : 6 : { return sal_uInt32(OfsLo)+0x00010000*sal_uInt32(OfsHi); }
74 : :
75 : :
76 : : /*************************************************************************
77 : : |*
78 : : |* operator>>( SvStream&, SgfEntry& )
79 : : |*
80 : : *************************************************************************/
81 : 12 : SvStream& operator>>(SvStream& rIStream, SgfEntry& rEntr)
82 : : {
83 : 12 : rIStream.Read((char*)&rEntr.Typ,SgfEntrySize);
84 : : #if defined OSL_BIGENDIAN
85 : : rEntr.Typ =OSL_SWAPWORD(rEntr.Typ );
86 : : rEntr.iFrei=OSL_SWAPWORD(rEntr.iFrei);
87 : : rEntr.lFreiLo=OSL_SWAPWORD (rEntr.lFreiLo);
88 : : rEntr.lFreiHi=OSL_SWAPWORD (rEntr.lFreiHi);
89 : : rEntr.OfsLo=OSL_SWAPWORD(rEntr.OfsLo);
90 : : rEntr.OfsHi=OSL_SWAPWORD(rEntr.OfsHi);
91 : : #endif
92 : 12 : return rIStream;
93 : : }
94 : :
95 : 12 : sal_uInt32 SgfEntry::GetOffset()
96 : 12 : { return sal_uInt32(OfsLo)+0x00010000*sal_uInt32(OfsHi); }
97 : :
98 : :
99 : : /*************************************************************************
100 : : |*
101 : : |* operator>>( SvStream&, SgfVector& )
102 : : |*
103 : : *************************************************************************/
104 : 0 : SvStream& operator>>(SvStream& rIStream, SgfVector& rVect)
105 : : {
106 : 0 : rIStream.Read((char*)&rVect,sizeof(rVect));
107 : : #if defined OSL_BIGENDIAN
108 : : rVect.Flag =OSL_SWAPWORD(rVect.Flag );
109 : : rVect.x =OSL_SWAPWORD(rVect.x );
110 : : rVect.y =OSL_SWAPWORD(rVect.y );
111 : : rVect.OfsLo=OSL_SWAPDWORD (rVect.OfsLo);
112 : : rVect.OfsHi=OSL_SWAPDWORD (rVect.OfsHi);
113 : : #endif
114 : 0 : return rIStream;
115 : : }
116 : :
117 : :
118 : : /*************************************************************************
119 : : |*
120 : : |* operator<<( SvStream&, BmpFileHeader& )
121 : : |*
122 : : *************************************************************************/
123 : 0 : SvStream& operator<<(SvStream& rOStream, BmpFileHeader& rHead)
124 : : {
125 : : #if defined OSL_BIGENDIAN
126 : : rHead.Typ =OSL_SWAPWORD(rHead.Typ );
127 : : rHead.SizeLo =OSL_SWAPWORD(rHead.SizeLo );
128 : : rHead.SizeHi =OSL_SWAPWORD(rHead.SizeHi );
129 : : rHead.Reserve1=OSL_SWAPWORD(rHead.Reserve1);
130 : : rHead.Reserve2=OSL_SWAPWORD(rHead.Reserve2);
131 : : rHead.OfsLo =OSL_SWAPWORD(rHead.OfsLo );
132 : : rHead.OfsHi =OSL_SWAPWORD(rHead.OfsHi );
133 : : #endif
134 : 0 : rOStream.Write((char*)&rHead,sizeof(rHead));
135 : : #if defined OSL_BIGENDIAN
136 : : rHead.Typ =OSL_SWAPWORD(rHead.Typ );
137 : : rHead.SizeLo =OSL_SWAPWORD(rHead.SizeLo );
138 : : rHead.SizeHi =OSL_SWAPWORD(rHead.SizeHi );
139 : : rHead.Reserve1=OSL_SWAPWORD(rHead.Reserve1);
140 : : rHead.Reserve2=OSL_SWAPWORD(rHead.Reserve2);
141 : : rHead.OfsLo =OSL_SWAPWORD(rHead.OfsLo );
142 : : rHead.OfsHi =OSL_SWAPWORD(rHead.OfsHi );
143 : : #endif
144 : 0 : return rOStream;
145 : : }
146 : :
147 : 0 : void BmpFileHeader::SetSize(sal_uInt32 Size)
148 : : {
149 : 0 : SizeLo=sal_uInt16(Size & 0x0000FFFF);
150 : 0 : SizeHi=sal_uInt16((Size & 0xFFFF0000)>>16);
151 : 0 : }
152 : :
153 : 0 : void BmpFileHeader::SetOfs(sal_uInt32 Ofs)
154 : : {
155 : 0 : OfsLo=sal_uInt16(Ofs & 0x0000FFFF);
156 : 0 : OfsHi=sal_uInt16((Ofs & 0xFFFF0000)>>16);
157 : 0 : }
158 : :
159 : 0 : sal_uInt32 BmpFileHeader::GetOfs()
160 : : {
161 : 0 : return sal_uInt32(OfsLo)+0x00010000*sal_uInt32(OfsHi);
162 : : }
163 : :
164 : : /*************************************************************************
165 : : |*
166 : : |* operator<<( SvStream&, BmpInfoHeader& )
167 : : |*
168 : : *************************************************************************/
169 : 0 : SvStream& operator<<(SvStream& rOStream, BmpInfoHeader& rInfo)
170 : : {
171 : : #if defined OSL_BIGENDIAN
172 : : rInfo.Size =OSL_SWAPDWORD (rInfo.Size );
173 : : rInfo.Width =OSL_SWAPDWORD (rInfo.Width );
174 : : rInfo.Hight =OSL_SWAPDWORD (rInfo.Hight );
175 : : rInfo.Planes =OSL_SWAPWORD(rInfo.Planes );
176 : : rInfo.PixBits =OSL_SWAPWORD(rInfo.PixBits );
177 : : rInfo.Compress=OSL_SWAPDWORD (rInfo.Compress);
178 : : rInfo.ImgSize =OSL_SWAPDWORD (rInfo.ImgSize );
179 : : rInfo.xDpmm =OSL_SWAPDWORD (rInfo.xDpmm );
180 : : rInfo.yDpmm =OSL_SWAPDWORD (rInfo.yDpmm );
181 : : rInfo.ColUsed =OSL_SWAPDWORD (rInfo.ColUsed );
182 : : rInfo.ColMust =OSL_SWAPDWORD (rInfo.ColMust );
183 : : #endif
184 : 0 : rOStream.Write((char*)&rInfo,sizeof(rInfo));
185 : : #if defined OSL_BIGENDIAN
186 : : rInfo.Size =OSL_SWAPDWORD (rInfo.Size );
187 : : rInfo.Width =OSL_SWAPDWORD (rInfo.Width );
188 : : rInfo.Hight =OSL_SWAPDWORD (rInfo.Hight );
189 : : rInfo.Planes =OSL_SWAPWORD(rInfo.Planes );
190 : : rInfo.PixBits =OSL_SWAPWORD(rInfo.PixBits );
191 : : rInfo.Compress=OSL_SWAPDWORD (rInfo.Compress);
192 : : rInfo.ImgSize =OSL_SWAPDWORD (rInfo.ImgSize );
193 : : rInfo.xDpmm =OSL_SWAPDWORD (rInfo.xDpmm );
194 : : rInfo.yDpmm =OSL_SWAPDWORD (rInfo.yDpmm );
195 : : rInfo.ColUsed =OSL_SWAPDWORD (rInfo.ColUsed );
196 : : rInfo.ColMust =OSL_SWAPDWORD (rInfo.ColMust );
197 : : #endif
198 : 0 : return rOStream;
199 : : }
200 : :
201 : :
202 : : /*************************************************************************
203 : : |*
204 : : |* operator<<( SvStream&, RGBQuad& )
205 : : |*
206 : : *************************************************************************/
207 : 0 : SvStream& operator<<(SvStream& rOStream, const RGBQuad& rQuad)
208 : : {
209 : 0 : rOStream.Write((char*)&rQuad,sizeof(rQuad));
210 : 0 : return rOStream;
211 : : }
212 : :
213 : :
214 : : ////////////////////////////////////////////////////////////////////////////////////////////////////
215 : : // PcxExpand ///////////////////////////////////////////////////////////////////////////////////////
216 : : ////////////////////////////////////////////////////////////////////////////////////////////////////
217 : :
218 : : class PcxExpand
219 : : {
220 : : private:
221 : : sal_uInt16 Count;
222 : : sal_uInt8 Data;
223 : : public:
224 : 0 : PcxExpand() { Count=0; }
225 : : sal_uInt8 GetByte(SvStream& rInp);
226 : : };
227 : :
228 : 0 : sal_uInt8 PcxExpand::GetByte(SvStream& rInp)
229 : : {
230 [ # # ]: 0 : if (Count>0) {
231 : 0 : Count--;
232 : : } else {
233 : 0 : rInp.Read((char*)&Data,1);
234 [ # # ]: 0 : if ((Data & 0xC0) == 0xC0) {
235 : 0 : Count=(Data & 0x3F) -1;
236 : 0 : rInp.Read((char*)&Data,1);
237 : : }
238 : : }
239 : 0 : return Data;
240 : : }
241 : :
242 : : ////////////////////////////////////////////////////////////////////////////////////////////////////
243 : : // SgfBMapFilter ///////////////////////////////////////////////////////////////////////////////////
244 : : ////////////////////////////////////////////////////////////////////////////////////////////////////
245 : :
246 : :
247 : : /*************************************************************************
248 : : |*
249 : : |* SgfFilterBmp()
250 : : |*
251 : : *************************************************************************/
252 : 0 : sal_Bool SgfFilterBMap(SvStream& rInp, SvStream& rOut, SgfHeader& rHead, SgfEntry&)
253 : : {
254 : : BmpFileHeader aBmpHead;
255 : : BmpInfoHeader aBmpInfo;
256 : 0 : sal_uInt16 nWdtInp=(rHead.Xsize+7)/8; // Breite der Input-Bitmap in Bytes
257 : : sal_uInt16 nWdtOut; // Breite der Output-Bitmap in Bytes
258 : : sal_uInt16 nColors; // Anzahl der Farben (1,16,256)
259 : : sal_uInt16 nColBits; // Anzahl der Bits/Pixel (2, 4, 8)
260 : : sal_uInt16 i,j,k; // Spaltenzaehler, Zeilenzaehler, Planezaehler
261 : : sal_uInt16 a,b; // Hilfsvariable
262 : 0 : sal_uInt8 pl1 = 0; // Masken fuer die Planes
263 : 0 : sal_uInt8* pBuf=NULL; // Buffer fuer eine Pixelzeile
264 : 0 : PcxExpand aPcx;
265 : : sal_uLong nOfs;
266 : : sal_uInt8 cRGB[4];
267 : :
268 [ # # ][ # # ]: 0 : if (rHead.Planes<=1) nColBits=1; else nColBits=4; if (rHead.Typ==4) nColBits=8;
269 : 0 : nColors=1<<nColBits;
270 : 0 : nWdtOut=((rHead.Xsize*nColBits+31)/32)*4;
271 : 0 : aBmpHead.Typ='B'+'M'*256;
272 : 0 : aBmpHead.SetOfs(sizeof(aBmpHead)+sizeof(aBmpInfo)+nColors*4);
273 : 0 : aBmpHead.SetSize(aBmpHead.GetOfs()+nWdtOut*rHead.Ysize);
274 : 0 : aBmpHead.Reserve1=0;
275 : 0 : aBmpHead.Reserve2=0;
276 : 0 : aBmpInfo.Size=sizeof(aBmpInfo);
277 : 0 : aBmpInfo.Width=rHead.Xsize;
278 : 0 : aBmpInfo.Hight=rHead.Ysize;
279 : 0 : aBmpInfo.Planes=1;
280 : 0 : aBmpInfo.PixBits=nColBits;
281 : 0 : aBmpInfo.Compress=0;
282 : 0 : aBmpInfo.ImgSize=0;
283 : 0 : aBmpInfo.xDpmm=0;
284 : 0 : aBmpInfo.yDpmm=0;
285 : 0 : aBmpInfo.ColUsed=0;
286 : 0 : aBmpInfo.ColMust=0;
287 [ # # ]: 0 : pBuf=new sal_uInt8[nWdtOut];
288 [ # # ]: 0 : if (!pBuf) return sal_False; // Fehler: kein Speichel da
289 [ # # ][ # # ]: 0 : rOut<<aBmpHead<<aBmpInfo;
290 : 0 : memset(pBuf,0,nWdtOut); // Buffer mit Nullen fuellen
291 : :
292 [ # # ]: 0 : if (nColors==2)
293 : : {
294 : :
295 [ # # ]: 0 : rOut<<RGBQuad(0x00,0x00,0x00); // Schwarz
296 [ # # ]: 0 : rOut<<RGBQuad(0xFF,0xFF,0xFF); // Weiss
297 : 0 : nOfs=rOut.Tell();
298 [ # # ]: 0 : for (j=0;j<rHead.Ysize;j++)
299 [ # # ]: 0 : rOut.Write((char*)pBuf,nWdtOut); // Datei erstmal komplett mit Nullen fuellen
300 [ # # ]: 0 : for (j=0;j<rHead.Ysize;j++) {
301 [ # # ]: 0 : for(i=0;i<nWdtInp;i++) {
302 [ # # ]: 0 : pBuf[i]=aPcx.GetByte(rInp);
303 : : }
304 [ # # ]: 0 : for(i=nWdtInp;i<nWdtOut;i++) pBuf[i]=0; // noch bis zu 3 Bytes
305 [ # # ]: 0 : rOut.Seek(nOfs+((sal_uLong)rHead.Ysize-j-1L)*(sal_uLong)nWdtOut); // rueckwaerts schreiben!
306 [ # # ]: 0 : rOut.Write((char*)pBuf,nWdtOut);
307 : : }
308 [ # # ]: 0 : } else if (nColors==16) {
309 : 0 : sal_uInt8 pl2= 0; // Masken fuer die Planes
310 : :
311 [ # # ]: 0 : rOut<<RGBQuad(0x00,0x00,0x00); // Schwarz
312 [ # # ]: 0 : rOut<<RGBQuad(0x24,0x24,0x24); // Grau 80%
313 [ # # ]: 0 : rOut<<RGBQuad(0x49,0x49,0x49); // Grau 60%
314 [ # # ]: 0 : rOut<<RGBQuad(0x92,0x92,0x92); // Grau 40%
315 [ # # ]: 0 : rOut<<RGBQuad(0x6D,0x6D,0x6D); // Grau 30%
316 [ # # ]: 0 : rOut<<RGBQuad(0xB6,0xB6,0xB6); // Grau 20%
317 [ # # ]: 0 : rOut<<RGBQuad(0xDA,0xDA,0xDA); // Grau 10%
318 [ # # ]: 0 : rOut<<RGBQuad(0xFF,0xFF,0xFF); // Weiss
319 [ # # ]: 0 : rOut<<RGBQuad(0x00,0x00,0x00); // Schwarz
320 [ # # ]: 0 : rOut<<RGBQuad(0xFF,0x00,0x00); // Rot
321 [ # # ]: 0 : rOut<<RGBQuad(0x00,0x00,0xFF); // Blau
322 [ # # ]: 0 : rOut<<RGBQuad(0xFF,0x00,0xFF); // Magenta
323 [ # # ]: 0 : rOut<<RGBQuad(0x00,0xFF,0x00); // Gruen
324 [ # # ]: 0 : rOut<<RGBQuad(0xFF,0xFF,0x00); // Gelb
325 [ # # ]: 0 : rOut<<RGBQuad(0x00,0xFF,0xFF); // Cyan
326 [ # # ]: 0 : rOut<<RGBQuad(0xFF,0xFF,0xFF); // Weiss
327 : :
328 : 0 : nOfs=rOut.Tell();
329 [ # # ]: 0 : for (j=0;j<rHead.Ysize;j++)
330 [ # # ]: 0 : rOut.Write((char*)pBuf,nWdtOut); // Datei erstmal komplett mit Nullen fuellen
331 [ # # ]: 0 : for (j=0;j<rHead.Ysize;j++) {
332 : 0 : memset(pBuf,0,nWdtOut);
333 [ # # ]: 0 : for(k=0;k<4;k++) {
334 [ # # ]: 0 : if (k==0) {
335 : 0 : pl1=0x10; pl2=0x01;
336 : : } else {
337 : 0 : pl1<<=1; pl2<<=1;
338 : : }
339 [ # # ]: 0 : for(i=0;i<nWdtInp;i++) {
340 : 0 : a=i*4;
341 [ # # ]: 0 : b=aPcx.GetByte(rInp);
342 [ # # ]: 0 : if (b & 0x80) pBuf[a ]|=pl1;
343 [ # # ]: 0 : if (b & 0x40) pBuf[a ]|=pl2;
344 [ # # ]: 0 : if (b & 0x20) pBuf[a+1]|=pl1;
345 [ # # ]: 0 : if (b & 0x10) pBuf[a+1]|=pl2;
346 [ # # ]: 0 : if (b & 0x08) pBuf[a+2]|=pl1;
347 [ # # ]: 0 : if (b & 0x04) pBuf[a+2]|=pl2;
348 [ # # ]: 0 : if (b & 0x02) pBuf[a+3]|=pl1;
349 [ # # ]: 0 : if (b & 0x01) pBuf[a+3]|=pl2;
350 : : }
351 : : }
352 [ # # ]: 0 : for(i=nWdtInp*4;i<nWdtOut;i++) pBuf[i]=0; // noch bis zu 3 Bytes
353 [ # # ]: 0 : rOut.Seek(nOfs+((sal_uLong)rHead.Ysize-j-1L)*(sal_uLong)nWdtOut); // rueckwaerts schreiben!
354 [ # # ]: 0 : rOut.Write((char*)pBuf,nWdtOut);
355 : : }
356 [ # # ]: 0 : } else if (nColors==256) {
357 : 0 : cRGB[3]=0; // der 4. Paletteneintrag fuer BMP
358 [ # # ]: 0 : for (i=0;i<256;i++) { // Palette kopieren
359 [ # # ]: 0 : rInp.Read((char*)cRGB,3);
360 : 0 : pl1=cRGB[0]; // Rot mit Blau tauschen
361 : 0 : cRGB[0]=cRGB[2];
362 : 0 : cRGB[2]=pl1;
363 [ # # ]: 0 : rOut.Write((char*)cRGB,4);
364 : : }
365 : :
366 : 0 : nOfs=rOut.Tell();
367 [ # # ]: 0 : for (j=0;j<rHead.Ysize;j++)
368 [ # # ]: 0 : rOut.Write((char*)pBuf,nWdtOut); // Datei erstmal komplett mit Nullen fuellen
369 [ # # ]: 0 : for (j=0;j<rHead.Ysize;j++) {
370 [ # # ]: 0 : for(i=0;i<rHead.Xsize;i++)
371 [ # # ]: 0 : pBuf[i]=aPcx.GetByte(rInp);
372 [ # # ]: 0 : for(i=rHead.Xsize;i<nWdtOut;i++) pBuf[i]=0; // noch bis zu 3 Bytes
373 [ # # ]: 0 : rOut.Seek(nOfs+((sal_uLong)rHead.Ysize-j-1L)*(sal_uLong)nWdtOut); // rueckwaerts schreiben!
374 [ # # ]: 0 : rOut.Write((char*)pBuf,nWdtOut);
375 : : }
376 : : }
377 [ # # ]: 0 : delete[] pBuf;
378 : 0 : return sal_True;
379 : : }
380 : :
381 : :
382 : : /*************************************************************************
383 : : |*
384 : : |* SgfBMapFilter()
385 : : |*
386 : : *************************************************************************/
387 : 0 : sal_Bool SgfBMapFilter(SvStream& rInp, SvStream& rOut)
388 : : {
389 : : sal_uLong nFileStart; // Offset des SgfHeaders. Im allgemeinen 0.
390 : : SgfHeader aHead;
391 : : SgfEntry aEntr;
392 : : sal_uLong nNext;
393 : 0 : sal_Bool bRdFlag=sal_False; // Grafikentry gelesen ?
394 : 0 : sal_Bool bRet=sal_False; // Returncode
395 : :
396 : 0 : nFileStart=rInp.Tell();
397 [ # # ]: 0 : rInp>>aHead;
398 [ # # ][ # # ]: 0 : if (aHead.ChkMagic() && (aHead.Typ==SgfBitImag0 || aHead.Typ==SgfBitImag1 ||
[ # # ][ # # ]
[ # # ][ # # ]
399 : : aHead.Typ==SgfBitImag2 || aHead.Typ==SgfBitImgMo)) {
400 : 0 : nNext=aHead.GetOffset();
401 [ # # ][ # # ]: 0 : while (nNext && !bRdFlag && !rInp.GetError() && !rOut.GetError()) {
[ # # ][ # # ]
[ # # ]
402 [ # # ]: 0 : rInp.Seek(nFileStart+nNext);
403 [ # # ]: 0 : rInp>>aEntr;
404 : 0 : nNext=aEntr.GetOffset();
405 [ # # ]: 0 : if (aEntr.Typ==aHead.Typ) {
406 : 0 : bRdFlag=sal_True;
407 [ # # ]: 0 : switch(aEntr.Typ) {
408 : : case SgfBitImag0:
409 : : case SgfBitImag1:
410 : : case SgfBitImag2:
411 [ # # ]: 0 : case SgfBitImgMo: bRet=SgfFilterBMap(rInp,rOut,aHead,aEntr); break;
412 : : }
413 : : }
414 : : } // while(nNext)
415 : : }
416 [ # # ]: 0 : if (rInp.GetError()) bRet=sal_False;
417 : 0 : return(bRet);
418 : : }
419 : :
420 : :
421 : : ////////////////////////////////////////////////////////////////////////////////////////////////////
422 : : // SgfVectFilter ///////////////////////////////////////////////////////////////////////////////////
423 : : ////////////////////////////////////////////////////////////////////////////////////////////////////
424 : :
425 : : // Fuer StarDraw Embedded SGF-Vector
426 : : long SgfVectXofs=0;
427 : : long SgfVectYofs=0;
428 : : long SgfVectXmul=0;
429 : : long SgfVectYmul=0;
430 : : long SgfVectXdiv=0;
431 : : long SgfVectYdiv=0;
432 : : sal_Bool SgfVectScal=sal_False;
433 : :
434 : : ////////////////////////////////////////////////////////////
435 : : // Hpgl2SvFarbe ////////////////////////////////////////////
436 : : ////////////////////////////////////////////////////////////
437 : :
438 : 0 : Color Hpgl2SvFarbe( sal_uInt8 nFarb )
439 : : {
440 : 0 : sal_uLong nColor = COL_BLACK;
441 : :
442 [ # # # # : 0 : switch (nFarb & 0x07) {
# # # #
# ]
443 : 0 : case 0: nColor=COL_WHITE; break;
444 : 0 : case 1: nColor=COL_YELLOW; break;
445 : 0 : case 2: nColor=COL_LIGHTMAGENTA; break;
446 : 0 : case 3: nColor=COL_LIGHTRED; break;
447 : 0 : case 4: nColor=COL_LIGHTCYAN; break;
448 : 0 : case 5: nColor=COL_LIGHTGREEN; break;
449 : 0 : case 6: nColor=COL_LIGHTBLUE; break;
450 : 0 : case 7: nColor=COL_BLACK; break;
451 : : }
452 : 0 : Color aColor( nColor );
453 : 0 : return aColor;
454 : : }
455 : :
456 : : /*************************************************************************
457 : : |*
458 : : |* SgfFilterVect()
459 : : |*
460 : : *************************************************************************/
461 : 0 : sal_Bool SgfFilterVect(SvStream& rInp, SgfHeader& rHead, SgfEntry&, GDIMetaFile& rMtf)
462 : : {
463 [ # # ]: 0 : VirtualDevice aOutDev;
464 : : SgfVector aVect;
465 : : sal_uInt8 nFarb;
466 : 0 : sal_uInt8 nFrb0=7;
467 : : sal_uInt8 nLTyp;
468 : : sal_uInt8 nOTyp;
469 : 0 : sal_Bool bEoDt=sal_False;
470 : 0 : sal_Bool bPDwn=sal_False;
471 : 0 : Point aP0(0,0);
472 : 0 : Point aP1(0,0);
473 [ # # ]: 0 : String Msg;
474 : 0 : sal_uInt16 RecNr=0;
475 : :
476 [ # # ]: 0 : rMtf.Record(&aOutDev);
477 [ # # ]: 0 : aOutDev.SetLineColor(Color(COL_BLACK));
478 [ # # ]: 0 : aOutDev.SetFillColor(Color(COL_BLACK));
479 : :
480 [ # # ][ # # ]: 0 : while (!bEoDt && !rInp.GetError()) {
[ # # ]
481 [ # # ]: 0 : rInp>>aVect; RecNr++;
482 : 0 : nFarb=(sal_uInt8) (aVect.Flag & 0x000F);
483 : 0 : nLTyp=(sal_uInt8)((aVect.Flag & 0x00F0) >>4);
484 : 0 : nOTyp=(sal_uInt8)((aVect.Flag & 0x0F00) >>8);
485 : 0 : bEoDt=(aVect.Flag & 0x4000) !=0;
486 : 0 : bPDwn=(aVect.Flag & 0x8000) !=0;
487 : :
488 : 0 : long x=aVect.x-rHead.Xoffs;
489 : 0 : long y=rHead.Ysize-(aVect.y-rHead.Yoffs);
490 [ # # ]: 0 : if (SgfVectScal) {
491 [ # # ]: 0 : if (SgfVectXdiv==0) SgfVectXdiv=rHead.Xsize;
492 [ # # ]: 0 : if (SgfVectYdiv==0) SgfVectYdiv=rHead.Ysize;
493 [ # # ]: 0 : if (SgfVectXdiv==0) SgfVectXdiv=1;
494 [ # # ]: 0 : if (SgfVectYdiv==0) SgfVectYdiv=1;
495 : 0 : x=SgfVectXofs+ x *SgfVectXmul /SgfVectXdiv;
496 : 0 : y=SgfVectYofs+ y *SgfVectXmul /SgfVectYdiv;
497 : : }
498 : 0 : aP1=Point(x,y);
499 [ # # ][ # # ]: 0 : if (!bEoDt && !rInp.GetError()) {
[ # # ]
500 [ # # ][ # # ]: 0 : if (bPDwn && nLTyp<=6) {
501 [ # # # # : 0 : switch(nOTyp) {
# ]
502 [ # # ]: 0 : case 1: if (nFarb!=nFrb0) {
503 [ # # # # ]: 0 : switch(rHead.SwGrCol) {
504 [ # # ]: 0 : case SgfVectFarb: aOutDev.SetLineColor(Hpgl2SvFarbe(nFarb)); break;
505 : 0 : case SgfVectGray: break;
506 : 0 : case SgfVectWdth: break;
507 : : }
508 : : }
509 [ # # ]: 0 : aOutDev.DrawLine(aP0,aP1); break; // Linie
510 : 0 : case 2: break; // Kreis
511 : 0 : case 3: break; // Text
512 [ # # ][ # # ]: 0 : case 5: aOutDev.DrawRect(Rectangle(aP0,aP1)); break; // Rechteck (solid)
513 : : }
514 : : }
515 : 0 : aP0=aP1;
516 : 0 : nFrb0=nFarb;
517 : : }
518 : : }
519 [ # # ]: 0 : rMtf.Stop();
520 [ # # ]: 0 : rMtf.WindStart();
521 : : MapMode aMap( MAP_10TH_MM, Point(),
522 [ # # ][ # # ]: 0 : Fraction( 1, 4 ), Fraction( 1, 4 ) );
[ # # ]
523 [ # # ]: 0 : rMtf.SetPrefMapMode( aMap );
524 : 0 : rMtf.SetPrefSize( Size( (short)rHead.Xsize, (short)rHead.Ysize ) );
525 [ # # ][ # # ]: 0 : return sal_True;
[ # # ]
526 : : }
527 : :
528 : :
529 : : /*************************************************************************
530 : : |*
531 : : |* SgfVectFilter()
532 : : |*
533 : : *************************************************************************/
534 : 0 : sal_Bool SgfVectFilter(SvStream& rInp, GDIMetaFile& rMtf)
535 : : {
536 : : sal_uLong nFileStart; // Offset des SgfHeaders. Im allgemeinen 0.
537 : : SgfHeader aHead;
538 : : SgfEntry aEntr;
539 : : sal_uLong nNext;
540 : 0 : sal_Bool bRdFlag=sal_False; // Grafikentry gelesen ?
541 : 0 : sal_Bool bRet=sal_False; // Returncode
542 : :
543 : 0 : nFileStart=rInp.Tell();
544 [ # # ]: 0 : rInp>>aHead;
545 [ # # ][ # # ]: 0 : if (aHead.ChkMagic() && aHead.Typ==SGF_SIMPVECT) {
[ # # ]
546 : 0 : nNext=aHead.GetOffset();
547 [ # # ][ # # ]: 0 : while (nNext && !bRdFlag && !rInp.GetError()) {
[ # # ][ # # ]
548 [ # # ]: 0 : rInp.Seek(nFileStart+nNext);
549 [ # # ]: 0 : rInp>>aEntr;
550 : 0 : nNext=aEntr.GetOffset();
551 [ # # ]: 0 : if (aEntr.Typ==aHead.Typ) {
552 [ # # ]: 0 : bRet=SgfFilterVect(rInp,aHead,aEntr,rMtf);
553 : : }
554 : : } // while(nNext)
555 [ # # ]: 0 : if (bRdFlag) {
556 [ # # ]: 0 : if (!rInp.GetError()) bRet=sal_True; // Scheinbar Ok
557 : : }
558 : : }
559 : 0 : return(bRet);
560 : : }
561 : :
562 : : /*************************************************************************
563 : : |*
564 : : |* CheckSgfTyp()
565 : : |*
566 : : |* Beschreibung Feststellen, um was fuer ein SGF/SGV es sich handelt.
567 : : |*
568 : : *************************************************************************/
569 : 6 : sal_uInt8 CheckSgfTyp(SvStream& rInp, sal_uInt16& nVersion)
570 : : {
571 : : #if OSL_DEBUG_LEVEL > 1 // Recordgroessen checken. Neuer Compiler hat vielleichte anderes Allignment!
572 : : if (sizeof(SgfHeader)!=SgfHeaderSize ||
573 : : sizeof(SgfEntry) !=SgfEntrySize ||
574 : : sizeof(SgfVector)!=SgfVectorSize ||
575 : : sizeof(BmpFileHeader)!=BmpFileHeaderSize ||
576 : : sizeof(BmpInfoHeader)!=BmpInfoHeaderSize ||
577 : : sizeof(RGBQuad )!=RGBQuadSize ) return SGF_DONTKNOW;
578 : : #endif
579 : :
580 : : sal_uLong nPos;
581 : : SgfHeader aHead;
582 : 6 : nVersion=0;
583 : 6 : nPos=rInp.Tell();
584 [ + - ]: 6 : rInp>>aHead;
585 [ + - ]: 6 : rInp.Seek(nPos);
586 [ + - ]: 6 : if (aHead.ChkMagic()) {
587 : 6 : nVersion=aHead.Version;
588 [ - - - + : 6 : switch(aHead.Typ) {
- ]
589 : : case SgfBitImag0:
590 : : case SgfBitImag1:
591 : : case SgfBitImag2:
592 : 0 : case SgfBitImgMo: return SGF_BITIMAGE;
593 : 0 : case SgfSimpVect: return SGF_SIMPVECT;
594 : 0 : case SgfPostScrp: return SGF_POSTSCRP;
595 : 6 : case SgfStarDraw: return SGF_STARDRAW;
596 : 0 : default : return SGF_DONTKNOW;
597 : : }
598 : : } else {
599 : 6 : return SGF_DONTKNOW;
600 : : }
601 : : }
602 : :
603 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
