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/bitmapex.hxx>
21 : #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
22 : #include <com/sun/star/drawing/LineStyle.hpp>
23 : #include <com/sun/star/drawing/LineDash.hpp>
24 : #include <com/sun/star/drawing/FillStyle.hpp>
25 : #include <com/sun/star/drawing/Hatch.hpp>
26 : #include <com/sun/star/awt/FontDescriptor.hpp>
27 : #include <com/sun/star/awt/FontWeight.hpp>
28 : #include <com/sun/star/awt/FontUnderline.hpp>
29 : #include <com/sun/star/drawing/XShapeGrouper.hpp>
30 : #include <com/sun/star/drawing/CircleKind.hpp>
31 : #include <com/sun/star/awt/XBitmap.hpp>
32 : #include <com/sun/star/drawing/PointSequenceSequence.hpp>
33 : #include <com/sun/star/drawing/PointSequence.hpp>
34 : #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
35 : #include <com/sun/star/drawing/FlagSequence.hpp>
36 : #include <com/sun/star/drawing/ShapeCollection.hpp>
37 : #include <com/sun/star/drawing/TextAdjust.hpp>
38 : #include <com/sun/star/text/XText.hpp>
39 : #include <com/sun/star/text/XTextRange.hpp>
40 : #include <com/sun/star/style/HorizontalAlignment.hpp>
41 :
42 : #include <comphelper/processfactory.hxx>
43 : #include <toolkit/helper/vclunohelper.hxx>
44 :
45 : #include "main.hxx"
46 : #include "outact.hxx"
47 :
48 : using namespace ::com::sun::star;
49 :
50 :
51 :
52 2 : CGMImpressOutAct::CGMImpressOutAct( CGM& rCGM, const uno::Reference< frame::XModel > & rModel ) :
53 : CGMOutAct ( rCGM ),
54 2 : nFinalTextCount ( 0 )
55 : {
56 2 : if ( mpCGM->mbStatus )
57 : {
58 2 : bool bStatRet = false;
59 :
60 2 : uno::Reference< drawing::XDrawPagesSupplier > aDrawPageSup( rModel, uno::UNO_QUERY );
61 2 : if( aDrawPageSup.is() )
62 : {
63 2 : maXDrawPages = aDrawPageSup->getDrawPages();
64 2 : if ( maXDrawPages.is() )
65 : {
66 2 : maXMultiServiceFactory.set( rModel, uno::UNO_QUERY);
67 2 : if( maXMultiServiceFactory.is() )
68 : {
69 2 : maXDrawPage = *static_cast<uno::Reference< drawing::XDrawPage > const *>(maXDrawPages->getByIndex( 0 ).getValue());
70 2 : if ( ImplInitPage() )
71 2 : bStatRet = true;
72 : }
73 : }
74 : }
75 2 : mpCGM->mbStatus = bStatRet;
76 : }
77 2 : }
78 :
79 15 : bool CGMImpressOutAct::ImplInitPage()
80 : {
81 15 : bool bStatRet = false;
82 15 : if( maXDrawPage.is() )
83 : {
84 15 : maXShapes = uno::Reference< drawing::XShapes >( maXDrawPage, uno::UNO_QUERY );
85 15 : if ( maXShapes.is() )
86 : {
87 15 : bStatRet = true;
88 : }
89 : }
90 15 : return bStatRet;
91 : }
92 :
93 :
94 :
95 116 : bool CGMImpressOutAct::ImplCreateShape( const OUString& rType )
96 : {
97 116 : uno::Reference< uno::XInterface > xNewShape( maXMultiServiceFactory->createInstance( rType ) );
98 116 : maXShape = uno::Reference< drawing::XShape >( xNewShape, uno::UNO_QUERY );
99 116 : maXPropSet = uno::Reference< beans::XPropertySet >( xNewShape, uno::UNO_QUERY );
100 116 : if ( maXShape.is() && maXPropSet.is() )
101 : {
102 116 : maXShapes->add( maXShape );
103 116 : return true;
104 : }
105 0 : return false;
106 : }
107 :
108 :
109 :
110 0 : void CGMImpressOutAct::ImplSetOrientation( FloatPoint& rRefPoint, double& rOrientation )
111 : {
112 0 : uno::Any aAny;
113 0 : aAny <<= (sal_Int32)rRefPoint.X;
114 0 : maXPropSet->setPropertyValue( "RotationPointX", aAny );
115 0 : aAny <<= (sal_Int32)rRefPoint.Y;
116 0 : maXPropSet->setPropertyValue( "RotationPointY", aAny );
117 0 : aAny <<= (sal_Int32)( rOrientation * 100.0 );
118 0 : maXPropSet->setPropertyValue( "RotateAngle", aAny );
119 0 : }
120 :
121 :
122 :
123 68 : void CGMImpressOutAct::ImplSetLineBundle()
124 : {
125 68 : uno::Any aAny;
126 : drawing::LineStyle eLS;
127 :
128 : sal_uInt32 nLineColor;
129 : LineType eLineType;
130 : double fLineWidth;
131 :
132 68 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_LINECOLOR )
133 0 : nLineColor = mpCGM->pElement->pLineBundle->GetColor();
134 : else
135 68 : nLineColor = mpCGM->pElement->aLineBundle.GetColor();
136 68 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_LINETYPE )
137 0 : eLineType = mpCGM->pElement->pLineBundle->eLineType;
138 : else
139 68 : eLineType = mpCGM->pElement->aLineBundle.eLineType;
140 68 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_LINEWIDTH )
141 0 : fLineWidth = mpCGM->pElement->pLineBundle->nLineWidth;
142 : else
143 68 : fLineWidth = mpCGM->pElement->aLineBundle.nLineWidth;
144 :
145 68 : aAny <<= (sal_Int32)nLineColor;
146 68 : maXPropSet->setPropertyValue( "LineColor", aAny );
147 :
148 68 : aAny <<= (sal_Int32)fLineWidth;
149 68 : maXPropSet->setPropertyValue( "LineWidth", aAny );
150 :
151 68 : switch( eLineType )
152 : {
153 : case LT_NONE :
154 0 : eLS = drawing::LineStyle_NONE;
155 0 : break;
156 : case LT_DASH :
157 : case LT_DOT :
158 : case LT_DASHDOT :
159 : case LT_DOTDOTSPACE :
160 : case LT_LONGDASH :
161 : case LT_DASHDASHDOT :
162 42 : eLS = drawing::LineStyle_DASH;
163 42 : break;
164 : case LT_SOLID :
165 : default:
166 26 : eLS = drawing::LineStyle_SOLID;
167 26 : break;
168 : }
169 68 : aAny <<= eLS;
170 68 : maXPropSet->setPropertyValue( "LineStyle", aAny );
171 68 : if ( eLS == drawing::LineStyle_DASH )
172 : {
173 42 : drawing::LineDash aLineDash( drawing::DashStyle_RECTRELATIVE, 1, 50, 3, 33, 100 );
174 42 : aAny <<= aLineDash;
175 42 : maXPropSet->setPropertyValue( "LineDash", aAny );
176 68 : }
177 68 : }
178 :
179 48 : void CGMImpressOutAct::ImplSetFillBundle()
180 : {
181 :
182 48 : uno::Any aAny;
183 : drawing::LineStyle eLS;
184 : drawing::FillStyle eFS;
185 :
186 48 : sal_uInt32 nEdgeColor = 0;
187 : EdgeType eEdgeType;
188 48 : double fEdgeWidth = 0;
189 :
190 : sal_uInt32 nFillColor;
191 : FillInteriorStyle eFillStyle;
192 : sal_uInt32 nHatchIndex;
193 :
194 48 : if ( mpCGM->pElement->eEdgeVisibility == EV_ON )
195 : {
196 30 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_EDGETYPE )
197 0 : eEdgeType = mpCGM->pElement->pEdgeBundle->eEdgeType;
198 : else
199 30 : eEdgeType = mpCGM->pElement->aEdgeBundle.eEdgeType;
200 30 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_EDGEWIDTH )
201 0 : fEdgeWidth = mpCGM->pElement->pEdgeBundle->nEdgeWidth;
202 : else
203 30 : fEdgeWidth = mpCGM->pElement->aEdgeBundle.nEdgeWidth;
204 30 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_EDGECOLOR )
205 0 : nEdgeColor = mpCGM->pElement->pEdgeBundle->GetColor();
206 : else
207 30 : nEdgeColor = mpCGM->pElement->aEdgeBundle.GetColor();
208 : }
209 : else
210 18 : eEdgeType = ET_NONE;
211 :
212 48 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_FILLINTERIORSTYLE )
213 0 : eFillStyle = mpCGM->pElement->pFillBundle->eFillInteriorStyle;
214 : else
215 48 : eFillStyle = mpCGM->pElement->aFillBundle.eFillInteriorStyle;
216 48 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_FILLCOLOR )
217 0 : nFillColor = mpCGM->pElement->pFillBundle->GetColor();
218 : else
219 48 : nFillColor = mpCGM->pElement->aFillBundle.GetColor();
220 48 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_HATCHINDEX )
221 0 : nHatchIndex = (sal_uInt32)mpCGM->pElement->pFillBundle->nFillHatchIndex;
222 : else
223 48 : nHatchIndex = (sal_uInt32)mpCGM->pElement->aFillBundle.nFillHatchIndex;
224 :
225 48 : aAny <<= (sal_Int32)nFillColor;
226 48 : maXPropSet->setPropertyValue( "FillColor", aAny );
227 :
228 48 : switch ( eFillStyle )
229 : {
230 : case FIS_HATCH :
231 : {
232 32 : if ( nHatchIndex == 0 )
233 0 : eFS = drawing::FillStyle_NONE;
234 : else
235 32 : eFS = drawing::FillStyle_HATCH;
236 : }
237 32 : break;
238 : case FIS_PATTERN :
239 : case FIS_SOLID :
240 : {
241 8 : eFS = drawing::FillStyle_SOLID;
242 : }
243 8 : break;
244 :
245 : case FIS_GEOPATTERN :
246 : {
247 0 : if ( mpCGM->pElement->eTransparency == T_ON )
248 0 : nFillColor = mpCGM->pElement->nAuxiliaryColor;
249 0 : eFS = drawing::FillStyle_NONE;
250 : }
251 0 : break;
252 :
253 : case FIS_INTERPOLATED :
254 : case FIS_GRADIENT :
255 : {
256 0 : eFS = drawing::FillStyle_GRADIENT;
257 : }
258 0 : break;
259 :
260 : case FIS_HOLLOW :
261 : case FIS_EMPTY :
262 : default:
263 : {
264 8 : eFS = drawing::FillStyle_NONE;
265 : }
266 : }
267 :
268 48 : if ( mpCGM->mnAct4PostReset & ACT4_GRADIENT_ACTION )
269 0 : eFS = drawing::FillStyle_GRADIENT;
270 :
271 48 : if ( eFS == drawing::FillStyle_GRADIENT )
272 : {
273 0 : aAny <<= *mpGradient;
274 0 : maXPropSet->setPropertyValue( "FillGradient", aAny );
275 : }
276 48 : aAny <<= eFS;
277 48 : maXPropSet->setPropertyValue( "FillStyle", aAny );
278 :
279 48 : eLS = drawing::LineStyle_NONE;
280 48 : if ( eFillStyle == FIS_HOLLOW )
281 : {
282 4 : eLS = drawing::LineStyle_SOLID;
283 4 : aAny <<= (sal_Int32)nFillColor;
284 4 : maXPropSet->setPropertyValue( "LineColor", aAny );
285 4 : aAny <<= (sal_Int32)0;
286 4 : maXPropSet->setPropertyValue( "LineWidth", aAny );
287 : }
288 44 : else if ( eEdgeType != ET_NONE )
289 : {
290 26 : aAny <<= (sal_Int32)nEdgeColor;
291 26 : maXPropSet->setPropertyValue( "LineColor", aAny );
292 :
293 26 : aAny <<= (sal_Int32)fEdgeWidth;
294 26 : maXPropSet->setPropertyValue( "LineWidth", aAny );
295 :
296 : switch( eEdgeType )
297 : {
298 : case ET_DASH :
299 : case ET_DOT :
300 : case ET_DASHDOT :
301 : case ET_DASHDOTDOT :
302 : case ET_DOTDOTSPACE :
303 : case ET_LONGDASH :
304 : case ET_DASHDASHDOT :
305 : default: // case ET_SOLID :
306 : {
307 26 : eLS = drawing::LineStyle_SOLID;
308 : }
309 26 : break;
310 : }
311 : }
312 :
313 48 : aAny <<= eLS;
314 48 : maXPropSet->setPropertyValue( "LineStyle", aAny );
315 :
316 48 : if ( eFS == drawing::FillStyle_HATCH )
317 : {
318 32 : drawing::Hatch aHatch;
319 :
320 32 : aHatch.Color = nFillColor;
321 32 : if ( mpCGM->pElement->maHatchMap.find( nHatchIndex ) != mpCGM->pElement->maHatchMap.end() )
322 : {
323 32 : HatchEntry& rHatchEntry = mpCGM->pElement->maHatchMap[ nHatchIndex ];
324 32 : switch ( rHatchEntry.HatchStyle )
325 : {
326 24 : case 0 : aHatch.Style = drawing::HatchStyle_SINGLE; break;
327 8 : case 1 : aHatch.Style = drawing::HatchStyle_DOUBLE; break;
328 0 : case 2 : aHatch.Style = drawing::HatchStyle_TRIPLE; break;
329 : }
330 32 : aHatch.Distance = rHatchEntry.HatchDistance;
331 32 : aHatch.Angle = rHatchEntry.HatchAngle;
332 : }
333 : else
334 : {
335 0 : aHatch.Style = drawing::HatchStyle_TRIPLE;
336 0 : aHatch.Distance = 10 * ( nHatchIndex & 0x1f ) | 100;
337 0 : aHatch.Angle = 15 * ( ( nHatchIndex & 0x1f ) - 5 );
338 : }
339 32 : aAny <<= aHatch;
340 32 : maXPropSet->setPropertyValue( "FillHatch", aAny );
341 48 : }
342 48 : }
343 :
344 0 : void CGMImpressOutAct::ImplSetTextBundle( const uno::Reference< beans::XPropertySet > & rProperty )
345 : {
346 0 : uno::Any aAny;
347 : sal_uInt32 nTextFontIndex;
348 : sal_uInt32 nTextColor;
349 :
350 0 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_TEXTFONTINDEX )
351 0 : nTextFontIndex = mpCGM->pElement->pTextBundle->nTextFontIndex;
352 : else
353 0 : nTextFontIndex = mpCGM->pElement->aTextBundle.nTextFontIndex;
354 0 : if ( mpCGM->pElement->nAspectSourceFlags & ASF_TEXTCOLOR )
355 0 : nTextColor = mpCGM->pElement->pTextBundle->GetColor();
356 : else
357 0 : nTextColor = mpCGM->pElement->aTextBundle.GetColor();
358 :
359 0 : aAny <<= (sal_Int32)nTextColor;
360 0 : rProperty->setPropertyValue( "CharColor", aAny );
361 :
362 0 : sal_uInt32 nFontType = 0;
363 0 : awt::FontDescriptor aFontDescriptor;
364 0 : FontEntry* pFontEntry = mpCGM->pElement->aFontList.GetFontEntry( nTextFontIndex );
365 0 : if ( pFontEntry )
366 : {
367 0 : nFontType = pFontEntry->nFontType;
368 0 : aFontDescriptor.Name = OUString::createFromAscii( reinterpret_cast<char*>(pFontEntry->pFontName) );
369 : }
370 0 : aFontDescriptor.Height = ( sal_Int16 )( ( mpCGM->pElement->nCharacterHeight * (double)1.50 ) );
371 0 : if ( nFontType & 1 )
372 0 : aFontDescriptor.Slant = awt::FontSlant_ITALIC;
373 0 : if ( nFontType & 2 )
374 0 : aFontDescriptor.Weight = awt::FontWeight::BOLD;
375 : else
376 0 : aFontDescriptor.Weight = awt::FontWeight::NORMAL;
377 :
378 0 : if ( mpCGM->pElement->eUnderlineMode != UM_OFF )
379 : {
380 0 : aFontDescriptor.Underline = awt::FontUnderline::SINGLE;
381 : }
382 0 : aAny <<= aFontDescriptor;
383 0 : rProperty->setPropertyValue( "FontDescriptor", aAny );
384 0 : }
385 :
386 14 : void CGMImpressOutAct::InsertPage()
387 : {
388 14 : if ( mnCurrentPage ) // one side is always existing, therefore the first side will be left out
389 : {
390 13 : uno::Reference< drawing::XDrawPage > xPage( maXDrawPages->insertNewByIndex( 0xffff ), uno::UNO_QUERY );
391 13 : maXDrawPage = xPage;
392 13 : if ( !ImplInitPage() )
393 0 : mpCGM->mbStatus = false;
394 : }
395 14 : mnCurrentPage++;
396 14 : }
397 :
398 14 : void CGMImpressOutAct::BeginGroup()
399 : {
400 14 : if ( mnGroupLevel < CGM_OUTACT_MAX_GROUP_LEVEL )
401 : {
402 14 : mpGroupLevel[ mnGroupLevel ] = maXShapes->getCount();
403 : }
404 14 : mnGroupLevel++;
405 14 : mnGroupActCount = mpCGM->mnActCount;
406 14 : }
407 :
408 28 : void CGMImpressOutAct::EndGroup()
409 : {
410 28 : if ( mnGroupLevel ) // preserve overflow
411 14 : mnGroupLevel--;
412 28 : if ( mnGroupLevel < CGM_OUTACT_MAX_GROUP_LEVEL )
413 : {
414 28 : sal_uInt32 mnFirstIndex = mpGroupLevel[ mnGroupLevel ];
415 28 : if ( mnFirstIndex == 0xffffffff )
416 0 : mnFirstIndex = 0;
417 28 : sal_uInt32 mnCurrentCount = maXShapes->getCount();
418 28 : if ( ( mnCurrentCount - mnFirstIndex ) > 1 )
419 : {
420 28 : uno::Reference< drawing::XShapeGrouper > aXShapeGrouper;
421 28 : aXShapeGrouper.set( maXDrawPage, uno::UNO_QUERY );
422 28 : if( aXShapeGrouper.is() )
423 : {
424 28 : uno::Reference< drawing::XShapes > aXShapes = drawing::ShapeCollection::create(comphelper::getProcessComponentContext());
425 144 : for ( sal_uInt32 i = mnFirstIndex; i < mnCurrentCount; i++ )
426 : {
427 116 : uno::Reference< drawing::XShape > aXShape = *static_cast<uno::Reference< drawing::XShape > const *>(maXShapes->getByIndex( i ).getValue());
428 116 : if (aXShape.is() )
429 : {
430 116 : aXShapes->add( aXShape );
431 : }
432 116 : }
433 28 : uno::Reference< drawing::XShapeGroup > aXShapeGroup = aXShapeGrouper->group( aXShapes );
434 28 : }
435 : }
436 : }
437 28 : }
438 :
439 14 : void CGMImpressOutAct::EndGrouping()
440 : {
441 28 : while ( mnGroupLevel )
442 : {
443 0 : EndGroup();
444 : }
445 14 : }
446 :
447 11 : void CGMImpressOutAct::DrawRectangle( FloatRect& rFloatRect )
448 : {
449 11 : if ( mnGroupActCount != ( mpCGM->mnActCount - 1 ) ) // POWERPOINT HACK !!!
450 : {
451 11 : if ( ImplCreateShape( "com.sun.star.drawing.RectangleShape" ) )
452 : {
453 11 : awt::Size aSize( (long)(rFloatRect.Right - rFloatRect.Left ), (long)(rFloatRect.Bottom-rFloatRect.Top ) );
454 11 : maXShape->setSize( aSize );
455 11 : maXShape->setPosition( awt::Point( (long)rFloatRect.Left, (long)rFloatRect.Top ) );
456 11 : ImplSetFillBundle();
457 : }
458 : }
459 11 : }
460 :
461 11 : void CGMImpressOutAct::DrawEllipse( FloatPoint& rCenter, FloatPoint& rSize, double& rOrientation )
462 : {
463 11 : if ( ImplCreateShape( "com.sun.star.drawing.EllipseShape" ) )
464 : {
465 11 : drawing::CircleKind eCircleKind = drawing::CircleKind_FULL;
466 11 : uno::Any aAny( &eCircleKind, ::cppu::UnoType<drawing::CircleKind>::get() );
467 11 : maXPropSet->setPropertyValue( "CircleKind", aAny );
468 :
469 11 : long nXSize = (long)( rSize.X * 2.0 ); // strange behaviour with a awt::Size of 0
470 11 : long nYSize = (long)( rSize.Y * 2.0 );
471 11 : if ( nXSize < 1 )
472 0 : nXSize = 1;
473 11 : if ( nYSize < 1 )
474 0 : nYSize = 1;
475 11 : maXShape->setSize( awt::Size( nXSize, nYSize ) );
476 11 : maXShape->setPosition( awt::Point( (long)( rCenter.X - rSize.X ), (long)( rCenter.Y - rSize.Y ) ) );
477 :
478 11 : if ( rOrientation != 0 )
479 : {
480 0 : ImplSetOrientation( rCenter, rOrientation );
481 : }
482 11 : ImplSetFillBundle();
483 : }
484 11 : }
485 :
486 38 : void CGMImpressOutAct::DrawEllipticalArc( FloatPoint& rCenter, FloatPoint& rSize, double& rOrientation,
487 : sal_uInt32 nType, double& fStartAngle, double& fEndAngle )
488 : {
489 38 : if ( ImplCreateShape( "com.sun.star.drawing.EllipseShape" ) )
490 : {
491 38 : uno::Any aAny;
492 : drawing::CircleKind eCircleKind;
493 :
494 :
495 38 : long nXSize = (long)( rSize.X * 2.0 ); // strange behaviour with a awt::Size of 0
496 38 : long nYSize = (long)( rSize.Y * 2.0 );
497 38 : if ( nXSize < 1 )
498 0 : nXSize = 1;
499 38 : if ( nYSize < 1 )
500 0 : nYSize = 1;
501 :
502 38 : maXShape->setSize( awt::Size ( nXSize, nYSize ) );
503 :
504 38 : if ( rOrientation != 0 )
505 : {
506 0 : fStartAngle += rOrientation;
507 0 : if ( fStartAngle >= 360 )
508 0 : fStartAngle -= 360;
509 0 : fEndAngle += rOrientation;
510 0 : if ( fEndAngle >= 360 )
511 0 : fEndAngle -= 360;
512 : }
513 38 : switch( nType )
514 : {
515 14 : case 0 : eCircleKind = drawing::CircleKind_SECTION; break;
516 12 : case 1 : eCircleKind = drawing::CircleKind_CUT; break;
517 12 : case 2 : eCircleKind = drawing::CircleKind_ARC; break;
518 0 : default : eCircleKind = drawing::CircleKind_FULL; break;
519 : }
520 38 : if ( (long)fStartAngle == (long)fEndAngle )
521 : {
522 2 : eCircleKind = drawing::CircleKind_FULL;
523 2 : aAny.setValue( &eCircleKind, ::cppu::UnoType<drawing::CircleKind>::get() );
524 : }
525 : else
526 : {
527 36 : aAny.setValue( &eCircleKind, ::cppu::UnoType<drawing::CircleKind>::get() );
528 36 : maXPropSet->setPropertyValue( "CircleKind", aAny );
529 36 : aAny <<= (sal_Int32)( (long)( fStartAngle * 100 ) );
530 36 : maXPropSet->setPropertyValue( "CircleStartAngle", aAny );
531 36 : aAny <<= (sal_Int32)( (long)( fEndAngle * 100 ) );
532 36 : maXPropSet->setPropertyValue( "CircleEndAngle", aAny );
533 : }
534 38 : maXShape->setPosition( awt::Point( (long)( rCenter.X - rSize.X ), (long)( rCenter.Y - rSize.Y ) ) );
535 38 : if ( rOrientation != 0 )
536 : {
537 0 : ImplSetOrientation( rCenter, rOrientation );
538 : }
539 38 : if ( eCircleKind == drawing::CircleKind_ARC )
540 : {
541 12 : ImplSetLineBundle();
542 : }
543 : else
544 : {
545 26 : ImplSetFillBundle();
546 26 : if ( nType == 2 )
547 : {
548 0 : ImplSetLineBundle();
549 0 : drawing::FillStyle eFillStyle = drawing::FillStyle_NONE;
550 0 : aAny.setValue( &eFillStyle, cppu::UnoType<drawing::FillStyle>::get());
551 0 : maXPropSet->setPropertyValue( "FillStyle", aAny );
552 : }
553 38 : }
554 : }
555 38 : }
556 :
557 0 : void CGMImpressOutAct::DrawBitmap( CGMBitmapDescriptor* pBmpDesc )
558 : {
559 0 : if ( pBmpDesc->mbStatus && pBmpDesc->mpBitmap )
560 : {
561 0 : FloatPoint aOrigin = pBmpDesc->mnOrigin;
562 0 : double fdx = pBmpDesc->mndx;
563 0 : double fdy = pBmpDesc->mndy;
564 :
565 0 : BmpMirrorFlags nMirr = BmpMirrorFlags::NONE;
566 0 : if ( pBmpDesc->mbVMirror )
567 0 : nMirr |= BmpMirrorFlags::Vertical;
568 0 : if ( pBmpDesc->mbHMirror )
569 0 : nMirr |= BmpMirrorFlags::Horizontal;
570 0 : if ( nMirr != BmpMirrorFlags::NONE )
571 0 : pBmpDesc->mpBitmap->Mirror( nMirr );
572 :
573 0 : mpCGM->ImplMapPoint( aOrigin );
574 0 : mpCGM->ImplMapX( fdx );
575 0 : mpCGM->ImplMapY( fdy );
576 :
577 0 : if ( ImplCreateShape( "com.sun.star.drawing.GraphicObjectShape" ) )
578 : {
579 0 : maXShape->setSize( awt::Size( (long)fdx, (long)fdy ) );
580 0 : maXShape->setPosition( awt::Point( (long)aOrigin.X, (long)aOrigin.Y ) );
581 :
582 0 : if ( pBmpDesc->mnOrientation != 0 )
583 : {
584 0 : ImplSetOrientation( aOrigin, pBmpDesc->mnOrientation );
585 : }
586 :
587 0 : uno::Reference< awt::XBitmap > xBitmap( VCLUnoHelper::CreateBitmap( BitmapEx( *( pBmpDesc->mpBitmap ) ) ) );
588 0 : uno::Any aAny;
589 0 : aAny <<= xBitmap;
590 0 : maXPropSet->setPropertyValue( "GraphicObjectFillBitmap", aAny );
591 :
592 : }
593 : }
594 0 : }
595 :
596 0 : void CGMImpressOutAct::DrawPolygon( Polygon& rPoly )
597 : {
598 0 : sal_uInt16 nPoints = rPoly.GetSize();
599 :
600 0 : if ( ( nPoints > 1 ) && ImplCreateShape( "com.sun.star.drawing.PolyPolygonShape" ) )
601 : {
602 0 : drawing::PointSequenceSequence aRetval;
603 :
604 : // prepare inside polygons
605 0 : aRetval.realloc( 1 );
606 :
607 : // get pointer to outside arrays
608 0 : drawing::PointSequence* pOuterSequence = aRetval.getArray();
609 :
610 : // make room in arrays
611 0 : pOuterSequence->realloc((sal_Int32)nPoints);
612 :
613 : // get pointer to arrays
614 0 : awt::Point* pInnerSequence = pOuterSequence->getArray();
615 :
616 0 : for( sal_uInt16 n = 0; n < nPoints; n++ )
617 0 : *pInnerSequence++ = awt::Point( rPoly[ n ].X(), rPoly[n].Y() );
618 :
619 0 : uno::Any aParam;
620 0 : aParam <<= aRetval;
621 0 : maXPropSet->setPropertyValue( "PolyPolygon", aParam );
622 0 : ImplSetFillBundle();
623 : }
624 0 : }
625 :
626 56 : void CGMImpressOutAct::DrawPolyLine( Polygon& rPoly )
627 : {
628 56 : sal_uInt16 nPoints = rPoly.GetSize();
629 :
630 56 : if ( ( nPoints > 1 ) && ImplCreateShape( "com.sun.star.drawing.PolyLineShape" ) )
631 : {
632 56 : drawing::PointSequenceSequence aRetval;
633 :
634 : // prepare inside polygons
635 56 : aRetval.realloc( 1 );
636 :
637 : // get pointer to outside arrays
638 56 : drawing::PointSequence* pOuterSequence = aRetval.getArray();
639 :
640 : // make room in arrays
641 56 : pOuterSequence->realloc((sal_Int32)nPoints);
642 :
643 : // get pointer to arrays
644 56 : awt::Point* pInnerSequence = pOuterSequence->getArray();
645 :
646 210 : for( sal_uInt16 n = 0; n < nPoints; n++ )
647 154 : *pInnerSequence++ = awt::Point( rPoly[ n ].X(), rPoly[n].Y() );
648 :
649 112 : uno::Any aParam;
650 56 : aParam <<= aRetval;
651 56 : maXPropSet->setPropertyValue( "PolyPolygon", aParam );
652 112 : ImplSetLineBundle();
653 : }
654 56 : }
655 :
656 0 : void CGMImpressOutAct::DrawPolybezier( Polygon& rPolygon )
657 : {
658 0 : sal_uInt16 nPoints = rPolygon.GetSize();
659 0 : if ( ( nPoints > 1 ) && ImplCreateShape( "com.sun.star.drawing.OpenBezierShape" ) )
660 : {
661 0 : drawing::PolyPolygonBezierCoords aRetval;
662 :
663 0 : aRetval.Coordinates.realloc( 1 );
664 0 : aRetval.Flags.realloc( 1 );
665 :
666 : // get pointer to outside arrays
667 0 : drawing::PointSequence* pOuterSequence = aRetval.Coordinates.getArray();
668 0 : drawing::FlagSequence* pOuterFlags = aRetval.Flags.getArray();
669 :
670 : // make room in arrays
671 0 : pOuterSequence->realloc( nPoints );
672 0 : pOuterFlags->realloc( nPoints );
673 :
674 0 : awt::Point* pInnerSequence = pOuterSequence->getArray();
675 0 : drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
676 :
677 0 : for( sal_uInt16 i = 0; i < nPoints; i++ )
678 : {
679 0 : *pInnerSequence++ = awt::Point( rPolygon[ i ].X(), rPolygon[ i ].Y() );
680 0 : *pInnerFlags++ = (drawing::PolygonFlags)rPolygon.GetFlags( i );
681 : }
682 0 : uno::Any aParam;
683 0 : aParam <<= aRetval;
684 0 : maXPropSet->setPropertyValue( "PolyPolygonBezier", aParam );
685 0 : ImplSetLineBundle();
686 : }
687 0 : }
688 :
689 14 : void CGMImpressOutAct::DrawPolyPolygon( tools::PolyPolygon& rPolyPolygon )
690 : {
691 14 : sal_uInt32 nNumPolys = rPolyPolygon.Count();
692 14 : if ( nNumPolys && ImplCreateShape( "com.sun.star.drawing.ClosedBezierShape" ) )
693 : {
694 0 : drawing::PolyPolygonBezierCoords aRetval;
695 :
696 : // prepare inside polygons
697 0 : aRetval.Coordinates.realloc((sal_Int32)nNumPolys);
698 0 : aRetval.Flags.realloc((sal_Int32)nNumPolys);
699 :
700 : // get pointer to outside arrays
701 0 : drawing::PointSequence* pOuterSequence = aRetval.Coordinates.getArray();
702 0 : drawing::FlagSequence* pOuterFlags = aRetval.Flags.getArray();
703 :
704 0 : for( sal_uInt32 a = 0; a < nNumPolys; a++ )
705 : {
706 0 : Polygon aPolygon( rPolyPolygon.GetObject( a ) );
707 0 : sal_uInt32 nNumPoints = aPolygon.GetSize();
708 :
709 : // make room in arrays
710 0 : pOuterSequence->realloc((sal_Int32)nNumPoints);
711 0 : pOuterFlags->realloc((sal_Int32)nNumPoints);
712 :
713 : // get pointer to arrays
714 0 : awt::Point* pInnerSequence = pOuterSequence->getArray();
715 0 : drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
716 :
717 0 : for( sal_uInt32 b = 0; b < nNumPoints; b++ )
718 : {
719 0 : *pInnerSequence++ = awt::Point( aPolygon.GetPoint( b ).X(), aPolygon.GetPoint( b ).Y() ) ;
720 0 : *pInnerFlags++ = (drawing::PolygonFlags)aPolygon.GetFlags( b );
721 : }
722 0 : pOuterSequence++;
723 0 : pOuterFlags++;
724 0 : }
725 0 : uno::Any aParam;
726 0 : aParam <<= aRetval;
727 0 : maXPropSet->setPropertyValue( "PolyPolygonBezier", aParam);
728 0 : ImplSetFillBundle();
729 : }
730 14 : }
731 :
732 0 : void CGMImpressOutAct::DrawText( awt::Point& rTextPos, awt::Size& rTextSize, char* pString, sal_uInt32 /*nSize*/, FinalFlag eFlag )
733 : {
734 0 : if ( ImplCreateShape( "com.sun.star.drawing.TextShape" ) )
735 : {
736 0 : uno::Any aAny;
737 0 : long nWidth = rTextSize.Width;
738 0 : long nHeight = rTextSize.Height;
739 :
740 0 : awt::Point aTextPos( rTextPos );
741 0 : switch ( mpCGM->pElement->eTextAlignmentV )
742 : {
743 : case TAV_HALF :
744 : {
745 0 : aTextPos.Y -= static_cast<sal_Int32>( ( mpCGM->pElement->nCharacterHeight * 1.5 ) / 2 );
746 : }
747 0 : break;
748 :
749 : case TAV_BASE :
750 : case TAV_BOTTOM :
751 : case TAV_NORMAL :
752 0 : aTextPos.Y -= static_cast<sal_Int32>( mpCGM->pElement->nCharacterHeight * 1.5 );
753 : case TAV_TOP :
754 0 : break;
755 : case TAV_CAP:
756 : case TAV_CONT:
757 0 : break; // -Wall these two were not here.
758 : }
759 :
760 0 : if ( nWidth < 0 )
761 : {
762 0 : nWidth = -nWidth;
763 : }
764 0 : else if ( nWidth == 0 )
765 : {
766 0 : nWidth = -1;
767 : }
768 0 : if ( nHeight < 0 )
769 : {
770 0 : nHeight = -nHeight;
771 : }
772 0 : else if ( nHeight == 0 )
773 : {
774 0 : nHeight = -1;
775 : }
776 0 : maXShape->setPosition( aTextPos );
777 0 : maXShape->setSize( awt::Size( nWidth, nHeight ) );
778 0 : double nX = mpCGM->pElement->nCharacterOrientation[ 2 ];
779 0 : double nY = mpCGM->pElement->nCharacterOrientation[ 3 ];
780 0 : double nOrientation = acos( nX / sqrt( nX * nX + nY * nY ) ) * 57.29577951308;
781 0 : if ( nY < 0 )
782 0 : nOrientation = 360 - nOrientation;
783 :
784 0 : if ( nOrientation )
785 : {
786 0 : aAny <<= (sal_Int32)( aTextPos.X );
787 0 : maXPropSet->setPropertyValue( "RotationPointX", aAny );
788 0 : aAny <<= (sal_Int32)( aTextPos.Y + nHeight );
789 0 : maXPropSet->setPropertyValue( "RotationPointY", aAny );
790 0 : aAny <<= (sal_Int32)( (sal_Int32)( nOrientation * 100 ) );
791 0 : maXPropSet->setPropertyValue( "RotateAngle", aAny );
792 : }
793 0 : if ( nWidth == -1 )
794 : {
795 0 : sal_Bool bTrue( sal_True );
796 0 : aAny.setValue( &bTrue, cppu::UnoType<sal_Bool>::get());
797 0 : maXPropSet->setPropertyValue( "TextAutoGrowWidth", aAny );
798 :
799 : drawing::TextAdjust eTextAdjust;
800 0 : switch ( mpCGM->pElement->eTextAlignmentH )
801 : {
802 : case TAH_RIGHT :
803 0 : eTextAdjust = drawing::TextAdjust_RIGHT;
804 0 : break;
805 : case TAH_LEFT :
806 : case TAH_CONT :
807 : case TAH_NORMAL :
808 0 : eTextAdjust = drawing::TextAdjust_LEFT;
809 0 : break;
810 : case TAH_CENTER :
811 0 : eTextAdjust = drawing::TextAdjust_CENTER;
812 0 : break;
813 : }
814 0 : aAny <<= eTextAdjust;
815 0 : maXPropSet->setPropertyValue( "TextHorizontalAdjust", aAny );
816 : }
817 0 : if ( nHeight == -1 )
818 : {
819 0 : sal_Bool bTrue = sal_True;
820 0 : aAny.setValue( &bTrue, cppu::UnoType<sal_Bool>::get());
821 0 : maXPropSet->setPropertyValue( "TextAutoGrowHeight", aAny );
822 : }
823 0 : uno::Reference< text::XText > xText;
824 0 : uno::Any aFirstQuery( maXShape->queryInterface( cppu::UnoType<text::XText>::get()));
825 0 : if( aFirstQuery >>= xText )
826 : {
827 0 : OUString aStr( OUString::createFromAscii( pString ) );
828 :
829 0 : uno::Reference< text::XTextCursor > aXTextCursor( xText->createTextCursor() );
830 : {
831 0 : aXTextCursor->gotoEnd( sal_False );
832 0 : uno::Reference< text::XTextRange > aCursorText;
833 0 : uno::Any aSecondQuery( aXTextCursor->queryInterface( cppu::UnoType<text::XTextRange>::get()));
834 0 : if ( aSecondQuery >>= aCursorText )
835 : {
836 0 : uno::Reference< beans::XPropertySet > aCursorPropSet;
837 :
838 0 : uno::Any aQuery( aCursorText->queryInterface( cppu::UnoType<beans::XPropertySet>::get()));
839 0 : if( aQuery >>= aCursorPropSet )
840 : {
841 0 : if ( nWidth != -1 ) // paragraph adjusting in a valid textbox ?
842 : {
843 0 : switch ( mpCGM->pElement->eTextAlignmentH )
844 : {
845 : case TAH_RIGHT :
846 0 : aAny <<= (sal_Int16)style::HorizontalAlignment_RIGHT;
847 0 : break;
848 : case TAH_LEFT :
849 : case TAH_CONT :
850 : case TAH_NORMAL :
851 0 : aAny <<= (sal_Int16)style::HorizontalAlignment_LEFT;
852 0 : break;
853 : case TAH_CENTER :
854 0 : aAny <<= (sal_Int16)style::HorizontalAlignment_CENTER;
855 0 : break;
856 : }
857 0 : aCursorPropSet->setPropertyValue( "ParaAdjust", aAny );
858 : }
859 0 : if ( nWidth > 0 && nHeight > 0 ) // restricted text
860 : {
861 0 : sal_Bool bTrue = sal_True;
862 0 : aAny.setValue( &bTrue, cppu::UnoType<sal_Bool>::get());
863 0 : maXPropSet->setPropertyValue( "TextFitToSize", aAny );
864 : }
865 0 : aCursorText->setString( aStr );
866 0 : aXTextCursor->gotoEnd( sal_True );
867 0 : ImplSetTextBundle( aCursorPropSet );
868 0 : }
869 0 : }
870 0 : }
871 : }
872 0 : if ( eFlag == FF_NOT_FINAL )
873 : {
874 0 : nFinalTextCount = maXShapes->getCount();
875 0 : }
876 : }
877 0 : }
878 :
879 0 : void CGMImpressOutAct::AppendText( char* pString, sal_uInt32 /*nSize*/, FinalFlag /*eFlag*/ )
880 : {
881 0 : if ( nFinalTextCount )
882 : {
883 0 : uno::Reference< drawing::XShape > aShape = *static_cast<uno::Reference< drawing::XShape > const *>(maXShapes->getByIndex( nFinalTextCount - 1 ).getValue());
884 0 : if ( aShape.is() )
885 : {
886 0 : uno::Reference< text::XText > xText;
887 0 : uno::Any aFirstQuery( aShape->queryInterface( cppu::UnoType<text::XText>::get()) );
888 0 : if( aFirstQuery >>= xText )
889 : {
890 0 : OUString aStr( OUString::createFromAscii( pString ) );
891 :
892 0 : uno::Reference< text::XTextCursor > aXTextCursor( xText->createTextCursor() );
893 0 : if ( aXTextCursor.is() )
894 : {
895 0 : aXTextCursor->gotoEnd( sal_False );
896 0 : uno::Reference< text::XTextRange > aCursorText;
897 0 : uno::Any aSecondQuery(aXTextCursor->queryInterface( cppu::UnoType<text::XTextRange>::get()));
898 0 : if ( aSecondQuery >>= aCursorText )
899 : {
900 0 : uno::Reference< beans::XPropertySet > aPropSet;
901 0 : uno::Any aQuery(aCursorText->queryInterface( cppu::UnoType<beans::XPropertySet>::get()));
902 0 : if( aQuery >>= aPropSet )
903 : {
904 0 : aCursorText->setString( aStr );
905 0 : aXTextCursor->gotoEnd( sal_True );
906 0 : ImplSetTextBundle( aPropSet );
907 0 : }
908 0 : }
909 0 : }
910 0 : }
911 0 : }
912 : }
913 0 : }
914 :
915 :
916 : // nCount != 0 -> Append Text
917 0 : sal_uInt32 CGMImpressOutAct::DrawText( TextEntry* /*pTextEntry*/, NodeFrameSet& /*rNodeFrameSet*/, sal_uInt32 /*nObjCount*/ )
918 : {
919 0 : return 0;
920 : }
921 :
922 :
923 :
924 0 : void CGMImpressOutAct::DrawChart()
925 : {
926 0 : }
927 :
928 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
