Line data Source code
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 : #include <vcl/graph.hxx>
21 : #include <tools/poly.hxx>
22 : #include <vcl/dibtools.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 0 : 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 0 : OSPath(){}
238 0 : ~OSPath(){}
239 : };
240 :
241 : struct OSFont {
242 : OSFont * pSucc;
243 : sal_uLong nID;
244 : Font aFont;
245 0 : 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 0 : 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 0 : 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 0 : sal_Bool OS2METReader::Callback(sal_uInt16 /*nPercent*/)
415 : {
416 0 : return sal_False;
417 : }
418 :
419 0 : OS2METReader::OS2METReader()
420 : {
421 0 : }
422 :
423 0 : OS2METReader::~OS2METReader()
424 : {
425 0 : }
426 :
427 0 : sal_Bool OS2METReader::IsLineInfo()
428 : {
429 0 : return ( ! ( aLineInfo.IsDefault() || ( aLineInfo.GetStyle() == LINE_NONE ) || ( pVirDev->GetLineColor() == COL_TRANSPARENT ) ) );
430 : }
431 :
432 0 : void OS2METReader::DrawPolyLine( const Polygon& rPolygon )
433 : {
434 0 : if ( aLineInfo.GetStyle() == LINE_DASH || ( aLineInfo.GetWidth() > 1 ) )
435 0 : pVirDev->DrawPolyLine( rPolygon, aLineInfo );
436 : else
437 0 : pVirDev->DrawPolyLine( rPolygon );
438 0 : }
439 :
440 0 : void OS2METReader::DrawPolygon( const Polygon& rPolygon )
441 : {
442 0 : if ( IsLineInfo() )
443 : {
444 0 : pVirDev->Push( PUSH_LINECOLOR );
445 0 : pVirDev->SetLineColor( COL_TRANSPARENT );
446 0 : pVirDev->DrawPolygon( rPolygon );
447 0 : pVirDev->Pop();
448 0 : pVirDev->DrawPolyLine( rPolygon, aLineInfo );
449 : }
450 : else
451 0 : pVirDev->DrawPolygon( rPolygon );
452 0 : }
453 :
454 0 : void OS2METReader::DrawPolyPolygon( const PolyPolygon& rPolyPolygon )
455 : {
456 0 : if ( IsLineInfo() )
457 : {
458 0 : pVirDev->Push( PUSH_LINECOLOR );
459 0 : pVirDev->SetLineColor( COL_TRANSPARENT );
460 0 : pVirDev->DrawPolyPolygon( rPolyPolygon );
461 0 : pVirDev->Pop();
462 0 : for ( sal_uInt16 i = 0; i < rPolyPolygon.Count(); i++ )
463 0 : pVirDev->DrawPolyLine( rPolyPolygon.GetObject( i ), aLineInfo );
464 : }
465 : else
466 0 : pVirDev->DrawPolyPolygon( rPolyPolygon );
467 0 : }
468 :
469 0 : void OS2METReader::AddPointsToArea(const Polygon & rPoly)
470 : {
471 : sal_uInt16 nOldSize, nNewSize,i;
472 :
473 0 : if (pAreaStack==NULL || rPoly.GetSize()==0) return;
474 0 : PolyPolygon * pPP=&(pAreaStack->aPPoly);
475 0 : if (pPP->Count()==0 || pAreaStack->bClosed==sal_True) pPP->Insert(rPoly);
476 : else {
477 0 : Polygon aLastPoly(pPP->GetObject(pPP->Count()-1));
478 0 : nOldSize=aLastPoly.GetSize();
479 0 : if (aLastPoly.GetPoint(nOldSize-1)==rPoly.GetPoint(0)) nOldSize--;
480 0 : nNewSize=nOldSize+rPoly.GetSize();
481 0 : aLastPoly.SetSize(nNewSize);
482 0 : for (i=nOldSize; i<nNewSize; i++) {
483 0 : aLastPoly.SetPoint(rPoly.GetPoint(i-nOldSize),i);
484 : }
485 0 : pPP->Replace(aLastPoly,pPP->Count()-1);
486 : }
487 0 : pAreaStack->bClosed=sal_False;
488 : }
489 :
490 0 : void OS2METReader::AddPointsToPath(const Polygon & rPoly)
491 : {
492 : sal_uInt16 nOldSize, nNewSize,i;
493 :
494 0 : if (pPathStack==NULL || rPoly.GetSize()==0) return;
495 0 : PolyPolygon * pPP=&(pPathStack->aPPoly);
496 0 : if (pPP->Count()==0 /*|| pPathStack->bClosed==sal_True*/) pPP->Insert(rPoly);
497 : else {
498 0 : Polygon aLastPoly(pPP->GetObject(pPP->Count()-1));
499 0 : nOldSize=aLastPoly.GetSize();
500 0 : if (aLastPoly.GetPoint(nOldSize-1)!=rPoly.GetPoint(0)) pPP->Insert(rPoly);
501 : else {
502 0 : nOldSize--;
503 0 : nNewSize=nOldSize+rPoly.GetSize();
504 0 : aLastPoly.SetSize(nNewSize);
505 0 : for (i=nOldSize; i<nNewSize; i++) {
506 0 : aLastPoly.SetPoint(rPoly.GetPoint(i-nOldSize),i);
507 : }
508 0 : pPP->Replace(aLastPoly,pPP->Count()-1);
509 0 : }
510 : }
511 0 : pPathStack->bClosed=sal_False;
512 : }
513 :
514 0 : void OS2METReader::CloseFigure()
515 : {
516 0 : if (pAreaStack!=NULL) pAreaStack->bClosed=sal_True;
517 0 : else if (pPathStack!=NULL) pPathStack->bClosed=sal_True;
518 0 : }
519 :
520 0 : void OS2METReader::PushAttr(sal_uInt16 nPushOrder)
521 : {
522 : OSAttr * p;
523 0 : p=new OSAttr;
524 0 : *p=aAttr;
525 0 : p->pSucc=pAttrStack; pAttrStack=p;
526 0 : p->nPushOrder=nPushOrder;
527 0 : }
528 :
529 0 : void OS2METReader::PopAttr()
530 : {
531 0 : OSAttr * p=pAttrStack;
532 :
533 0 : if (p==NULL) return;
534 0 : switch (p->nPushOrder) {
535 :
536 : case GOrdPIvAtr:
537 0 : switch (p->nIvAttrA) {
538 0 : case 1: switch (p->nIvAttrP) {
539 0 : case 1: aAttr.aLinCol=p->aLinCol; break;
540 0 : case 2: aAttr.aChrCol=p->aChrCol; break;
541 0 : case 3: aAttr.aMrkCol=p->aMrkCol; break;
542 0 : case 4: aAttr.aPatCol=p->aPatCol; break;
543 0 : case 5: aAttr.aImgCol=p->aImgCol; break;
544 0 : } break;
545 0 : case 2: switch (p->nIvAttrP) {
546 0 : case 1: aAttr.aLinBgCol=p->aLinBgCol; break;
547 0 : case 2: aAttr.aChrBgCol=p->aChrBgCol; break;
548 0 : case 3: aAttr.aMrkBgCol=p->aMrkBgCol; break;
549 0 : case 4: aAttr.aPatBgCol=p->aPatBgCol; break;
550 0 : case 5: aAttr.aImgBgCol=p->aImgBgCol; break;
551 0 : } break;
552 0 : case 3: switch (p->nIvAttrP) {
553 0 : case 1: aAttr.eLinMix=p->eLinMix; break;
554 0 : case 2: aAttr.eChrMix=p->eChrMix; break;
555 0 : case 3: aAttr.eMrkMix=p->eMrkMix; break;
556 0 : case 4: aAttr.ePatMix=p->ePatMix; break;
557 0 : case 5: aAttr.eImgMix=p->eImgMix; break;
558 0 : } break;
559 0 : case 4: switch (p->nIvAttrP) {
560 0 : case 1: aAttr.eLinBgMix=p->eLinBgMix; break;
561 0 : case 2: aAttr.eChrBgMix=p->eChrBgMix; break;
562 0 : case 3: aAttr.eMrkBgMix=p->eMrkBgMix; break;
563 0 : case 4: aAttr.ePatBgMix=p->ePatBgMix; break;
564 0 : case 5: aAttr.eImgBgMix=p->eImgBgMix; break;
565 0 : } break;
566 : }
567 0 : break;
568 :
569 0 : case GOrdPLnTyp: aAttr.eLinStyle=p->eLinStyle; break;
570 :
571 0 : case GOrdPLnWdt: aAttr.nLinWidth=p->nLinWidth; break;
572 :
573 0 : case GOrdPStLWd: aAttr.nStrLinWidth=p->nStrLinWidth; break;
574 :
575 0 : case GOrdPChSet: aAttr.nChrSet=p->nChrSet; break;
576 :
577 0 : case GOrdPChAng: aAttr.nChrAng=p->nChrAng; break;
578 :
579 : case GOrdPMixMd:
580 0 : aAttr.eLinMix=p->eLinMix;
581 0 : aAttr.eChrMix=p->eChrMix;
582 0 : aAttr.eMrkMix=p->eMrkMix;
583 0 : aAttr.ePatMix=p->ePatMix;
584 0 : aAttr.eImgMix=p->eImgMix;
585 0 : break;
586 :
587 : case GOrdPBgMix:
588 0 : aAttr.eLinBgMix=p->eLinBgMix;
589 0 : aAttr.eChrBgMix=p->eChrBgMix;
590 0 : aAttr.eMrkBgMix=p->eMrkBgMix;
591 0 : aAttr.ePatBgMix=p->ePatBgMix;
592 0 : aAttr.eImgBgMix=p->eImgBgMix;
593 0 : break;
594 :
595 0 : case GOrdPPtSym: aAttr.bFill = p->bFill; break;
596 :
597 : case GOrdPColor:
598 : case GOrdPIxCol:
599 : case GOrdPXtCol:
600 0 : aAttr.aLinCol=p->aLinCol;
601 0 : aAttr.aChrCol=p->aChrCol;
602 0 : aAttr.aMrkCol=p->aMrkCol;
603 0 : aAttr.aPatCol=p->aPatCol;
604 0 : aAttr.aImgCol=p->aImgCol;
605 0 : break;
606 :
607 : case GOrdPBgCol:
608 : case GOrdPBxCol:
609 0 : aAttr.aLinBgCol=p->aLinBgCol;
610 0 : aAttr.aChrBgCol=p->aChrBgCol;
611 0 : aAttr.aMrkBgCol=p->aMrkBgCol;
612 0 : aAttr.aPatBgCol=p->aPatBgCol;
613 0 : aAttr.aImgBgCol=p->aImgBgCol;
614 0 : break;
615 :
616 0 : case GOrdPMkPrc: aAttr.nMrkPrec=aDefAttr.nMrkPrec; break;
617 :
618 0 : case GOrdPMkSet: aAttr.nMrkSet=aDefAttr.nMrkSet; break;
619 :
620 0 : case GOrdPMkSym: aAttr.nMrkSymbol=aDefAttr.nMrkSymbol; break;
621 :
622 0 : case GOrdPMkCel: aAttr.aMrkCellSize=aDefAttr.aMrkCellSize; break;
623 :
624 : case GOrdPArcPa:
625 0 : aAttr.nArcP=p->nArcP; aAttr.nArcQ=p->nArcQ;
626 0 : aAttr.nArcR=p->nArcR; aAttr.nArcS=p->nArcS;
627 0 : break;
628 :
629 : case GOrdPCrPos:
630 0 : aAttr.aCurPos=p->aCurPos;
631 0 : break;
632 : }
633 0 : pAttrStack=p->pSucc;
634 0 : delete p;
635 : }
636 :
637 0 : void OS2METReader::ChangeBrush(const Color& rPatColor, const Color& /*rBGColor*/, sal_Bool bFill )
638 : {
639 0 : Color aColor;
640 :
641 0 : if( bFill )
642 0 : aColor = rPatColor;
643 : else
644 0 : aColor = Color( COL_TRANSPARENT );
645 :
646 0 : if( pVirDev->GetFillColor() != aColor )
647 0 : pVirDev->SetFillColor( aColor );
648 0 : }
649 :
650 0 : void OS2METReader::SetPen( const Color& rColor, sal_uInt16 nLineWidth, PenStyle ePenStyle )
651 : {
652 0 : LineStyle eLineStyle( LINE_SOLID );
653 :
654 0 : if ( pVirDev->GetLineColor() != rColor )
655 0 : pVirDev->SetLineColor( rColor );
656 0 : aLineInfo.SetWidth( nLineWidth );
657 :
658 0 : sal_uInt16 nDotCount = 0;
659 0 : sal_uInt16 nDashCount = 0;
660 0 : switch ( ePenStyle )
661 : {
662 : case PEN_NULL :
663 0 : eLineStyle = LINE_NONE;
664 0 : break;
665 : case PEN_DASHDOT :
666 0 : nDashCount++;
667 : case PEN_DOT :
668 0 : nDotCount++;
669 0 : nDashCount--;
670 : case PEN_DASH :
671 0 : nDashCount++;
672 0 : aLineInfo.SetDotCount( nDotCount );
673 0 : aLineInfo.SetDashCount( nDashCount );
674 0 : aLineInfo.SetDistance( nLineWidth );
675 0 : aLineInfo.SetDotLen( nLineWidth );
676 0 : aLineInfo.SetDashLen( nLineWidth << 2 );
677 0 : eLineStyle = LINE_DASH;
678 0 : break;
679 : case PEN_SOLID:
680 0 : break; // -Wall not handled...
681 : }
682 0 : aLineInfo.SetStyle( eLineStyle );
683 0 : }
684 :
685 0 : void OS2METReader::SetRasterOp(RasterOp eROP)
686 : {
687 0 : if (pVirDev->GetRasterOp()!=eROP) pVirDev->SetRasterOp(eROP);
688 0 : }
689 :
690 :
691 0 : void OS2METReader::SetPalette0RGB(sal_uInt16 nIndex, sal_uLong nCol)
692 : {
693 0 : if (pPaletteStack==NULL) {
694 0 : pPaletteStack=new OSPalette;
695 0 : pPaletteStack->pSucc=NULL;
696 0 : pPaletteStack->p0RGB=NULL;
697 0 : pPaletteStack->nSize=0;
698 : }
699 0 : if (pPaletteStack->p0RGB==NULL || nIndex>=pPaletteStack->nSize) {
700 0 : sal_uInt32 * pOld0RGB=pPaletteStack->p0RGB;
701 0 : sal_uInt16 i,nOldSize=pPaletteStack->nSize;
702 0 : if (pOld0RGB==NULL) nOldSize=0;
703 0 : pPaletteStack->nSize=2*(nIndex+1);
704 0 : if (pPaletteStack->nSize<256) pPaletteStack->nSize=256;
705 0 : pPaletteStack->p0RGB = new sal_uInt32[pPaletteStack->nSize];
706 0 : for (i=0; i<pPaletteStack->nSize; i++) {
707 0 : if (i<nOldSize) pPaletteStack->p0RGB[i]=pOld0RGB[i];
708 0 : else if (i==0) pPaletteStack->p0RGB[i]=0x00ffffff;
709 0 : else pPaletteStack->p0RGB[i]=0;
710 : }
711 0 : if (pOld0RGB!=NULL) delete[] pOld0RGB;
712 : }
713 0 : pPaletteStack->p0RGB[nIndex]=nCol;
714 0 : }
715 :
716 0 : sal_uInt32 OS2METReader::GetPalette0RGB(sal_uInt32 nIndex)
717 : {
718 0 : if (pPaletteStack!=NULL && pPaletteStack->p0RGB!=NULL &&
719 0 : pPaletteStack->nSize>nIndex) nIndex=pPaletteStack->p0RGB[nIndex];
720 0 : return nIndex;
721 : }
722 :
723 0 : Color OS2METReader::GetPaletteColor(sal_uInt32 nIndex)
724 : {
725 0 : nIndex=GetPalette0RGB(nIndex);
726 0 : return Color(sal::static_int_cast< sal_uInt8 >((nIndex>>16)&0xff),
727 0 : sal::static_int_cast< sal_uInt8 >((nIndex>>8)&0xff),
728 0 : sal::static_int_cast< sal_uInt8 >(nIndex&0xff));
729 : }
730 :
731 :
732 0 : sal_uInt16 OS2METReader::ReadBigEndianWord()
733 : {
734 : sal_uInt8 nLo,nHi;
735 0 : *pOS2MET >> nHi >> nLo;
736 0 : return (((sal_uInt16)nHi)<<8)|(((sal_uInt16)nLo)&0x00ff);
737 : }
738 :
739 0 : sal_uLong OS2METReader::ReadBigEndian3BytesLong()
740 : {
741 : sal_uInt16 nLo;
742 : sal_uInt8 nHi;
743 0 : *pOS2MET >> nHi;
744 0 : nLo=ReadBigEndianWord();
745 0 : return ((((sal_uLong)nHi)<<16)&0x00ff0000)|((sal_uLong)nLo);
746 : }
747 :
748 0 : sal_uLong OS2METReader::ReadLittleEndian3BytesLong()
749 : {
750 : sal_uInt8 nHi,nMed,nLo;
751 :
752 0 : *pOS2MET >> nLo >> nMed >> nHi;
753 0 : return ((((sal_uLong)nHi)&0xff)<<16)|((((sal_uLong)nMed)&0xff)<<8)|(((sal_uLong)nLo)&0xff);
754 : }
755 :
756 0 : long OS2METReader::ReadCoord(sal_Bool b32)
757 : {
758 : sal_Int32 l;
759 :
760 0 : if (b32) *pOS2MET >> l;
761 0 : else { short s;*pOS2MET >> s; l=(sal_Int32)s; }
762 0 : return l;
763 : }
764 :
765 0 : Point OS2METReader::ReadPoint( const sal_Bool bAdjustBoundRect )
766 : {
767 : long x,y;
768 :
769 0 : x=ReadCoord(bCoord32);
770 0 : y=ReadCoord(bCoord32);
771 0 : x=x-aBoundingRect.Left();
772 0 : y=aBoundingRect.Bottom()-y;
773 :
774 0 : if ( bAdjustBoundRect )
775 0 : aCalcBndRect.Union(Rectangle(x,y,x+1,y+1));
776 :
777 0 : return Point(x,y);
778 : }
779 :
780 0 : RasterOp OS2METReader::OS2MixToRasterOp(sal_uInt8 nMix)
781 : {
782 0 : switch (nMix) {
783 0 : case 0x0c: return ROP_INVERT;
784 0 : case 0x04: return ROP_XOR;
785 0 : case 0x0b: return ROP_XOR;
786 0 : default: return ROP_OVERPAINT;
787 : }
788 : }
789 :
790 0 : void OS2METReader::ReadLine(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
791 : {
792 : sal_uInt16 i,nPolySize;
793 :
794 0 : if (bCoord32) nPolySize=nOrderLen/8; else nPolySize=nOrderLen/4;
795 0 : if (!bGivenPos) nPolySize++;
796 0 : if (nPolySize==0) return;
797 0 : Polygon aPolygon(nPolySize);
798 0 : for (i=0; i<nPolySize; i++) {
799 0 : if (i==0 && !bGivenPos) aPolygon.SetPoint(aAttr.aCurPos,i);
800 0 : else aPolygon.SetPoint(ReadPoint(),i);
801 : }
802 0 : aAttr.aCurPos=aPolygon.GetPoint(nPolySize-1);
803 0 : if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
804 0 : else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
805 : else
806 : {
807 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
808 0 : SetRasterOp(aAttr.eLinMix);
809 0 : DrawPolyLine( aPolygon );
810 0 : }
811 : }
812 :
813 0 : void OS2METReader::ReadRelLine(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
814 : {
815 : sal_uInt16 i,nPolySize;
816 0 : Point aP0;
817 :
818 :
819 0 : if (bGivenPos) {
820 0 : aP0=ReadPoint();
821 0 : if (bCoord32) nOrderLen-=8; else nOrderLen-=4;
822 : }
823 0 : else aP0=aAttr.aCurPos;
824 0 : nPolySize=nOrderLen/2;
825 0 : if (nPolySize==0) return;
826 0 : Polygon aPolygon(nPolySize);
827 0 : 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 0 : *pOS2MET >> nsignedbyte; aP0.X()+=(long)nsignedbyte;
835 0 : *pOS2MET >> nsignedbyte; aP0.Y()-=(long)nsignedbyte;
836 : #endif
837 0 : aCalcBndRect.Union(Rectangle(aP0,Size(1,1)));
838 0 : aPolygon.SetPoint(aP0,i);
839 : }
840 0 : aAttr.aCurPos=aPolygon.GetPoint(nPolySize-1);
841 0 : if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
842 0 : else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
843 : else
844 : {
845 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
846 0 : SetRasterOp(aAttr.eLinMix);
847 0 : DrawPolyLine( aPolygon );
848 0 : }
849 : }
850 :
851 0 : void OS2METReader::ReadBox(sal_Bool bGivenPos)
852 : {
853 : sal_uInt8 nFlags;
854 0 : Point P0;
855 : long nHRound,nVRound;
856 :
857 0 : *pOS2MET >> nFlags;
858 0 : pOS2MET->SeekRel(1);
859 :
860 0 : if ( bGivenPos )
861 0 : P0 = ReadPoint();
862 : else
863 0 : P0 = aAttr.aCurPos;
864 :
865 0 : aAttr.aCurPos=ReadPoint();
866 0 : nHRound=ReadCoord(bCoord32);
867 0 : nVRound=ReadCoord(bCoord32);
868 :
869 0 : Rectangle aBoxRect( P0, aAttr.aCurPos );
870 :
871 0 : if ( pAreaStack )
872 0 : AddPointsToArea( Polygon( aBoxRect ) );
873 0 : else if ( pPathStack )
874 0 : AddPointsToPath( Polygon( aBoxRect ) );
875 : else
876 : {
877 0 : if ( nFlags & 0x20 )
878 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
879 : else
880 0 : SetPen( COL_TRANSPARENT );
881 :
882 0 : if ( nFlags & 0x40 )
883 : {
884 0 : ChangeBrush(aAttr.aPatCol,aAttr.aPatBgCol,aAttr.bFill);
885 0 : SetRasterOp(aAttr.ePatMix);
886 : }
887 : else
888 : {
889 0 : ChangeBrush( Color( COL_TRANSPARENT ), Color( COL_TRANSPARENT ), sal_False );
890 0 : SetRasterOp(aAttr.eLinMix);
891 : }
892 :
893 0 : if ( IsLineInfo() )
894 : {
895 0 : Polygon aPolygon( aBoxRect, nHRound, nVRound );
896 0 : if ( nFlags & 0x40 )
897 : {
898 0 : pVirDev->Push( PUSH_LINECOLOR );
899 0 : pVirDev->SetLineColor( COL_TRANSPARENT );
900 0 : pVirDev->DrawRect( aBoxRect, nHRound, nVRound );
901 0 : pVirDev->Pop();
902 : }
903 0 : pVirDev->DrawPolyLine( aPolygon, aLineInfo );
904 : }
905 : else
906 0 : pVirDev->DrawRect( aBoxRect, nHRound, nVRound );
907 : }
908 0 : }
909 :
910 0 : void OS2METReader::ReadBitBlt()
911 : {
912 0 : Point aP1,aP2;
913 0 : Size aSize;
914 : sal_uInt32 nID;
915 : OSBitmap * pB;
916 : long nt;
917 :
918 0 : pOS2MET->SeekRel(4);
919 0 : *pOS2MET >> nID;
920 0 : pOS2MET->SeekRel(4);
921 0 : aP1=ReadPoint(); aP2=ReadPoint();
922 0 : if (aP1.X() > aP2.X()) { nt=aP1.X(); aP1.X()=aP2.X(); aP2.X()=nt; }
923 0 : if (aP1.Y() > aP2.Y()) { nt=aP1.Y(); aP1.Y()=aP2.Y(); aP2.Y()=nt; }
924 0 : aSize=Size(aP2.X()-aP1.X(),aP2.Y()-aP1.Y());
925 :
926 0 : pB=pBitmapList;
927 0 : while (pB!=NULL && pB->nID!=nID) pB=pB->pSucc;
928 0 : if (pB!=NULL) {
929 0 : SetRasterOp(aAttr.ePatMix);
930 0 : pVirDev->DrawBitmap(aP1,aSize,pB->aBitmap);
931 : }
932 0 : }
933 :
934 0 : void OS2METReader::ReadChrStr(sal_Bool bGivenPos, sal_Bool bMove, sal_Bool bExtra, sal_uInt16 nOrderLen)
935 : {
936 0 : Point aP0;
937 : sal_uInt16 i, nLen;
938 : char * pChr;
939 : OSFont * pF;
940 0 : Font aFont;
941 0 : Size aSize;
942 :
943 0 : pF = pFontList;
944 0 : while (pF!=NULL && pF->nID!=aAttr.nChrSet) pF=pF->pSucc;
945 0 : if (pF!=NULL)
946 0 : aFont = pF->aFont;
947 0 : aFont.SetColor(aAttr.aChrCol);
948 0 : aFont.SetSize(Size(0,aAttr.aChrCellSize.Height()));
949 0 : if ( aAttr.nChrAng != 0 )
950 0 : aFont.SetOrientation(aAttr.nChrAng);
951 :
952 0 : if (bGivenPos)
953 0 : aP0 = ReadPoint();
954 : else
955 0 : aP0 = aAttr.aCurPos;
956 0 : if (bExtra)
957 : {
958 0 : pOS2MET->SeekRel(2);
959 0 : ReadPoint( sal_False );
960 0 : ReadPoint( sal_False );
961 0 : *pOS2MET >> nLen;
962 : }
963 : else
964 : {
965 0 : if ( !bGivenPos )
966 0 : nLen = nOrderLen;
967 0 : else if ( bCoord32 )
968 0 : nLen = nOrderLen-8;
969 : else
970 0 : nLen = nOrderLen-4;
971 : }
972 0 : pChr = new char[nLen+1];
973 0 : for (i=0; i<nLen; i++)
974 0 : *pOS2MET >> pChr[i];
975 0 : pChr[nLen] = 0;
976 0 : String aStr( (const sal_Char*)pChr, osl_getThreadTextEncoding() );
977 0 : SetRasterOp(aAttr.eChrMix);
978 0 : if (pVirDev->GetFont()!=aFont)
979 0 : pVirDev->SetFont(aFont);
980 0 : pVirDev->DrawText(aP0,aStr);
981 :
982 0 : aSize = Size( pVirDev->GetTextWidth(aStr), pVirDev->GetTextHeight() );
983 0 : if ( aAttr.nChrAng == 0 )
984 : {
985 0 : aCalcBndRect.Union(Rectangle( Point(aP0.X(),aP0.Y()-aSize.Height()),
986 0 : Size(aSize.Width(),aSize.Height()*2)));
987 0 : if (bMove)
988 0 : aAttr.aCurPos = Point( aP0.X() + aSize.Width(), aP0.Y());
989 : }
990 : else
991 : {
992 0 : Polygon aDummyPoly(4);
993 :
994 0 : aDummyPoly.SetPoint( Point( aP0.X(), aP0.Y() ), 0); // TOP LEFT
995 0 : aDummyPoly.SetPoint( Point( aP0.X(), aP0.Y() - aSize.Height() ), 1); // BOTTOM LEFT
996 0 : aDummyPoly.SetPoint( Point( aP0.X() + aSize.Width(), aP0.Y() ), 2); // TOP RIGHT
997 0 : aDummyPoly.SetPoint( Point( aP0.X() + aSize.Width(), aP0.Y() - aSize.Height() ), 3);// BOTTOM RIGHT
998 0 : aDummyPoly.Rotate( aP0, (short)aAttr.nChrAng );
999 0 : if ( bMove )
1000 0 : aAttr.aCurPos = aDummyPoly.GetPoint( 0 );
1001 0 : aCalcBndRect.Union( Rectangle( aDummyPoly.GetPoint( 0 ), aDummyPoly.GetPoint( 3 ) ) );
1002 0 : aCalcBndRect.Union( Rectangle( aDummyPoly.GetPoint( 1 ), aDummyPoly.GetPoint( 2 ) ) );
1003 : }
1004 0 : delete[] pChr;
1005 0 : }
1006 :
1007 0 : void OS2METReader::ReadArc(sal_Bool bGivenPos)
1008 : {
1009 0 : Point aP1, aP2, aP3;
1010 : double x1,y1,x2,y2,x3,y3,p,q,cx,cy,ncx,ncy,r,rx,ry,w1,w3;
1011 0 : if (bGivenPos) aP1=ReadPoint(); else aP1=aAttr.aCurPos;
1012 0 : aP2=ReadPoint(); aP3=ReadPoint();
1013 0 : aAttr.aCurPos=aP3;
1014 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1015 0 : 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 0 : x1=aP1.X(); y1=aP1.Y();
1019 0 : x2=aP2.X(); y2=aP2.Y();
1020 0 : x3=aP3.X(); y3=aP3.Y();
1021 0 : p=aAttr.nArcP;q=aAttr.nArcQ;
1022 : // Calculation of the center point cx, cy of the ellipse:
1023 0 : ncy=2*p*p*((y3-y1)*(x2-x1)-(y1-y2)*(x1-x3));
1024 0 : ncx=2*q*q*(x2-x1);
1025 0 : 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 0 : pVirDev->DrawLine(aP1,aP2);
1028 0 : pVirDev->DrawLine(aP2,aP3);
1029 0 : return;
1030 : }
1031 0 : cy=( q*q*((x3*x3-x1*x1)*(x2-x1)+(x2*x2-x1*x1)*(x1-x3)) +
1032 0 : p*p*((y3*y3-y1*y1)*(x2-x1)+(y2*y2-y1*y1)*(x1-x3)) ) / ncy;
1033 0 : 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 0 : r=sqrt(q*q*(x1-cx)*(x1-cx)+p*p*(y1-cy)*(y1-cy));
1036 0 : 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 0 : w1=fmod((atan2(x1-cx,y1-cy)-atan2(x2-cx,y2-cy)),6.28318530718); if (w1<0) w1+=6.28318530718;
1040 0 : w3=fmod((atan2(x3-cx,y3-cy)-atan2(x2-cx,y2-cy)),6.28318530718); if (w3<0) w3+=6.28318530718;
1041 0 : if (w3<w1) {
1042 0 : pVirDev->DrawArc(Rectangle((long)(cx-rx),(long)(cy-ry),
1043 0 : (long)(cx+rx),(long)(cy+ry)),aP1,aP3);
1044 : }
1045 : else {
1046 0 : pVirDev->DrawArc(Rectangle((long)(cx-rx),(long)(cy-ry),
1047 0 : (long)(cx+rx),(long)(cy+ry)),aP3,aP1);
1048 : }
1049 : }
1050 :
1051 0 : void OS2METReader::ReadFullArc(sal_Bool bGivenPos, sal_uInt16 nOrderSize)
1052 : {
1053 0 : Point aCenter;
1054 : long nP,nQ,nR,nS;
1055 0 : Rectangle aRect;
1056 : sal_uInt32 nMul; sal_uInt16 nMulS;
1057 :
1058 0 : if (bGivenPos) {
1059 0 : aCenter=ReadPoint();
1060 0 : if (bCoord32) nOrderSize-=8; else nOrderSize-=4;
1061 : }
1062 0 : else aCenter=aAttr.aCurPos;
1063 :
1064 0 : nP=aAttr.nArcP; nQ=aAttr.nArcQ; nR=aAttr.nArcR; nS=aAttr.nArcS;
1065 0 : if (nP<0) nP=-nP;
1066 0 : if (nQ<0) nQ=-nQ;
1067 0 : if (nR<0) nR=-nR;
1068 0 : if (nS<0) nS=-nS;
1069 0 : if (nOrderSize>=4) *pOS2MET >> nMul;
1070 0 : else { *pOS2MET >> nMulS; nMul=((sal_uLong)nMulS)<<8; }
1071 0 : if (nMul!=0x00010000) {
1072 0 : nP=(nP*nMul)>>16;
1073 0 : nQ=(nQ*nMul)>>16;
1074 0 : nR=(nR*nMul)>>16;
1075 0 : nS=(nS*nMul)>>16;
1076 : }
1077 :
1078 0 : aRect=Rectangle(aCenter.X()-nP,aCenter.Y()-nQ,
1079 0 : aCenter.X()+nP,aCenter.Y()+nQ);
1080 0 : aCalcBndRect.Union(aRect);
1081 :
1082 0 : if (pAreaStack!=NULL) {
1083 0 : ChangeBrush(aAttr.aPatCol,aAttr.aPatBgCol,aAttr.bFill);
1084 0 : SetRasterOp(aAttr.ePatMix);
1085 0 : if ((pAreaStack->nFlags&0x40)!=0)
1086 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1087 : else
1088 0 : SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1089 : }
1090 : else
1091 : {
1092 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1093 0 : ChangeBrush(Color( COL_TRANSPARENT ),Color( COL_TRANSPARENT ),sal_False);
1094 0 : SetRasterOp(aAttr.eLinMix);
1095 : }
1096 0 : pVirDev->DrawEllipse(aRect);
1097 0 : }
1098 :
1099 0 : void OS2METReader::ReadPartialArc(sal_Bool bGivenPos, sal_uInt16 nOrderSize)
1100 : {
1101 0 : Point aP0, aCenter,aPStart,aPEnd;
1102 : sal_Int32 nP,nQ,nR,nS,nStart, nSweep;
1103 0 : Rectangle aRect;
1104 : sal_uInt32 nMul; sal_uInt16 nMulS;
1105 : double fStart, fEnd;
1106 :
1107 0 : if (bGivenPos) {
1108 0 : aP0=ReadPoint();
1109 0 : if (bCoord32) nOrderSize-=8; else nOrderSize-=4;
1110 : }
1111 0 : else aP0=aAttr.aCurPos;
1112 0 : aCenter=ReadPoint();
1113 :
1114 0 : nP=aAttr.nArcP; nQ=aAttr.nArcQ; nR=aAttr.nArcR; nS=aAttr.nArcS;
1115 0 : if (nP<0) nP=-nP;
1116 0 : if (nQ<0) nQ=-nQ;
1117 0 : if (nR<0) nR=-nR;
1118 0 : if (nS<0) nS=-nS;
1119 0 : if (nOrderSize>=12) *pOS2MET >> nMul;
1120 0 : else { *pOS2MET >> nMulS; nMul=((sal_uLong)nMulS)<<8; }
1121 0 : if (nMul!=0x00010000) {
1122 0 : nP=(nP*nMul)>>16;
1123 0 : nQ=(nQ*nMul)>>16;
1124 0 : nR=(nR*nMul)>>16;
1125 0 : nS=(nS*nMul)>>16;
1126 : }
1127 :
1128 0 : *pOS2MET >> nStart >> nSweep;
1129 0 : fStart=((double)nStart)/65536.0/180.0*3.14159265359;
1130 0 : fEnd=fStart+((double)nSweep)/65536.0/180.0*3.14159265359;
1131 0 : aPStart=Point(aCenter.X()+(sal_Int32)( cos(fStart)*nP),
1132 0 : aCenter.Y()+(sal_Int32)(-sin(fStart)*nQ));
1133 0 : aPEnd= Point(aCenter.X()+(sal_Int32)( cos(fEnd)*nP),
1134 0 : aCenter.Y()+(sal_Int32)(-sin(fEnd)*nQ));
1135 :
1136 0 : aRect=Rectangle(aCenter.X()-nP,aCenter.Y()-nQ,
1137 0 : aCenter.X()+nP,aCenter.Y()+nQ);
1138 0 : aCalcBndRect.Union(aRect);
1139 :
1140 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1141 0 : SetRasterOp(aAttr.eLinMix);
1142 :
1143 0 : pVirDev->DrawLine(aP0,aPStart);
1144 0 : pVirDev->DrawArc(aRect,aPStart,aPEnd);
1145 0 : aAttr.aCurPos=aPEnd;
1146 0 : }
1147 :
1148 0 : void OS2METReader::ReadPolygons()
1149 : {
1150 : sal_uInt32 i,j,nNumPolys, nNumPoints;
1151 0 : PolyPolygon aPolyPoly;
1152 0 : Polygon aPoly;
1153 0 : Point aPoint;
1154 : sal_uInt8 nFlags;
1155 :
1156 0 : *pOS2MET >> nFlags >> nNumPolys;
1157 0 : for (i=0; i<nNumPolys; i++) {
1158 0 : *pOS2MET >> nNumPoints;
1159 0 : if (i==0) nNumPoints++;
1160 0 : aPoly.SetSize((short)nNumPoints);
1161 0 : for (j=0; j<nNumPoints; j++) {
1162 0 : if (i==0 && j==0) aPoint=aAttr.aCurPos;
1163 0 : else aPoint=ReadPoint();
1164 0 : aPoly.SetPoint(aPoint,(short)j);
1165 0 : if (i==nNumPolys-1 && j==nNumPoints-1) aAttr.aCurPos=aPoint;
1166 : }
1167 0 : aPolyPoly.Insert(aPoly);
1168 : }
1169 :
1170 0 : ChangeBrush(aAttr.aPatCol,aAttr.aPatBgCol,aAttr.bFill);
1171 0 : SetRasterOp(aAttr.ePatMix);
1172 0 : if ((nFlags&0x01)!=0)
1173 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1174 : else
1175 0 : SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1176 0 : DrawPolyPolygon( aPolyPoly );
1177 0 : }
1178 :
1179 0 : void OS2METReader::ReadBezier(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1180 : {
1181 0 : sal_uInt16 i, nNumPoints = nOrderLen / ( bCoord32 ? 8 : 4 );
1182 :
1183 0 : if( !bGivenPos )
1184 0 : nNumPoints++;
1185 :
1186 0 : if( !nNumPoints )
1187 0 : return;
1188 :
1189 0 : Polygon aPolygon( nNumPoints );
1190 :
1191 0 : for( i=0; i < nNumPoints; i++ )
1192 : {
1193 0 : if( i==0 && !bGivenPos)
1194 0 : aPolygon.SetPoint( aAttr.aCurPos, i );
1195 : else
1196 0 : aPolygon.SetPoint( ReadPoint(), i );
1197 : }
1198 :
1199 0 : if( !( nNumPoints % 4 ) )
1200 : {
1201 : // create bezier polygon
1202 0 : const sal_uInt16 nSegPoints = 25;
1203 0 : const sal_uInt16 nSegments = aPolygon.GetSize() >> 2;
1204 0 : Polygon aBezPoly( nSegments * nSegPoints );
1205 :
1206 : sal_uInt16 nSeg, nBezPos, nStartPos;
1207 0 : for( nSeg = 0, nBezPos = 0, nStartPos = 0; nSeg < nSegments; nSeg++, nStartPos += 4 )
1208 : {
1209 0 : const Polygon aSegPoly( aPolygon[ nStartPos ], aPolygon[ nStartPos + 1 ],
1210 0 : aPolygon[ nStartPos + 3 ], aPolygon[ nStartPos + 2 ],
1211 0 : nSegPoints );
1212 :
1213 0 : for( sal_uInt16 nSegPos = 0; nSegPos < nSegPoints; )
1214 0 : aBezPoly[ nBezPos++ ] = aSegPoly[ nSegPos++ ];
1215 0 : }
1216 :
1217 0 : nNumPoints = nBezPos;
1218 :
1219 0 : if( nNumPoints != aBezPoly.GetSize() )
1220 0 : aBezPoly.SetSize( nNumPoints );
1221 :
1222 0 : aPolygon = aBezPoly;
1223 : }
1224 :
1225 0 : aAttr.aCurPos = aPolygon[ nNumPoints - 1 ];
1226 :
1227 0 : if (pAreaStack!=NULL)
1228 0 : AddPointsToArea(aPolygon);
1229 0 : else if (pPathStack!=NULL)
1230 0 : AddPointsToPath(aPolygon);
1231 : else
1232 : {
1233 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1234 0 : SetRasterOp(aAttr.eLinMix);
1235 0 : DrawPolyLine( aPolygon );
1236 0 : }
1237 : }
1238 :
1239 0 : void OS2METReader::ReadFillet(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1240 : {
1241 : sal_uInt16 i,nNumPoints;
1242 :
1243 0 : if (bCoord32) nNumPoints=nOrderLen/8; else nNumPoints=nOrderLen/4;
1244 0 : if (!bGivenPos) nNumPoints++;
1245 0 : if (nNumPoints==0) return;
1246 0 : Polygon aPolygon(nNumPoints);
1247 0 : for (i=0; i<nNumPoints; i++) {
1248 0 : if (i==0 && !bGivenPos) aPolygon.SetPoint(aAttr.aCurPos,i);
1249 0 : else aPolygon.SetPoint(ReadPoint(),i);
1250 : }
1251 0 : aAttr.aCurPos=aPolygon.GetPoint(nNumPoints-1);
1252 0 : if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
1253 0 : else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
1254 : else {
1255 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1256 0 : SetRasterOp(aAttr.eLinMix);
1257 0 : DrawPolyLine( aPolygon );
1258 0 : }
1259 : }
1260 :
1261 0 : void OS2METReader::ReadFilletSharp(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1262 : {
1263 : sal_uInt16 i,nNumPoints;
1264 :
1265 0 : if (bGivenPos) {
1266 0 : aAttr.aCurPos=ReadPoint();
1267 0 : if (bCoord32) nOrderLen-=8; else nOrderLen-=4;
1268 : }
1269 0 : if (bCoord32) nNumPoints=1+nOrderLen/10;
1270 0 : else nNumPoints=1+nOrderLen/6;
1271 0 : Polygon aPolygon(nNumPoints);
1272 0 : aPolygon.SetPoint(aAttr.aCurPos,0);
1273 0 : for (i=1; i<nNumPoints; i++) aPolygon.SetPoint(ReadPoint(),i);
1274 0 : aAttr.aCurPos=aPolygon.GetPoint(nNumPoints-1);
1275 0 : if (pAreaStack!=NULL) AddPointsToArea(aPolygon);
1276 0 : else if (pPathStack!=NULL) AddPointsToPath(aPolygon);
1277 : else
1278 : {
1279 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1280 0 : SetRasterOp(aAttr.eLinMix);
1281 0 : DrawPolyLine( aPolygon );
1282 0 : }
1283 0 : }
1284 :
1285 0 : void OS2METReader::ReadMarker(sal_Bool bGivenPos, sal_uInt16 nOrderLen)
1286 : {
1287 : sal_uInt16 i,nNumPoints;
1288 : long x,y;
1289 :
1290 0 : SetPen( aAttr.aMrkCol );
1291 0 : SetRasterOp(aAttr.eMrkMix);
1292 0 : if (aAttr.nMrkSymbol>=5 && aAttr.nMrkSymbol<=9)
1293 : {
1294 0 : ChangeBrush(aAttr.aMrkCol,aAttr.aMrkCol,sal_True);
1295 : }
1296 : else
1297 : {
1298 0 : ChangeBrush(Color(COL_TRANSPARENT),Color(COL_TRANSPARENT),sal_False);
1299 : }
1300 0 : if (bCoord32) nNumPoints=nOrderLen/8; else nNumPoints=nOrderLen/4;
1301 0 : if (!bGivenPos) nNumPoints++;
1302 0 : for (i=0; i<nNumPoints; i++) {
1303 0 : if (i!=0 || bGivenPos) aAttr.aCurPos=ReadPoint();
1304 0 : x=aAttr.aCurPos.X(); y=aAttr.aCurPos.Y();
1305 0 : aCalcBndRect.Union(Rectangle(x-5,y-5,x+5,y+5));
1306 0 : switch (aAttr.nMrkSymbol) {
1307 : case 2: // PLUS
1308 0 : pVirDev->DrawLine(Point(x-4,y),Point(x+4,y));
1309 0 : pVirDev->DrawLine(Point(x,y-4),Point(x,y+4));
1310 0 : break;
1311 : case 3: // DIAMOND
1312 : case 7: { // SOLIDDIAMOND
1313 0 : Polygon aPoly(4);
1314 0 : aPoly.SetPoint(Point(x,y+4),0);
1315 0 : aPoly.SetPoint(Point(x+4,y),1);
1316 0 : aPoly.SetPoint(Point(x,y-4),2);
1317 0 : aPoly.SetPoint(Point(x-4,y),3);
1318 0 : pVirDev->DrawPolygon(aPoly);
1319 0 : break;
1320 : }
1321 : case 4: // SQARE
1322 : case 8: { // SOLIDSUARE
1323 0 : Polygon aPoly(4);
1324 0 : aPoly.SetPoint(Point(x+4,y+4),0);
1325 0 : aPoly.SetPoint(Point(x+4,y-4),1);
1326 0 : aPoly.SetPoint(Point(x-4,y-4),2);
1327 0 : aPoly.SetPoint(Point(x-4,y+4),3);
1328 0 : pVirDev->DrawPolygon(aPoly);
1329 0 : break;
1330 : }
1331 : case 5: { // SIXPOINTSTAR
1332 0 : Polygon aPoly(12);
1333 0 : aPoly.SetPoint(Point(x ,y-4),0);
1334 0 : aPoly.SetPoint(Point(x+2,y-2),1);
1335 0 : aPoly.SetPoint(Point(x+4,y-2),2);
1336 0 : aPoly.SetPoint(Point(x+2,y ),3);
1337 0 : aPoly.SetPoint(Point(x+4,y+2),4);
1338 0 : aPoly.SetPoint(Point(x+2,y+2),5);
1339 0 : aPoly.SetPoint(Point(x ,y+4),6);
1340 0 : aPoly.SetPoint(Point(x-2,y+2),7);
1341 0 : aPoly.SetPoint(Point(x-4,y+2),8);
1342 0 : aPoly.SetPoint(Point(x-2,y ),9);
1343 0 : aPoly.SetPoint(Point(x-4,y-2),10);
1344 0 : aPoly.SetPoint(Point(x-2,y-2),11);
1345 0 : pVirDev->DrawPolygon(aPoly);
1346 0 : break;
1347 : }
1348 : case 6: { // EIGHTPOINTSTAR
1349 0 : Polygon aPoly(16);
1350 0 : aPoly.SetPoint(Point(x ,y-4),0);
1351 0 : aPoly.SetPoint(Point(x+1,y-2),1);
1352 0 : aPoly.SetPoint(Point(x+3,y-3),2);
1353 0 : aPoly.SetPoint(Point(x+2,y-1),3);
1354 0 : aPoly.SetPoint(Point(x+4,y ),4);
1355 0 : aPoly.SetPoint(Point(x+2,y+1),5);
1356 0 : aPoly.SetPoint(Point(x+3,y+3),6);
1357 0 : aPoly.SetPoint(Point(x+1,y+2),7);
1358 0 : aPoly.SetPoint(Point(x ,y+4),8);
1359 0 : aPoly.SetPoint(Point(x-1,y+2),9);
1360 0 : aPoly.SetPoint(Point(x-3,y+3),10);
1361 0 : aPoly.SetPoint(Point(x-2,y+1),11);
1362 0 : aPoly.SetPoint(Point(x-4,y ),12);
1363 0 : aPoly.SetPoint(Point(x-2,y-1),13);
1364 0 : aPoly.SetPoint(Point(x-3,y-3),14);
1365 0 : aPoly.SetPoint(Point(x-1,y-2),15);
1366 0 : pVirDev->DrawPolygon(aPoly);
1367 0 : break;
1368 : }
1369 : case 9: // DOT
1370 0 : pVirDev->DrawEllipse(Rectangle(x-1,y-1,x+1,y+1));
1371 0 : break;
1372 : case 10: // SMALLCIRCLE
1373 0 : pVirDev->DrawEllipse(Rectangle(x-2,y-2,x+2,y+2));
1374 0 : break;
1375 : case 64: // BLANK
1376 0 : break;
1377 : default: // (=1) CROSS
1378 0 : pVirDev->DrawLine(Point(x-4,y-4),Point(x+4,y+4));
1379 0 : pVirDev->DrawLine(Point(x-4,y+4),Point(x+4,y-4));
1380 0 : break;
1381 : }
1382 : }
1383 0 : }
1384 :
1385 0 : void OS2METReader::ReadOrder(sal_uInt16 nOrderID, sal_uInt16 nOrderLen)
1386 : {
1387 0 : switch (nOrderID) {
1388 :
1389 0 : case GOrdGivArc: ReadArc(sal_True); break;
1390 0 : case GOrdCurArc: ReadArc(sal_False); break;
1391 :
1392 0 : case GOrdGivBzr: ReadBezier(sal_True,nOrderLen); break;
1393 0 : case GOrdCurBzr: ReadBezier(sal_False,nOrderLen); break;
1394 :
1395 0 : case GOrdGivBox: ReadBox(sal_True); break;
1396 0 : case GOrdCurBox: ReadBox(sal_False); break;
1397 :
1398 0 : case GOrdGivFil: ReadFillet(sal_True,nOrderLen); break;
1399 0 : case GOrdCurFil: ReadFillet(sal_False,nOrderLen); break;
1400 :
1401 0 : case GOrdGivCrc: ReadFullArc(sal_True,nOrderLen); break;
1402 0 : case GOrdCurCrc: ReadFullArc(sal_False,nOrderLen); break;
1403 :
1404 0 : case GOrdGivLin: ReadLine(sal_True, nOrderLen); break;
1405 0 : case GOrdCurLin: ReadLine(sal_False, nOrderLen); break;
1406 :
1407 0 : case GOrdGivMrk: ReadMarker(sal_True, nOrderLen); break;
1408 0 : case GOrdCurMrk: ReadMarker(sal_False, nOrderLen); break;
1409 :
1410 0 : case GOrdGivArP: ReadPartialArc(sal_True,nOrderLen); break;
1411 0 : case GOrdCurArP: ReadPartialArc(sal_False,nOrderLen); break;
1412 :
1413 0 : case GOrdGivRLn: ReadRelLine(sal_True,nOrderLen); break;
1414 0 : case GOrdCurRLn: ReadRelLine(sal_False,nOrderLen); break;
1415 :
1416 0 : case GOrdGivSFl: ReadFilletSharp(sal_True,nOrderLen); break;
1417 0 : case GOrdCurSFl: ReadFilletSharp(sal_False,nOrderLen); break;
1418 :
1419 0 : case GOrdGivStM: ReadChrStr(sal_True , sal_True , sal_False, nOrderLen); break;
1420 0 : case GOrdCurStM: ReadChrStr(sal_False, sal_True , sal_False, nOrderLen); break;
1421 0 : case GOrdGivStr: ReadChrStr(sal_True , sal_False, sal_False, nOrderLen); break;
1422 0 : case GOrdCurStr: ReadChrStr(sal_False, sal_False, sal_False, nOrderLen); break;
1423 0 : case GOrdGivStx: ReadChrStr(sal_True , sal_False, sal_True , nOrderLen); break;
1424 0 : case GOrdCurStx: ReadChrStr(sal_False, sal_False, sal_True , nOrderLen); break;
1425 :
1426 : case GOrdGivImg: OOODEBUG("GOrdGivImg",0);
1427 0 : break;
1428 : case GOrdCurImg: OOODEBUG("GOrdCurImg",0);
1429 0 : break;
1430 : case GOrdImgDat: OOODEBUG("GOrdImgDat",0);
1431 0 : break;
1432 : case GOrdEndImg: OOODEBUG("GOrdEndImg",0);
1433 0 : break;
1434 :
1435 : case GOrdBegAra: {
1436 0 : OSArea * p=new OSArea;
1437 0 : p->bClosed=sal_False;
1438 0 : p->pSucc=pAreaStack; pAreaStack=p;
1439 0 : *pOS2MET >> (p->nFlags);
1440 0 : p->aCol=aAttr.aPatCol;
1441 0 : p->aBgCol=aAttr.aPatBgCol;
1442 0 : p->eMix=aAttr.ePatMix;
1443 0 : p->eBgMix=aAttr.ePatBgMix;
1444 0 : p->bFill=aAttr.bFill;
1445 0 : break;
1446 : }
1447 : case GOrdEndAra:
1448 : {
1449 0 : OSArea * p=pAreaStack;
1450 0 : if ( p )
1451 : {
1452 0 : pAreaStack = p->pSucc;
1453 0 : if ( pPathStack )
1454 : {
1455 0 : for ( sal_uInt16 i=0; i<p->aPPoly.Count(); i++ )
1456 : {
1457 0 : AddPointsToPath( p->aPPoly.GetObject( i ) );
1458 0 : CloseFigure();
1459 : }
1460 : }
1461 : else
1462 : {
1463 0 : if ( ( p->nFlags & 0x40 ) == 0 )
1464 0 : SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1465 : else
1466 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1467 :
1468 0 : ChangeBrush(p->aCol,p->aBgCol,p->bFill);
1469 0 : SetRasterOp(p->eMix);
1470 0 : DrawPolyPolygon( p->aPPoly );
1471 : }
1472 0 : delete p;
1473 : }
1474 : }
1475 0 : break;
1476 :
1477 : case GOrdBegElm:// OOODEBUG("GOrdBegElm",0);
1478 0 : break;
1479 : case GOrdEndElm:// OOODEBUG("GOrdEndElm",0);
1480 0 : break;
1481 :
1482 : case GOrdBegPth: {
1483 0 : OSPath * p=new OSPath;
1484 0 : p->pSucc=pPathStack; pPathStack=p;
1485 0 : pOS2MET->SeekRel(2);
1486 0 : *pOS2MET >> p->nID;
1487 0 : p->bClosed=sal_False;
1488 0 : p->bStroke=sal_False;
1489 0 : break;
1490 : }
1491 : case GOrdEndPth: {
1492 : OSPath * p, * pprev, * psucc;
1493 0 : if (pPathStack==NULL) break;
1494 0 : p=pPathList; pprev=NULL;
1495 0 : while (p!=NULL) {
1496 0 : psucc=p->pSucc;
1497 0 : if (p->nID==pPathStack->nID) {
1498 0 : if (pprev==NULL) pPathList=psucc; else pprev->pSucc=psucc;
1499 0 : delete p;
1500 : }
1501 0 : else pprev=p;
1502 0 : p=psucc;
1503 : }
1504 0 : p=pPathStack;
1505 0 : pPathStack=p->pSucc;
1506 0 : p->pSucc=pPathList; pPathList=p;
1507 0 : break;
1508 : }
1509 : case GOrdFilPth:
1510 : {
1511 : sal_uInt32 nID;
1512 : sal_uInt16 nDummy;
1513 0 : OSPath* p = pPathList;
1514 :
1515 0 : *pOS2MET >> nDummy
1516 0 : >> nID;
1517 :
1518 0 : 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 0 : while( p && p->nID != nID )
1521 0 : p = p->pSucc;
1522 :
1523 0 : if( p )
1524 : {
1525 0 : if( p->bStroke )
1526 : {
1527 0 : SetPen( aAttr.aPatCol, aAttr.nStrLinWidth, PEN_SOLID );
1528 0 : ChangeBrush(Color(COL_TRANSPARENT),Color(COL_TRANSPARENT),sal_False);
1529 0 : SetRasterOp( aAttr.ePatMix );
1530 0 : if ( IsLineInfo() )
1531 : {
1532 0 : for ( sal_uInt16 i = 0; i < p->aPPoly.Count(); i++ )
1533 0 : pVirDev->DrawPolyLine( p->aPPoly.GetObject( i ), aLineInfo );
1534 : }
1535 : else
1536 0 : pVirDev->DrawPolyPolygon( p->aPPoly );
1537 : }
1538 : else
1539 : {
1540 0 : SetPen( COL_TRANSPARENT, 0, PEN_NULL );
1541 0 : ChangeBrush( aAttr.aPatCol, aAttr.aPatBgCol, aAttr.bFill );
1542 0 : SetRasterOp( aAttr.ePatMix );
1543 0 : pVirDev->DrawPolyPolygon( p->aPPoly );
1544 : }
1545 : }
1546 : }
1547 : }
1548 0 : break;
1549 :
1550 : case GOrdModPth:
1551 : {
1552 0 : OSPath* p = pPathList;
1553 :
1554 0 : while( p && p->nID != 1 )
1555 0 : p = p->pSucc;
1556 :
1557 0 : if( p )
1558 0 : p->bStroke = sal_True;
1559 : }
1560 0 : break;
1561 :
1562 : case GOrdOutPth:
1563 : {
1564 : sal_uInt32 nID;
1565 : sal_uInt16 i,nC;
1566 0 : OSPath* p=pPathList;
1567 0 : pOS2MET->SeekRel(2);
1568 0 : *pOS2MET >> nID;
1569 0 : while (p!=NULL && p->nID!=nID)
1570 0 : p=p->pSucc;
1571 :
1572 0 : if( p!=NULL )
1573 : {
1574 0 : SetPen( aAttr.aLinCol, aAttr.nStrLinWidth, aAttr.eLinStyle );
1575 0 : SetRasterOp(aAttr.eLinMix);
1576 0 : ChangeBrush(Color(COL_TRANSPARENT),Color(COL_TRANSPARENT),sal_False);
1577 0 : nC=p->aPPoly.Count();
1578 0 : for (i=0; i<nC; i++)
1579 : {
1580 0 : if (i+1<nC || p->bClosed==sal_True)
1581 0 : DrawPolygon( p->aPPoly.GetObject( i ) );
1582 : else
1583 0 : DrawPolyLine( p->aPPoly.GetObject( i ) );
1584 : }
1585 : }
1586 0 : break;
1587 : }
1588 : case GOrdSClPth: { OOODEBUG("GOrdSClPth",0);
1589 : sal_uInt32 nID;
1590 0 : OSPath * p=pPathList;
1591 0 : pOS2MET->SeekRel(2);
1592 0 : *pOS2MET >> nID;
1593 0 : if (nID==0) p=NULL;
1594 0 : while (p!=NULL && p->nID!=nID) p=p->pSucc;
1595 0 : if (p!=NULL) pVirDev->SetClipRegion(Region(p->aPPoly));
1596 0 : else pVirDev->SetClipRegion();
1597 0 : break;
1598 : }
1599 : case GOrdNopNop:
1600 0 : break;
1601 : case GOrdRemark: //OOODEBUG("GOrdRemark",0);
1602 0 : break;
1603 : case GOrdSegLab: OOODEBUG("GOrdSegLab",0);
1604 0 : break;
1605 :
1606 0 : case GOrdBitBlt: ReadBitBlt(); break;
1607 :
1608 : case GOrdCalSeg: OOODEBUG("GOrdCalSeg",0);
1609 0 : break;
1610 : case GOrdSSgBnd: OOODEBUG("GOrdSSgBnd",0);
1611 0 : break;
1612 : case GOrdSegChr: OOODEBUG("GOrdSegChr",0);
1613 0 : break;
1614 : case GOrdCloFig:
1615 0 : CloseFigure();
1616 0 : break;
1617 : case GOrdEndSym: OOODEBUG("GOrdEndSym",0);
1618 0 : break;
1619 : case GOrdEndPlg: OOODEBUG("GOrdEndPlg",0);
1620 0 : break;
1621 : case GOrdEscape: OOODEBUG("GOrdEscape",0);
1622 0 : break;
1623 : case GOrdExtEsc: OOODEBUG("GOrdExtEsc",0);
1624 0 : break;
1625 :
1626 0 : case GOrdPolygn: ReadPolygons(); break;
1627 :
1628 0 : case GOrdStkPop: PopAttr(); break;
1629 :
1630 0 : case GOrdPIvAtr: PushAttr(nOrderID);
1631 : case GOrdSIvAtr: {
1632 : sal_uInt8 nA, nP, nFlags, nMix;
1633 : sal_uLong nVal;
1634 0 : Color aCol;
1635 : RasterOp eROP;
1636 0 : *pOS2MET >> nA >> nP >> nFlags;
1637 0 : if (nOrderID==GOrdPIvAtr) {
1638 0 : pAttrStack->nIvAttrA=nA;
1639 0 : pAttrStack->nIvAttrP=nP;
1640 : }
1641 0 : if (nA<=2) {
1642 0 : if ((nFlags&0x80)!=0) {
1643 0 : if (nA==1) switch (nP) {
1644 0 : case 1: aAttr.aLinCol=aDefAttr.aLinCol; break;
1645 0 : case 2: aAttr.aChrCol=aDefAttr.aChrCol; break;
1646 0 : case 3: aAttr.aMrkCol=aDefAttr.aMrkCol; break;
1647 0 : case 4: aAttr.aPatCol=aDefAttr.aPatCol; break;
1648 0 : case 5: aAttr.aImgCol=aDefAttr.aImgCol; break;
1649 : }
1650 0 : else switch (nP) {
1651 0 : case 1: aAttr.aLinBgCol=aDefAttr.aLinBgCol; break;
1652 0 : case 2: aAttr.aChrBgCol=aDefAttr.aChrBgCol; break;
1653 0 : case 3: aAttr.aMrkBgCol=aDefAttr.aMrkBgCol; break;
1654 0 : case 4: aAttr.aPatBgCol=aDefAttr.aPatBgCol; break;
1655 0 : case 5: aAttr.aImgBgCol=aDefAttr.aImgBgCol; break;
1656 : }
1657 : }
1658 : else {
1659 0 : nVal=ReadLittleEndian3BytesLong();
1660 0 : if ((nFlags&0x40)!=0 && nVal==1) aCol=Color(COL_BLACK);
1661 0 : else if ((nFlags&0x40)!=0 && nVal==2) aCol=Color(COL_WHITE);
1662 0 : else if ((nFlags&0x40)!=0 && nVal==4) aCol=Color(COL_WHITE);
1663 0 : else if ((nFlags&0x40)!=0 && nVal==5) aCol=Color(COL_BLACK);
1664 0 : else aCol=GetPaletteColor(nVal);
1665 0 : if (nA==1) switch (nP) {
1666 0 : case 1: aAttr.aLinCol=aCol; break;
1667 0 : case 2: aAttr.aChrCol=aCol; break;
1668 0 : case 3: aAttr.aMrkCol=aCol; break;
1669 0 : case 4: aAttr.aPatCol=aCol; break;
1670 0 : case 5: aAttr.aImgCol=aCol; break;
1671 : }
1672 0 : else switch (nP) {
1673 0 : case 1: aAttr.aLinBgCol=aCol; break;
1674 0 : case 2: aAttr.aChrBgCol=aCol; break;
1675 0 : case 3: aAttr.aMrkBgCol=aCol; break;
1676 0 : case 4: aAttr.aPatBgCol=aCol; break;
1677 0 : case 5: aAttr.aImgBgCol=aCol; break;
1678 : }
1679 : }
1680 : }
1681 : else {
1682 0 : *pOS2MET >> nMix;
1683 0 : if (nMix==0) {
1684 0 : switch (nP) {
1685 0 : case 1: aAttr.eLinBgMix=aDefAttr.eLinBgMix; break;
1686 0 : case 2: aAttr.eChrBgMix=aDefAttr.eChrBgMix; break;
1687 0 : case 3: aAttr.eMrkBgMix=aDefAttr.eMrkBgMix; break;
1688 0 : case 4: aAttr.ePatBgMix=aDefAttr.ePatBgMix; break;
1689 0 : case 5: aAttr.eImgBgMix=aDefAttr.eImgBgMix; break;
1690 : }
1691 : }
1692 : else {
1693 0 : eROP=OS2MixToRasterOp(nMix);
1694 0 : switch (nP) {
1695 0 : case 1: aAttr.eLinBgMix=eROP; break;
1696 0 : case 2: aAttr.eChrBgMix=eROP; break;
1697 0 : case 3: aAttr.eMrkBgMix=eROP; break;
1698 0 : case 4: aAttr.ePatBgMix=eROP; break;
1699 0 : case 5: aAttr.eImgBgMix=eROP; break;
1700 : }
1701 : }
1702 : }
1703 0 : break;
1704 : }
1705 0 : case GOrdPIxCol: PushAttr(nOrderID);
1706 : case GOrdSIxCol: {
1707 : sal_uInt8 nFlags;
1708 : sal_uLong nVal;
1709 0 : Color aCol;
1710 0 : *pOS2MET >> nFlags;
1711 0 : if ((nFlags&0x80)!=0) {
1712 0 : aAttr.aLinCol=aDefAttr.aLinCol;
1713 0 : aAttr.aChrCol=aDefAttr.aChrCol;
1714 0 : aAttr.aMrkCol=aDefAttr.aMrkCol;
1715 0 : aAttr.aPatCol=aDefAttr.aPatCol;
1716 0 : aAttr.aImgCol=aDefAttr.aImgCol;
1717 : }
1718 : else {
1719 0 : nVal=ReadLittleEndian3BytesLong();
1720 0 : if ((nFlags&0x40)!=0 && nVal==1) aCol=Color(COL_BLACK);
1721 0 : else if ((nFlags&0x40)!=0 && nVal==2) aCol=Color(COL_WHITE);
1722 0 : else if ((nFlags&0x40)!=0 && nVal==4) aCol=Color(COL_WHITE);
1723 0 : else if ((nFlags&0x40)!=0 && nVal==5) aCol=Color(COL_BLACK);
1724 0 : else aCol=GetPaletteColor(nVal);
1725 : aAttr.aLinCol = aAttr.aChrCol = aAttr.aMrkCol = aAttr.aPatCol =
1726 0 : aAttr.aImgCol = aCol;
1727 : }
1728 0 : break;
1729 : }
1730 :
1731 : case GOrdPColor:
1732 0 : case GOrdPXtCol: PushAttr(nOrderID);
1733 : case GOrdSColor:
1734 : case GOrdSXtCol: {
1735 : sal_uInt8 nbyte;
1736 : sal_uInt16 nVal;
1737 0 : Color aCol;
1738 0 : if (nOrderID==GOrdPColor || nOrderID==GOrdSColor) {
1739 0 : *pOS2MET >> nbyte; nVal=((sal_uInt16)nbyte)|0xff00;
1740 : }
1741 0 : else *pOS2MET >> nVal;
1742 0 : if (nVal==0x0000 || nVal==0xff00) {
1743 0 : aAttr.aLinCol=aDefAttr.aLinCol;
1744 0 : aAttr.aChrCol=aDefAttr.aChrCol;
1745 0 : aAttr.aMrkCol=aDefAttr.aMrkCol;
1746 0 : aAttr.aPatCol=aDefAttr.aPatCol;
1747 0 : aAttr.aImgCol=aDefAttr.aImgCol;
1748 : }
1749 : else {
1750 0 : if (nVal==0x0007) aCol=Color(COL_WHITE);
1751 0 : else if (nVal==0x0008) aCol=Color(COL_BLACK);
1752 0 : else if (nVal==0xff08) aCol=GetPaletteColor(1);
1753 0 : else aCol=GetPaletteColor(((sal_uLong)nVal) & 0x000000ff);
1754 : aAttr.aLinCol = aAttr.aChrCol = aAttr.aMrkCol = aAttr.aPatCol =
1755 0 : aAttr.aImgCol = aCol;
1756 : }
1757 0 : break;
1758 : }
1759 :
1760 0 : case GOrdPBgCol: PushAttr(nOrderID);
1761 : case GOrdSBgCol: {
1762 : sal_uInt16 nVal;
1763 0 : Color aCol;
1764 0 : *pOS2MET >> nVal;
1765 0 : if (nVal==0x0000 || nVal==0xff00) {
1766 0 : aAttr.aLinBgCol=aDefAttr.aLinBgCol;
1767 0 : aAttr.aChrBgCol=aDefAttr.aChrBgCol;
1768 0 : aAttr.aMrkBgCol=aDefAttr.aMrkBgCol;
1769 0 : aAttr.aPatBgCol=aDefAttr.aPatBgCol;
1770 0 : aAttr.aImgBgCol=aDefAttr.aImgBgCol;
1771 : }
1772 : else {
1773 0 : if (nVal==0x0007) aCol=Color(COL_WHITE);
1774 0 : else if (nVal==0x0008) aCol=Color(COL_BLACK);
1775 0 : else if (nVal==0xff08) aCol=GetPaletteColor(0);
1776 0 : else aCol=GetPaletteColor(((sal_uLong)nVal) & 0x000000ff);
1777 : aAttr.aLinBgCol = aAttr.aChrBgCol = aAttr.aMrkBgCol =
1778 0 : aAttr.aPatBgCol = aAttr.aImgBgCol = aCol;
1779 : }
1780 0 : break;
1781 : }
1782 0 : case GOrdPBxCol: PushAttr(nOrderID);
1783 : case GOrdSBxCol: {
1784 : sal_uInt8 nFlags;
1785 : sal_uLong nVal;
1786 0 : Color aCol;
1787 0 : *pOS2MET >> nFlags;
1788 0 : if ((nFlags&0x80)!=0) {
1789 0 : aAttr.aLinBgCol=aDefAttr.aLinBgCol;
1790 0 : aAttr.aChrBgCol=aDefAttr.aChrBgCol;
1791 0 : aAttr.aMrkBgCol=aDefAttr.aMrkBgCol;
1792 0 : aAttr.aPatBgCol=aDefAttr.aPatBgCol;
1793 0 : aAttr.aImgBgCol=aDefAttr.aImgBgCol;
1794 : }
1795 : else {
1796 0 : nVal=ReadLittleEndian3BytesLong();
1797 0 : if ((nFlags&0x40)!=0 && nVal==1) aCol=Color(COL_BLACK);
1798 0 : else if ((nFlags&0x40)!=0 && nVal==2) aCol=Color(COL_WHITE);
1799 0 : else if ((nFlags&0x40)!=0 && nVal==4) aCol=Color(COL_WHITE);
1800 0 : else if ((nFlags&0x40)!=0 && nVal==5) aCol=Color(COL_BLACK);
1801 0 : else aCol=GetPaletteColor(nVal);
1802 : aAttr.aLinBgCol = aAttr.aChrBgCol = aAttr.aMrkBgCol =
1803 0 : aAttr.aPatBgCol = aAttr.aImgBgCol = aCol;
1804 : }
1805 0 : break;
1806 : }
1807 :
1808 0 : case GOrdPMixMd: PushAttr(nOrderID);
1809 : case GOrdSMixMd: {
1810 : sal_uInt8 nMix;
1811 0 : *pOS2MET >> nMix;
1812 0 : if (nMix==0) {
1813 0 : aAttr.eLinMix=aDefAttr.eLinMix;
1814 0 : aAttr.eChrMix=aDefAttr.eChrMix;
1815 0 : aAttr.eMrkMix=aDefAttr.eMrkMix;
1816 0 : aAttr.ePatMix=aDefAttr.ePatMix;
1817 0 : aAttr.eImgMix=aDefAttr.eImgMix;
1818 : }
1819 : else {
1820 : aAttr.eLinMix = aAttr.eChrMix = aAttr.eMrkMix =
1821 0 : aAttr.ePatMix = aAttr.eImgMix = OS2MixToRasterOp(nMix);
1822 : }
1823 0 : break;
1824 : }
1825 0 : case GOrdPBgMix: PushAttr(nOrderID);
1826 : case GOrdSBgMix: {
1827 : sal_uInt8 nMix;
1828 0 : *pOS2MET >> nMix;
1829 0 : if (nMix==0) {
1830 0 : aAttr.eLinBgMix=aDefAttr.eLinBgMix;
1831 0 : aAttr.eChrBgMix=aDefAttr.eChrBgMix;
1832 0 : aAttr.eMrkBgMix=aDefAttr.eMrkBgMix;
1833 0 : aAttr.ePatBgMix=aDefAttr.ePatBgMix;
1834 0 : aAttr.eImgBgMix=aDefAttr.eImgBgMix;
1835 : }
1836 : else {
1837 : aAttr.eLinBgMix = aAttr.eChrBgMix = aAttr.eMrkBgMix =
1838 0 : aAttr.ePatBgMix = aAttr.eImgBgMix = OS2MixToRasterOp(nMix);
1839 : }
1840 0 : break;
1841 : }
1842 0 : case GOrdPPtSet: PushAttr(nOrderID);
1843 : case GOrdSPtSet: OOODEBUG("GOrdSPtSet",0);
1844 0 : break;
1845 :
1846 0 : case GOrdPPtSym: PushAttr(nOrderID);
1847 : case GOrdSPtSym: {
1848 : sal_uInt8 nPatt;
1849 0 : *pOS2MET >> nPatt;
1850 0 : aAttr.bFill = ( nPatt != 0x0f );
1851 0 : break;
1852 : }
1853 :
1854 0 : case GOrdPPtRef: PushAttr(nOrderID);
1855 : case GOrdSPtRef: OOODEBUG("GOrdSPtRef",0);
1856 0 : break;
1857 :
1858 0 : case GOrdPLnEnd: PushAttr(nOrderID);
1859 : case GOrdSLnEnd:
1860 0 : break;
1861 :
1862 0 : case GOrdPLnJoi: PushAttr(nOrderID);
1863 : case GOrdSLnJoi:
1864 0 : break;
1865 :
1866 0 : case GOrdPLnTyp: PushAttr(nOrderID);
1867 : case GOrdSLnTyp: {
1868 : sal_uInt8 nType;
1869 0 : *pOS2MET >> nType;
1870 0 : switch (nType) {
1871 0 : case 0: aAttr.eLinStyle=aDefAttr.eLinStyle; break;
1872 0 : case 1: case 4: aAttr.eLinStyle=PEN_DOT; break;
1873 0 : case 2: case 5: aAttr.eLinStyle=PEN_DASH; break;
1874 0 : case 3: case 6: aAttr.eLinStyle=PEN_DASHDOT; break;
1875 0 : case 8: aAttr.eLinStyle=PEN_NULL; break;
1876 0 : default: aAttr.eLinStyle=PEN_SOLID;
1877 : }
1878 0 : break;
1879 : }
1880 0 : case GOrdPLnWdt: PushAttr(nOrderID);
1881 : case GOrdSLnWdt: {
1882 : sal_uInt8 nbyte;
1883 0 : *pOS2MET >> nbyte;
1884 0 : if (nbyte==0) aAttr.nLinWidth=aDefAttr.nLinWidth;
1885 0 : else aAttr.nLinWidth=(sal_uInt16)nbyte-1;
1886 0 : break;
1887 : }
1888 0 : case GOrdPFrLWd: PushAttr(nOrderID);
1889 : case GOrdSFrLWd:
1890 0 : break;
1891 :
1892 0 : case GOrdPStLWd: PushAttr(nOrderID);
1893 : case GOrdSStLWd :
1894 : {
1895 : sal_uInt8 nFlags;
1896 :
1897 0 : *pOS2MET >> nFlags;
1898 0 : if ( nFlags & 0x80 )
1899 0 : aAttr.nStrLinWidth = aDefAttr.nStrLinWidth;
1900 : else
1901 : {
1902 0 : pOS2MET->SeekRel( 1 );
1903 0 : long nWd = ReadCoord( bCoord32 );
1904 0 : if ( nWd < 0 )
1905 0 : nWd = -nWd;
1906 0 : aAttr.nStrLinWidth = (sal_uInt16)nWd;
1907 : }
1908 0 : break;
1909 : }
1910 0 : case GOrdPChDir: PushAttr(nOrderID);
1911 : case GOrdSChDir:
1912 0 : break;
1913 :
1914 0 : case GOrdPChPrc: PushAttr(nOrderID);
1915 : case GOrdSChPrc:
1916 0 : break;
1917 :
1918 0 : case GOrdPChSet: PushAttr(nOrderID);
1919 : case GOrdSChSet: {
1920 0 : sal_uInt8 nbyte; *pOS2MET >> nbyte;
1921 0 : aAttr.nChrSet=((sal_uLong)nbyte)&0xff;
1922 0 : break;
1923 : }
1924 0 : case GOrdPChAng: PushAttr(nOrderID);
1925 : case GOrdSChAng: {
1926 : long nX,nY;
1927 0 : nX=ReadCoord(bCoord32); nY=ReadCoord(bCoord32);
1928 0 : if (nX>=0 && nY==0) aAttr.nChrAng=0;
1929 : else {
1930 0 : aAttr.nChrAng=(short)(atan2((double)nY,(double)nX)/3.1415926539*1800.0);
1931 0 : while (aAttr.nChrAng<0) aAttr.nChrAng+=3600;
1932 0 : aAttr.nChrAng%=3600;
1933 : }
1934 0 : break;
1935 : }
1936 0 : case GOrdPChBrx: PushAttr(nOrderID);
1937 : case GOrdSChBrx:
1938 0 : break;
1939 :
1940 0 : case GOrdPChCel: PushAttr(nOrderID);
1941 : case GOrdSChCel: {
1942 : sal_uInt8 nbyte;
1943 0 : sal_uInt16 nLen=nOrderLen;
1944 0 : aAttr.aChrCellSize.Width()=ReadCoord(bCoord32);
1945 0 : aAttr.aChrCellSize.Height()=ReadCoord(bCoord32);
1946 0 : if (bCoord32) nLen-=8; else nLen-=4;
1947 0 : if (nLen>=4) {
1948 0 : pOS2MET->SeekRel(4); nLen-=4;
1949 : }
1950 0 : if (nLen>=2) {
1951 0 : *pOS2MET >> nbyte;
1952 0 : if ((nbyte&0x80)==0 && aAttr.aChrCellSize==Size(0,0))
1953 0 : aAttr.aChrCellSize=aDefAttr.aChrCellSize;
1954 : }
1955 0 : break;
1956 : }
1957 0 : case GOrdPChXtr: PushAttr(nOrderID);
1958 : case GOrdSChXtr:
1959 0 : break;
1960 :
1961 0 : case GOrdPChShr: PushAttr(nOrderID);
1962 : case GOrdSChShr:
1963 0 : break;
1964 :
1965 0 : case GOrdPTxAlg: PushAttr(nOrderID);
1966 : case GOrdSTxAlg: OOODEBUG("GOrdSTxAlg",0);
1967 0 : break;
1968 :
1969 0 : case GOrdPMkPrc: PushAttr(nOrderID);
1970 : case GOrdSMkPrc: {
1971 : sal_uInt8 nbyte;
1972 0 : *pOS2MET >> nbyte;
1973 0 : if (nbyte==0) aAttr.nMrkPrec=aDefAttr.nMrkPrec;
1974 0 : else aAttr.nMrkPrec=nbyte;
1975 0 : break;
1976 : }
1977 :
1978 0 : case GOrdPMkSet: PushAttr(nOrderID);
1979 : case GOrdSMkSet: {
1980 : sal_uInt8 nbyte;
1981 0 : *pOS2MET >> nbyte;
1982 0 : if (nbyte==0) aAttr.nMrkSet=aDefAttr.nMrkSet;
1983 0 : else aAttr.nMrkSet=nbyte;
1984 0 : break;
1985 : }
1986 :
1987 0 : case GOrdPMkSym: PushAttr(nOrderID);
1988 : case GOrdSMkSym: {
1989 : sal_uInt8 nbyte;
1990 0 : *pOS2MET >> nbyte;
1991 0 : if (nbyte==0) aAttr.nMrkSymbol=aDefAttr.nMrkSymbol;
1992 0 : else aAttr.nMrkSymbol=nbyte;
1993 0 : break;
1994 : }
1995 :
1996 0 : case GOrdPMkCel: PushAttr(nOrderID);
1997 : case GOrdSMkCel: {
1998 : sal_uInt8 nbyte;
1999 0 : sal_uInt16 nLen=nOrderLen;
2000 0 : aAttr.aMrkCellSize.Width()=ReadCoord(bCoord32);
2001 0 : aAttr.aMrkCellSize.Height()=ReadCoord(bCoord32);
2002 0 : if (bCoord32) nLen-=8; else nLen-=4;
2003 0 : if (nLen>=2) {
2004 0 : *pOS2MET >> nbyte;
2005 0 : if ((nbyte&0x80)==0 && aAttr.aMrkCellSize==Size(0,0))
2006 0 : aAttr.aMrkCellSize=aDefAttr.aMrkCellSize;
2007 : }
2008 0 : break;
2009 : }
2010 :
2011 0 : case GOrdPArcPa: PushAttr(nOrderID);
2012 : case GOrdSArcPa:
2013 0 : aAttr.nArcP=ReadCoord(bCoord32);
2014 0 : aAttr.nArcQ=ReadCoord(bCoord32);
2015 0 : aAttr.nArcR=ReadCoord(bCoord32);
2016 0 : aAttr.nArcS=ReadCoord(bCoord32);
2017 0 : break;
2018 :
2019 0 : case GOrdPCrPos: PushAttr(nOrderID);
2020 : case GOrdSCrPos:
2021 0 : aAttr.aCurPos=ReadPoint();
2022 0 : break;
2023 :
2024 0 : case GOrdPMdTrn: PushAttr(nOrderID);
2025 : case GOrdSMdTrn: OOODEBUG("GOrdSMdTrn",0);
2026 0 : break;
2027 :
2028 0 : case GOrdPPkIdn: PushAttr(nOrderID);
2029 : case GOrdSPkIdn: OOODEBUG("GOrdSPkIdn",0);
2030 0 : break;
2031 :
2032 : case GOrdSVwTrn: OOODEBUG("GOrdSVwTrn",0);
2033 0 : break;
2034 :
2035 0 : case GOrdPVwWin: PushAttr(nOrderID);
2036 : case GOrdSVwWin: OOODEBUG("GOrdSVwWin",0);
2037 0 : break;
2038 : default: OOODEBUG("Order unbekannt:",nOrderID);
2039 : }
2040 0 : }
2041 :
2042 0 : void OS2METReader::ReadDsc(sal_uInt16 nDscID, sal_uInt16 /*nDscLen*/)
2043 : {
2044 0 : switch (nDscID) {
2045 : case 0x00f7: { // 'Specify GVM Subset'
2046 : sal_uInt8 nbyte;
2047 0 : pOS2MET->SeekRel(6);
2048 0 : *pOS2MET >> nbyte;
2049 0 : if (nbyte==0x05) bCoord32=sal_True;
2050 0 : else if (nbyte==0x04) bCoord32=sal_False;
2051 : else {
2052 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2053 0 : ErrorCode=1;
2054 : }
2055 0 : 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 0 : pOS2MET->SeekRel(2);
2065 0 : *pOS2MET >> nbyte;
2066 :
2067 0 : if (nbyte==0x05)
2068 0 : b32=sal_True;
2069 0 : else if(nbyte==0x04)
2070 0 : b32=sal_False;
2071 : else
2072 : {
2073 0 : b32 = sal_False; // -Wall added the case.
2074 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2075 0 : ErrorCode=2;
2076 : }
2077 :
2078 0 : *pOS2MET >> nUnitType;
2079 :
2080 0 : xr=ReadCoord(b32);
2081 0 : yr=ReadCoord(b32);
2082 :
2083 0 : ReadCoord(b32);
2084 :
2085 0 : if (nUnitType==0x00 && xr>0 && yr>0)
2086 0 : aGlobMapMode=MapMode(MAP_INCH,Point(0,0),Fraction(10,xr),Fraction(10,yr));
2087 0 : else if (nUnitType==0x01 && xr>0 && yr>0)
2088 0 : aGlobMapMode=MapMode(MAP_CM,Point(0,0),Fraction(10,xr),Fraction(10,yr));
2089 : else
2090 0 : aGlobMapMode=MapMode();
2091 :
2092 0 : x1=ReadCoord(b32);
2093 0 : x2=ReadCoord(b32);
2094 0 : y1=ReadCoord(b32);
2095 0 : y2=ReadCoord(b32);
2096 :
2097 0 : if (x1>x2)
2098 : {
2099 0 : nt=x1;
2100 0 : x1=x2;
2101 0 : x2=nt;
2102 : }
2103 :
2104 0 : if (y1>y2)
2105 : {
2106 0 : nt=y1;
2107 0 : y1=y2;
2108 0 : y2=nt;
2109 : }
2110 :
2111 0 : aBoundingRect.Left() = x1;
2112 0 : aBoundingRect.Right() = x2;
2113 0 : aBoundingRect.Top() = y1;
2114 0 : aBoundingRect.Bottom() = y2;
2115 :
2116 : // no output beside this bounding rect
2117 0 : pVirDev->IntersectClipRegion( Rectangle( Point(), aBoundingRect.GetSize() ) );
2118 :
2119 0 : break;
2120 : }
2121 : case 0x0021: // 'Set Current Defaults'
2122 0 : break;
2123 : }
2124 0 : }
2125 :
2126 0 : void OS2METReader::ReadImageData(sal_uInt16 nDataID, sal_uInt16 nDataLen)
2127 : {
2128 0 : OSBitmap * p=pBitmapList; if (p==NULL) return;
2129 :
2130 0 : switch (nDataID) {
2131 :
2132 : case 0x0070: // Begin Segment
2133 0 : break;
2134 :
2135 : case 0x0091: // Begin Image Content
2136 0 : break;
2137 :
2138 : case 0x0094: // Image Size
2139 0 : pOS2MET->SeekRel(5);
2140 0 : p->nHeight=ReadBigEndianWord();
2141 0 : p->nWidth=ReadBigEndianWord();
2142 0 : break;
2143 :
2144 : case 0x0095: // Image Encoding
2145 0 : break;
2146 :
2147 : case 0x0096: { // Image IDE-Size
2148 : sal_uInt8 nbyte;
2149 0 : *pOS2MET >> nbyte; p->nBitsPerPixel=nbyte;
2150 0 : break;
2151 : }
2152 :
2153 : case 0x0097: // Image LUT-ID
2154 0 : break;
2155 :
2156 : case 0x009b: // IDE Structure
2157 0 : 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 0 : if (p->pBMP==NULL) {
2163 0 : p->pBMP=new SvMemoryStream();
2164 0 : p->pBMP->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
2165 0 : if (p->nWidth==0 || p->nHeight==0 || p->nBitsPerPixel==0) {
2166 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2167 0 : ErrorCode=3;
2168 0 : return;
2169 : }
2170 : // write (Windows-)BITMAPINFOHEADER:
2171 0 : *(p->pBMP) << ((sal_uInt32)40) << p->nWidth << p->nHeight;
2172 0 : *(p->pBMP) << ((sal_uInt16)1) << p->nBitsPerPixel;
2173 0 : *(p->pBMP) << ((sal_uInt32)0) << ((sal_uInt32)0) << ((sal_uInt32)0) << ((sal_uInt32)0);
2174 0 : *(p->pBMP) << ((sal_uInt32)0) << ((sal_uInt32)0);
2175 : // write color table:
2176 0 : if (p->nBitsPerPixel<=8) {
2177 0 : sal_uInt16 i, nColTabSize=1<<(p->nBitsPerPixel);
2178 0 : 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 0 : sal_uInt8 * pBuf=new sal_uInt8[nDataLen];
2184 0 : pOS2MET->Read(pBuf,nDataLen);
2185 0 : if (p->nBitsPerPixel==24) {
2186 : sal_uLong i, j, nAlign, nBytesPerLine;
2187 : sal_uInt8 nTemp;
2188 0 : nBytesPerLine=(p->nWidth*3+3)&0xfffffffc;
2189 0 : nAlign=p->nMapPos-(p->nMapPos % nBytesPerLine);
2190 0 : i=0;
2191 0 : while (nAlign+i+2<p->nMapPos+nDataLen) {
2192 0 : if (nAlign+i>=p->nMapPos) {
2193 0 : j=nAlign+i-p->nMapPos;
2194 0 : nTemp=pBuf[j]; pBuf[j]=pBuf[j+2]; pBuf[j+2]=nTemp;
2195 : }
2196 0 : i+=3; if (i+2>=nBytesPerLine) {
2197 0 : nAlign+=nBytesPerLine;
2198 0 : i=0;
2199 : }
2200 : }
2201 : }
2202 0 : p->pBMP->Write(pBuf,nDataLen);
2203 0 : p->nMapPos+=nDataLen;
2204 0 : delete[] pBuf;
2205 0 : break;
2206 : }
2207 : case 0x0093: // End Image Content
2208 0 : break;
2209 :
2210 : case 0x0071: // End Segment
2211 0 : break;
2212 : }
2213 : }
2214 :
2215 0 : void OS2METReader::ReadFont(sal_uInt16 nFieldSize)
2216 : {
2217 : sal_uLong nPos, nMaxPos;
2218 : sal_uInt16 nLen;
2219 : sal_uInt8 nByte, nTripType, nTripType2;
2220 0 : OSFont * pF=new OSFont;
2221 0 : pF->pSucc=pFontList; pFontList=pF;
2222 0 : pF->nID=0;
2223 0 : pF->aFont.SetTransparent(sal_True);
2224 0 : pF->aFont.SetAlign(ALIGN_BASELINE);
2225 :
2226 0 : nPos=pOS2MET->Tell();
2227 0 : nMaxPos=nPos+(sal_uLong)nFieldSize;
2228 0 : pOS2MET->SeekRel(2); nPos+=2;
2229 0 : while (nPos<nMaxPos && pOS2MET->GetError()==0) {
2230 0 : *pOS2MET >> nByte; nLen =((sal_uInt16)nByte) & 0x00ff;
2231 0 : *pOS2MET >> nTripType;
2232 0 : switch (nTripType) {
2233 : case 0x02:
2234 0 : *pOS2MET >> nTripType2;
2235 0 : switch (nTripType2) {
2236 : case 0x84: // Font name
2237 0 : break;
2238 : case 0x08: { // Font Typeface
2239 : char str[33];
2240 0 : pOS2MET->SeekRel(1);
2241 0 : pOS2MET->Read( &str, 32 );
2242 0 : str[ 32 ] = 0;
2243 0 : String aStr( (const sal_Char*)str, osl_getThreadTextEncoding() );
2244 0 : if ( aStr.CompareIgnoreCaseToAscii( "Helv" ) == COMPARE_EQUAL )
2245 0 : aStr = OUString("Helvetica");
2246 0 : pF->aFont.SetName( aStr );
2247 0 : break;
2248 : }
2249 : }
2250 0 : break;
2251 : case 0x24: // Icid
2252 0 : *pOS2MET >> nTripType2;
2253 0 : switch (nTripType2) {
2254 : case 0x05: //Icid
2255 0 : *pOS2MET >> nByte;
2256 0 : pF->nID=((sal_uLong)nByte)&0xff;
2257 0 : break;
2258 : }
2259 0 : break;
2260 : case 0x20: // Font Binary GCID
2261 0 : break;
2262 : case 0x1f: { // Font Attributes
2263 : FontWeight eWeight;
2264 : sal_uInt8 nbyte;
2265 0 : *pOS2MET >> nbyte;
2266 0 : switch (nbyte) {
2267 0 : case 1: eWeight=WEIGHT_THIN; break;
2268 0 : case 2: eWeight=WEIGHT_ULTRALIGHT; break;
2269 0 : case 3: eWeight=WEIGHT_LIGHT; break;
2270 0 : case 4: eWeight=WEIGHT_SEMILIGHT; break;
2271 0 : case 5: eWeight=WEIGHT_NORMAL; break;
2272 0 : case 6: eWeight=WEIGHT_SEMIBOLD; break;
2273 0 : case 7: eWeight=WEIGHT_BOLD; break;
2274 0 : case 8: eWeight=WEIGHT_ULTRABOLD; break;
2275 0 : case 9: eWeight=WEIGHT_BLACK; break;
2276 0 : default: eWeight=WEIGHT_DONTKNOW;
2277 : }
2278 0 : pF->aFont.SetWeight(eWeight);
2279 0 : break;
2280 : }
2281 : }
2282 0 : nPos+=nLen; pOS2MET->Seek(nPos);
2283 : }
2284 0 : }
2285 :
2286 0 : void OS2METReader::ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize)
2287 : {
2288 0 : switch (nFieldType) {
2289 : case BegDocumnMagic:
2290 0 : break;
2291 : case EndDocumnMagic:
2292 0 : break;
2293 : case BegResGrpMagic:
2294 0 : break;
2295 : case EndResGrpMagic:
2296 0 : break;
2297 : case BegColAtrMagic:
2298 0 : break;
2299 : case EndColAtrMagic:
2300 0 : 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 0 : nPos=pOS2MET->Tell();
2308 0 : nMaxPos=nPos+(sal_uLong)nFieldSize;
2309 0 : pOS2MET->SeekRel(3); nPos+=3;
2310 0 : while (nPos<nMaxPos && pOS2MET->GetError()==0) {
2311 0 : *pOS2MET >> nbyte; nElemLen=((sal_uInt16)nbyte) & 0x00ff;
2312 0 : if (nElemLen>11) {
2313 0 : pOS2MET->SeekRel(4);
2314 0 : nStartIndex=ReadBigEndianWord();
2315 0 : pOS2MET->SeekRel(3);
2316 0 : *pOS2MET >> nbyte; nBytesPerCol=((sal_uInt16)nbyte) & 0x00ff;
2317 0 : nEndIndex=nStartIndex+(nElemLen-11)/nBytesPerCol;
2318 0 : for (i=nStartIndex; i<nEndIndex; i++) {
2319 0 : if (nBytesPerCol > 3) pOS2MET->SeekRel(nBytesPerCol-3);
2320 0 : nCol=ReadBigEndian3BytesLong();
2321 0 : SetPalette0RGB(i,nCol);
2322 : }
2323 : }
2324 0 : else if (nElemLen<10) {
2325 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2326 0 : ErrorCode=4;
2327 : }
2328 0 : nPos+=(sal_uLong)nElemLen;
2329 0 : pOS2MET->Seek(nPos);
2330 : }
2331 0 : break;
2332 : }
2333 : case MapColAtrMagic:
2334 0 : break;
2335 : case BegImgObjMagic: {
2336 : // create new bitmap by now: (will be filled later)
2337 0 : OSBitmap * pB=new OSBitmap;
2338 0 : pB->pSucc=pBitmapList; pBitmapList=pB;
2339 0 : pB->pBMP=NULL; pB->nWidth=0; pB->nHeight=0; pB->nBitsPerPixel=0;
2340 0 : pB->nMapPos=0;
2341 : // determine ID of the bitmap:
2342 : sal_uInt8 i,nbyte,nbyte2;
2343 0 : pB->nID=0;
2344 0 : for (i=0; i<4; i++) {
2345 0 : *pOS2MET >> nbyte >> nbyte2;
2346 0 : nbyte=((nbyte-0x30)<<4)|(nbyte2-0x30);
2347 0 : pB->nID=(pB->nID>>8)|(((sal_uLong)nbyte)<<24);
2348 : }
2349 : // put new palette on the palette stack: (will be filled later)
2350 0 : OSPalette * pP=new OSPalette;
2351 0 : pP->pSucc=pPaletteStack; pPaletteStack=pP;
2352 0 : pP->p0RGB=NULL; pP->nSize=0;
2353 0 : break;
2354 : }
2355 : case EndImgObjMagic: {
2356 : // read temporary Windows BMP file:
2357 0 : if (pBitmapList==NULL || pBitmapList->pBMP==NULL ||
2358 0 : pBitmapList->pBMP->GetError()!=0) {
2359 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2360 0 : ErrorCode=5;
2361 0 : return;
2362 : }
2363 0 : pBitmapList->pBMP->Seek(0);
2364 :
2365 0 : ReadDIB(pBitmapList->aBitmap, *(pBitmapList->pBMP), false);
2366 :
2367 0 : if (pBitmapList->pBMP->GetError()!=0) {
2368 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2369 0 : ErrorCode=6;
2370 : }
2371 0 : delete pBitmapList->pBMP; pBitmapList->pBMP=NULL;
2372 : // kill palette from stack:
2373 0 : OSPalette * pP=pPaletteStack;
2374 0 : if (pP!=NULL) {
2375 0 : pPaletteStack=pP->pSucc;
2376 0 : if (pP->p0RGB!=NULL) delete[] pP->p0RGB;
2377 0 : delete pP;
2378 : }
2379 0 : break;
2380 : }
2381 : case DscImgObjMagic:
2382 0 : break;
2383 : case DatImgObjMagic: {
2384 : sal_uInt16 nDataID, nDataLen;
2385 : sal_uInt8 nbyte;
2386 : sal_uLong nPos, nMaxPos;
2387 :
2388 0 : nPos=pOS2MET->Tell();
2389 0 : nMaxPos=nPos+(sal_uLong)nFieldSize;
2390 0 : while (nPos<nMaxPos && pOS2MET->GetError()==0) {
2391 0 : *pOS2MET >> nbyte; nDataID=((sal_uInt16)nbyte)&0x00ff;
2392 0 : if (nDataID==0x00fe) {
2393 0 : *pOS2MET >> nbyte;
2394 0 : nDataID=(nDataID<<8)|(((sal_uInt16)nbyte)&0x00ff);
2395 0 : nDataLen=ReadBigEndianWord();
2396 0 : nPos+=4;
2397 : }
2398 : else {
2399 0 : *pOS2MET >> nbyte; nDataLen=((sal_uInt16)nbyte)&0x00ff;
2400 0 : nPos+=2;
2401 : }
2402 0 : ReadImageData(nDataID, nDataLen);
2403 0 : nPos+=(sal_uLong)nDataLen;
2404 0 : pOS2MET->Seek(nPos);
2405 : }
2406 0 : break;
2407 : }
2408 :
2409 : case BegObEnv1Magic:
2410 0 : break;
2411 : case EndObEnv1Magic:
2412 0 : break;
2413 : case BegGrfObjMagic:
2414 0 : break;
2415 : case EndGrfObjMagic: {
2416 : SvStream * pSave;
2417 : sal_uLong nPos, nMaxPos;
2418 : sal_uInt16 nOrderID, nOrderLen;
2419 : sal_uInt8 nbyte;
2420 :
2421 0 : 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 0 : pSave=pOS2MET;
2429 0 : pOS2MET=pOrdFile; //(!)
2430 0 : nMaxPos=pOS2MET->Tell();
2431 0 : pOS2MET->Seek(0);
2432 :
2433 : // "Segment header":
2434 0 : *pOS2MET >> nbyte;
2435 0 : if (nbyte==0x70) { // header exists
2436 0 : pOS2MET->SeekRel(15); // but we don't need it
2437 : }
2438 0 : else pOS2MET->SeekRel(-1); // no header, go back one byte
2439 :
2440 : // loop through Order:
2441 0 : while (pOS2MET->Tell()<nMaxPos && pOS2MET->GetError()==0) {
2442 0 : *pOS2MET >> nbyte; nOrderID=((sal_uInt16)nbyte) & 0x00ff;
2443 0 : if (nOrderID==0x00fe) {
2444 0 : *pOS2MET >> nbyte;
2445 0 : nOrderID=(nOrderID << 8) | (((sal_uInt16)nbyte) & 0x00ff);
2446 : }
2447 0 : 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 0 : *pOS2MET >> nbyte; nOrderLen=(sal_uInt16)nbyte&0x00ff;
2454 0 : *pOS2MET >> nbyte; if (nbyte!=0) nOrderLen=nOrderLen<<8|(((sal_uInt16)nbyte)&0x00ff);
2455 : }
2456 0 : else if (nOrderID==GOrdSTxAlg || nOrderID==GOrdPTxAlg) nOrderLen=2;
2457 0 : else if ((nOrderID&0xff88)==0x0008) nOrderLen=1;
2458 0 : else if (nOrderID==0x0000 || nOrderID==0x00ff) nOrderLen=0;
2459 0 : else { *pOS2MET >> nbyte; nOrderLen=((sal_uInt16)nbyte) & 0x00ff; }
2460 0 : nPos=pOS2MET->Tell();
2461 0 : ReadOrder(nOrderID, nOrderLen);
2462 0 : if (nPos+nOrderLen < pOS2MET->Tell()) {
2463 : OOODEBUG("Order shorter than he assumes! OrderID:",nOrderID);
2464 : OOODEBUG("...und zwar bei Position (Parameteranfang):",nPos);
2465 : }
2466 0 : else if (nPos+nOrderLen != pOS2MET->Tell()) {
2467 : OOODEBUG(String(nOrderID)+String(" Order nicht alles gelesen! bei:"),nPos);
2468 : }
2469 0 : pOS2MET->Seek(nPos+nOrderLen);
2470 : }
2471 :
2472 0 : pOS2MET=pSave;
2473 0 : if (pOrdFile->GetError()) {
2474 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2475 0 : ErrorCode=10;
2476 : }
2477 0 : delete pOrdFile; pOrdFile=NULL;
2478 0 : break;
2479 : }
2480 : case DscGrfObjMagic: {
2481 : sal_uLong nPos, nMaxPos;
2482 : sal_uInt16 nDscID, nDscLen;
2483 : sal_uInt8 nbyte;
2484 :
2485 0 : nMaxPos=pOS2MET->Tell()+(sal_uLong)nFieldSize;
2486 0 : while (pOS2MET->Tell()<nMaxPos && pOS2MET->GetError()==0) {
2487 0 : *pOS2MET >> nbyte; nDscID =((sal_uInt16)nbyte) & 0x00ff;
2488 0 : *pOS2MET >> nbyte; nDscLen=((sal_uInt16)nbyte) & 0x00ff;
2489 0 : nPos=pOS2MET->Tell();
2490 0 : ReadDsc(nDscID, nDscLen);
2491 0 : pOS2MET->Seek(nPos+nDscLen);
2492 : }
2493 0 : break;
2494 : }
2495 : case DatGrfObjMagic: {
2496 0 : if (pOrdFile==NULL) {
2497 0 : pOrdFile = new SvMemoryStream;
2498 0 : pOrdFile->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
2499 : }
2500 0 : sal_uInt8 * pBuf; pBuf = new sal_uInt8[nFieldSize];
2501 0 : pOS2MET->Read(pBuf,nFieldSize);
2502 0 : pOrdFile->Write(pBuf,nFieldSize);
2503 0 : delete[] pBuf;
2504 0 : break;
2505 : }
2506 : case MapCodFntMagic:
2507 0 : ReadFont(nFieldSize);
2508 0 : break;
2509 :
2510 : case MapDatResMagic:
2511 0 : break;
2512 : }
2513 : }
2514 :
2515 0 : 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 0 : ErrorCode=0;
2523 :
2524 0 : pOS2MET = &rStreamOS2MET;
2525 0 : nOrigPos = pOS2MET->Tell();
2526 0 : nOrigNumberFormat = pOS2MET->GetNumberFormatInt();
2527 :
2528 0 : bCoord32 = sal_True;
2529 0 : pPaletteStack=NULL;
2530 0 : pAreaStack=NULL;
2531 0 : pPathStack=NULL;
2532 0 : pPathList=NULL;
2533 0 : pFontList=NULL;
2534 0 : pBitmapList=NULL;
2535 0 : pAttrStack=NULL;
2536 :
2537 0 : aDefAttr.aLinCol =Color(COL_BLACK);
2538 0 : aDefAttr.aLinBgCol =Color(COL_WHITE);
2539 0 : aDefAttr.eLinMix =ROP_OVERPAINT;
2540 0 : aDefAttr.eLinBgMix =ROP_OVERPAINT;
2541 0 : aDefAttr.aChrCol =Color(COL_BLACK);
2542 0 : aDefAttr.aChrBgCol =Color(COL_WHITE);
2543 0 : aDefAttr.eChrMix =ROP_OVERPAINT;
2544 0 : aDefAttr.eChrBgMix =ROP_OVERPAINT;
2545 0 : aDefAttr.aMrkCol =Color(COL_BLACK);
2546 0 : aDefAttr.aMrkBgCol =Color(COL_WHITE);
2547 0 : aDefAttr.eMrkMix =ROP_OVERPAINT;
2548 0 : aDefAttr.eMrkBgMix =ROP_OVERPAINT;
2549 0 : aDefAttr.aPatCol =Color(COL_BLACK);
2550 0 : aDefAttr.aPatBgCol =Color(COL_WHITE);
2551 0 : aDefAttr.ePatMix =ROP_OVERPAINT;
2552 0 : aDefAttr.ePatBgMix =ROP_OVERPAINT;
2553 0 : aDefAttr.aImgCol =Color(COL_BLACK);
2554 0 : aDefAttr.aImgBgCol =Color(COL_WHITE);
2555 0 : aDefAttr.eImgMix =ROP_OVERPAINT;
2556 0 : aDefAttr.eImgBgMix =ROP_OVERPAINT;
2557 0 : aDefAttr.nArcP =1;
2558 0 : aDefAttr.nArcQ =1;
2559 0 : aDefAttr.nArcR =0;
2560 0 : aDefAttr.nArcS =0;
2561 0 : aDefAttr.nChrAng =0;
2562 0 : aDefAttr.aChrCellSize=Size(12,12);
2563 0 : aDefAttr.nChrSet =0;
2564 0 : aDefAttr.aCurPos =Point(0,0);
2565 0 : aDefAttr.eLinStyle =PEN_SOLID;
2566 0 : aDefAttr.nLinWidth =0;
2567 0 : aDefAttr.aMrkCellSize=Size(10,10);
2568 0 : aDefAttr.nMrkPrec =0x01;
2569 0 : aDefAttr.nMrkSet =0xff;
2570 0 : aDefAttr.nMrkSymbol =0x01;
2571 0 : aDefAttr.bFill =sal_True;
2572 0 : aDefAttr.nStrLinWidth=0;
2573 :
2574 0 : aAttr=aDefAttr;
2575 :
2576 0 : pOrdFile=NULL;
2577 :
2578 0 : pVirDev = new VirtualDevice();
2579 0 : pVirDev->EnableOutput(sal_False);
2580 0 : rGDIMetaFile.Record(pVirDev);
2581 :
2582 0 : pOS2MET->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
2583 :
2584 0 : nStartPos=pOS2MET->Tell();
2585 0 : nEndPos=pOS2MET->Seek(STREAM_SEEK_TO_END); pOS2MET->Seek(nStartPos);
2586 0 : Callback(0); nLastPercent=0;
2587 :
2588 0 : nPos=pOS2MET->Tell();
2589 0 : if ( nStartPos == nEndPos )
2590 : {
2591 0 : nEndPos = 100;
2592 0 : nStartPos = 0;
2593 : }
2594 :
2595 : for (;;) {
2596 :
2597 0 : nPercent=(nPos-nStartPos)*100/(nEndPos-nStartPos);
2598 0 : if (nLastPercent+4<=nPercent) {
2599 0 : if (Callback((sal_uInt16)nPercent)==sal_True) break;
2600 0 : nLastPercent=nPercent;
2601 : }
2602 :
2603 0 : nFieldSize=ReadBigEndianWord();
2604 :
2605 0 : *pOS2MET >> nMagicByte;
2606 0 : if (nMagicByte!=0xd3) {
2607 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2608 0 : ErrorCode=7;
2609 0 : break;
2610 : }
2611 0 : *pOS2MET >> nFieldType;
2612 :
2613 0 : pOS2MET->SeekRel(3);
2614 0 : nPos+=8; nFieldSize-=8;
2615 :
2616 0 : if (pOS2MET->GetError()) break;
2617 0 : if (pOS2MET->IsEof()) {
2618 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2619 0 : ErrorCode=8;
2620 0 : break;
2621 : }
2622 :
2623 0 : if (nFieldType==EndDocumnMagic) break;
2624 :
2625 0 : ReadField(nFieldType, nFieldSize);
2626 :
2627 0 : nPos+=(sal_uLong)nFieldSize;
2628 0 : if (pOS2MET->Tell()>nPos) {
2629 0 : pOS2MET->SetError(SVSTREAM_FILEFORMAT_ERROR);
2630 0 : ErrorCode=9;
2631 0 : break;
2632 : }
2633 0 : pOS2MET->Seek(nPos);
2634 : }
2635 :
2636 0 : rGDIMetaFile.Stop();
2637 0 : delete pVirDev;
2638 :
2639 0 : rGDIMetaFile.SetPrefMapMode( aGlobMapMode );
2640 :
2641 0 : if( aBoundingRect.GetWidth() && aBoundingRect.GetHeight() )
2642 0 : rGDIMetaFile.SetPrefSize( aBoundingRect.GetSize() );
2643 : else
2644 : {
2645 0 : if( aCalcBndRect.Left() || aCalcBndRect.Top() )
2646 0 : rGDIMetaFile.Move( -aCalcBndRect.Left(), -aCalcBndRect.Top() );
2647 :
2648 0 : rGDIMetaFile.SetPrefSize( aCalcBndRect.GetSize() );
2649 : }
2650 :
2651 0 : if (pOrdFile!=NULL) delete pOrdFile;
2652 :
2653 0 : while (pAreaStack!=NULL) {
2654 0 : OSArea * p=pAreaStack;
2655 0 : pAreaStack=p->pSucc;
2656 0 : delete p;
2657 : }
2658 :
2659 0 : while (pPathStack!=NULL) {
2660 0 : OSPath * p=pPathStack;
2661 0 : pPathStack=p->pSucc;
2662 0 : delete p;
2663 : }
2664 :
2665 0 : while (pPathList!=NULL) {
2666 0 : OSPath * p=pPathList;
2667 0 : pPathList=p->pSucc;
2668 0 : delete p;
2669 : }
2670 :
2671 0 : while (pFontList!=NULL) {
2672 0 : OSFont * p=pFontList;
2673 0 : pFontList=p->pSucc;
2674 0 : delete p;
2675 : }
2676 :
2677 0 : while (pBitmapList!=NULL) {
2678 0 : OSBitmap * p=pBitmapList;
2679 0 : pBitmapList=p->pSucc;
2680 0 : if (p->pBMP!=NULL) delete p->pBMP;
2681 0 : delete p;
2682 : }
2683 :
2684 0 : while (pAttrStack!=NULL) {
2685 0 : OSAttr * p=pAttrStack;
2686 0 : pAttrStack=p->pSucc;
2687 0 : delete p;
2688 : }
2689 :
2690 0 : while (pPaletteStack!=NULL) {
2691 0 : OSPalette * p=pPaletteStack;
2692 0 : pPaletteStack=p->pSucc;
2693 0 : if (p->p0RGB!=NULL) delete[] p->p0RGB;
2694 0 : delete p;
2695 : }
2696 :
2697 0 : pOS2MET->SetNumberFormatInt(nOrigNumberFormat);
2698 :
2699 0 : if (pOS2MET->GetError()) {
2700 : OOODEBUG("Fehler Nr.:",ErrorCode);
2701 0 : pOS2MET->Seek(nOrigPos);
2702 0 : }
2703 0 : }
2704 :
2705 : //================== GraphicImport - the exported function ================
2706 :
2707 : #if defined(DISABLE_DYNLOADING) || defined(LIBO_MERGELIBS)
2708 : #define GraphicImport imeGraphicImport
2709 : #endif
2710 :
2711 : extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool SAL_CALL
2712 0 : GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, sal_Bool)
2713 : {
2714 0 : OS2METReader aOS2METReader;
2715 0 : GDIMetaFile aMTF;
2716 0 : sal_Bool bRet = sal_False;
2717 :
2718 0 : aOS2METReader.ReadOS2MET( rStream, aMTF );
2719 :
2720 0 : if ( !rStream.GetError() )
2721 : {
2722 0 : rGraphic=Graphic( aMTF );
2723 0 : bRet = sal_True;
2724 : }
2725 :
2726 0 : return bRet;
2727 0 : }
2728 :
2729 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
