?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / filter / source / graphicfilter / ios2met / ios2met.cxx
blobdebf296e56138a0bd0fa5de8fda192a918527abf
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <vcl/graph.hxx>
22 #include <tools/poly.hxx>
23 #include <vcl/virdev.hxx>
24 #include <vcl/lineinfo.hxx>
25
26 #include <math.h>
27
28 class FilterConfigItem;
29
30 // MT: NOOLDSV, someone should change the code...
31 enum PenStyle { PEN_NULL, PEN_SOLID, PEN_DOT, PEN_DASH, PEN_DASHDOT };
32
33
34 //============================== defines ===================================
35
36 #define OOODEBUG(str,Num) //InfoBox(NULL,String(str)+String(" ")+String(Num)).Execute();
37
38 // -----------------------------Feld-Typen-------------------------------
39
40 #define BegDocumnMagic 0xA8A8 /* Begin Document */
41 #define EndDocumnMagic 0xA8A9 /* End Document */
42
43 #define BegResGrpMagic 0xC6A8 /* Begin Resource Group */
44 #define EndResGrpMagic 0xC6A9 /* End Resource Group */
45
46 #define BegColAtrMagic 0x77A8 /* Begin Color Attribute Table */
47 #define EndColAtrMagic 0x77A9 /* End Color Attribute Table */
48 #define BlkColAtrMagic 0x77B0 /* Color Attribute Table */
49 #define MapColAtrMagic 0x77AB /* Map Color Attribute Table */
50
51 #define BegImgObjMagic 0xFBA8 /* Begin Image Object */
52 #define EndImgObjMagic 0xFBA9 /* End Image Object */
53 #define DscImgObjMagic 0xFBA6 /* Image Data Descriptor */
54 #define DatImgObjMagic 0xFBEE /* Image Picture Data */
55
56 #define BegObEnv1Magic 0xC7A8 /* Begin Object Environment Group */
57 #define EndObEnv1Magic 0xC7A9 /* End Object Environment Group */
58
59 #define BegGrfObjMagic 0xBBA8 /* Begin Graphics Object */
60 #define EndGrfObjMagic 0xBBA9 /* End Graphics Object */
61 #define DscGrfObjMagic 0xBBA6 /* Graphics Data Descritor */
62 #define DatGrfObjMagic 0xBBEE /* Graphics Data */
63
64 #define MapCodFntMagic 0x8AAB /* Map Coded Font */
65 #define MapDatResMagic 0xC3AB /* Map Data Resource */
66
67 // -----------------------------Order-Typen-------------------------------
68
69 #define GOrdGivArc 0xC6 /* 1 Arc at given position */
70 #define GOrdCurArc 0x86 /* 1 Arc at current position */
71 #define GOrdGivBzr 0xE5 /* 1 Beziercurve at given position */
72 #define GOrdCurBzr 0xA5 /* 1 Beziercurve at current position */
73 #define GOrdGivBox 0xC0 /* 1 Box at given position */
74 #define GOrdCurBox 0x80 /* 1 Box at current position */
75 #define GOrdGivFil 0xC5 /* 1 Fillet at given position */
76 #define GOrdCurFil 0x85 /* 1 Fillet at current position */
77 #define GOrdGivCrc 0xC7 /* 1 Full arc (circle) at given position */
78 #define GOrdCurCrc 0x87 /* 1 Full arc (circle) at current position */
79 #define GOrdGivLin 0xC1 /* 1 Line at given position */
80 #define GOrdCurLin 0x81 /* 1 Line at current position */
81 #define GOrdGivMrk 0xC2 /* 1 Marker at given position */
82 #define GOrdCurMrk 0x82 /* 1 Marker at current position */
83 #define GOrdGivArP 0xE3 /* 1 Partial arc at given position */
84 #define GOrdCurArP 0xA3 /* 1 Partial arc at current position */
85 #define GOrdGivRLn 0xE1 /* 1 Relative line at given position */
86 #define GOrdCurRLn 0xA1 /* 1 Relative line at current position */
87 #define GOrdGivSFl 0xE4 /* 1 Sharp fillet at given position */
88 #define GOrdCurSFl 0xA4 /* 1 Sharp fillet at current position */
89
90 #define GOrdGivStM 0xF1 /* 1 Character string move at given position */
91 #define GOrdCurStM 0xB1 /* 1 Character string move at current position */
92 #define GOrdGivStr 0xC3 /* 1 Character string at given position */
93 #define GOrdCurStr 0x83 /* 1 Character string at current position */
94 #define GOrdGivStx 0xFEF0 /* 2 Character string extended at given position */
95 #define GOrdCurStx 0xFEB0 /* 2 Character string extended at current position */
96
97 #define GOrdGivImg 0xD1 /* 1 Begin Image at given position */
98 #define GOrdCurImg 0x91 /* 1 Begin Image at current position */
99 #define GOrdImgDat 0x92 /* 1 Image data */
100 #define GOrdEndImg 0x93 /* 1 End Image */
101 #define GOrdBegAra 0x68 /* 0 1 Begin area */
102 #define GOrdEndAra 0x60 /* 1 End area */
103 #define GOrdBegElm 0xD2 /* 1 Begin element */
104 #define GOrdEndElm 0x49 /* 0 1 End element */
105
106 #define GOrdBegPth 0xD0 /* 1 Begin path */
107 #define GOrdEndPth 0x7F /* 0 1 End path */
108 #define GOrdFilPth 0xD7 /* 1 Fill path */
109 #define GOrdModPth 0xD8 /* 1 Modify path */
110 #define GOrdOutPth 0xD4 /* 1 Outline path */
111 #define GOrdSClPth 0xB4 /* 1 Set clip path */
112
113 #define GOrdNopNop 0x00 /* 0 0 No operation */
114 #define GOrdRemark 0x01 /* 1 Comment */
115 #define GOrdSegLab 0xD3 /* 1 Label */
116 #define GOrdBitBlt 0xD6 /* 1 Bitblt */
117 #define GOrdCalSeg 0x07 /* 1 Call Segment */
118 #define GOrdSSgBnd 0x32 /* 1 Set segment boundary */
119 #define GOrdSegChr 0x04 /* 1 Segment characteristics */
120 #define GOrdCloFig 0x7D /* 0 1 Close Figure */
121 #define GOrdEndSym 0xFF /* 0 0 End of symbol definition */
122 #define GOrdEndPlg 0x3E /* 0 1 End prolog */
123 #define GOrdEscape 0xD5 /* 1 Escape */
124 #define GOrdExtEsc 0xFED5 /* 2 Extended Escape */
125 #define GOrdPolygn 0xF3 /* 2 Polygons */
126
127 #define GOrdStkPop 0x3F /* 0 1 Pop */
128
129 #define GOrdSIvAtr 0x14 /* 1 Set individual attribute */
130 #define GOrdPIvAtr 0x54 /* 1 Push and set individual attribute */
131 #define GOrdSColor 0x0A /* 0 1 Set color */
132 #define GOrdPColor 0x4A /* 0 1 Push and set color */
133 #define GOrdSIxCol 0xA6 /* 1 Set indexed color */
134 #define GOrdPIxCol 0xE6 /* 1 Push and set indexed color */
135 #define GOrdSXtCol 0x26 /* 1 Set extended color */
136 #define GOrdPXtCol 0x66 /* 1 Push and set extended color */
137 #define GOrdSBgCol 0x25 /* 1 Set background color */
138 #define GOrdPBgCol 0x65 /* 1 Push and set background color */
139 #define GOrdSBxCol 0xA7 /* 1 Set background indexed color */
140 #define GOrdPBxCol 0xE7 /* 1 Push and set background indexed color */
141 #define GOrdSMixMd 0x0C /* 0 1 Set mix */
142 #define GOrdPMixMd 0x4C /* 0 1 Push and set mix */
143 #define GOrdSBgMix 0x0D /* 0 1 Set background mix */
144 #define GOrdPBgMix 0x4D /* 0 1 Push and set background mix */
145
146 #define GOrdSPtSet 0x08 /* 0 1 Set pattern set */
147 #define GOrdPPtSet 0x48 /* 0 1 Push and set pattern set */
148 #define GOrdSPtSym 0x28 /* 0 1 Set pattern symbol */
149 #define GOrdPPtSym 0x09 /* 0 1 Push and set pattern symbol */
150 #define GOrdSPtRef 0xA0 /* 1 Set model pattern reference */
151 #define GOrdPPtRef 0xE0 /* 1 Push and set pattern reference point */
152
153 #define GOrdSLnEnd 0x1A /* 0 1 Set line end */
154 #define GOrdPLnEnd 0x5A /* 0 1 Push and set line end */
155 #define GOrdSLnJoi 0x1B /* 0 1 Set line join */
156 #define GOrdPLnJoi 0x5B /* 0 1 Push and set line join */
157 #define GOrdSLnTyp 0x18 /* 0 1 Set line type */
158 #define GOrdPLnTyp 0x58 /* 0 1 Push and set line type */
159 #define GOrdSLnWdt 0x19 /* 0 1 Set line width */
160 #define GOrdPLnWdt 0x59 /* 0 1 Push and set line width */
161 #define GOrdSFrLWd 0x11 /* 1 Set fractional line width */
162 #define GOrdPFrLWd 0x51 /* 1 Push and set fractional line width */
163 #define GOrdSStLWd 0x15 /* 1 Set stroke line width */
164 #define GOrdPStLWd 0x55 /* 1 Push and set stroke line width */
165
166 #define GOrdSChDir 0x3A /* 0 1 Set character direction */
167 #define GOrdPChDir 0x7A /* 0 1 Push and set character direction */
168 #define GOrdSChPrc 0x39 /* 0 1 Set character precision */
169 #define GOrdPChPrc 0x79 /* 0 1 Push and set character precision */
170 #define GOrdSChSet 0x38 /* 0 1 Set character set */
171 #define GOrdPChSet 0x78 /* 0 1 Push and set character set */
172 #define GOrdSChAng 0x34 /* 1 Set character angle */
173 #define GOrdPChAng 0x74 /* 1 Push and set character angle */
174 #define GOrdSChBrx 0x05 /* 1 Set character break extra */
175 #define GOrdPChBrx 0x45 /* 1 Push and set character break extra */
176 #define GOrdSChCel 0x33 /* 1 Set character cell */
177 #define GOrdPChCel 0x03 /* 1 Push and set character cell */
178 #define GOrdSChXtr 0x17 /* 1 Set character extra */
179 #define GOrdPChXtr 0x57 /* 1 Push and set character extra */
180 #define GOrdSChShr 0x35 /* 1 Set character shear */
181 #define GOrdPChShr 0x75 /* 1 Push and set character shear */
182 #define GOrdSTxAlg 0x36 /* 0 2 Set text allingment */
183 #define GOrdPTxAlg 0x76 /* 0 2 Push and set text allingment */
184
185 #define GOrdSMkPrc 0x3B /* 0 1 Set marker precision */
186 #define GOrdPMkPrc 0x7B /* 0 1 Push and set marker precision */
187 #define GOrdSMkSet 0x3C /* 0 1 Set marker set */
188 #define GOrdPMkSet 0x7C /* 0 1 Push and set marker set */
189 #define GOrdSMkSym 0x29 /* 0 1 Set marker symbol */
190 #define GOrdPMkSym 0x69 /* 0 1 Push and set marker symbol */
191 #define GOrdSMkCel 0x37 /* 1 Set marker cell */
192 #define GOrdPMkCel 0x77 /* 1 Push and set marker cell */
193
194 #define GOrdSArcPa 0x22 /* 1 Set arc parameters */
195 #define GOrdPArcPa 0x62 /* 1 Push and set arc parameters */
196
197 #define GOrdSCrPos 0x21 /* 1 Set current position */
198 #define GOrdPCrPos 0x61 /* 1 Push and set current position */
199
200 #define GOrdSMdTrn 0x24 /* 1 Set model transform */
201 #define GOrdPMdTrn 0x64 /* 1 Push and set model transform */
202 #define GOrdSPkIdn 0x43 /* 1 Set pick identifier */
203 #define GOrdPPkIdn 0x23 /* 1 Push and set pick identifier */
204 #define GOrdSVwTrn 0x31 /* 1 Set viewing transform */
205 #define GOrdSVwWin 0x27 /* 1 Set viewing window */
206 #define GOrdPVwWin 0x67 /* 1 Push and set viewing window */
207
208 //============================ OS2METReader ==================================
209
210 struct OSPalette {
211 OSPalette * pSucc;
212 sal_uInt32 * p0RGB; // May be NULL!
213 sal_uInt16 nSize;
214 };
215
216 struct OSArea {
217 OSArea * pSucc;
218 sal_uInt8 nFlags;
219 PolyPolygon aPPoly;
220 sal_Bool bClosed;
221 Color aCol;
222 Color aBgCol;
223 RasterOp eMix;
224 RasterOp eBgMix;
225 sal_Bool bFill;
226 OSArea(){} ~OSArea(){}
227 };
228
229 struct OSPath
230 {
231 OSPath* pSucc;
232 sal_uInt32 nID;
233 PolyPolygon aPPoly;
234 sal_Bool bClosed;
235 sal_Bool bStroke;
236
237 OSPath(){}
238 ~OSPath(){}
239 };
240
241 struct OSFont {
242 OSFont * pSucc;
243 sal_uLong nID;
244 Font aFont;
245 OSFont(){} ~OSFont(){}
246 };
247
248 struct OSBitmap {
249 OSBitmap * pSucc;
250 sal_uLong nID;
251 Bitmap aBitmap;
252
253 // required during reading of the bitmap:
254 SvStream * pBMP; // pointer to temporary Windows-BMP file or NULL
255 sal_uInt32 nWidth, nHeight;
256 sal_uInt16 nBitsPerPixel;
257 sal_uLong nMapPos;
258 OSBitmap(){} ~OSBitmap(){}
259 };
260
261 struct OSAttr {
262 OSAttr * pSucc;
263 sal_uInt16 nPushOrder;
264 sal_uInt8 nIvAttrA, nIvAttrP; // special variables for the Order "GOrdPIvAtr"
265
266 Color aLinCol;
267 Color aLinBgCol;
268 RasterOp eLinMix;
269 RasterOp eLinBgMix;
270 Color aChrCol;
271 Color aChrBgCol;
272 RasterOp eChrMix;
273 RasterOp eChrBgMix;
274 Color aMrkCol;
275 Color aMrkBgCol;
276 RasterOp eMrkMix;
277 RasterOp eMrkBgMix;
278 Color aPatCol;
279 Color aPatBgCol;
280 RasterOp ePatMix;
281 RasterOp ePatBgMix;
282 Color aImgCol;
283 Color aImgBgCol;
284 RasterOp eImgMix;
285 RasterOp eImgBgMix;
286 long nArcP, nArcQ, nArcR, nArcS;
287 short nChrAng;
288 // long nChrBreakExtra;
289 Size aChrCellSize;
290 // sal_uInt8 nChrDir;
291 // long nChrExtra;
292 // sal_uInt8 nChrPrec;
293 sal_uLong nChrSet;
294 // Size aChrShear;
295 Point aCurPos;
296 // long nFracLinWidth;
297 // sal_uInt8 nLinEnd;
298 // sal_uInt8 nLinJoin;
299 PenStyle eLinStyle;
300 sal_uInt16 nLinWidth;
301 Size aMrkCellSize;
302 sal_uInt8 nMrkPrec;
303 sal_uInt8 nMrkSet;
304 sal_uInt8 nMrkSymbol;
305 // //... aModTransform;
306 // Point aPatRef;
307 // sal_uInt8 nPatSet;
308 sal_Bool bFill;
309 // sal_uLong nPickId;
310 // //... aSegBound;
311 sal_uInt16 nStrLinWidth;
312 // sal_uInt8 nTxtAlignHor,nTxtAlignVer;
313 // //... aViewTransform;
314 // //... aViewWindow;
315 OSAttr(){} ~OSAttr(){}
316 };
317
318 class OS2METReader {
319
320 private:
321
322 long ErrorCode;
323
324 SvStream * pOS2MET; // the OS2MET file to be read
325 VirtualDevice * pVirDev; // here the drawing methods are being called
326 // While doing this a recording in the GDIMetaFile
327 // will take place.
328 sal_uLong nOrigPos; // initial position in pOS2MET
329 sal_uInt16 nOrigNumberFormat; // initial number format of pOS2MET
330 Rectangle aBoundingRect; // bounding rectangle as stored in the file
331 Rectangle aCalcBndRect; // bounding rectangle calculated on our own
332 MapMode aGlobMapMode; // resolution of the picture
333 sal_Bool bCoord32;
334
335 OSPalette * pPaletteStack;
336
337 LineInfo aLineInfo;
338
339 OSArea * pAreaStack; // Areas that are being worked on
340
341 OSPath * pPathStack; // Paths that are being worked on
342 OSPath * pPathList; // finished Paths
343
344 OSFont * pFontList;
345
346 OSBitmap * pBitmapList;
347
348 OSAttr aDefAttr;
349 OSAttr aAttr;
350 OSAttr * pAttrStack;
351
352 SvStream * pOrdFile;
353
354 sal_Bool Callback(sal_uInt16 nPercent);
355
356 void AddPointsToPath(const Polygon & rPoly);
357 void AddPointsToArea(const Polygon & rPoly);
358 void CloseFigure();
359 void PushAttr(sal_uInt16 nPushOrder);
360 void PopAttr();
361
362 void ChangeBrush( const Color& rPatColor, const Color& rBGColor, sal_Bool bFill );
363 void SetPen( const Color& rColor, sal_uInt16 nStrLinWidth = 0, PenStyle ePenStyle = PEN_SOLID );
364 void SetRasterOp(RasterOp eROP);
365
366 void SetPalette0RGB(sal_uInt16 nIndex, sal_uLong nCol);
367 sal_uInt32 GetPalette0RGB(sal_uInt32 nIndex);
368 // gets color from palette, or, if it doesn't exist,
369 // interprets nIndex as immediate RGB value.
370 Color GetPaletteColor(sal_uInt32 nIndex);
371
372
373 sal_Bool IsLineInfo();
374 void DrawPolyLine( const Polygon& rPolygon );
375 void DrawPolygon( const Polygon& rPolygon );
376 void DrawPolyPolygon( const PolyPolygon& rPolygon );
377 sal_uInt16 ReadBigEndianWord();
378 sal_uLong ReadBigEndian3BytesLong();
379 sal_uLong ReadLittleEndian3BytesLong();
380 long ReadCoord(sal_Bool b32);
381 Point ReadPoint( const sal_Bool bAdjustBoundRect = sal_True );
382 RasterOp OS2MixToRasterOp(sal_uInt8 nMix);
383 void ReadLine(sal_Bool bGivenPos, sal_uInt16 nOrderLen);
384 void ReadRelLine(sal_Bool bGivenPos, sal_uInt16 nOrderLen);
385 void ReadBox(sal_Bool bGivenPos);
386 void ReadBitBlt();
387 void ReadChrStr(sal_Bool bGivenPos, sal_Bool bMove, sal_Bool bExtra, sal_uInt16 nOrderLen);
388 void ReadArc(sal_Bool bGivenPos);
389 void ReadFullArc(sal_Bool bGivenPos, sal_uInt16 nOrderSize);
390 void ReadPartialArc(sal_Bool bGivenPos, sal_uInt16 nOrderSize);
391 void ReadPolygons();
392 void ReadBezier(sal_Bool bGivenPos, sal_uInt16 nOrderLen);
393 void ReadFillet(sal_Bool bGivenPos, sal_uInt16 nOrderLen);
394 void ReadFilletSharp(sal_Bool bGivenPos, sal_uInt16 nOrderLen);
395 void ReadMarker(sal_Bool bGivenPos, sal_uInt16 nOrderLen);
396 void ReadOrder(sal_uInt16 nOrderID, sal_uInt16 nOrderLen);
397 void ReadDsc(sal_uInt16 nDscID, sal_uInt16 nDscLen);
398 void ReadImageData(sal_uInt16 nDataID, sal_uInt16 nDataLen);
399 void ReadFont(sal_uInt16 nFieldSize);
400 void ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize);
401
402 public:
403
404 OS2METReader();
405 ~OS2METReader();
406
407 void ReadOS2MET( SvStream & rStreamOS2MET, GDIMetaFile & rGDIMetaFile );
408 // Reads from the stream a OS2MET file und and fills up the GDIMetaFile
409
410 };
411
412 //=================== Methods of OS2METReader ==============================
413
414 sal_Bool OS2METReader::Callback(sal_uInt16 /*nPercent*/)
415 {
416 return sal_False;
417 }
418
419 OS2METReader::OS2METReader()
420 {
421 }
422
423 OS2METReader::~OS2METReader()
424 {
425 }
426
427 sal_Bool OS2METReader::IsLineInfo()
428 {
429 return ( ! ( aLineInfo.IsDefault() || ( aLineInfo.GetStyle() == LINE_NONE ) || ( pVirDev->GetLineColor() == COL_TRANSPARENT ) ) );
430 }
431
432 void OS2METReader::DrawPolyLine( const Polygon& rPolygon )
433 {
434 if ( aLineInfo.GetStyle() == LINE_DASH || ( aLineInfo.GetWidth() > 1 ) )
435 pVirDev->DrawPolyLine( rPolygon, aLineInfo );
436 else
437 pVirDev->DrawPolyLine( rPolygon );
438 }
439
440 void OS2METReader::DrawPolygon( const Polygon& rPolygon )
441 {
442 if ( IsLineInfo() )
443 {
444 pVirDev->Push( PUSH_LINECOLOR );
445 pVirDev->SetLineColor( COL_TRANSPARENT );
446 pVirDev->DrawPolygon( rPolygon );
447 pVirDev->Pop();
448 pVirDev->DrawPolyLine( rPolygon, aLineInfo );
449 }
450 else
451 pVirDev->DrawPolygon( rPolygon );
452 }
453
454 void OS2METReader::DrawPolyPolygon( const PolyPolygon& rPolyPolygon )
455 {
456 if ( IsLineInfo() )
457 {
458 pVirDev->Push( PUSH_LINECOLOR );
459 pVirDev->SetLineColor( COL_TRANSPARENT );
460 pVirDev->DrawPolyPolygon( rPolyPolygon );
461 pVirDev->Pop();
462 for ( sal_uInt16 i = 0; i < rPolyPolygon.Count(); i++ )
463 pVirDev->DrawPolyLine( rPolyPolygon.GetObject( i ), aLineInfo );
464 }
465 else
466 pVirDev->DrawPolyPolygon( rPolyPolygon );
467 }
468
469 void OS2METReader::AddPointsToArea(const Polygon & rPoly)
470 {
471 sal_uInt16 nOldSize, nNewSize,i;
472
473 if (pAreaStack==NULL || rPoly.GetSize()==0) return;
474 PolyPolygon * pPP=&(pAreaStack->aPPoly);
475 if (pPP->Count()==0 || pAreaStack->bClosed==sal_True) pPP->Insert(rPoly);
476 else {
477 Polygon aLastPoly(pPP->GetObject(pPP->Count()-1));
478 nOldSize=aLastPoly.GetSize();
479 if (aLastPoly.GetPoint(nOldSize-1)==rPoly.GetPoint(0)) nOldSize--;
480 nNewSize=nOldSize+rPoly.GetSize();
481 aLastPoly.SetSize(nNewSize);
482 for (i=nOldSize; i<nNewSize; i++) {
483 aLastPoly.SetPoint(rPoly.GetPoint(i-nOldSize),i);
484 }
485 pPP->Replace(aLastPoly,pPP->Count()-1);
486 }
487 pAreaStack->bClosed=sal_False;
488 }
489
490 void OS2METReader::AddPointsToPath(const Polygon & rPoly)
491 {
492 sal_uInt16 nOldSize, nNewSize,i;
493
494 if (pPathStack==NULL || rPoly.GetSize()==0) return;
495 PolyPolygon * pPP=&(pPathStack->aPPoly);
496 if (pPP->Count()==0 /*|| pPathStack->bClosed==sal_True*/) pPP->Insert(rPoly);
497 else {
498 Polygon aLastPoly(pPP->GetObject(pPP->Count()-1));
499 nOldSize=aLastPoly.GetSize();
500 if (aLastPoly.GetPoint(nOldSize-1)!=rPoly.GetPoint(0)) pPP->Insert(rPoly);
501 else {
502 nOldSize--;
503 nNewSize=nOldSize+rPoly.GetSize();
504 aLastPoly.SetSize(nNewSize);
505 for (i=nOldSize; i<nNewSize; i++) {
506 aLastPoly.SetPoint(rPoly.GetPoint(i-nOldSize),i);
507 }
508 pPP->Replace(aLastPoly,pPP->Count()-1);
509 }
510 }
511 pPathStack->bClosed=sal_False;
512 }
513
514 void OS2METReader::CloseFigure()
515 {
516 if (pAreaStack!=NULL) pAreaStack->bClosed=sal_True;
517 else if (pPathStack!=NULL) pPathStack->bClosed=sal_True;
518 }
519
520 void OS2METReader::PushAttr(sal_uInt16 nPushOrder)
521 {
522 OSAttr * p;
523 p=new OSAttr;
524 *p=aAttr;
525 p->pSucc=pAttrStack; pAttrStack=p;
526 p->nPushOrder=nPushOrder;
527 }
528
529 void OS2METReader::PopAttr()
530 {
531 OSAttr * p=pAttrStack;
532
533 if (p==NULL) return;
534 switch (p->nPushOrder) {
535
536 case GOrdPIvAtr:
537 switch (p->nIvAttrA) {
538 case 1: switch (p->nIvAttrP) {
539 case 1: aAttr.aLinCol=p->aLinCol; break;
540 case 2: aAttr.aChrCol=p->aChrCol; break;
541 case 3: aAttr.aMrkCol=p->aMrkCol; break;
542 case 4: aAttr.aPatCol=p->aPatCol; break;
543 case 5: aAttr.aImgCol=p->aImgCol; break;
544 } break;
545 case 2: switch (p->nIvAttrP) {
546 case 1: aAttr.aLinBgCol=p->aLinBgCol; break;
547 case 2: aAttr.aChrBgCol=p->aChrBgCol; break;
548 case 3: aAttr.aMrkBgCol=p->aMrkBgCol; break;
549 case 4: aAttr.aPatBgCol=p->aPatBgCol; break;
550 case 5: aAttr.aImgBgCol=p->aImgBgCol; break;
551 } break;
552 case 3: switch (p->nIvAttrP) {
553 case 1: aAttr.eLinMix=p->eLinMix; break;
554 case 2: aAttr.eChrMix=p->eChrMix; break;
555 case 3: aAttr.eMrkMix=p->eMrkMix; break;
556 case 4: aAttr.ePatMix=p->ePatMix; break;
557 case 5: aAttr.eImgMix=p->eImgMix; break;
558 } break;
559 case 4: switch (p->nIvAttrP) {
560 case 1: aAttr.eLinBgMix=p->eLinBgMix; break;
561 case 2: aAttr.eChrBgMix=p->eChrBgMix; break;
562 case 3: aAttr.eMrkBgMix=p->eMrkBgMix; break;
563 case 4: aAttr.ePatBgMix=p->ePatBgMix; break;
564 case 5: aAttr.eImgBgMix=p->eImgBgMix; break;
565 } break;
566 }
567 break;
568
569 case GOrdPLnTyp: aAttr.eLinStyle=p->eLinStyle; break;
570
571 case GOrdPLnWdt: aAttr.nLinWidth=p->nLinWidth; break;
572
573 case GOrdPStLWd: aAttr.nStrLinWidth=p->nStrLinWidth; break;
574
575 case GOrdPChSet: aAttr.nChrSet=p->nChrSet; break;
576
577 case GOrdPChAng: aAttr.nChrAng=p->nChrAng; break;
578
579 case GOrdPMixMd:
580 aAttr.eLinMix=p->eLinMix;
581 aAttr.eChrMix=p->eChrMix;
582 aAttr.eMrkMix=p->eMrkMix;
583 aAttr.ePatMix=p->ePatMix;
584 aAttr.eImgMix=p->eImgMix;
585 break;
586
587 case GOrdPBgMix:
588 aAttr.eLinBgMix=p->eLinBgMix;
589 aAttr.eChrBgMix=p->eChrBgMix;
590 aAttr.eMrkBgMix=p->eMrkBgMix;
591 aAttr.ePatBgMix=p->ePatBgMix;
592 aAttr.eImgBgMix=p->eImgBgMix;
593 break;
594
595 case GOrdPPtSym: aAttr.bFill = p->bFill; break;
596
597 case GOrdPColor:
598 case GOrdPIxCol:
599 case GOrdPXtCol:
600 aAttr.aLinCol=p->aLinCol;
601 aAttr.aChrCol=p->aChrCol;
602 aAttr.aMrkCol=p->aMrkCol;
603 aAttr.aPatCol=p->aPatCol;
604 aAttr.aImgCol=p->aImgCol;
605 break;
606
607 case GOrdPBgCol:
608 case GOrdPBxCol:
609 aAttr.aLinBgCol=p->aLinBgCol;
610 aAttr.aChrBgCol=p->aChrBgCol;
611 aAttr.aMrkBgCol=p->aMrkBgCol;
612 aAttr.aPatBgCol=p->aPatBgCol;
613 aAttr.aImgBgCol=p->aImgBgCol;
614 break;
615
616 case GOrdPMkPrc: aAttr.nMrkPrec=aDefAttr.nMrkPrec; break;
617
618 case GOrdPMkSet: aAttr.nMrkSet=aDefAttr.nMrkSet; break;
619
620 case GOrdPMkSym: aAttr.nMrkSymbol=aDefAttr.nMrkSymbol; break;
621
622 case GOrdPMkCel: aAttr.aMrkCellSize=aDefAttr.aMrkCellSize; break;
623
624 case GOrdPArcPa:
625 aAttr.nArcP=p->nArcP; aAttr.nArcQ=p->nArcQ;
626 aAttr.nArcR=p->nArcR; aAttr.nArcS=p->nArcS;
627 break;
628
629 case GOrdPCrPos:
630 aAttr.aCurPos=p->aCurPos;
631 break;
632 }
633 pAttrStack=p->pSucc;
634 delete p;
635 }
636
637 void OS2METReader::ChangeBrush(const Color& rPatColor, const Color& /*rBGColor*/, sal_Bool bFill )
638 {
639 Color aColor;
640
641 if( bFill )
642 aColor = rPatColor;
643 else
644 aColor = Color( COL_TRANSPARENT );
645
646 if( pVirDev->GetFillColor() != aColor )
647 pVirDev->SetFillColor( aColor );
648 }
649
650 void OS2METReader::SetPen( const Color& rColor, sal_uInt16 nLineWidth, PenStyle ePenStyle )
651 {
652 LineStyle eLineStyle( LINE_SOLID );
653
654 if ( pVirDev->GetLineColor() != rColor )
655 pVirDev->SetLineColor( rColor );
656 aLineInfo.SetWidth( nLineWidth );
657
658 sal_uInt16 nDotCount = 0;
659 sal_uInt16 nDashCount = 0;
660 switch ( ePenStyle )
661 {
662 case PEN_NULL :
663 eLineStyle = LINE_NONE;
664 break;
665 case PEN_DASHDOT :
666 nDashCount++;
667 case PEN_DOT :
668 nDotCount++;
669 nDashCount--;
670 case PEN_DASH :
671 nDashCount++;
672 aLineInfo.SetDotCount( nDotCount );
673 aLineInfo.SetDashCount( nDashCount );
674 aLineInfo.SetDistance( nLineWidth );
675 aLineInfo.SetDotLen( nLineWidth );
676 aLineInfo.SetDashLen( nLineWidth << 2 );
677 eLineStyle = LINE_DASH;
678 break;
679 case PEN_SOLID:
680 break; // -Wall not handled...
681 }
682 aLineInfo.SetStyle( eLineStyle );
683 }
684
685 void OS2METReader::SetRasterOp(RasterOp eROP)
686 {
687 if (pVirDev->GetRasterOp()!=eROP) pVirDev->SetRasterOp(eROP);
688 }
689
690
691 void OS2METReader::SetPalette0RGB(sal_uInt16 nIndex, sal_uLong nCol)
692 {
693 if (pPaletteStack==NULL) {
694 pPaletteStack=new OSPalette;
695 pPaletteStack->pSucc=NULL;
696 pPaletteStack->p0RGB=NULL;
697 pPaletteStack->nSize=0;
698 }
699 if (pPaletteStack->p0RGB==NULL || nIndex>=pPaletteStack->nSize) {
700 sal_uInt32 * pOld0RGB=pPaletteStack->p0RGB;
701 sal_uInt16 i,nOldSize=pPaletteStack->nSize;
702 if (pOld0RGB==NULL) nOldSize=0;
703 pPaletteStack->nSize=2*(nIndex+1);
704 if (pPaletteStack->nSize<256) pPaletteStack->nSize=256;
705 pPaletteStack->p0RGB = new sal_uInt32[pPaletteStack->nSize];
706 for (i=0; i<pPaletteStack->nSize; i++) {
707 if (i<nOldSize) pPaletteStack->p0RGB[i]=pOld0RGB[i];
708 else if (i==0) pPaletteStack->p0RGB[i]=0x00ffffff;
709 else pPaletteStack->p0RGB[i]=0;
710 }
711 if (pOld0RGB!=NULL) delete[] pOld0RGB;
712 }
713 pPaletteStack->p0RGB[nIndex]=nCol;
714 }
715
716 sal_uInt32 OS2METReader::GetPalette0RGB(sal_uInt32 nIndex)
717 {
718 if (pPaletteStack!=NULL && pPaletteStack->p0RGB!=NULL &&
719 pPaletteStack->nSize>nIndex) nIndex=pPaletteStack->p0RGB[nIndex];
720 return nIndex;
721 }
722
723 Color OS2METReader::GetPaletteColor(sal_uInt32 nIndex)
724 {
725 nIndex=GetPalette0RGB(nIndex);
726 return Color(sal::static_int_cast< sal_uInt8 >((nIndex>>16)&0xff),
727 sal::static_int_cast< sal_uInt8 >((nIndex>>8)&0xff),
728 sal::static_int_cast< sal_uInt8 >(nIndex&0xff));
729 }
730
731
732 sal_uInt16 OS2METReader::ReadBigEndianWord()
733 {
734 sal_uInt8 nLo,nHi;
735 *pOS2MET >> nHi >> nLo;
736 return (((sal_uInt16)nHi)<<8)|(((sal_uInt16)nLo)&0x00ff);
737 }
738
739 sal_uLong OS2METReader::ReadBigEndian3BytesLong()
740 {
741 sal_uInt16 nLo;
742 sal_uInt8 nHi;
743 *pOS2MET >> nHi;
744 nLo=ReadBigEndianWord();
745 return ((((sal_uLong)nHi)<<16)&0x00ff0000)|((sal_uLong)nLo);
746 }
747
748 sal_uLong OS2METReader::ReadLittleEndian3BytesLong()
749 {
750 sal_uInt8 nHi,nMed,nLo;
751
752 *pOS2MET >> nLo >> nMed >> nHi;
753 return ((((sal_uLong)nHi)&0xff)<<16)|((((sal_uLong)nMed)&0xff)<<8)|(((sal_uLong)nLo)&0xff);
754 }
755
756 long OS2METReader::ReadCoord(sal_Bool b32)
757 {
758 sal_Int32 l;
759
760 if (b32) *pOS2MET >> l;
761 else { short s;*pOS2MET >> s; l=(sal_Int32)s; }
762 return l;
763 }
764
765 Point OS2METReader::ReadPoint( const sal_Bool bAdjustBoundRect )
766 {
767 long x,y;
768
769 x=ReadCoord(bCoord32);
770 y=ReadCoord(bCoord32);
771 x=x-aBoundingRect.Left();
772 y=aBoundingRect.Bottom()-y;
773
774 if ( bAdjustBoundRect )
775 aCalcBndRect.Union(Rectangle(x,y,x+1,y+1));
776
777 return Point(x,y);
778 }
779
780 RasterOp OS2METReader::OS2MixToRasterOp(sal_uInt8 nMix)
781 {
782 switch (nMix) {
783 case 0x0c: return ROP_INVERT;
784 case 0x04: return ROP_XOR;
785 case 0x0b: return ROP_XOR;
786 default: return ROP_OVERPAINT;
787 }
788 }
789
790 void OS2METReader::ReadLine(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
791 {
792 sal_uInt16 i,nPolySize;
793
794 if (bCoord32) nPolySize=nOrderLen/8; else nPolySize=nOrderLen/4;
795 if (!bGivenPos) nPolySize++;
796 if (nPolySize==0) return;
797 Polygon aPolygon(nPolySize);
798 for (i=0; i<nPolySize; i++) {
799 if (i==0 && !bGivenPos) aPolygon.SetPoint(aAttr.aCurPos,i);
800 else aPolygon.SetPoint(ReadPoint(),i);
801 }
802 aAttr.aCurPos=aPolygon.GetPoint(nPolySize-1);
803 if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
804 else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
805 else
806 {
807 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
808 SetRasterOp(aAttr.eLinMix);
809 DrawPolyLine( aPolygon );
810 }
811 }
812
813 void OS2METReader::ReadRelLine(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
814 {
815 sal_uInt16 i,nPolySize;
816 Point aP0;
817
818
819 if (bGivenPos) {
820 aP0=ReadPoint();
821 if (bCoord32) nOrderLen-=8; else nOrderLen-=4;
822 }
823 else aP0=aAttr.aCurPos;
824 nPolySize=nOrderLen/2;
825 if (nPolySize==0) return;
826 Polygon aPolygon(nPolySize);
827 for (i=0; i<nPolySize; i++) {
828 #if defined SOLARIS && defined PPC
829 sal_uInt8 nunsignedbyte;
830 *pOS2MET >> nunsignedbyte; aP0.X()+=(sal_Int8)nunsignedbyte;
831 *pOS2MET >> nunsignedbyte; aP0.Y()+=(sal_Int8)nunsignedbyte;
832 #else
833 sal_Int8 nsignedbyte;
834 *pOS2MET >> nsignedbyte; aP0.X()+=(long)nsignedbyte;
835 *pOS2MET >> nsignedbyte; aP0.Y()-=(long)nsignedbyte;
836 #endif
837 aCalcBndRect.Union(Rectangle(aP0,Size(1,1)));
838 aPolygon.SetPoint(aP0,i);
839 }
840 aAttr.aCurPos=aPolygon.GetPoint(nPolySize-1);
841 if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
842 else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
843 else
844 {
845 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
846 SetRasterOp(aAttr.eLinMix);
847 DrawPolyLine( aPolygon );
848 }
849 }
850
851 void OS2METReader::ReadBox(sal_Bool bGivenPos)
852 {
853 sal_uInt8 nFlags;
854 Point P0;
855 long nHRound,nVRound;
856
857 *pOS2MET >> nFlags;
858 pOS2MET->SeekRel(1);
859
860 if ( bGivenPos )
861 P0 = ReadPoint();
862 else
863 P0 = aAttr.aCurPos;
864
865 aAttr.aCurPos=ReadPoint();
866 nHRound=ReadCoord(bCoord32);
867 nVRound=ReadCoord(bCoord32);
868
869 Rectangle aBoxRect( P0, aAttr.aCurPos );
870
871 if ( pAreaStack )
872 AddPointsToArea( Polygon( aBoxRect ) );
873 else if ( pPathStack )
874 AddPointsToPath( Polygon( aBoxRect ) );
875 else
876 {
877 if ( nFlags & 0x20 )
878 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
879 else
880 SetPen( COL_TRANSPARENT );
881
882 if ( nFlags & 0x40 )
883 {
884 ChangeBrush(aAttr.aPatCol,aAttr.aPatBgCol,aAttr.bFill);
885 SetRasterOp(aAttr.ePatMix);
886 }
887 else
888 {
889 ChangeBrush( Color( COL_TRANSPARENT ), Color( COL_TRANSPARENT ), sal_False );
890 SetRasterOp(aAttr.eLinMix);
891 }
892
893 if ( IsLineInfo() )
894 {
895 Polygon aPolygon( aBoxRect, nHRound, nVRound );
896 if ( nFlags & 0x40 )
897 {
898 pVirDev->Push( PUSH_LINECOLOR );
899 pVirDev->SetLineColor( COL_TRANSPARENT );
900 pVirDev->DrawRect( aBoxRect, nHRound, nVRound );
901 pVirDev->Pop();
902 }
903 pVirDev->DrawPolyLine( aPolygon, aLineInfo );
904 }
905 else
906 pVirDev->DrawRect( aBoxRect, nHRound, nVRound );
907 }
908 }
909
910 void OS2METReader::ReadBitBlt()
911 {
912 Point aP1,aP2;
913 Size aSize;
914 sal_uInt32 nID;
915 OSBitmap * pB;
916 long nt;
917
918 pOS2MET->SeekRel(4);
919 *pOS2MET >> nID;
920 pOS2MET->SeekRel(4);
921 aP1=ReadPoint(); aP2=ReadPoint();
922 if (aP1.X() > aP2.X()) { nt=aP1.X(); aP1.X()=aP2.X(); aP2.X()=nt; }
923 if (aP1.Y() > aP2.Y()) { nt=aP1.Y(); aP1.Y()=aP2.Y(); aP2.Y()=nt; }
924 aSize=Size(aP2.X()-aP1.X(),aP2.Y()-aP1.Y());
925
926 pB=pBitmapList;
927 while (pB!=NULL && pB->nID!=nID) pB=pB->pSucc;
928 if (pB!=NULL) {
929 SetRasterOp(aAttr.ePatMix);
930 pVirDev->DrawBitmap(aP1,aSize,pB->aBitmap);
931 }
932 }
933
934 void OS2METReader::ReadChrStr(sal_Bool bGivenPos, sal_Bool bMove, sal_Bool bExtra, sal_uInt16 nOrderLen)
935 {
936 Point aP0;
937 sal_uInt16 i, nLen;
938 char * pChr;
939 OSFont * pF;
940 Font aFont;
941 Size aSize;
942
943 pF = pFontList;
944 while (pF!=NULL && pF->nID!=aAttr.nChrSet) pF=pF->pSucc;
945 if (pF!=NULL)
946 aFont = pF->aFont;
947 aFont.SetColor(aAttr.aChrCol);
948 aFont.SetSize(Size(0,aAttr.aChrCellSize.Height()));
949 if ( aAttr.nChrAng != 0 )
950 aFont.SetOrientation(aAttr.nChrAng);
951
952 if (bGivenPos)
953 aP0 = ReadPoint();
954 else
955 aP0 = aAttr.aCurPos;
956 if (bExtra)
957 {
958 pOS2MET->SeekRel(2);
959 ReadPoint( sal_False );
960 ReadPoint( sal_False );
961 *pOS2MET >> nLen;
962 }
963 else
964 {
965 if ( !bGivenPos )
966 nLen = nOrderLen;
967 else if ( bCoord32 )
968 nLen = nOrderLen-8;
969 else
970 nLen = nOrderLen-4;
971 }
972 pChr = new char[nLen+1];
973 for (i=0; i<nLen; i++)
974 *pOS2MET >> pChr[i];
975 pChr[nLen] = 0;
976 String aStr( (const sal_Char*)pChr, osl_getThreadTextEncoding() );
977 SetRasterOp(aAttr.eChrMix);
978 if (pVirDev->GetFont()!=aFont)
979 pVirDev->SetFont(aFont);
980 pVirDev->DrawText(aP0,aStr);
981
982 aSize = Size( pVirDev->GetTextWidth(aStr), pVirDev->GetTextHeight() );
983 if ( aAttr.nChrAng == 0 )
984 {
985 aCalcBndRect.Union(Rectangle( Point(aP0.X(),aP0.Y()-aSize.Height()),
986 Size(aSize.Width(),aSize.Height()*2)));
987 if (bMove)
988 aAttr.aCurPos = Point( aP0.X() + aSize.Width(), aP0.Y());
989 }
990 else
991 {
992 Polygon aDummyPoly(4);
993
994 aDummyPoly.SetPoint( Point( aP0.X(), aP0.Y() ), 0); // TOP LEFT
995 aDummyPoly.SetPoint( Point( aP0.X(), aP0.Y() - aSize.Height() ), 1); // BOTTOM LEFT
996 aDummyPoly.SetPoint( Point( aP0.X() + aSize.Width(), aP0.Y() ), 2); // TOP RIGHT
997 aDummyPoly.SetPoint( Point( aP0.X() + aSize.Width(), aP0.Y() - aSize.Height() ), 3);// BOTTOM RIGHT
998 aDummyPoly.Rotate( aP0, (short)aAttr.nChrAng );
999 if ( bMove )
1000 aAttr.aCurPos = aDummyPoly.GetPoint( 0 );
1001 aCalcBndRect.Union( Rectangle( aDummyPoly.GetPoint( 0 ), aDummyPoly.GetPoint( 3 ) ) );
1002 aCalcBndRect.Union( Rectangle( aDummyPoly.GetPoint( 1 ), aDummyPoly.GetPoint( 2 ) ) );
1003 }
1004 delete[] pChr;
1005 }
1006
1007 void OS2METReader::ReadArc(sal_Bool bGivenPos)
1008 {
1009 Point aP1, aP2, aP3;
1010 double x1,y1,x2,y2,x3,y3,p,q,cx,cy,ncx,ncy,r,rx,ry,w1,w3;
1011 if (bGivenPos) aP1=ReadPoint(); else aP1=aAttr.aCurPos;
1012 aP2=ReadPoint(); aP3=ReadPoint();
1013 aAttr.aCurPos=aP3;
1014 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1015 SetRasterOp(aAttr.eLinMix);
1016 // Ok, given are 3 point of the ellipse, and the relation
1017 // of width and height (as p to q):
1018 x1=aP1.X(); y1=aP1.Y();
1019 x2=aP2.X(); y2=aP2.Y();
1020 x3=aP3.X(); y3=aP3.Y();
1021 p=aAttr.nArcP;q=aAttr.nArcQ;
1022 // Calculation of the center point cx, cy of the ellipse:
1023 ncy=2*p*p*((y3-y1)*(x2-x1)-(y1-y2)*(x1-x3));
1024 ncx=2*q*q*(x2-x1);
1025 if ( (ncx<0.001 && ncx>-0.001) || (ncy<0.001 && ncy>-0.001) ) {
1026 // Calculation impossible, points are all on the same straight line
1027 pVirDev->DrawLine(aP1,aP2);
1028 pVirDev->DrawLine(aP2,aP3);
1029 return;
1030 }
1031 cy=( q*q*((x3*x3-x1*x1)*(x2-x1)+(x2*x2-x1*x1)*(x1-x3)) +
1032 p*p*((y3*y3-y1*y1)*(x2-x1)+(y2*y2-y1*y1)*(x1-x3)) ) / ncy;
1033 cx=( q*q*(x2*x2-x1*x1)+p*p*(y2*y2-y1*y1)+cy*2*p*p*(y1-y2) ) / ncx;
1034 // now we still need the radius in x and y direction:
1035 r=sqrt(q*q*(x1-cx)*(x1-cx)+p*p*(y1-cy)*(y1-cy));
1036 rx=r/q; ry=r/p;
1037 // We now have to find out how the the starting and the end point
1038 // have to be choosen so that point no. 2 lies inside the drawn arc:
1039 w1=fmod((atan2(x1-cx,y1-cy)-atan2(x2-cx,y2-cy)),6.28318530718); if (w1<0) w1+=6.28318530718;
1040 w3=fmod((atan2(x3-cx,y3-cy)-atan2(x2-cx,y2-cy)),6.28318530718); if (w3<0) w3+=6.28318530718;
1041 if (w3<w1) {
1042 pVirDev->DrawArc(Rectangle((long)(cx-rx),(long)(cy-ry),
1043 (long)(cx+rx),(long)(cy+ry)),aP1,aP3);
1044 }
1045 else {
1046 pVirDev->DrawArc(Rectangle((long)(cx-rx),(long)(cy-ry),
1047 (long)(cx+rx),(long)(cy+ry)),aP3,aP1);
1048 }
1049 }
1050
1051 void OS2METReader::ReadFullArc(sal_Bool bGivenPos, sal_uInt16 nOrderSize)
1052 {
1053 Point aCenter;
1054 long nP,nQ,nR,nS;
1055 Rectangle aRect;
1056 sal_uInt32 nMul; sal_uInt16 nMulS;
1057
1058 if (bGivenPos) {
1059 aCenter=ReadPoint();
1060 if (bCoord32) nOrderSize-=8; else nOrderSize-=4;
1061 }
1062 else aCenter=aAttr.aCurPos;
1063
1064 nP=aAttr.nArcP; nQ=aAttr.nArcQ; nR=aAttr.nArcR; nS=aAttr.nArcS;
1065 if (nP<0) nP=-nP;
1066 if (nQ<0) nQ=-nQ;
1067 if (nR<0) nR=-nR;
1068 if (nS<0) nS=-nS;
1069 if (nOrderSize>=4) *pOS2MET >> nMul;
1070 else { *pOS2MET >> nMulS; nMul=((sal_uLong)nMulS)<<8; }
1071 if (nMul!=0x00010000) {
1072 nP=(nP*nMul)>>16;
1073 nQ=(nQ*nMul)>>16;
1074 nR=(nR*nMul)>>16;
1075 nS=(nS*nMul)>>16;
1076 }
1077
1078 aRect=Rectangle(aCenter.X()-nP,aCenter.Y()-nQ,
1079 aCenter.X()+nP,aCenter.Y()+nQ);
1080 aCalcBndRect.Union(aRect);
1081
1082 if (pAreaStack!=NULL) {
1083 ChangeBrush(aAttr.aPatCol,aAttr.aPatBgCol,aAttr.bFill);
1084 SetRasterOp(aAttr.ePatMix);
1085 if ((pAreaStack->nFlags&0x40)!=0)
1086 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1087 else
1088 SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1089 }
1090 else
1091 {
1092 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1093 ChangeBrush(Color( COL_TRANSPARENT ),Color( COL_TRANSPARENT ),sal_False);
1094 SetRasterOp(aAttr.eLinMix);
1095 }
1096 pVirDev->DrawEllipse(aRect);
1097 }
1098
1099 void OS2METReader::ReadPartialArc(sal_Bool bGivenPos, sal_uInt16 nOrderSize)
1100 {
1101 Point aP0, aCenter,aPStart,aPEnd;
1102 sal_Int32 nP,nQ,nR,nS,nStart, nSweep;
1103 Rectangle aRect;
1104 sal_uInt32 nMul; sal_uInt16 nMulS;
1105 double fStart, fEnd;
1106
1107 if (bGivenPos) {
1108 aP0=ReadPoint();
1109 if (bCoord32) nOrderSize-=8; else nOrderSize-=4;
1110 }
1111 else aP0=aAttr.aCurPos;
1112 aCenter=ReadPoint();
1113
1114 nP=aAttr.nArcP; nQ=aAttr.nArcQ; nR=aAttr.nArcR; nS=aAttr.nArcS;
1115 if (nP<0) nP=-nP;
1116 if (nQ<0) nQ=-nQ;
1117 if (nR<0) nR=-nR;
1118 if (nS<0) nS=-nS;
1119 if (nOrderSize>=12) *pOS2MET >> nMul;
1120 else { *pOS2MET >> nMulS; nMul=((sal_uLong)nMulS)<<8; }
1121 if (nMul!=0x00010000) {
1122 nP=(nP*nMul)>>16;
1123 nQ=(nQ*nMul)>>16;
1124 nR=(nR*nMul)>>16;
1125 nS=(nS*nMul)>>16;
1126 }
1127
1128 *pOS2MET >> nStart >> nSweep;
1129 fStart=((double)nStart)/65536.0/180.0*3.14159265359;
1130 fEnd=fStart+((double)nSweep)/65536.0/180.0*3.14159265359;
1131 aPStart=Point(aCenter.X()+(sal_Int32)( cos(fStart)*nP),
1132 aCenter.Y()+(sal_Int32)(-sin(fStart)*nQ));
1133 aPEnd= Point(aCenter.X()+(sal_Int32)( cos(fEnd)*nP),
1134 aCenter.Y()+(sal_Int32)(-sin(fEnd)*nQ));
1135
1136 aRect=Rectangle(aCenter.X()-nP,aCenter.Y()-nQ,
1137 aCenter.X()+nP,aCenter.Y()+nQ);
1138 aCalcBndRect.Union(aRect);
1139
1140 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1141 SetRasterOp(aAttr.eLinMix);
1142
1143 pVirDev->DrawLine(aP0,aPStart);
1144 pVirDev->DrawArc(aRect,aPStart,aPEnd);
1145 aAttr.aCurPos=aPEnd;
1146 }
1147
1148 void OS2METReader::ReadPolygons()
1149 {
1150 sal_uInt32 i,j,nNumPolys, nNumPoints;
1151 PolyPolygon aPolyPoly;
1152 Polygon aPoly;
1153 Point aPoint;
1154 sal_uInt8 nFlags;
1155
1156 *pOS2MET >> nFlags >> nNumPolys;
1157 for (i=0; i<nNumPolys; i++) {
1158 *pOS2MET >> nNumPoints;
1159 if (i==0) nNumPoints++;
1160 aPoly.SetSize((short)nNumPoints);
1161 for (j=0; j<nNumPoints; j++) {
1162 if (i==0 && j==0) aPoint=aAttr.aCurPos;
1163 else aPoint=ReadPoint();
1164 aPoly.SetPoint(aPoint,(short)j);
1165 if (i==nNumPolys-1 && j==nNumPoints-1) aAttr.aCurPos=aPoint;
1166 }
1167 aPolyPoly.Insert(aPoly);
1168 }
1169
1170 ChangeBrush(aAttr.aPatCol,aAttr.aPatBgCol,aAttr.bFill);
1171 SetRasterOp(aAttr.ePatMix);
1172 if ((nFlags&0x01)!=0)
1173 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1174 else
1175 SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1176 DrawPolyPolygon( aPolyPoly );
1177 }
1178
1179 void OS2METReader::ReadBezier(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1180 {
1181 sal_uInt16 i, nNumPoints = nOrderLen / ( bCoord32 ? 8 : 4 );
1182
1183 if( !bGivenPos )
1184 nNumPoints++;
1185
1186 if( !nNumPoints )
1187 return;
1188
1189 Polygon aPolygon( nNumPoints );
1190
1191 for( i=0; i < nNumPoints; i++ )
1192 {
1193 if( i==0 && !bGivenPos)
1194 aPolygon.SetPoint( aAttr.aCurPos, i );
1195 else
1196 aPolygon.SetPoint( ReadPoint(), i );
1197 }
1198
1199 if( !( nNumPoints % 4 ) )
1200 {
1201 // create bezier polygon
1202 const sal_uInt16 nSegPoints = 25;
1203 const sal_uInt16 nSegments = aPolygon.GetSize() >> 2;
1204 Polygon aBezPoly( nSegments * nSegPoints );
1205
1206 sal_uInt16 nSeg, nBezPos, nStartPos;
1207 for( nSeg = 0, nBezPos = 0, nStartPos = 0; nSeg < nSegments; nSeg++, nStartPos += 4 )
1208 {
1209 const Polygon aSegPoly( aPolygon[ nStartPos ], aPolygon[ nStartPos + 1 ],
1210 aPolygon[ nStartPos + 3 ], aPolygon[ nStartPos + 2 ],
1211 nSegPoints );
1212
1213 for( sal_uInt16 nSegPos = 0; nSegPos < nSegPoints; )
1214 aBezPoly[ nBezPos++ ] = aSegPoly[ nSegPos++ ];
1215 }
1216
1217 nNumPoints = nBezPos;
1218
1219 if( nNumPoints != aBezPoly.GetSize() )
1220 aBezPoly.SetSize( nNumPoints );
1221
1222 aPolygon = aBezPoly;
1223 }
1224
1225 aAttr.aCurPos = aPolygon[ nNumPoints - 1 ];
1226
1227 if (pAreaStack!=NULL)
1228 AddPointsToArea(aPolygon);
1229 else if (pPathStack!=NULL)
1230 AddPointsToPath(aPolygon);
1231 else
1232 {
1233 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1234 SetRasterOp(aAttr.eLinMix);
1235 DrawPolyLine( aPolygon );
1236 }
1237 }
1238
1239 void OS2METReader::ReadFillet(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1240 {
1241 sal_uInt16 i,nNumPoints;
1242
1243 if (bCoord32) nNumPoints=nOrderLen/8; else nNumPoints=nOrderLen/4;
1244 if (!bGivenPos) nNumPoints++;
1245 if (nNumPoints==0) return;
1246 Polygon aPolygon(nNumPoints);
1247 for (i=0; i<nNumPoints; i++) {
1248 if (i==0 && !bGivenPos) aPolygon.SetPoint(aAttr.aCurPos,i);
1249 else aPolygon.SetPoint(ReadPoint(),i);
1250 }
1251 aAttr.aCurPos=aPolygon.GetPoint(nNumPoints-1);
1252 if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
1253 else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
1254 else {
1255 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1256 SetRasterOp(aAttr.eLinMix);
1257 DrawPolyLine( aPolygon );
1258 }
1259 }
1260
1261 void OS2METReader::ReadFilletSharp(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1262 {
1263 sal_uInt16 i,nNumPoints;
1264
1265 if (bGivenPos) {
1266 aAttr.aCurPos=ReadPoint();
1267 if (bCoord32) nOrderLen-=8; else nOrderLen-=4;
1268 }
1269 if (bCoord32) nNumPoints=1+nOrderLen/10;
1270 else nNumPoints=1+nOrderLen/6;
1271 Polygon aPolygon(nNumPoints);
1272 aPolygon.SetPoint(aAttr.aCurPos,0);
1273 for (i=1; i<nNumPoints; i++) aPolygon.SetPoint(ReadPoint(),i);
1274 aAttr.aCurPos=aPolygon.GetPoint(nNumPoints-1);
1275 if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
1276 else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
1277 else
1278 {
1279 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1280 SetRasterOp(aAttr.eLinMix);
1281 DrawPolyLine( aPolygon );
1282 }
1283 }
1284
1285 void OS2METReader::ReadMarker(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1286 {
1287 sal_uInt16 i,nNumPoints;
1288 long x,y;
1289
1290 SetPen( aAttr.aMrkCol );
1291 SetRasterOp(aAttr.eMrkMix);
1292 if (aAttr.nMrkSymbol>=5 && aAttr.nMrkSymbol<=9)
1293 {
1294 ChangeBrush(aAttr.aMrkCol,aAttr.aMrkCol,sal_True);
1295 }
1296 else
1297 {
1298 ChangeBrush(Color(COL_TRANSPARENT),Color(COL_TRANSPARENT),sal_False);
1299 }
1300 if (bCoord32) nNumPoints=nOrderLen/8; else nNumPoints=nOrderLen/4;
1301 if (!bGivenPos) nNumPoints++;
1302 for (i=0; i<nNumPoints; i++) {
1303 if (i!=0 || bGivenPos) aAttr.aCurPos=ReadPoint();
1304 x=aAttr.aCurPos.X(); y=aAttr.aCurPos.Y();
1305 aCalcBndRect.Union(Rectangle(x-5,y-5,x+5,y+5));
1306 switch (aAttr.nMrkSymbol) {
1307 case 2: // PLUS
1308 pVirDev->DrawLine(Point(x-4,y),Point(x+4,y));
1309 pVirDev->DrawLine(Point(x,y-4),Point(x,y+4));
1310 break;
1311 case 3: // DIAMOND
1312 case 7: { // SOLIDDIAMOND
1313 Polygon aPoly(4);
1314 aPoly.SetPoint(Point(x,y+4),0);
1315 aPoly.SetPoint(Point(x+4,y),1);
1316 aPoly.SetPoint(Point(x,y-4),2);
1317 aPoly.SetPoint(Point(x-4,y),3);
1318 pVirDev->DrawPolygon(aPoly);
1319 break;
1320 }
1321 case 4: // SQARE
1322 case 8: { // SOLIDSUARE
1323 Polygon aPoly(4);
1324 aPoly.SetPoint(Point(x+4,y+4),0);
1325 aPoly.SetPoint(Point(x+4,y-4),1);
1326 aPoly.SetPoint(Point(x-4,y-4),2);
1327 aPoly.SetPoint(Point(x-4,y+4),3);
1328 pVirDev->DrawPolygon(aPoly);
1329 break;
1330 }
1331 case 5: { // SIXPOINTSTAR
1332 Polygon aPoly(12);
1333 aPoly.SetPoint(Point(x ,y-4),0);
1334 aPoly.SetPoint(Point(x+2,y-2),1);
1335 aPoly.SetPoint(Point(x+4,y-2),2);
1336 aPoly.SetPoint(Point(x+2,y ),3);
1337 aPoly.SetPoint(Point(x+4,y+2),4);
1338 aPoly.SetPoint(Point(x+2,y+2),5);
1339 aPoly.SetPoint(Point(x ,y+4),6);
1340 aPoly.SetPoint(Point(x-2,y+2),7);
1341 aPoly.SetPoint(Point(x-4,y+2),8);
1342 aPoly.SetPoint(Point(x-2,y ),9);
1343 aPoly.SetPoint(Point(x-4,y-2),10);
1344 aPoly.SetPoint(Point(x-2,y-2),11);
1345 pVirDev->DrawPolygon(aPoly);
1346 break;
1347 }
1348 case 6: { // EIGHTPOINTSTAR
1349 Polygon aPoly(16);
1350 aPoly.SetPoint(Point(x ,y-4),0);
1351 aPoly.SetPoint(Point(x+1,y-2),1);
1352 aPoly.SetPoint(Point(x+3,y-3),2);
1353 aPoly.SetPoint(Point(x+2,y-1),3);
1354 aPoly.SetPoint(Point(x+4,y ),4);
1355 aPoly.SetPoint(Point(x+2,y+1),5);
1356 aPoly.SetPoint(Point(x+3,y+3),6);
1357 aPoly.SetPoint(Point(x+1,y+2),7);
1358 aPoly.SetPoint(Point(x ,y+4),8);
1359 aPoly.SetPoint(Point(x-1,y+2),9);
1360 aPoly.SetPoint(Point(x-3,y+3),10);
1361 aPoly.SetPoint(Point(x-2,y+1),11);
1362 aPoly.SetPoint(Point(x-4,y ),12);
1363 aPoly.SetPoint(Point(x-2,y-1),13);
1364 aPoly.SetPoint(Point(x-3,y-3),14);
1365 aPoly.SetPoint(Point(x-1,y-2),15);
1366 pVirDev->DrawPolygon(aPoly);
1367 break;
1368 }
1369 case 9: // DOT
1370 pVirDev->DrawEllipse(Rectangle(x-1,y-1,x+1,y+1));
1371 break;
1372 case 10: // SMALLCIRCLE
1373 pVirDev->DrawEllipse(Rectangle(x-2,y-2,x+2,y+2));
1374 break;
1375 case 64: // BLANK
1376 break;
1377 default: // (=1) CROSS
1378 pVirDev->DrawLine(Point(x-4,y-4),Point(x+4,y+4));
1379 pVirDev->DrawLine(Point(x-4,y+4),Point(x+4,y-4));
1380 break;
1381 }
1382 }
1383 }
1384
1385 void OS2METReader::ReadOrder(sal_uInt16 nOrderID, sal_uInt16 nOrderLen)
1386 {
1387 switch (nOrderID) {
1388
1389 case GOrdGivArc: ReadArc(sal_True); break;
1390 case GOrdCurArc: ReadArc(sal_False); break;
1391
1392 case GOrdGivBzr: ReadBezier(sal_True,nOrderLen); break;
1393 case GOrdCurBzr: ReadBezier(sal_False,nOrderLen); break;
1394
1395 case GOrdGivBox: ReadBox(sal_True); break;
1396 case GOrdCurBox: ReadBox(sal_False); break;
1397
1398 case GOrdGivFil: ReadFillet(sal_True,nOrderLen); break;
1399 case GOrdCurFil: ReadFillet(sal_False,nOrderLen); break;
1400
1401 case GOrdGivCrc: ReadFullArc(sal_True,nOrderLen); break;
1402 case GOrdCurCrc: ReadFullArc(sal_False,nOrderLen); break;
1403
1404 case GOrdGivLin: ReadLine(sal_True, nOrderLen); break;
1405 case GOrdCurLin: ReadLine(sal_False, nOrderLen); break;
1406
1407 case GOrdGivMrk: ReadMarker(sal_True, nOrderLen); break;
1408 case GOrdCurMrk: ReadMarker(sal_False, nOrderLen); break;
1409
1410 case GOrdGivArP: ReadPartialArc(sal_True,nOrderLen); break;
1411 case GOrdCurArP: ReadPartialArc(sal_False,nOrderLen); break;
1412
1413 case GOrdGivRLn: ReadRelLine(sal_True,nOrderLen); break;
1414 case GOrdCurRLn: ReadRelLine(sal_False,nOrderLen); break;
1415
1416 case GOrdGivSFl: ReadFilletSharp(sal_True,nOrderLen); break;
1417 case GOrdCurSFl: ReadFilletSharp(sal_False,nOrderLen); break;
1418
1419 case GOrdGivStM: ReadChrStr(sal_True , sal_True , sal_False, nOrderLen); break;
1420 case GOrdCurStM: ReadChrStr(sal_False, sal_True , sal_False, nOrderLen); break;
1421 case GOrdGivStr: ReadChrStr(sal_True , sal_False, sal_False, nOrderLen); break;
1422 case GOrdCurStr: ReadChrStr(sal_False, sal_False, sal_False, nOrderLen); break;
1423 case GOrdGivStx: ReadChrStr(sal_True , sal_False, sal_True , nOrderLen); break;
1424 case GOrdCurStx: ReadChrStr(sal_False, sal_False, sal_True , nOrderLen); break;
1425
1426 case GOrdGivImg: OOODEBUG("GOrdGivImg",0);
1427 break;
1428 case GOrdCurImg: OOODEBUG("GOrdCurImg",0);
1429 break;
1430 case GOrdImgDat: OOODEBUG("GOrdImgDat",0);
1431 break;
1432 case GOrdEndImg: OOODEBUG("GOrdEndImg",0);
1433 break;
1434
1435 case GOrdBegAra: {
1436 OSArea * p=new OSArea;
1437 p->bClosed=sal_False;
1438 p->pSucc=pAreaStack; pAreaStack=p;
1439 *pOS2MET >> (p->nFlags);
1440 p->aCol=aAttr.aPatCol;
1441 p->aBgCol=aAttr.aPatBgCol;
1442 p->eMix=aAttr.ePatMix;
1443 p->eBgMix=aAttr.ePatBgMix;
1444 p->bFill=aAttr.bFill;
1445 break;
1446 }
1447 case GOrdEndAra:
1448 {
1449 OSArea * p=pAreaStack;
1450 if ( p )
1451 {
1452 pAreaStack = p->pSucc;
1453 if ( pPathStack )
1454 {
1455 for ( sal_uInt16 i=0; i<p->aPPoly.Count(); i++ )
1456 {
1457 AddPointsToPath( p->aPPoly.GetObject( i ) );
1458 CloseFigure();
1459 }
1460 }
1461 else
1462 {
1463 if ( ( p->nFlags & 0x40 ) == 0 )
1464 SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1465 else
1466 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1467
1468 ChangeBrush(p->aCol,p->aBgCol,p->bFill);
1469 SetRasterOp(p->eMix);
1470 DrawPolyPolygon( p->aPPoly );
1471 }
1472 delete p;
1473 }
1474 }
1475 break;
1476
1477 case GOrdBegElm:// OOODEBUG("GOrdBegElm",0);
1478 break;
1479 case GOrdEndElm:// OOODEBUG("GOrdEndElm",0);
1480 break;
1481
1482 case GOrdBegPth: {
1483 OSPath * p=new OSPath;
1484 p->pSucc=pPathStack; pPathStack=p;
1485 pOS2MET->SeekRel(2);
1486 *pOS2MET >> p->nID;
1487 p->bClosed=sal_False;
1488 p->bStroke=sal_False;
1489 break;
1490 }
1491 case GOrdEndPth: {
1492 OSPath * p, * pprev, * psucc;
1493 if (pPathStack==NULL) break;
1494 p=pPathList; pprev=NULL;
1495 while (p!=NULL) {
1496 psucc=p->pSucc;
1497 if (p->nID==pPathStack->nID) {
1498 if (pprev==NULL) pPathList=psucc; else pprev->pSucc=psucc;
1499 delete p;
1500 }
1501 else pprev=p;
1502 p=psucc;
1503 }
1504 p=pPathStack;
1505 pPathStack=p->pSucc;
1506 p->pSucc=pPathList; pPathList=p;
1507 break;
1508 }
1509 case GOrdFilPth:
1510 {
1511 sal_uInt32 nID;
1512 sal_uInt16 nDummy;
1513 OSPath* p = pPathList;
1514
1515 *pOS2MET >> nDummy
1516 >> nID;
1517
1518 if ( ! ( nDummy & 0x20 ) ) // #30933# i do not know the exact meaning of this bit,
1519 { // but if set it seems to be better not to fill this path
1520 while( p && p->nID != nID )
1521 p = p->pSucc;
1522
1523 if( p )
1524 {
1525 if( p->bStroke )
1526 {
1527 SetPen( aAttr.aPatCol, aAttr.nStrLinWidth, PEN_SOLID );
1528 ChangeBrush(Color(COL_TRANSPARENT),Color(COL_TRANSPARENT),sal_False);
1529 SetRasterOp( aAttr.ePatMix );
1530 if ( IsLineInfo() )
1531 {
1532 for ( sal_uInt16 i = 0; i < p->aPPoly.Count(); i++ )
1533 pVirDev->DrawPolyLine( p->aPPoly.GetObject( i ), aLineInfo );
1534 }
1535 else
1536 pVirDev->DrawPolyPolygon( p->aPPoly );
1537 }
1538 else
1539 {
1540 SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1541 ChangeBrush( aAttr.aPatCol, aAttr.aPatBgCol, aAttr.bFill );
1542 SetRasterOp( aAttr.ePatMix );
1543 pVirDev->DrawPolyPolygon( p->aPPoly );
1544 }
1545 }
1546 }
1547 }
1548 break;
1549
1550 case GOrdModPth:
1551 {
1552 OSPath* p = pPathList;
1553
1554 while( p && p->nID != 1 )
1555 p = p->pSucc;
1556
1557 if( p )
1558 p->bStroke = sal_True;
1559 }
1560 break;
1561
1562 case GOrdOutPth:
1563 {
1564 sal_uInt32 nID;
1565 sal_uInt16 i,nC;
1566 OSPath* p=pPathList;
1567 pOS2MET->SeekRel(2);
1568 *pOS2MET >> nID;
1569 while (p!=NULL && p->nID!=nID)
1570 p=p->pSucc;
1571
1572 if( p!=NULL )
1573 {
1574 SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1575 SetRasterOp(aAttr.eLinMix);
1576 ChangeBrush(Color(COL_TRANSPARENT),Color(COL_TRANSPARENT),sal_False);
1577 nC=p->aPPoly.Count();
1578 for (i=0; i<nC; i++)
1579 {
1580 if (i+1<nC || p->bClosed==sal_True)
1581 DrawPolygon( p->aPPoly.GetObject( i ) );
1582 else
1583 DrawPolyLine( p->aPPoly.GetObject( i ) );
1584 }
1585 }
1586 break;
1587 }
1588 case GOrdSClPth: { OOODEBUG("GOrdSClPth",0);
1589 sal_uInt32 nID;
1590 OSPath * p=pPathList;
1591 pOS2MET->SeekRel(2);
1592 *pOS2MET >> nID;
1593 if (nID==0) p=NULL;
1594 while (p!=NULL && p->nID!=nID) p=p->pSucc;
1595 if (p!=NULL) pVirDev->SetClipRegion(Region(p->aPPoly));
1596 else pVirDev->SetClipRegion();
1597 break;
1598 }
1599 case GOrdNopNop:
1600 break;
1601 case GOrdRemark: //OOODEBUG("GOrdRemark",0);
1602 break;
1603 case GOrdSegLab: OOODEBUG("GOrdSegLab",0);
1604 break;
1605
1606 case GOrdBitBlt: ReadBitBlt(); break;
1607
1608 case GOrdCalSeg: OOODEBUG("GOrdCalSeg",0);
1609 break;
1610 case GOrdSSgBnd: OOODEBUG("GOrdSSgBnd",0);
1611 break;
1612 case GOrdSegChr: OOODEBUG("GOrdSegChr",0);
1613 break;
1614 case GOrdCloFig:
1615 CloseFigure();
1616 break;
1617 case GOrdEndSym: OOODEBUG("GOrdEndSym",0);
1618 break;
1619 case GOrdEndPlg: OOODEBUG("GOrdEndPlg",0);
1620 break;
1621 case GOrdEscape: OOODEBUG("GOrdEscape",0);
1622 break;
1623 case GOrdExtEsc: OOODEBUG("GOrdExtEsc",0);
1624 break;
1625
1626 case GOrdPolygn: ReadPolygons(); break;
1627
1628 case GOrdStkPop: PopAttr(); break;
1629
1630 case GOrdPIvAtr: PushAttr(nOrderID);
1631 case GOrdSIvAtr: {
1632 sal_uInt8 nA, nP, nFlags, nMix;
1633 sal_uLong nVal;
1634 Color aCol;
1635 RasterOp eROP;
1636 *pOS2MET >> nA >> nP >> nFlags;
1637 if (nOrderID==GOrdPIvAtr) {
1638 pAttrStack->nIvAttrA=nA;
1639 pAttrStack->nIvAttrP=nP;
1640 }
1641 if (nA<=2) {
1642 if ((nFlags&0x80)!=0) {
1643 if (nA==1) switch (nP) {
1644 case 1: aAttr.aLinCol=aDefAttr.aLinCol; break;
1645 case 2: aAttr.aChrCol=aDefAttr.aChrCol; break;
1646 case 3: aAttr.aMrkCol=aDefAttr.aMrkCol; break;
1647 case 4: aAttr.aPatCol=aDefAttr.aPatCol; break;
1648 case 5: aAttr.aImgCol=aDefAttr.aImgCol; break;
1649 }
1650 else switch (nP) {
1651 case 1: aAttr.aLinBgCol=aDefAttr.aLinBgCol; break;
1652 case 2: aAttr.aChrBgCol=aDefAttr.aChrBgCol; break;
1653 case 3: aAttr.aMrkBgCol=aDefAttr.aMrkBgCol; break;
1654 case 4: aAttr.aPatBgCol=aDefAttr.aPatBgCol; break;
1655 case 5: aAttr.aImgBgCol=aDefAttr.aImgBgCol; break;
1656 }
1657 }
1658 else {
1659 nVal=ReadLittleEndian3BytesLong();
1660 if ((nFlags&0x40)!=0 && nVal==1) aCol=Color(COL_BLACK);
1661 else if ((nFlags&0x40)!=0 && nVal==2) aCol=Color(COL_WHITE);
1662 else if ((nFlags&0x40)!=0 && nVal==4) aCol=Color(COL_WHITE);
1663 else if ((nFlags&0x40)!=0 && nVal==5) aCol=Color(COL_BLACK);
1664 else aCol=GetPaletteColor(nVal);
1665 if (nA==1) switch (nP) {
1666 case 1: aAttr.aLinCol=aCol; break;
1667 case 2: aAttr.aChrCol=aCol; break;
1668 case 3: aAttr.aMrkCol=aCol; break;
1669 case 4: aAttr.aPatCol=aCol; break;
1670 case 5: aAttr.aImgCol=aCol; break;
1671 }
1672 else switch (nP) {
1673 case 1: aAttr.aLinBgCol=aCol; break;
1674 case 2: aAttr.aChrBgCol=aCol; break;
1675 case 3: aAttr.aMrkBgCol=aCol; break;
1676 case 4: aAttr.aPatBgCol=aCol; break;
1677 case 5: aAttr.aImgBgCol=aCol; break;
1678 }
1679 }
1680 }
1681 else {
1682 *pOS2MET >> nMix;
1683 if (nMix==0) {
1684 switch (nP) {
1685 case 1: aAttr.eLinBgMix=aDefAttr.eLinBgMix; break;
1686 case 2: aAttr.eChrBgMix=aDefAttr.eChrBgMix; break;
1687 case 3: aAttr.eMrkBgMix=aDefAttr.eMrkBgMix; break;
1688 case 4: aAttr.ePatBgMix=aDefAttr.ePatBgMix; break;
1689 case 5: aAttr.eImgBgMix=aDefAttr.eImgBgMix; break;
1690 }
1691 }
1692 else {
1693 eROP=OS2MixToRasterOp(nMix);
1694 switch (nP) {
1695 case 1: aAttr.eLinBgMix=eROP; break;
1696 case 2: aAttr.eChrBgMix=eROP; break;
1697 case 3: aAttr.eMrkBgMix=eROP; break;
1698 case 4: aAttr.ePatBgMix=eROP; break;
1699 case 5: aAttr.eImgBgMix=eROP; break;
1700 }
1701 }
1702 }
1703 break;
1704 }
1705 case GOrdPIxCol: PushAttr(nOrderID);
1706 case GOrdSIxCol: {
1707 sal_uInt8 nFlags;
1708 sal_uLong nVal;
1709 Color aCol;
1710 *pOS2MET >> nFlags;
1711 if ((nFlags&0x80)!=0) {
1712 aAttr.aLinCol=aDefAttr.aLinCol;
1713 aAttr.aChrCol=aDefAttr.aChrCol;
1714 aAttr.aMrkCol=aDefAttr.aMrkCol;
1715 aAttr.aPatCol=aDefAttr.aPatCol;
1716 aAttr.aImgCol=aDefAttr.aImgCol;
1717 }
1718 else {
1719 nVal=ReadLittleEndian3BytesLong();
1720 if ((nFlags&0x40)!=0 && nVal==1) aCol=Color(COL_BLACK);
1721 else if ((nFlags&0x40)!=0 && nVal==2) aCol=Color(COL_WHITE);
1722 else if ((nFlags&0x40)!=0 && nVal==4) aCol=Color(COL_WHITE);
1723 else if ((nFlags&0x40)!=0 && nVal==5) aCol=Color(COL_BLACK);
1724 else aCol=GetPaletteColor(nVal);
1725 aAttr.aLinCol = aAttr.aChrCol = aAttr.aMrkCol = aAttr.aPatCol =
1726 aAttr.aImgCol = aCol;
1727 }
1728 break;
1729 }
1730
1731 case GOrdPColor:
1732 case GOrdPXtCol: PushAttr(nOrderID);
1733 case GOrdSColor:
1734 case GOrdSXtCol: {
1735 sal_uInt8 nbyte;
1736 sal_uInt16 nVal;
1737 Color aCol;
1738 if (nOrderID==GOrdPColor || nOrderID==GOrdSColor) {
1739 *pOS2MET >> nbyte; nVal=((sal_uInt16)nbyte)|0xff00;
1740 }
1741 else *pOS2MET >> nVal;
1742 if (nVal==0x0000 || nVal==0xff00) {
1743 aAttr.aLinCol=aDefAttr.aLinCol;
1744 aAttr.aChrCol=aDefAttr.aChrCol;
1745 aAttr.aMrkCol=aDefAttr.aMrkCol;
1746 aAttr.aPatCol=aDefAttr.aPatCol;
1747 aAttr.aImgCol=aDefAttr.aImgCol;
1748 }
1749 else {
1750 if (nVal==0x0007) aCol=Color(COL_WHITE);
1751 else if (nVal==0x0008) aCol=Color(COL_BLACK);
1752 else if (nVal==0xff08) aCol=GetPaletteColor(1);
1753 else aCol=GetPaletteColor(((sal_uLong)nVal) & 0x000000ff);
1754 aAttr.aLinCol = aAttr.aChrCol = aAttr.aMrkCol = aAttr.aPatCol =
1755 aAttr.aImgCol = aCol;
1756 }
1757 break;
1758 }
1759
1760 case GOrdPBgCol: PushAttr(nOrderID);
1761 case GOrdSBgCol: {
1762 sal_uInt16 nVal;
1763 Color aCol;
1764 *pOS2MET >> nVal;
1765 if (nVal==0x0000 || nVal==0xff00) {
1766 aAttr.aLinBgCol=aDefAttr.aLinBgCol;
1767 aAttr.aChrBgCol=aDefAttr.aChrBgCol;
1768 aAttr.aMrkBgCol=aDefAttr.aMrkBgCol;
1769 aAttr.aPatBgCol=aDefAttr.aPatBgCol;
1770 aAttr.aImgBgCol=aDefAttr.aImgBgCol;
1771 }
1772 else {
1773 if (nVal==0x0007) aCol=Color(COL_WHITE);
1774 else if (nVal==0x0008) aCol=Color(COL_BLACK);
1775 else if (nVal==0xff08) aCol=GetPaletteColor(0);
1776 else aCol=GetPaletteColor(((sal_uLong)nVal) & 0x000000ff);
1777 aAttr.aLinBgCol = aAttr.aChrBgCol = aAttr.aMrkBgCol =
1778 aAttr.aPatBgCol = aAttr.aImgBgCol = aCol;
1779 }
1780 break;
1781 }
1782 case GOrdPBxCol: PushAttr(nOrderID);
1783 case GOrdSBxCol: {
1784 sal_uInt8 nFlags;
1785 sal_uLong nVal;
1786 Color aCol;
1787 *pOS2MET >> nFlags;
1788 if ((nFlags&0x80)!=0) {
1789 aAttr.aLinBgCol=aDefAttr.aLinBgCol;
1790 aAttr.aChrBgCol=aDefAttr.aChrBgCol;
1791 aAttr.aMrkBgCol=aDefAttr.aMrkBgCol;
1792 aAttr.aPatBgCol=aDefAttr.aPatBgCol;
1793 aAttr.aImgBgCol=aDefAttr.aImgBgCol;
1794 }
1795 else {
1796 nVal=ReadLittleEndian3BytesLong();
1797 if ((nFlags&0x40)!=0 && nVal==1) aCol=Color(COL_BLACK);
1798 else if ((nFlags&0x40)!=0 && nVal==2) aCol=Color(COL_WHITE);
1799 else if ((nFlags&0x40)!=0 && nVal==4) aCol=Color(COL_WHITE);
1800 else if ((nFlags&0x40)!=0 && nVal==5) aCol=Color(COL_BLACK);
1801 else aCol=GetPaletteColor(nVal);
1802 aAttr.aLinBgCol = aAttr.aChrBgCol = aAttr.aMrkBgCol =
1803 aAttr.aPatBgCol = aAttr.aImgBgCol = aCol;
1804 }
1805 break;
1806 }
1807
1808 case GOrdPMixMd: PushAttr(nOrderID);
1809 case GOrdSMixMd: {
1810 sal_uInt8 nMix;
1811 *pOS2MET >> nMix;
1812 if (nMix==0) {
1813 aAttr.eLinMix=aDefAttr.eLinMix;
1814 aAttr.eChrMix=aDefAttr.eChrMix;
1815 aAttr.eMrkMix=aDefAttr.eMrkMix;
1816 aAttr.ePatMix=aDefAttr.ePatMix;
1817 aAttr.eImgMix=aDefAttr.eImgMix;
1818 }
1819 else {
1820 aAttr.eLinMix = aAttr.eChrMix = aAttr.eMrkMix =
1821 aAttr.ePatMix = aAttr.eImgMix = OS2MixToRasterOp(nMix);
1822 }
1823 break;
1824 }
1825 case GOrdPBgMix: PushAttr(nOrderID);
1826 case GOrdSBgMix: {
1827 sal_uInt8 nMix;
1828 *pOS2MET >> nMix;
1829 if (nMix==0) {
1830 aAttr.eLinBgMix=aDefAttr.eLinBgMix;
1831 aAttr.eChrBgMix=aDefAttr.eChrBgMix;
1832 aAttr.eMrkBgMix=aDefAttr.eMrkBgMix;
1833 aAttr.ePatBgMix=aDefAttr.ePatBgMix;
1834 aAttr.eImgBgMix=aDefAttr.eImgBgMix;
1835 }
1836 else {
1837 aAttr.eLinBgMix = aAttr.eChrBgMix = aAttr.eMrkBgMix =
1838 aAttr.ePatBgMix = aAttr.eImgBgMix = OS2MixToRasterOp(nMix);
1839 }
1840 break;
1841 }
1842 case GOrdPPtSet: PushAttr(nOrderID);
1843 case GOrdSPtSet: OOODEBUG("GOrdSPtSet",0);
1844 break;
1845
1846 case GOrdPPtSym: PushAttr(nOrderID);
1847 case GOrdSPtSym: {
1848 sal_uInt8 nPatt;
1849 *pOS2MET >> nPatt;
1850 aAttr.bFill = ( nPatt != 0x0f );
1851 break;
1852 }
1853
1854 case GOrdPPtRef: PushAttr(nOrderID);
1855 case GOrdSPtRef: OOODEBUG("GOrdSPtRef",0);
1856 break;
1857
1858 case GOrdPLnEnd: PushAttr(nOrderID);
1859 case GOrdSLnEnd:
1860 break;
1861
1862 case GOrdPLnJoi: PushAttr(nOrderID);
1863 case GOrdSLnJoi:
1864 break;
1865
1866 case GOrdPLnTyp: PushAttr(nOrderID);
1867 case GOrdSLnTyp: {
1868 sal_uInt8 nType;
1869 *pOS2MET >> nType;
1870 switch (nType) {
1871 case 0: aAttr.eLinStyle=aDefAttr.eLinStyle; break;
1872 case 1: case 4: aAttr.eLinStyle=PEN_DOT; break;
1873 case 2: case 5: aAttr.eLinStyle=PEN_DASH; break;
1874 case 3: case 6: aAttr.eLinStyle=PEN_DASHDOT; break;
1875 case 8: aAttr.eLinStyle=PEN_NULL; break;
1876 default: aAttr.eLinStyle=PEN_SOLID;
1877 }
1878 break;
1879 }
1880 case GOrdPLnWdt: PushAttr(nOrderID);
1881 case GOrdSLnWdt: {
1882 sal_uInt8 nbyte;
1883 *pOS2MET >> nbyte;
1884 if (nbyte==0) aAttr.nLinWidth=aDefAttr.nLinWidth;
1885 else aAttr.nLinWidth=(sal_uInt16)nbyte-1;
1886 break;
1887 }
1888 case GOrdPFrLWd: PushAttr(nOrderID);
1889 case GOrdSFrLWd:
1890 break;
1891
1892 case GOrdPStLWd: PushAttr(nOrderID);
1893 case GOrdSStLWd :
1894 {
1895 sal_uInt8 nFlags;
1896
1897 *pOS2MET >> nFlags;
1898 if ( nFlags & 0x80 )
1899 aAttr.nStrLinWidth = aDefAttr.nStrLinWidth;
1900 else
1901 {
1902 pOS2MET->SeekRel( 1 );
1903 long nWd = ReadCoord( bCoord32 );
1904 if ( nWd < 0 )
1905 nWd = -nWd;
1906 aAttr.nStrLinWidth = (sal_uInt16)nWd;
1907 }
1908 break;
1909 }
1910 case GOrdPChDir: PushAttr(nOrderID);
1911 case GOrdSChDir:
1912 break;
1913
1914 case GOrdPChPrc: PushAttr(nOrderID);
1915 case GOrdSChPrc:
1916 break;
1917
1918 case GOrdPChSet: PushAttr(nOrderID);
1919 case GOrdSChSet: {
1920 sal_uInt8 nbyte; *pOS2MET >> nbyte;
1921 aAttr.nChrSet=((sal_uLong)nbyte)&0xff;
1922 break;
1923 }
1924 case GOrdPChAng: PushAttr(nOrderID);
1925 case GOrdSChAng: {
1926 long nX,nY;
1927 nX=ReadCoord(bCoord32); nY=ReadCoord(bCoord32);
1928 if (nX>=0 && nY==0) aAttr.nChrAng=0;
1929 else {
1930 aAttr.nChrAng=(short)(atan2((double)nY,(double)nX)/3.1415926539*1800.0);
1931 while (aAttr.nChrAng<0) aAttr.nChrAng+=3600;
1932 aAttr.nChrAng%=3600;
1933 }
1934 break;
1935 }
1936 case GOrdPChBrx: PushAttr(nOrderID);
1937 case GOrdSChBrx:
1938 break;
1939
1940 case GOrdPChCel: PushAttr(nOrderID);
1941 case GOrdSChCel: {
1942 sal_uInt8 nbyte;
1943 sal_uInt16 nLen=nOrderLen;
1944 aAttr.aChrCellSize.Width()=ReadCoord(bCoord32);
1945 aAttr.aChrCellSize.Height()=ReadCoord(bCoord32);
1946 if (bCoord32) nLen-=8; else nLen-=4;
1947 if (nLen>=4) {
1948 pOS2MET->SeekRel(4); nLen-=4;
1949 }
1950 if (nLen>=2) {
1951 *pOS2MET >> nbyte;
1952 if ((nbyte&0x80)==0 && aAttr.aChrCellSize==Size(0,0))
1953 aAttr.aChrCellSize=aDefAttr.aChrCellSize;
1954 }
1955 break;
1956 }
1957 case GOrdPChXtr: PushAttr(nOrderID);
1958 case GOrdSChXtr:
1959 break;
1960
1961 case GOrdPChShr: PushAttr(nOrderID);
1962 case GOrdSChShr:
1963 break;
1964
1965 case GOrdPTxAlg: PushAttr(nOrderID);
1966 case GOrdSTxAlg: OOODEBUG("GOrdSTxAlg",0);
1967 break;
1968
1969 case GOrdPMkPrc: PushAttr(nOrderID);
1970 case GOrdSMkPrc: {
1971 sal_uInt8 nbyte;
1972 *pOS2MET >> nbyte;
1973 if (nbyte==0) aAttr.nMrkPrec=aDefAttr.nMrkPrec;
1974 else aAttr.nMrkPrec=nbyte;
1975 break;
1976 }
1977
1978 case GOrdPMkSet: PushAttr(nOrderID);
1979 case GOrdSMkSet: {
1980 sal_uInt8 nbyte;
1981 *pOS2MET >> nbyte;
1982 if (nbyte==0) aAttr.nMrkSet=aDefAttr.nMrkSet;
1983 else aAttr.nMrkSet=nbyte;
1984 break;
1985 }
1986
1987 case GOrdPMkSym: PushAttr(nOrderID);
1988 case GOrdSMkSym: {
1989 sal_uInt8 nbyte;
1990 *pOS2MET >> nbyte;
1991 if (nbyte==0) aAttr.nMrkSymbol=aDefAttr.nMrkSymbol;
1992 else aAttr.nMrkSymbol=nbyte;
1993 break;
1994 }
1995
1996 case GOrdPMkCel: PushAttr(nOrderID);
1997 case GOrdSMkCel: {
1998 sal_uInt8 nbyte;
1999 sal_uInt16 nLen=nOrderLen;
2000 aAttr.aMrkCellSize.Width()=ReadCoord(bCoord32);
2001 aAttr.aMrkCellSize.Height()=ReadCoord(bCoord32);
2002 if (bCoord32) nLen-=8; else nLen-=4;
2003 if (nLen>=2) {
2004 *pOS2MET >> nbyte;
2005 if ((nbyte&0x80)==0 && aAttr.aMrkCellSize==Size(0,0))
2006 aAttr.aMrkCellSize=aDefAttr.aMrkCellSize;
2007 }
2008 break;
2009 }
2010
2011 case GOrdPArcPa: PushAttr(nOrderID);
2012 case GOrdSArcPa:
2013 aAttr.nArcP=ReadCoord(bCoord32);
2014 aAttr.nArcQ=ReadCoord(bCoord32);
2015 aAttr.nArcR=ReadCoord(bCoord32);
2016 aAttr.nArcS=ReadCoord(bCoord32);
2017 break;
2018
2019 case GOrdPCrPos: PushAttr(nOrderID);
2020 case GOrdSCrPos:
2021 aAttr.aCurPos=ReadPoint();
2022 break;
2023
2024 case GOrdPMdTrn: PushAttr(nOrderID);
2025 case GOrdSMdTrn: OOODEBUG("GOrdSMdTrn",0);
2026 break;
2027
2028 case GOrdPPkIdn: PushAttr(nOrderID);
2029 case GOrdSPkIdn: OOODEBUG("GOrdSPkIdn",0);
2030 break;
2031
2032 case GOrdSVwTrn: OOODEBUG("GOrdSVwTrn",0);
2033 break;
2034
2035 case GOrdPVwWin: PushAttr(nOrderID);
2036 case GOrdSVwWin: OOODEBUG("GOrdSVwWin",0);
2037 break;
2038 default: OOODEBUG("Order unbekannt:",nOrderID);
2039 }
2040 }
2041
2042 void OS2METReader::ReadDsc(sal_uInt16 nDscID, sal_uInt16 /*nDscLen*/)
2043 {
2044 switch (nDscID) {
2045 case 0x00f7: { // 'Specify GVM Subset'
2046 sal_uInt8 nbyte;
2047 pOS2MET->SeekRel(6);
2048 *pOS2MET >> nbyte;
2049 if (nbyte==0x05) bCoord32=sal_True;
2050 else if (nbyte==0x04) bCoord32=sal_False;
2051 else {
2052 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2053 ErrorCode=1;
2054 }
2055 break;
2056 }
2057 case 0x00f6:
2058 {
2059 // 'Set Picture Descriptor'
2060 sal_Bool b32;
2061 sal_uInt8 nbyte,nUnitType;
2062 long x1,y1,x2,y2,nt,xr,yr;
2063
2064 pOS2MET->SeekRel(2);
2065 *pOS2MET >> nbyte;
2066
2067 if (nbyte==0x05)
2068 b32=sal_True;
2069 else if(nbyte==0x04)
2070 b32=sal_False;
2071 else
2072 {
2073 b32 = sal_False; // -Wall added the case.
2074 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2075 ErrorCode=2;
2076 }
2077
2078 *pOS2MET >> nUnitType;
2079
2080 xr=ReadCoord(b32);
2081 yr=ReadCoord(b32);
2082
2083 ReadCoord(b32);
2084
2085 if (nUnitType==0x00 && xr>0 && yr>0)
2086 aGlobMapMode=MapMode(MAP_INCH,Point(0,0),Fraction(10,xr),Fraction(10,yr));
2087 else if (nUnitType==0x01 && xr>0 && yr>0)
2088 aGlobMapMode=MapMode(MAP_CM,Point(0,0),Fraction(10,xr),Fraction(10,yr));
2089 else
2090 aGlobMapMode=MapMode();
2091
2092 x1=ReadCoord(b32);
2093 x2=ReadCoord(b32);
2094 y1=ReadCoord(b32);
2095 y2=ReadCoord(b32);
2096
2097 if (x1>x2)
2098 {
2099 nt=x1;
2100 x1=x2;
2101 x2=nt;
2102 }
2103
2104 if (y1>y2)
2105 {
2106 nt=y1;
2107 y1=y2;
2108 y2=nt;
2109 }
2110
2111 aBoundingRect.Left() = x1;
2112 aBoundingRect.Right() = x2;
2113 aBoundingRect.Top() = y1;
2114 aBoundingRect.Bottom() = y2;
2115
2116 // no output beside this bounding rect
2117 pVirDev->IntersectClipRegion( Rectangle( Point(), aBoundingRect.GetSize() ) );
2118
2119 break;
2120 }
2121 case 0x0021: // 'Set Current Defaults'
2122 break;
2123 }
2124 }
2125
2126 void OS2METReader::ReadImageData(sal_uInt16 nDataID, sal_uInt16 nDataLen)
2127 {
2128 OSBitmap * p=pBitmapList; if (p==NULL) return;
2129
2130 switch (nDataID) {
2131
2132 case 0x0070: // Begin Segment
2133 break;
2134
2135 case 0x0091: // Begin Image Content
2136 break;
2137
2138 case 0x0094: // Image Size
2139 pOS2MET->SeekRel(5);
2140 p->nHeight=ReadBigEndianWord();
2141 p->nWidth=ReadBigEndianWord();
2142 break;
2143
2144 case 0x0095: // Image Encoding
2145 break;
2146
2147 case 0x0096: { // Image IDE-Size
2148 sal_uInt8 nbyte;
2149 *pOS2MET >> nbyte; p->nBitsPerPixel=nbyte;
2150 break;
2151 }
2152
2153 case 0x0097: // Image LUT-ID
2154 break;
2155
2156 case 0x009b: // IDE Structure
2157 break;
2158
2159 case 0xfe92: { // Image Data
2160 // At the latest we now need the temprary BMP file and
2161 // inside this file we need the header and the palette.
2162 if (p->pBMP==NULL) {
2163 p->pBMP=new SvMemoryStream();
2164 p->pBMP->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
2165 if (p->nWidth==0 || p->nHeight==0 || p->nBitsPerPixel==0) {
2166 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2167 ErrorCode=3;
2168 return;
2169 }
2170 // write (Windows-)BITMAPINFOHEADER:
2171 *(p->pBMP) << ((sal_uInt32)40) << p->nWidth << p->nHeight;
2172 *(p->pBMP) << ((sal_uInt16)1) << p->nBitsPerPixel;
2173 *(p->pBMP) << ((sal_uInt32)0) << ((sal_uInt32)0) << ((sal_uInt32)0) << ((sal_uInt32)0);
2174 *(p->pBMP) << ((sal_uInt32)0) << ((sal_uInt32)0);
2175 // write color table:
2176 if (p->nBitsPerPixel<=8) {
2177 sal_uInt16 i, nColTabSize=1<<(p->nBitsPerPixel);
2178 for (i=0; i<nColTabSize; i++) *(p->pBMP) << GetPalette0RGB(i);
2179 }
2180 }
2181 // OK, now the map data is beeing pushed. Unfortunatly OS2 and BMP
2182 // do habe a different RGB ordering when using 24-bit
2183 sal_uInt8 * pBuf=new sal_uInt8[nDataLen];
2184 pOS2MET->Read(pBuf,nDataLen);
2185 if (p->nBitsPerPixel==24) {
2186 sal_uLong i, j, nAlign, nBytesPerLine;
2187 sal_uInt8 nTemp;
2188 nBytesPerLine=(p->nWidth*3+3)&0xfffffffc;
2189 nAlign=p->nMapPos-(p->nMapPos % nBytesPerLine);
2190 i=0;
2191 while (nAlign+i+2<p->nMapPos+nDataLen) {
2192 if (nAlign+i>=p->nMapPos) {
2193 j=nAlign+i-p->nMapPos;
2194 nTemp=pBuf[j]; pBuf[j]=pBuf[j+2]; pBuf[j+2]=nTemp;
2195 }
2196 i+=3; if (i+2>=nBytesPerLine) {
2197 nAlign+=nBytesPerLine;
2198 i=0;
2199 }
2200 }
2201 }
2202 p->pBMP->Write(pBuf,nDataLen);
2203 p->nMapPos+=nDataLen;
2204 delete[] pBuf;
2205 break;
2206 }
2207 case 0x0093: // End Image Content
2208 break;
2209
2210 case 0x0071: // End Segment
2211 break;
2212 }
2213 }
2214
2215 void OS2METReader::ReadFont(sal_uInt16 nFieldSize)
2216 {
2217 sal_uLong nPos, nMaxPos;
2218 sal_uInt16 nLen;
2219 sal_uInt8 nByte, nTripType, nTripType2;
2220 OSFont * pF=new OSFont;
2221 pF->pSucc=pFontList; pFontList=pF;
2222 pF->nID=0;
2223 pF->aFont.SetTransparent(sal_True);
2224 pF->aFont.SetAlign(ALIGN_BASELINE);
2225
2226 nPos=pOS2MET->Tell();
2227 nMaxPos=nPos+(sal_uLong)nFieldSize;
2228 pOS2MET->SeekRel(2); nPos+=2;
2229 while (nPos<nMaxPos && pOS2MET->GetError()==0) {
2230 *pOS2MET >> nByte; nLen =((sal_uInt16)nByte) & 0x00ff;
2231 *pOS2MET >> nTripType;
2232 switch (nTripType) {
2233 case 0x02:
2234 *pOS2MET >> nTripType2;
2235 switch (nTripType2) {
2236 case 0x84: // Font name
2237 break;
2238 case 0x08: { // Font Typeface
2239 char str[33];
2240 pOS2MET->SeekRel(1);
2241 pOS2MET->Read( &str, 32 );
2242 str[ 32 ] = 0;
2243 String aStr( (const sal_Char*)str, osl_getThreadTextEncoding() );
2244 if ( aStr.CompareIgnoreCaseToAscii( "Helv" ) == COMPARE_EQUAL )
2245 aStr = OUString("Helvetica");
2246 pF->aFont.SetName( aStr );
2247 break;
2248 }
2249 }
2250 break;
2251 case 0x24: // Icid
2252 *pOS2MET >> nTripType2;
2253 switch (nTripType2) {
2254 case 0x05: //Icid
2255 *pOS2MET >> nByte;
2256 pF->nID=((sal_uLong)nByte)&0xff;
2257 break;
2258 }
2259 break;
2260 case 0x20: // Font Binary GCID
2261 break;
2262 case 0x1f: { // Font Attributes
2263 FontWeight eWeight;
2264 sal_uInt8 nbyte;
2265 *pOS2MET >> nbyte;
2266 switch (nbyte) {
2267 case 1: eWeight=WEIGHT_THIN; break;
2268 case 2: eWeight=WEIGHT_ULTRALIGHT; break;
2269 case 3: eWeight=WEIGHT_LIGHT; break;
2270 case 4: eWeight=WEIGHT_SEMILIGHT; break;
2271 case 5: eWeight=WEIGHT_NORMAL; break;
2272 case 6: eWeight=WEIGHT_SEMIBOLD; break;
2273 case 7: eWeight=WEIGHT_BOLD; break;
2274 case 8: eWeight=WEIGHT_ULTRABOLD; break;
2275 case 9: eWeight=WEIGHT_BLACK; break;
2276 default: eWeight=WEIGHT_DONTKNOW;
2277 }
2278 pF->aFont.SetWeight(eWeight);
2279 break;
2280 }
2281 }
2282 nPos+=nLen; pOS2MET->Seek(nPos);
2283 }
2284 }
2285
2286 void OS2METReader::ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize)
2287 {
2288 switch (nFieldType) {
2289 case BegDocumnMagic:
2290 break;
2291 case EndDocumnMagic:
2292 break;
2293 case BegResGrpMagic:
2294 break;
2295 case EndResGrpMagic:
2296 break;
2297 case BegColAtrMagic:
2298 break;
2299 case EndColAtrMagic:
2300 break;
2301 case BlkColAtrMagic: {
2302 sal_uLong nPos, nMaxPos;
2303 sal_uInt8 nbyte;
2304 sal_uLong nCol;
2305 sal_uInt16 nStartIndex, nEndIndex, i, nElemLen, nBytesPerCol;
2306
2307 nPos=pOS2MET->Tell();
2308 nMaxPos=nPos+(sal_uLong)nFieldSize;
2309 pOS2MET->SeekRel(3); nPos+=3;
2310 while (nPos<nMaxPos && pOS2MET->GetError()==0) {
2311 *pOS2MET >> nbyte; nElemLen=((sal_uInt16)nbyte) & 0x00ff;
2312 if (nElemLen>11) {
2313 pOS2MET->SeekRel(4);
2314 nStartIndex=ReadBigEndianWord();
2315 pOS2MET->SeekRel(3);
2316 *pOS2MET >> nbyte; nBytesPerCol=((sal_uInt16)nbyte) & 0x00ff;
2317 nEndIndex=nStartIndex+(nElemLen-11)/nBytesPerCol;
2318 for (i=nStartIndex; i<nEndIndex; i++) {
2319 if (nBytesPerCol > 3) pOS2MET->SeekRel(nBytesPerCol-3);
2320 nCol=ReadBigEndian3BytesLong();
2321 SetPalette0RGB(i,nCol);
2322 }
2323 }
2324 else if (nElemLen<10) {
2325 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2326 ErrorCode=4;
2327 }
2328 nPos+=(sal_uLong)nElemLen;
2329 pOS2MET->Seek(nPos);
2330 }
2331 break;
2332 }
2333 case MapColAtrMagic:
2334 break;
2335 case BegImgObjMagic: {
2336 // create new bitmap by now: (will be filled later)
2337 OSBitmap * pB=new OSBitmap;
2338 pB->pSucc=pBitmapList; pBitmapList=pB;
2339 pB->pBMP=NULL; pB->nWidth=0; pB->nHeight=0; pB->nBitsPerPixel=0;
2340 pB->nMapPos=0;
2341 // determine ID of the bitmap:
2342 sal_uInt8 i,nbyte,nbyte2;
2343 pB->nID=0;
2344 for (i=0; i<4; i++) {
2345 *pOS2MET >> nbyte >> nbyte2;
2346 nbyte=((nbyte-0x30)<<4)|(nbyte2-0x30);
2347 pB->nID=(pB->nID>>8)|(((sal_uLong)nbyte)<<24);
2348 }
2349 // put new palette on the palette stack: (will be filled later)
2350 OSPalette * pP=new OSPalette;
2351 pP->pSucc=pPaletteStack; pPaletteStack=pP;
2352 pP->p0RGB=NULL; pP->nSize=0;
2353 break;
2354 }
2355 case EndImgObjMagic: {
2356 // read temporary Windows BMP file:
2357 if (pBitmapList==NULL || pBitmapList->pBMP==NULL ||
2358 pBitmapList->pBMP->GetError()!=0) {
2359 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2360 ErrorCode=5;
2361 return;
2362 }
2363 pBitmapList->pBMP->Seek(0);
2364
2365 pBitmapList->aBitmap.Read( *( pBitmapList->pBMP ), sal_False );
2366
2367 if (pBitmapList->pBMP->GetError()!=0) {
2368 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2369 ErrorCode=6;
2370 }
2371 delete pBitmapList->pBMP; pBitmapList->pBMP=NULL;
2372 // kill palette from stack:
2373 OSPalette * pP=pPaletteStack;
2374 if (pP!=NULL) {
2375 pPaletteStack=pP->pSucc;
2376 if (pP->p0RGB!=NULL) delete[] pP->p0RGB;
2377 delete pP;
2378 }
2379 break;
2380 }
2381 case DscImgObjMagic:
2382 break;
2383 case DatImgObjMagic: {
2384 sal_uInt16 nDataID, nDataLen;
2385 sal_uInt8 nbyte;
2386 sal_uLong nPos, nMaxPos;
2387
2388 nPos=pOS2MET->Tell();
2389 nMaxPos=nPos+(sal_uLong)nFieldSize;
2390 while (nPos<nMaxPos && pOS2MET->GetError()==0) {
2391 *pOS2MET >> nbyte; nDataID=((sal_uInt16)nbyte)&0x00ff;
2392 if (nDataID==0x00fe) {
2393 *pOS2MET >> nbyte;
2394 nDataID=(nDataID<<8)|(((sal_uInt16)nbyte)&0x00ff);
2395 nDataLen=ReadBigEndianWord();
2396 nPos+=4;
2397 }
2398 else {
2399 *pOS2MET >> nbyte; nDataLen=((sal_uInt16)nbyte)&0x00ff;
2400 nPos+=2;
2401 }
2402 ReadImageData(nDataID, nDataLen);
2403 nPos+=(sal_uLong)nDataLen;
2404 pOS2MET->Seek(nPos);
2405 }
2406 break;
2407 }
2408
2409 case BegObEnv1Magic:
2410 break;
2411 case EndObEnv1Magic:
2412 break;
2413 case BegGrfObjMagic:
2414 break;
2415 case EndGrfObjMagic: {
2416 SvStream * pSave;
2417 sal_uLong nPos, nMaxPos;
2418 sal_uInt16 nOrderID, nOrderLen;
2419 sal_uInt8 nbyte;
2420
2421 if (pOrdFile==NULL) break;
2422
2423 // In pOrdFile all "DatGrfObj" fields were collected so that the
2424 // thererin contained "Orders" are continuous and not segmented by fields.
2425 // To read them from the memory stream without having any trouble,
2426 // we use a little trick:
2427
2428 pSave=pOS2MET;
2429 pOS2MET=pOrdFile; //(!)
2430 nMaxPos=pOS2MET->Tell();
2431 pOS2MET->Seek(0);
2432
2433 // "Segment header":
2434 *pOS2MET >> nbyte;
2435 if (nbyte==0x70) { // header exists
2436 pOS2MET->SeekRel(15); // but we don't need it
2437 }
2438 else pOS2MET->SeekRel(-1); // no header, go back one byte
2439
2440 // loop through Order:
2441 while (pOS2MET->Tell()<nMaxPos && pOS2MET->GetError()==0) {
2442 *pOS2MET >> nbyte; nOrderID=((sal_uInt16)nbyte) & 0x00ff;
2443 if (nOrderID==0x00fe) {
2444 *pOS2MET >> nbyte;
2445 nOrderID=(nOrderID << 8) | (((sal_uInt16)nbyte) & 0x00ff);
2446 }
2447 if (nOrderID>0x00ff || nOrderID==GOrdPolygn) {
2448 // ooo: As written in OS2 documentation, the order length should now
2449 // be written as big endian word. (Quote: "Highorder byte precedes loworder byte").
2450 // In reality there are files in which the length is stored as little endian word
2451 // (at least for nOrderID==GOrdPolygn)
2452 // So we throw a coin or what else can we do?
2453 *pOS2MET >> nbyte; nOrderLen=(sal_uInt16)nbyte&0x00ff;
2454 *pOS2MET >> nbyte; if (nbyte!=0) nOrderLen=nOrderLen<<8|(((sal_uInt16)nbyte)&0x00ff);
2455 }
2456 else if (nOrderID==GOrdSTxAlg || nOrderID==GOrdPTxAlg) nOrderLen=2;
2457 else if ((nOrderID&0xff88)==0x0008) nOrderLen=1;
2458 else if (nOrderID==0x0000 || nOrderID==0x00ff) nOrderLen=0;
2459 else { *pOS2MET >> nbyte; nOrderLen=((sal_uInt16)nbyte) & 0x00ff; }
2460 nPos=pOS2MET->Tell();
2461 ReadOrder(nOrderID, nOrderLen);
2462 if (nPos+nOrderLen < pOS2MET->Tell()) {
2463 OOODEBUG("Order shorter than he assumes! OrderID:",nOrderID);
2464 OOODEBUG("...und zwar bei Position (Parameteranfang):",nPos);
2465 }
2466 else if (nPos+nOrderLen != pOS2MET->Tell()) {
2467 OOODEBUG(String(nOrderID)+String(" Order nicht alles gelesen! bei:"),nPos);
2468 }
2469 pOS2MET->Seek(nPos+nOrderLen);
2470 }
2471
2472 pOS2MET=pSave;
2473 if (pOrdFile->GetError()) {
2474 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2475 ErrorCode=10;
2476 }
2477 delete pOrdFile; pOrdFile=NULL;
2478 break;
2479 }
2480 case DscGrfObjMagic: {
2481 sal_uLong nPos, nMaxPos;
2482 sal_uInt16 nDscID, nDscLen;
2483 sal_uInt8 nbyte;
2484
2485 nMaxPos=pOS2MET->Tell()+(sal_uLong)nFieldSize;
2486 while (pOS2MET->Tell()<nMaxPos && pOS2MET->GetError()==0) {
2487 *pOS2MET >> nbyte; nDscID =((sal_uInt16)nbyte) & 0x00ff;
2488 *pOS2MET >> nbyte; nDscLen=((sal_uInt16)nbyte) & 0x00ff;
2489 nPos=pOS2MET->Tell();
2490 ReadDsc(nDscID, nDscLen);
2491 pOS2MET->Seek(nPos+nDscLen);
2492 }
2493 break;
2494 }
2495 case DatGrfObjMagic: {
2496 if (pOrdFile==NULL) {
2497 pOrdFile = new SvMemoryStream;
2498 pOrdFile->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
2499 }
2500 sal_uInt8 * pBuf; pBuf = new sal_uInt8[nFieldSize];
2501 pOS2MET->Read(pBuf,nFieldSize);
2502 pOrdFile->Write(pBuf,nFieldSize);
2503 delete[] pBuf;
2504 break;
2505 }
2506 case MapCodFntMagic:
2507 ReadFont(nFieldSize);
2508 break;
2509
2510 case MapDatResMagic:
2511 break;
2512 }
2513 }
2514
2515 void OS2METReader::ReadOS2MET( SvStream & rStreamOS2MET, GDIMetaFile & rGDIMetaFile )
2516 {
2517 sal_uInt16 nFieldSize;
2518 sal_uInt16 nFieldType;
2519 sal_uLong nPos, nStartPos, nEndPos, nPercent, nLastPercent;
2520 sal_uInt8 nMagicByte;
2521
2522 ErrorCode=0;
2523
2524 pOS2MET = &rStreamOS2MET;
2525 nOrigPos = pOS2MET->Tell();
2526 nOrigNumberFormat = pOS2MET->GetNumberFormatInt();
2527
2528 bCoord32 = sal_True;
2529 pPaletteStack=NULL;
2530 pAreaStack=NULL;
2531 pPathStack=NULL;
2532 pPathList=NULL;
2533 pFontList=NULL;
2534 pBitmapList=NULL;
2535 pAttrStack=NULL;
2536
2537 aDefAttr.aLinCol =Color(COL_BLACK);
2538 aDefAttr.aLinBgCol =Color(COL_WHITE);
2539 aDefAttr.eLinMix =ROP_OVERPAINT;
2540 aDefAttr.eLinBgMix =ROP_OVERPAINT;
2541 aDefAttr.aChrCol =Color(COL_BLACK);
2542 aDefAttr.aChrBgCol =Color(COL_WHITE);
2543 aDefAttr.eChrMix =ROP_OVERPAINT;
2544 aDefAttr.eChrBgMix =ROP_OVERPAINT;
2545 aDefAttr.aMrkCol =Color(COL_BLACK);
2546 aDefAttr.aMrkBgCol =Color(COL_WHITE);
2547 aDefAttr.eMrkMix =ROP_OVERPAINT;
2548 aDefAttr.eMrkBgMix =ROP_OVERPAINT;
2549 aDefAttr.aPatCol =Color(COL_BLACK);
2550 aDefAttr.aPatBgCol =Color(COL_WHITE);
2551 aDefAttr.ePatMix =ROP_OVERPAINT;
2552 aDefAttr.ePatBgMix =ROP_OVERPAINT;
2553 aDefAttr.aImgCol =Color(COL_BLACK);
2554 aDefAttr.aImgBgCol =Color(COL_WHITE);
2555 aDefAttr.eImgMix =ROP_OVERPAINT;
2556 aDefAttr.eImgBgMix =ROP_OVERPAINT;
2557 aDefAttr.nArcP =1;
2558 aDefAttr.nArcQ =1;
2559 aDefAttr.nArcR =0;
2560 aDefAttr.nArcS =0;
2561 aDefAttr.nChrAng =0;
2562 aDefAttr.aChrCellSize=Size(12,12);
2563 aDefAttr.nChrSet =0;
2564 aDefAttr.aCurPos =Point(0,0);
2565 aDefAttr.eLinStyle =PEN_SOLID;
2566 aDefAttr.nLinWidth =0;
2567 aDefAttr.aMrkCellSize=Size(10,10);
2568 aDefAttr.nMrkPrec =0x01;
2569 aDefAttr.nMrkSet =0xff;
2570 aDefAttr.nMrkSymbol =0x01;
2571 aDefAttr.bFill =sal_True;
2572 aDefAttr.nStrLinWidth=0;
2573
2574 aAttr=aDefAttr;
2575
2576 pOrdFile=NULL;
2577
2578 pVirDev = new VirtualDevice();
2579 pVirDev->EnableOutput(sal_False);
2580 rGDIMetaFile.Record(pVirDev);
2581
2582 pOS2MET->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
2583
2584 nStartPos=pOS2MET->Tell();
2585 nEndPos=pOS2MET->Seek(STREAM_SEEK_TO_END); pOS2MET->Seek(nStartPos);
2586 Callback(0); nLastPercent=0;
2587
2588 nPos=pOS2MET->Tell();
2589 if ( nStartPos == nEndPos )
2590 {
2591 nEndPos = 100;
2592 nStartPos = 0;
2593 }
2594
2595 for (;;) {
2596
2597 nPercent=(nPos-nStartPos)*100/(nEndPos-nStartPos);
2598 if (nLastPercent+4<=nPercent) {
2599 if (Callback((sal_uInt16)nPercent)==sal_True) break;
2600 nLastPercent=nPercent;
2601 }
2602
2603 nFieldSize=ReadBigEndianWord();
2604
2605 *pOS2MET >> nMagicByte;
2606 if (nMagicByte!=0xd3) {
2607 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2608 ErrorCode=7;
2609 break;
2610 }
2611 *pOS2MET >> nFieldType;
2612
2613 pOS2MET->SeekRel(3);
2614 nPos+=8; nFieldSize-=8;
2615
2616 if (pOS2MET->GetError()) break;
2617 if (pOS2MET->IsEof()) {
2618 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2619 ErrorCode=8;
2620 break;
2621 }
2622
2623 if (nFieldType==EndDocumnMagic) break;
2624
2625 ReadField(nFieldType, nFieldSize);
2626
2627 nPos+=(sal_uLong)nFieldSize;
2628 if (pOS2MET->Tell()>nPos) {
2629 pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2630 ErrorCode=9;
2631 break;
2632 }
2633 pOS2MET->Seek(nPos);
2634 }
2635
2636 rGDIMetaFile.Stop();
2637 delete pVirDev;
2638
2639 rGDIMetaFile.SetPrefMapMode( aGlobMapMode );
2640
2641 if( aBoundingRect.GetWidth() && aBoundingRect.GetHeight() )
2642 rGDIMetaFile.SetPrefSize( aBoundingRect.GetSize() );
2643 else
2644 {
2645 if( aCalcBndRect.Left() || aCalcBndRect.Top() )
2646 rGDIMetaFile.Move( -aCalcBndRect.Left(), -aCalcBndRect.Top() );
2647
2648 rGDIMetaFile.SetPrefSize( aCalcBndRect.GetSize() );
2649 }
2650
2651 if (pOrdFile!=NULL) delete pOrdFile;
2652
2653 while (pAreaStack!=NULL) {
2654 OSArea * p=pAreaStack;
2655 pAreaStack=p->pSucc;
2656 delete p;
2657 }
2658
2659 while (pPathStack!=NULL) {
2660 OSPath * p=pPathStack;
2661 pPathStack=p->pSucc;
2662 delete p;
2663 }
2664
2665 while (pPathList!=NULL) {
2666 OSPath * p=pPathList;
2667 pPathList=p->pSucc;
2668 delete p;
2669 }
2670
2671 while (pFontList!=NULL) {
2672 OSFont * p=pFontList;
2673 pFontList=p->pSucc;
2674 delete p;
2675 }
2676
2677 while (pBitmapList!=NULL) {
2678 OSBitmap * p=pBitmapList;
2679 pBitmapList=p->pSucc;
2680 if (p->pBMP!=NULL) delete p->pBMP;
2681 delete p;
2682 }
2683
2684 while (pAttrStack!=NULL) {
2685 OSAttr * p=pAttrStack;
2686 pAttrStack=p->pSucc;
2687 delete p;
2688 }
2689
2690 while (pPaletteStack!=NULL) {
2691 OSPalette * p=pPaletteStack;
2692 pPaletteStack=p->pSucc;
2693 if (p->p0RGB!=NULL) delete[] p->p0RGB;
2694 delete p;
2695 }
2696
2697 pOS2MET->SetNumberFormatInt(nOrigNumberFormat);
2698
2699 if (pOS2MET->GetError()) {
2700 OOODEBUG("Fehler Nr.:",ErrorCode);
2701 pOS2MET->Seek(nOrigPos);
2702 }
2703 }
2704
2705 //================== GraphicImport - the exported function ================
2706
2707 // this needs to be kept in sync with
2708 // ImpFilterLibCacheEntry::GetImportFunction() from
2709 // vcl/source/filter/graphicfilter.cxx
2710 #if defined(DISABLE_DYNLOADING)
2711 #define GraphicImport imeGraphicImport
2712 #endif
2713
2714 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool SAL_CALL
2715 GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, sal_Bool)
2716 {
2717 OS2METReader aOS2METReader;
2718 GDIMetaFile aMTF;
2719 sal_Bool bRet = sal_False;
2720
2721 aOS2METReader.ReadOS2MET( rStream, aMTF );
2722
2723 if ( !rStream.GetError() )
2724 {
2725 rGraphic=Graphic( aMTF );
2726 bRet = sal_True;
2727 }
2728
2729 return bRet;
2730 }
2731
2732 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE