Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : //#define VCL_NEED_BASETSD
30 : :
31 : : #include <main.hxx>
32 : : #include <outact.hxx>
33 : :
34 : :
35 : : // ---------------------------------------------------------------
36 : :
37 : 0 : void CGM::ImplDoClass5()
38 : : {
39 : 0 : switch ( mnElementID )
40 : : {
41 : : case 0x01 : /*Line Bundle Index*/
42 : 0 : pElement->pLineBundle = (LineBundle*)pElement->GetBundleIndex( ImplGetI( pElement->nIndexPrecision ), pElement->aLineList, pElement->aLineBundle );
43 : 0 : break;
44 : : case 0x02 : /*Line Type*/
45 : : {
46 : 0 : if ( pElement->nAspectSourceFlags & ASF_LINETYPE )
47 : 0 : pElement->pLineBundle->eLineType = (LineType)ImplGetI( pElement->nIndexPrecision );
48 : : else
49 : 0 : pElement->aLineBundle.eLineType = (LineType)ImplGetI( pElement->nIndexPrecision );
50 : : }
51 : 0 : break;
52 : : case 0x03 : /*Line Width*/
53 : : {
54 : : double nWidth;
55 : 0 : if ( pElement->eLineWidthSpecMode == SM_ABSOLUTE )
56 : : {
57 : 0 : if ( pElement->eVDCType == VDC_REAL )
58 : 0 : nWidth = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
59 : : else
60 : 0 : nWidth = (double)ImplGetI( pElement->nVDCIntegerPrecision );
61 : :
62 : 0 : ImplMapDouble( nWidth );
63 : : }
64 : : else
65 : 0 : nWidth = (sal_uInt32)ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize ) * 25; // scaling in 1/4 mm
66 : :
67 : : ( pElement->nAspectSourceFlags & ASF_LINEWIDTH )
68 : : ? pElement->aLineBundle.nLineWidth = nWidth
69 : 0 : : pElement->aLineBundle.nLineWidth = nWidth;
70 : : }
71 : 0 : break;
72 : : case 0x04 : /*Line Color*/
73 : : {
74 : 0 : if ( pElement->nAspectSourceFlags & ASF_LINECOLOR )
75 : 0 : pElement->pLineBundle->SetColor( ImplGetBitmapColor() );
76 : : else
77 : 0 : pElement->aLineBundle.SetColor( ImplGetBitmapColor() );
78 : : }
79 : 0 : break;
80 : : case 0x05 : /*Marker Bundle Index*/
81 : 0 : pElement->pMarkerBundle = (MarkerBundle*)pElement->GetBundleIndex( ImplGetI( pElement->nIndexPrecision ), pElement->aMarkerList, pElement->aMarkerBundle );
82 : 0 : break;
83 : : case 0x06 : /*Marker Type*/
84 : : {
85 : 0 : if ( pElement->nAspectSourceFlags & ASF_MARKERTYPE )
86 : 0 : pElement->pMarkerBundle->eMarkerType = (MarkerType)ImplGetI( pElement->nIndexPrecision );
87 : : else
88 : 0 : pElement->aMarkerBundle.eMarkerType = (MarkerType)ImplGetI( pElement->nIndexPrecision );
89 : : }
90 : 0 : break;
91 : : case 0x07 : /*Marker Size*/
92 : : {
93 : : double nWidth;
94 : 0 : if ( pElement->eMarkerSizeSpecMode == SM_ABSOLUTE )
95 : : {
96 : 0 : if ( pElement->eVDCType == VDC_REAL )
97 : 0 : nWidth = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
98 : : else
99 : 0 : nWidth = (double)ImplGetI( pElement->nVDCIntegerPrecision );
100 : 0 : ImplMapDouble( nWidth );
101 : : }
102 : : else
103 : 0 : nWidth = (sal_uInt32)ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize ) * 25;
104 : : ( pElement->nAspectSourceFlags & ASF_MARKERSIZE )
105 : : ? pElement->aMarkerBundle.nMarkerSize = nWidth
106 : 0 : : pElement->aMarkerBundle.nMarkerSize = nWidth;
107 : : }
108 : 0 : break;
109 : : case 0x08 : /*Marker Color*/
110 : : {
111 : 0 : if ( pElement->nAspectSourceFlags & ASF_MARKERCOLOR )
112 : 0 : pElement->pMarkerBundle->SetColor( ImplGetBitmapColor() );
113 : : else
114 : 0 : pElement->aMarkerBundle.SetColor( ImplGetBitmapColor() );
115 : : }
116 : 0 : break;
117 : : case 0x09 : /*Text Bundle Index*/
118 : 0 : pElement->pTextBundle = (TextBundle*)pElement->GetBundleIndex( ImplGetI( pElement->nIndexPrecision ), pElement->aTextList, pElement->aTextBundle );
119 : 0 : break;
120 : : case 0x0a : /*Text Font Index*/
121 : : {
122 : 0 : if ( pElement->nAspectSourceFlags & ASF_TEXTFONTINDEX )
123 : 0 : pElement->pTextBundle->nTextFontIndex = ImplGetI( pElement->nIndexPrecision );
124 : : else
125 : 0 : pElement->aTextBundle.nTextFontIndex = ImplGetI( pElement->nIndexPrecision );
126 : : }
127 : 0 : break;
128 : : case 0x0b : /*Text Precision*/
129 : : {
130 : : TextBundle* pBundle;
131 : 0 : if ( pElement->nAspectSourceFlags & ASF_TEXTPRECISION )
132 : 0 : pBundle = pElement->pTextBundle;
133 : : else
134 : 0 : pBundle = &pElement->aTextBundle;
135 : 0 : switch( ImplGetUI16() )
136 : : {
137 : 0 : case 0 : pBundle->eTextPrecision = TPR_STRING; break;
138 : 0 : case 1 : pBundle->eTextPrecision = TPR_CHARACTER; break;
139 : 0 : case 2 : pBundle->eTextPrecision = TPR_STROKE; break;
140 : 0 : default : pBundle->eTextPrecision = TPR_UNDEFINED; break;
141 : : }
142 : : }
143 : 0 : break;
144 : : case 0x0c : /*Character Expansion Factor*/
145 : : {
146 : 0 : if ( pElement->nAspectSourceFlags & ASF_CHARACTEREXPANSION )
147 : 0 : pElement->pTextBundle->nCharacterExpansion = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
148 : : else
149 : 0 : pElement->aTextBundle.nCharacterExpansion = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
150 : : }
151 : 0 : break;
152 : : case 0x0d : /*Character Spacing*/
153 : : {
154 : 0 : if ( pElement->nAspectSourceFlags & ASF_CHARACTERSPACING )
155 : 0 : pElement->pTextBundle->nCharacterSpacing = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
156 : : else
157 : 0 : pElement->aTextBundle.nCharacterSpacing = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
158 : : }
159 : 0 : break;
160 : : case 0x0e : /*Text Color*/
161 : : {
162 : 0 : if ( pElement->nAspectSourceFlags & ASF_TEXTCOLOR )
163 : 0 : pElement->pTextBundle->SetColor( ImplGetBitmapColor() );
164 : : else
165 : 0 : pElement->aTextBundle.SetColor( ImplGetBitmapColor() );
166 : : }
167 : 0 : break;
168 : : case 0x0f : /*Character Height*/
169 : : {
170 : 0 : if ( pElement->eVDCType == VDC_INTEGER )
171 : 0 : pElement->nCharacterHeight = ImplGetI( pElement->nVDCIntegerPrecision );
172 : : else // ->floating points
173 : 0 : pElement->nCharacterHeight = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
174 : 0 : ImplMapDouble( pElement->nCharacterHeight );
175 : 0 : pElement->nCharacterHeight /= 18.0;
176 : : }
177 : 0 : break;
178 : : case 0x10 : /*Character Orientation*/
179 : : {
180 : 0 : if ( pElement->eVDCType == VDC_INTEGER )
181 : : {
182 : 0 : pElement->nCharacterOrientation[0] = ImplGetI( pElement->nVDCIntegerPrecision );
183 : 0 : pElement->nCharacterOrientation[1] = ImplGetI( pElement->nVDCIntegerPrecision );
184 : 0 : pElement->nCharacterOrientation[2] = ImplGetI( pElement->nVDCIntegerPrecision );
185 : 0 : pElement->nCharacterOrientation[3] = ImplGetI( pElement->nVDCIntegerPrecision );
186 : : }
187 : : else // ->floating points
188 : : {
189 : 0 : pElement->nCharacterOrientation[0] = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
190 : 0 : pElement->nCharacterOrientation[1] = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
191 : 0 : pElement->nCharacterOrientation[2] = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
192 : 0 : pElement->nCharacterOrientation[3] = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
193 : : }
194 : : }
195 : 0 : break;
196 : : case 0x11 : /*Text Path*/
197 : : {
198 : 0 : switch( ImplGetUI16() )
199 : : {
200 : 0 : case 0 : pElement->eTextPath = TPR_RIGHT; break;
201 : 0 : case 1 : pElement->eTextPath = TPR_LEFT; break;
202 : 0 : case 2 : pElement->eTextPath = TPR_UP; break;
203 : 0 : case 3 : pElement->eTextPath = TPR_DOWN; break;
204 : 0 : default : mbStatus = sal_False; break;
205 : : }
206 : : }
207 : 0 : break;
208 : : case 0x12 : /*Text Alignment*/
209 : : {
210 : 0 : pElement->eTextAlignmentH = (TextAlignmentH)ImplGetUI16();
211 : 0 : pElement->eTextAlignmentV = (TextAlignmentV)ImplGetUI16( 8 );
212 : 0 : pElement->nTextAlignmentHCont = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
213 : 0 : pElement->nTextAlignmentVCont = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
214 : : }
215 : 0 : break;
216 : : case 0x13 : /*Character Set Index*/
217 : 0 : pElement->nCharacterSetIndex = ImplGetI( pElement->nIndexPrecision );
218 : 0 : break;
219 : : case 0x14 : /*Alternate Character Set Index*/
220 : 0 : pElement->nAlternateCharacterSetIndex = ImplGetI( pElement->nIndexPrecision );
221 : 0 : break;
222 : : case 0x15 : /*Fill Bundle Index*/
223 : 0 : pElement->pFillBundle = (FillBundle*)pElement->GetBundleIndex( ImplGetI( pElement->nIndexPrecision ), pElement->aFillList, pElement->aFillBundle );
224 : 0 : break;
225 : : case 0x16 : /*Fill Interior Style*/
226 : : {
227 : 0 : if ( pElement->nAspectSourceFlags & ASF_FILLINTERIORSTYLE )
228 : 0 : pElement->pFillBundle->eFillInteriorStyle = (FillInteriorStyle)ImplGetUI16();
229 : : else
230 : 0 : pElement->aFillBundle.eFillInteriorStyle = (FillInteriorStyle)ImplGetUI16();
231 : : }
232 : 0 : break;
233 : : case 0x17 : /*Fill Color*/
234 : : {
235 : 0 : if ( pElement->nAspectSourceFlags & ASF_FILLCOLOR )
236 : 0 : pElement->pFillBundle->SetColor( ImplGetBitmapColor() );
237 : : else
238 : 0 : pElement->aFillBundle.SetColor( ImplGetBitmapColor() );
239 : : }
240 : 0 : break;
241 : : case 0x18 : /*Fill Hatch Index*/
242 : : {
243 : 0 : if ( pElement->nAspectSourceFlags & ASF_HATCHINDEX )
244 : 0 : pElement->pFillBundle->nFillHatchIndex = ImplGetI( pElement->nIndexPrecision );
245 : : else
246 : 0 : pElement->aFillBundle.nFillHatchIndex = ImplGetI( pElement->nIndexPrecision );
247 : : }
248 : 0 : break;
249 : : case 0x19 : /*Fill Pattern Index*/
250 : : {
251 : 0 : if ( pElement->nAspectSourceFlags & ASF_PATTERNINDEX )
252 : 0 : pElement->pFillBundle->nFillPatternIndex = ImplGetI( pElement->nIndexPrecision );
253 : : else
254 : 0 : pElement->aFillBundle.nFillPatternIndex = ImplGetI( pElement->nIndexPrecision );
255 : : }
256 : 0 : break;
257 : : case 0x1a : /*Edge Bundle Index*/
258 : 0 : pElement->pEdgeBundle = (EdgeBundle*)pElement->GetBundleIndex( ImplGetI( pElement->nIndexPrecision ), pElement->aEdgeList, pElement->aEdgeBundle );
259 : 0 : break;
260 : : case 0x1b : /*Edge Type*/
261 : : {
262 : 0 : if ( pElement->nAspectSourceFlags & ASF_EDGETYPE )
263 : 0 : pElement->pEdgeBundle->eEdgeType = (EdgeType)ImplGetI( pElement->nIndexPrecision );
264 : : else
265 : 0 : pElement->aEdgeBundle.eEdgeType = (EdgeType)ImplGetI( pElement->nIndexPrecision );
266 : : }
267 : 0 : break;
268 : : case 0x1c : /*Edge Width*/
269 : : {
270 : : double nWidth;
271 : 0 : if ( pElement->eEdgeWidthSpecMode == SM_ABSOLUTE )
272 : : {
273 : 0 : if ( pElement->eVDCType == VDC_REAL )
274 : 0 : nWidth = ImplGetFloat( pElement->eVDCRealPrecision, pElement->nVDCRealSize );
275 : : else
276 : 0 : nWidth = (double)ImplGetI( pElement->nVDCIntegerPrecision );
277 : :
278 : 0 : ImplMapDouble( nWidth );
279 : : }
280 : : else
281 : 0 : nWidth = (sal_uInt32)ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize ) * 25;
282 : : ( pElement->nAspectSourceFlags & ASF_EDGEWIDTH )
283 : : ? pElement->aEdgeBundle.nEdgeWidth = nWidth
284 : 0 : : pElement->aEdgeBundle.nEdgeWidth = nWidth;
285 : : }
286 : 0 : break;
287 : : case 0x1d : /*Edge Color*/
288 : : {
289 : 0 : if ( pElement->nAspectSourceFlags & ASF_EDGECOLOR )
290 : 0 : pElement->pEdgeBundle->SetColor( ImplGetBitmapColor() );
291 : : else
292 : 0 : pElement->aEdgeBundle.SetColor( ImplGetBitmapColor() );
293 : : }
294 : 0 : break;
295 : : case 0x1e : /*Edge Visibility*/
296 : : {
297 : 0 : switch( ImplGetUI16() )
298 : : {
299 : 0 : case 0 : pElement->eEdgeVisibility = EV_OFF; break;
300 : 0 : case 1 : pElement->eEdgeVisibility = EV_ON; break;
301 : 0 : default : mbStatus = sal_False;
302 : : }
303 : : }
304 : 0 : break;
305 : : case 0x1f : /*Fill Reference Point*/
306 : 0 : ImplGetPoint( pElement->aFillRefPoint );
307 : 0 : break;
308 : 0 : case 0x20 : /*Pattern Table" )*/ break;
309 : 0 : case 0x21 : /*Pattern Size" )*/ break;
310 : : case 0x22 : /*Color Table*/
311 : : {
312 : 0 : sal_uInt32 nColorStartIndex = ImplGetUI( pElement->nColorIndexPrecision );
313 : 0 : if ( ( nColorStartIndex > 255 ) ||
314 : : ( ( ( mnElementSize - pElement->nColorIndexPrecision ) % ( pElement->nColorPrecision * 3 ) ) != 0 ) )
315 : : {
316 : 0 : mbStatus = sal_False;
317 : : }
318 : : else
319 : : {
320 : 0 : sal_uInt32 nColors = ( mnElementSize - pElement->nColorIndexPrecision ) / ( 3 * pElement->nColorPrecision );
321 : 0 : if ( nColors )
322 : : {
323 : 0 : sal_uInt32 nMaxColorIndex = nColorStartIndex + nColors - 1;
324 : : sal_uInt32 nIndex;
325 : 0 : if ( nMaxColorIndex > 255 )
326 : : {
327 : 0 : mbStatus = sal_False;
328 : : }
329 : : else
330 : : {
331 : 0 : if ( pElement->nLatestColorMaximumIndex < nMaxColorIndex )
332 : 0 : pElement->nLatestColorMaximumIndex = nMaxColorIndex;
333 : :
334 : 0 : for ( nIndex = nColorStartIndex; nIndex <= nMaxColorIndex; nIndex++ )
335 : : {
336 : 0 : pElement->aLatestColorTable[ nIndex ] = ImplGetBitmapColor( sal_True );
337 : : }
338 : : }
339 : 0 : pElement->nColorMaximumIndex = pElement->nLatestColorMaximumIndex;
340 : 0 : for ( nIndex = nColorStartIndex; nIndex <= nMaxColorIndex; nIndex++ )
341 : : {
342 : 0 : if ( !pElement->aColorTableEntryIs[ nIndex ] )
343 : : {
344 : 0 : pElement->aColorTableEntryIs[ nIndex ] = 1;
345 : 0 : pElement->aColorTable[ nIndex ] = pElement->aLatestColorTable[ nIndex ];
346 : : }
347 : : }
348 : : }
349 : : }
350 : : }
351 : 0 : break;
352 : : case 0x23 : /*Aspect Source Flags*/
353 : : {
354 : 0 : int nFlags = mnElementSize >> 2;
355 : 0 : while ( nFlags-- > 0 )
356 : : {
357 : 0 : sal_uInt32 nFlag = 0;
358 : 0 : switch( ImplGetUI16() )
359 : : {
360 : 0 : case 0 : nFlag = ASF_LINETYPE; break;
361 : 0 : case 1 : nFlag = ASF_LINEWIDTH; break;
362 : 0 : case 2 : nFlag = ASF_LINECOLOR; break;
363 : 0 : case 3 : nFlag = ASF_MARKERTYPE; break;
364 : 0 : case 4 : nFlag = ASF_MARKERSIZE; break;
365 : 0 : case 5 : nFlag = ASF_MARKERCOLOR; break;
366 : 0 : case 6 : nFlag = ASF_FILLINTERIORSTYLE; break;
367 : 0 : case 7 : nFlag = ASF_HATCHINDEX; break;
368 : 0 : case 8 : nFlag = ASF_PATTERNINDEX; break;
369 : 0 : case 9 : nFlag = ASF_BITMAPINDEX; break;
370 : 0 : case 10 : nFlag = ASF_FILLCOLOR; break;
371 : 0 : case 11 : nFlag = ASF_EDGETYPE; break;
372 : 0 : case 12 : nFlag = ASF_EDGEWIDTH; break;
373 : 0 : case 13 : nFlag = ASF_EDGECOLOR; break;
374 : 0 : case 14 : nFlag = ASF_TEXTFONTINDEX; break;
375 : 0 : case 15 : nFlag = ASF_TEXTPRECISION; break;
376 : 0 : case 16 : nFlag = ASF_CHARACTEREXPANSION; break;
377 : 0 : case 17 : nFlag = ASF_CHARACTERSPACING; break;
378 : 0 : case 18 : nFlag = ASF_TEXTCOLOR; break;
379 : 0 : default : mbStatus = sal_False; break;
380 : : }
381 : 0 : sal_uInt32 nASF = ImplGetUI16();
382 : 0 : switch ( nASF )
383 : : {
384 : 0 : case 0 : pElement->nAspectSourceFlags &= ~nFlag; break; // INDIVIDUAL
385 : 0 : case 1 : pElement->nAspectSourceFlags |= nFlag; break; // BUNDLED
386 : 0 : default : mbStatus = sal_False; break;
387 : : }
388 : : }
389 : : }
390 : 0 : break;
391 : : case 0x24 : /*Pick Identifier" ) bre*/
392 : : case 0x25 : /*Line Cap*/
393 : : {
394 : 0 : switch( ImplGetUI16() )
395 : : {
396 : 0 : case 0 : pElement->eLineCapType = LCT_BUTT; break;
397 : 0 : case 1 : pElement->eLineCapType = LCT_ROUND; break;
398 : 0 : case 2 : pElement->eLineCapType = LCT_SQUARE; break;
399 : 0 : case 3 : pElement->eLineCapType = LCT_TRIANGLE; break;
400 : 0 : case 4 : pElement->eLineCapType = LCT_ARROW; break;
401 : 0 : default : pElement->eLineCapType = LCT_NONE; break;
402 : : }
403 : : }
404 : 0 : break;
405 : : case 0x26 : /*Line Join*/
406 : : {
407 : 0 : switch( ImplGetUI16() )
408 : : {
409 : 0 : case 0 : pElement->eLineJoinType = LJT_MITER; break;
410 : 0 : case 1 : pElement->eLineJoinType = LJT_ROUND; break;
411 : 0 : case 2 : pElement->eLineJoinType = LJT_BEVEL; break;
412 : 0 : default : pElement->eLineJoinType = LJT_NONE; break;
413 : : }
414 : : }
415 : 0 : break;
416 : 0 : case 0x27 : /*Line Type Continuation*/ break; // NS
417 : 0 : case 0x28 : /*Line Type Initial Offset*/ break; // NS
418 : 0 : case 0x29 : /*Text Score Type*/ break;
419 : 0 : case 0x2a : /*Restricted Text Type*/ break;
420 : 0 : case 0x2b : /*Interpolated interior*/ break;
421 : 0 : case 0x2c : /*Edge Cap*/ break; // NS
422 : 0 : case 0x2d : /*Edge Join*/ break;
423 : 0 : case 0x2e : /*Edge Type Continuation*/ break; // NS
424 : 0 : case 0x2f : /*Edge Type Initial Offset*/ break; // NS
425 : 0 : case 0x30 : /*Symbol Library Index*/ break; // NS
426 : 0 : case 0x31 : /*Symbol Color*/ break; // NS
427 : 0 : case 0x32 : /*Symbol Size*/ break; // NS
428 : 0 : case 0x33 : /*Symbol Orientation*/ break; // NS
429 : 0 : case 0x50 : /*Block Text Region Margins*/ break;
430 : 0 : case 0x51 : /*Block Text Region Expansion*/ break;
431 : 0 : case 0x52 : /*Block Text Region Anchor*/ break;
432 : 0 : case 0x53 : /*Block Text Paragraph Horizontal Alignment*/ break;
433 : 0 : case 0x54 : /*Block Text Paragraph Vertical Alignment*/ break;
434 : 0 : case 0x55 : /*Block Text Line Flow*/ break;
435 : 0 : case 0x60 : /*Block Text Paragraph Spacing*/ break;
436 : 0 : case 0x61 : /*Block Text Paragraph Indent*/ break;
437 : 0 : case 0x62 : /*Block Text Paragraph Tabs*/ break;
438 : 0 : case 0x63 : /*Block Text Paragraph Bullets*/ break;
439 : 0 : case 0x64 : /*Block Text Paragraph Bullet Level*/ break;
440 : 0 : case 0x65 : /*Block Text Paragraph Line Horizontal Alignment*/ break;
441 : 0 : case 0x66 : /*Block Text Paragraph Line Vertical Alignment*/ break;
442 : 0 : case 0x67 : /*Block Text Paragragh Line Spacing*/ break;
443 : 0 : case 0x68 : /*Block Text Paragraph Word Wrap*/ break;
444 : 0 : case 0x70 : /*Block Text Forward Advance Distance*/ break;
445 : 0 : case 0x71 : /*Word Spacing*/ break;
446 : 0 : case 0x72 : /*External Leading*/ break;
447 : : case 0x7a : /*set Gradient Offset*/
448 : : {
449 : 0 : long nHorzOffset = ImplGetI( pElement->nIndexPrecision );
450 : 0 : long nVertOffset = ImplGetI( pElement->nIndexPrecision );
451 : 0 : sal_uInt32 nType = ImplGetUI16();
452 : 0 : mpOutAct->SetGradientOffset( nHorzOffset, nVertOffset, nType );
453 : 0 : mnAct4PostReset |= ACT4_GRADIENT_ACTION;
454 : : }
455 : 0 : break;
456 : : case 0x7b : /*set Gradient Edge*/
457 : : {
458 : 0 : mnAct4PostReset |= ACT4_GRADIENT_ACTION;
459 : : }
460 : 0 : break;
461 : : case 0x7c : /*set Gradient Angle*/
462 : : {
463 : 0 : mpOutAct->SetGradientAngle( ImplGetI( pElement->nIndexPrecision ) );
464 : 0 : mnAct4PostReset |= ACT4_GRADIENT_ACTION;
465 : : }
466 : 0 : break;
467 : : case 0x7d : /*set Gradient Description*/
468 : : {
469 : 0 : ImplGetI( pElement->nIndexPrecision ); // -Wall is this needed?
470 : 0 : sal_uInt32 nNumberOfStages = ImplGetI( pElement->nIndexPrecision );
471 : 0 : sal_uInt32 i, nColorFrom = 0;
472 : 0 : sal_uInt32 nColorTo = 0xffffff;
473 : :
474 : : //FIXME, does this loop actually do anything?
475 : 0 : for ( i = 0; i < nNumberOfStages; i++ )
476 : : {
477 : 0 : ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize ); // -Wall is this needed
478 : : }
479 : :
480 : 0 : for ( i = 0; i <= nNumberOfStages; i++ )
481 : : {
482 : 0 : sal_uInt32 nPara = mnParaSize + 24;
483 : 0 : if ( i == 0 )
484 : : {
485 : 0 : nColorTo = ImplGetBitmapColor();
486 : 0 : nColorFrom = nColorTo ^ 0xffffff;
487 : : }
488 : 0 : else if ( i == 1 )
489 : 0 : nColorFrom = ImplGetBitmapColor();
490 : 0 : mnParaSize = nPara;
491 : : }
492 : 0 : if ( nNumberOfStages > 1 )
493 : 0 : mpOutAct->SetGradientStyle( 0xff, 1 );
494 : :
495 : 0 : mpOutAct->SetGradientDescriptor( nColorFrom, nColorTo );
496 : 0 : mnAct4PostReset |= ACT4_GRADIENT_ACTION;
497 : : }
498 : 0 : break;
499 : : case 0x7e : /*set Gradient Style*/
500 : : {
501 : 0 : sal_uInt32 nStyle = ImplGetUI16( 8 );
502 : 0 : double fRatio = ImplGetFloat( pElement->eRealPrecision, pElement->nRealSize );
503 : 0 : mpOutAct->SetGradientStyle( nStyle, fRatio );
504 : 0 : mnAct4PostReset |= ACT4_GRADIENT_ACTION;
505 : : }
506 : 0 : break;
507 : 0 : case 0xff : /*inquire Font metrics*/ break;
508 : 0 : case 0xfe : /*inquire character widths*/ break;
509 : 0 : case 0xfd : /*set Text Font*/ break;
510 : 0 : case 0xfc : /*set current position*/ break;
511 : 0 : case 0xfb : /*set current position mode*/ break;
512 : 0 : case 0xfa : /*set character height mode*/ break;
513 : 0 : case 0xf9 : /*set Transform matrix 2D*/ break;
514 : 0 : case 0xf8 : /*set Transform matrix 3D*/ break;
515 : 0 : case 0xf7 : /*pop transformation state*/ break;
516 : 0 : case 0xf6 : /*clear transformation state*/ break;
517 : 0 : case 0xf5 : /*set character widths*/ break;
518 : 0 : case 0xf4 : /*set color name - for Pantone support*/ break;
519 : 0 : default: break;
520 : : }
521 : 0 : };
522 : :
523 : :
524 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
