1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26
27 #include <vector>
28 #include <vos/mutex.hxx>
29 #include <com/sun/star/io/XOutputStream.hpp>
30 #include <com/sun/star/container/XChild.hpp>
31 #include <com/sun/star/frame/XModel.hpp>
32 #include <com/sun/star/document/XFilter.hpp>
33 #include <com/sun/star/document/XExporter.hpp>
34 #include <com/sun/star/document/XMimeTypeInfo.hpp>
35 #include <com/sun/star/lang/XServiceInfo.hpp>
36 #include <com/sun/star/lang/XComponent.hpp>
37 #include <com/sun/star/drawing/XShape.hpp>
38 #include <com/sun/star/drawing/XDrawPage.hpp>
39 #include <com/sun/star/graphic/XGraphic.hpp>
40 #include <com/sun/star/graphic/XGraphicRenderer.hpp>
41 #include <com/sun/star/task/XStatusIndicator.hpp>
42 #include <com/sun/star/task/XInteractionHandler.hpp>
43 #include <com/sun/star/task/XInteractionContinuation.hpp>
44
45 #include <comphelper/interaction.hxx>
46 #include <framework/interaction.hxx>
47 #include <com/sun/star/drawing/GraphicFilterRequest.hpp>
48 #include <com/sun/star/util/URL.hpp>
49 #include <cppuhelper/implbase4.hxx>
50 #include <osl/diagnose.h>
51 #include <osl/mutex.hxx>
52 #include <vcl/metaact.hxx>
53 #include <vcl/svapp.hxx>
54 #include <vcl/virdev.hxx>
55 #include <svtools/FilterConfigItem.hxx>
56 #include <svl/outstrm.hxx>
57 #include <svx/sdr/contact/objectcontactofobjlistpainter.hxx>
58 #include <svx/sdr/contact/viewobjectcontact.hxx>
59 #include <svx/sdr/contact/viewcontact.hxx>
60 #include <svx/sdr/contact/displayinfo.hxx>
61 #include <svx/sdr/contact/viewcontactofsdrobj.hxx>
62 #include <editeng/numitem.hxx>
63 #include <svx/svdpagv.hxx>
64 #include <svx/svdograf.hxx>
65 #include "svx/xoutbmp.hxx"
66 #include "svtools/filter.hxx"
67 #include "svx/unoapi.hxx"
68 #include <svx/svdpage.hxx>
69 #include <svx/svdmodel.hxx>
70 #include <svx/fmview.hxx>
71 #include <svx/fmmodel.hxx>
72 #include <svx/unopage.hxx>
73 #include <svx/pageitem.hxx>
74 #include <editeng/eeitem.hxx>
75 #include <svx/svdoutl.hxx>
76 #include <editeng/flditem.hxx>
77
78 #include "boost/scoped_ptr.hpp"
79
80 #define MAX_EXT_PIX 2048
81
82 using namespace ::comphelper;
83 using namespace ::osl;
84 using namespace ::vos;
85 using ::rtl::OUString;
86 using namespace ::cppu;
87 using namespace ::com::sun::star;
88 using namespace ::com::sun::star::uno;
89 using namespace ::com::sun::star::util;
90 using namespace ::com::sun::star::container;
91 using namespace ::com::sun::star::drawing;
92 using namespace ::com::sun::star::lang;
93 using namespace ::com::sun::star::document;
94 using namespace ::com::sun::star::frame;
95 using namespace ::com::sun::star::beans;
96 using namespace ::com::sun::star::task;
97 #include <svx/sdr/contact/viewobjectcontactredirector.hxx>
98 #include <svx/sdr/contact/viewobjectcontact.hxx>
99 #include <svx/sdr/contact/viewcontact.hxx>
100
101 // #i102251#
102 #include <editeng/editstat.hxx>
103
104 //////////////////////////////////////////////////////////////////////////////
105
106 namespace svx
107 {
108 struct ExportSettings
109 {
110 OUString maFilterName;
111 OUString maMediaType;
112 URL maURL;
113 com::sun::star::uno::Reference< com::sun::star::io::XOutputStream > mxOutputStream;
114 com::sun::star::uno::Reference< com::sun::star::graphic::XGraphicRenderer > mxGraphicRenderer;
115 com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > mxStatusIndicator;
116 com::sun::star::uno::Reference< com::sun::star::task::XInteractionHandler > mxInteractionHandler;
117
118 sal_Int32 mnWidth;
119 sal_Int32 mnHeight;
120 sal_Bool mbExportOnlyBackground;
121 sal_Bool mbVerboseComments;
122 sal_Bool mbScrollText;
123 sal_Bool mbUseHighContrast;
124 sal_Bool mbTranslucent;
125
126 Sequence< PropertyValue > maFilterData;
127
128 Fraction maScaleX;
129 Fraction maScaleY;
130
131 ExportSettings( SdrModel* pDoc );
132 };
133
ExportSettings(SdrModel * pDoc)134 ExportSettings::ExportSettings( SdrModel* pDoc )
135 : mnWidth( 0 )
136 , mnHeight( 0 )
137 , mbExportOnlyBackground( false )
138 , mbVerboseComments( false )
139 , mbScrollText( false )
140 , mbUseHighContrast( false )
141 , mbTranslucent( sal_False )
142 , maScaleX( 1, 1 )
143 , maScaleY( 1, 1 )
144 {
145 if( pDoc )
146 {
147 maScaleX = pDoc->GetScaleFraction();
148 maScaleY = pDoc->GetScaleFraction();
149 }
150 }
151
152 /** implements a component to export shapes or pages to external graphic formats.
153
154 @implements com.sun.star.drawing.GraphicExportFilter
155 */
156 class GraphicExporter : public WeakImplHelper4< XFilter, XExporter, XServiceInfo, XMimeTypeInfo >
157 {
158 public:
159 GraphicExporter();
160 virtual ~GraphicExporter();
161
162 // XFilter
163 virtual sal_Bool SAL_CALL filter( const Sequence< PropertyValue >& aDescriptor ) throw(RuntimeException);
164 virtual void SAL_CALL cancel( ) throw(RuntimeException);
165
166 // XExporter
167 virtual void SAL_CALL setSourceDocument( const Reference< XComponent >& xDoc ) throw(IllegalArgumentException, RuntimeException);
168
169 // XServiceInfo
170 virtual OUString SAL_CALL getImplementationName( ) throw(RuntimeException);
171 virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException);
172 virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) throw(RuntimeException);
173
174 // XMimeTypeInfo
175 virtual sal_Bool SAL_CALL supportsMimeType( const ::rtl::OUString& MimeTypeName ) throw (RuntimeException);
176 virtual Sequence< OUString > SAL_CALL getSupportedMimeTypeNames( ) throw (RuntimeException);
177
178 VirtualDevice* CreatePageVDev( SdrPage* pPage, sal_uIntPtr nWidthPixel, sal_uIntPtr nHeightPixel ) const;
179
180 DECL_LINK( CalcFieldValueHdl, EditFieldInfo* );
181
182 void ParseSettings( const Sequence< PropertyValue >& aDescriptor, ExportSettings& rSettings );
183 bool GetGraphic( ExportSettings& rSettings, Graphic& aGraphic, sal_Bool bVectorType );
184
185 private:
186 Reference< XShape > mxShape;
187 Reference< XDrawPage > mxPage;
188 Reference< XShapes > mxShapes;
189
190 SvxDrawPage* mpUnoPage;
191
192 Link maOldCalcFieldValueHdl;
193 sal_Int32 mnPageNumber;
194 SdrPage* mpCurrentPage;
195 SdrModel* mpDoc;
196 };
197
GraphicExporter_createInstance(const Reference<XMultiServiceFactory> &)198 SVX_DLLPUBLIC Reference< XInterface > SAL_CALL GraphicExporter_createInstance(const Reference< XMultiServiceFactory > & )
199 throw( Exception )
200 {
201 return (XWeak*)new GraphicExporter();
202 }
203
GraphicExporter_getSupportedServiceNames()204 SVX_DLLPUBLIC Sequence< OUString > SAL_CALL GraphicExporter_getSupportedServiceNames()
205 throw()
206 {
207 Sequence< OUString > aSupportedServiceNames( 1 );
208 aSupportedServiceNames[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.GraphicExportFilter" ) );
209 return aSupportedServiceNames;
210 }
211
GraphicExporter_getImplementationName()212 SVX_DLLPUBLIC OUString SAL_CALL GraphicExporter_getImplementationName()
213 throw()
214 {
215 return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Draw.GraphicExporter" ) );
216 }
217
218 /** creates a bitmap that is optionaly transparent from a metafile
219 */
GetBitmapFromMetaFile(const GDIMetaFile & rMtf,sal_Bool bTransparent,const Size * pSize)220 BitmapEx GetBitmapFromMetaFile( const GDIMetaFile& rMtf, sal_Bool bTransparent, const Size* pSize )
221 {
222 BitmapEx aBmpEx;
223
224 if(bTransparent)
225 {
226 // use new primitive conversion tooling
227 basegfx::B2DRange aRange(basegfx::B2DPoint(0.0, 0.0));
228 sal_uInt32 nMaximumQuadraticPixels(500000);
229
230 if(pSize)
231 {
232 // use 100th mm for primitive bitmap converter tool, input is pixel
233 // use a real OutDev to get the correct DPI, the static LogicToLogic assumes 72dpi which is wrong (!)
234 const Size aSize100th(Application::GetDefaultDevice()->PixelToLogic(*pSize, MapMode(MAP_100TH_MM)));
235
236 aRange.expand(basegfx::B2DPoint(aSize100th.Width(), aSize100th.Height()));
237
238 // when explicitly pixels are requested from the GraphicExporter, use a *very* high limit
239 // of 16gb (4096x4096 pixels), else use the default for the converters
240 nMaximumQuadraticPixels = std::min(sal_uInt32(4096 * 4096), sal_uInt32(pSize->Width() * pSize->Height()));
241 }
242 else
243 {
244 // use 100th mm for primitive bitmap converter tool
245 const Size aSize100th(Application::GetDefaultDevice()->LogicToLogic(rMtf.GetPrefSize(), rMtf.GetPrefMapMode(), MapMode(MAP_100TH_MM)));
246
247 aRange.expand(basegfx::B2DPoint(aSize100th.Width(), aSize100th.Height()));
248 }
249
250 aBmpEx = convertMetafileToBitmapEx(rMtf, aRange, nMaximumQuadraticPixels);
251 }
252 else
253 {
254 const SvtOptionsDrawinglayer aDrawinglayerOpt;
255 Size aTargetSize(0, 0);
256
257 if(pSize)
258 {
259 // #122820# If a concrete target size in pixels is given, use it
260 aTargetSize = *pSize;
261
262 // get hairline and full bound rect to evtl. reduce given target pixel size when
263 // it is known that it will be expanded to get the right and bottom hairlines right
264 Rectangle aHairlineRect;
265 const Rectangle aRect(rMtf.GetBoundRect(*Application::GetDefaultDevice(), &aHairlineRect));
266
267 if(!aRect.IsEmpty() && !aHairlineRect.IsEmpty())
268 {
269 if(aRect.Right() == aHairlineRect.Right() || aRect.Bottom() == aHairlineRect.Bottom())
270 {
271 if(aTargetSize.Width())
272 {
273 aTargetSize.Width() -= 1;
274 }
275
276 if(aTargetSize.Height())
277 {
278 aTargetSize.Height() -= 1;
279 }
280 }
281 }
282 }
283
284 const GraphicConversionParameters aParameters(
285 aTargetSize,
286 true, // allow unlimited size
287 aDrawinglayerOpt.IsAntiAliasing(),
288 aDrawinglayerOpt.IsSnapHorVerLinesToDiscrete());
289 const Graphic aGraphic(rMtf);
290
291 aBmpEx = BitmapEx(aGraphic.GetBitmap(aParameters));
292 aBmpEx.SetPrefMapMode( rMtf.GetPrefMapMode() );
293 aBmpEx.SetPrefSize( rMtf.GetPrefSize() );
294 }
295
296 return aBmpEx;
297 }
298
CalcSize(sal_Int32 nWidth,sal_Int32 nHeight,const Size & aBoundSize,Size & aOutSize)299 Size* CalcSize( sal_Int32 nWidth, sal_Int32 nHeight, const Size& aBoundSize, Size& aOutSize )
300 {
301 if( (nWidth == 0) && (nHeight == 0) )
302 return NULL;
303
304 if( (nWidth == 0) && (nHeight != 0) && (aBoundSize.Height() != 0) )
305 {
306 nWidth = ( nHeight * aBoundSize.Width() ) / aBoundSize.Height();
307 }
308 else if( (nWidth != 0) && (nHeight == 0) && (aBoundSize.Width() != 0) )
309 {
310 nHeight = ( nWidth * aBoundSize.Height() ) / aBoundSize.Width();
311 }
312
313 aOutSize.Width() = nWidth;
314 aOutSize.Height() = nHeight;
315
316 return &aOutSize;
317 }
318 }
319
320 class ImplExportCheckVisisbilityRedirector : public ::sdr::contact::ViewObjectContactRedirector
321 {
322 public:
323 ImplExportCheckVisisbilityRedirector( SdrPage* pCurrentPage );
324 virtual ~ImplExportCheckVisisbilityRedirector();
325
326 virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
327 const sdr::contact::ViewObjectContact& rOriginal,
328 const sdr::contact::DisplayInfo& rDisplayInfo);
329
330 private:
331 SdrPage* mpCurrentPage;
332 };
333
ImplExportCheckVisisbilityRedirector(SdrPage * pCurrentPage)334 ImplExportCheckVisisbilityRedirector::ImplExportCheckVisisbilityRedirector( SdrPage* pCurrentPage )
335 : ViewObjectContactRedirector(), mpCurrentPage( pCurrentPage )
336 {
337 }
338
~ImplExportCheckVisisbilityRedirector()339 ImplExportCheckVisisbilityRedirector::~ImplExportCheckVisisbilityRedirector()
340 {
341 }
342
createRedirectedPrimitive2DSequence(const sdr::contact::ViewObjectContact & rOriginal,const sdr::contact::DisplayInfo & rDisplayInfo)343 drawinglayer::primitive2d::Primitive2DSequence ImplExportCheckVisisbilityRedirector::createRedirectedPrimitive2DSequence(
344 const sdr::contact::ViewObjectContact& rOriginal,
345 const sdr::contact::DisplayInfo& rDisplayInfo)
346 {
347 SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
348
349 if(pObject)
350 {
351 SdrPage* pPage = mpCurrentPage;
352 if( pPage == 0 )
353 pPage = pObject->GetPage();
354
355 if( (pPage == 0) || pPage->checkVisibility(rOriginal, rDisplayInfo, false) )
356 {
357 return ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
358 }
359
360 return drawinglayer::primitive2d::Primitive2DSequence();
361 }
362 else
363 {
364 // not an object, maybe a page
365 return ::sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
366 }
367 }
368
369 using namespace ::svx;
370
GraphicExporter()371 GraphicExporter::GraphicExporter()
372 : mpUnoPage( NULL ), mnPageNumber(-1), mpCurrentPage(0), mpDoc( NULL )
373 {
374 }
375
~GraphicExporter()376 GraphicExporter::~GraphicExporter()
377 {
378 }
379
IMPL_LINK(GraphicExporter,CalcFieldValueHdl,EditFieldInfo *,pInfo)380 IMPL_LINK(GraphicExporter, CalcFieldValueHdl, EditFieldInfo*, pInfo)
381 {
382 if( pInfo )
383 {
384 if( mpCurrentPage )
385 {
386 pInfo->SetSdrPage( mpCurrentPage );
387 }
388 else if( mnPageNumber != -1 )
389 {
390 const SvxFieldData* pField = pInfo->GetField().GetField();
391 if( pField && pField->ISA( SvxPageField ) )
392 {
393 String aPageNumValue;
394 sal_Bool bUpper = sal_False;
395
396 switch(mpDoc->GetPageNumType())
397 {
398 case SVX_CHARS_UPPER_LETTER:
399 aPageNumValue += (sal_Unicode)(char)((mnPageNumber - 1) % 26 + 'A');
400 break;
401 case SVX_CHARS_LOWER_LETTER:
402 aPageNumValue += (sal_Unicode)(char)((mnPageNumber - 1) % 26 + 'a');
403 break;
404 case SVX_ROMAN_UPPER:
405 bUpper = sal_True;
406 case SVX_ROMAN_LOWER:
407 aPageNumValue += SvxNumberFormat::CreateRomanString(mnPageNumber, bUpper);
408 break;
409 case SVX_NUMBER_NONE:
410 aPageNumValue.Erase();
411 aPageNumValue += sal_Unicode(' ');
412 break;
413 default:
414 aPageNumValue += String::CreateFromInt32( (sal_Int32)mnPageNumber );
415 }
416
417 pInfo->SetRepresentation( aPageNumValue );
418
419 return(0);
420 }
421 }
422 }
423
424 long nRet = maOldCalcFieldValueHdl.Call( pInfo );
425
426 if( pInfo && mpCurrentPage )
427 pInfo->SetSdrPage( 0 );
428
429 return nRet;
430 }
431
432 /** creates an virtual device for the given page
433
434 @return the returned VirtualDevice is owned by the caller
435 */
CreatePageVDev(SdrPage * pPage,sal_uIntPtr nWidthPixel,sal_uIntPtr nHeightPixel) const436 VirtualDevice* GraphicExporter::CreatePageVDev( SdrPage* pPage, sal_uIntPtr nWidthPixel, sal_uIntPtr nHeightPixel ) const
437 {
438 VirtualDevice* pVDev = new VirtualDevice();
439 MapMode aMM( MAP_100TH_MM );
440
441 Point aPoint( 0, 0 );
442 Size aPageSize(pPage->GetSize());
443
444 // use scaling?
445 if( nWidthPixel )
446 {
447 const Fraction aFrac( (long) nWidthPixel, pVDev->LogicToPixel( aPageSize, aMM ).Width() );
448
449 aMM.SetScaleX( aFrac );
450
451 if( nHeightPixel == 0 )
452 aMM.SetScaleY( aFrac );
453 }
454
455 if( nHeightPixel )
456 {
457 const Fraction aFrac( (long) nHeightPixel, pVDev->LogicToPixel( aPageSize, aMM ).Height() );
458
459 if( nWidthPixel == 0 )
460 aMM.SetScaleX( aFrac );
461
462 aMM.SetScaleY( aFrac );
463 }
464
465 pVDev->SetMapMode( aMM );
466 bool bSuccess(false);
467
468 // #122820# If available, use pixel size directly
469 if(nWidthPixel && nHeightPixel)
470 {
471 bSuccess = pVDev->SetOutputSizePixel(Size(nWidthPixel, nHeightPixel));
472 }
473 else
474 {
475 bSuccess = pVDev->SetOutputSize(aPageSize);
476 }
477
478 if(bSuccess)
479 {
480 SdrView* pView = new SdrView(mpDoc, pVDev);
481 pView->SetPageVisible( sal_False );
482 pView->SetBordVisible( sal_False );
483 pView->SetGridVisible( sal_False );
484 pView->SetHlplVisible( sal_False );
485 pView->SetGlueVisible( sal_False );
486 pView->ShowSdrPage(pPage);
487 Region aRegion (Rectangle( aPoint, aPageSize ) );
488
489 ImplExportCheckVisisbilityRedirector aRedirector( mpCurrentPage );
490
491 pView->CompleteRedraw(pVDev, aRegion, &aRedirector);
492 delete pView;
493 }
494 else
495 {
496 OSL_ENSURE(false, "Could not get a VirtualDevice of requested size (!)");
497 }
498
499 return pVDev;
500 }
501
ParseSettings(const Sequence<PropertyValue> & aDescriptor,ExportSettings & rSettings)502 void GraphicExporter::ParseSettings( const Sequence< PropertyValue >& aDescriptor, ExportSettings& rSettings )
503 {
504 sal_Int32 nArgs = aDescriptor.getLength();
505 const PropertyValue* pValues = aDescriptor.getConstArray();
506 while( nArgs-- )
507 {
508 if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FilterName" ) ) )
509 {
510 pValues->Value >>= rSettings.maFilterName;
511 }
512 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MediaType" ) ) )
513 {
514 pValues->Value >>= rSettings.maMediaType;
515 }
516 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "URL" ) ) )
517 {
518 if( !( pValues->Value >>= rSettings.maURL ) )
519 {
520 pValues->Value >>= rSettings.maURL.Complete;
521 }
522 }
523 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "OutputStream" ) ) )
524 {
525 pValues->Value >>= rSettings.mxOutputStream;
526 }
527 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "GraphicRenderer" ) ) )
528 {
529 pValues->Value >>= rSettings.mxGraphicRenderer;
530 }
531 else if ( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StatusIndicator" ) ) )
532 {
533 pValues->Value >>= rSettings.mxStatusIndicator;
534 }
535 else if ( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "InteractionHandler" ) ) )
536 {
537 pValues->Value >>= rSettings.mxInteractionHandler;
538 }
539 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Width" ) ) ) // for compatibility reasons, deprecated
540 {
541 pValues->Value >>= rSettings.mnWidth;
542 }
543 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Height" ) ) ) // for compatibility reasons, deprecated
544 {
545 pValues->Value >>= rSettings.mnHeight;
546 }
547 else if( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ExportOnlyBackground" ) ) ) // for compatibility reasons, deprecated
548 {
549 pValues->Value >>= rSettings.mbExportOnlyBackground;
550 }
551 else if ( pValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FilterData" ) ) )
552 {
553 pValues->Value >>= rSettings.maFilterData;
554
555 sal_Int32 nFilterArgs = rSettings.maFilterData.getLength();
556 PropertyValue* pDataValues = rSettings.maFilterData.getArray();
557 while( nFilterArgs-- )
558 {
559 if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Translucent" ) ) )
560 {
561 if ( !( pDataValues->Value >>= rSettings.mbTranslucent ) ) // SJ: TODO: The GIF Transparency is stored as int32 in
562 { // configuration files, this has to be changed to boolean
563 sal_Int32 nTranslucent = 0;
564 if ( pDataValues->Value >>= nTranslucent )
565 rSettings.mbTranslucent = nTranslucent != 0;
566 }
567 }
568 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "PixelWidth" ) ) )
569 {
570 pDataValues->Value >>= rSettings.mnWidth;
571 }
572 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "PixelHeight" ) ) )
573 {
574 pDataValues->Value >>= rSettings.mnHeight;
575 }
576 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Width" ) ) ) // for compatibility reasons, deprecated
577 {
578 pDataValues->Value >>= rSettings.mnWidth;
579 pDataValues->Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PixelWidth" ) );
580 }
581 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Height" ) ) ) // for compatibility reasons, deprecated
582 {
583 pDataValues->Value >>= rSettings.mnHeight;
584 pDataValues->Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PixelHeight" ) );
585 }
586 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ExportOnlyBackground" ) ) )
587 {
588 pDataValues->Value >>= rSettings.mbExportOnlyBackground;
589 }
590 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "HighContrast" ) ) )
591 {
592 pDataValues->Value >>= rSettings.mbUseHighContrast;
593 }
594 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "PageNumber" ) ) )
595 {
596 pDataValues->Value >>= mnPageNumber;
597 }
598 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "VerboseComments" ) ) )
599 {
600 // #110496# Read flag for verbose metafile comments
601 pDataValues->Value >>= rSettings.mbVerboseComments;
602 }
603 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ScrollText" ) ) )
604 {
605 // #110496# Read flag solitary scroll text metafile
606 pDataValues->Value >>= rSettings.mbScrollText;
607 }
608 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CurrentPage" ) ) )
609 {
610 Reference< XDrawPage > xPage;
611 pDataValues->Value >>= xPage;
612 if( xPage.is() )
613 {
614 SvxDrawPage* pUnoPage = SvxDrawPage::getImplementation( xPage );
615 if( pUnoPage && pUnoPage->GetSdrPage() )
616 mpCurrentPage = pUnoPage->GetSdrPage();
617 }
618 }
619 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ScaleXNumerator" ) ) )
620 {
621 sal_Int32 nVal = 1;
622 if( pDataValues->Value >>= nVal )
623 rSettings.maScaleX = Fraction( nVal, rSettings.maScaleX.GetDenominator() );
624 }
625 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ScaleXDenominator" ) ) )
626 {
627 sal_Int32 nVal = 1;
628 if( pDataValues->Value >>= nVal )
629 rSettings.maScaleX = Fraction( rSettings.maScaleX.GetNumerator(), nVal );
630 }
631 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ScaleYNumerator" ) ) )
632 {
633 sal_Int32 nVal = 1;
634 if( pDataValues->Value >>= nVal )
635 rSettings.maScaleY = Fraction( nVal, rSettings.maScaleY.GetDenominator() );
636 }
637 else if( pDataValues->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ScaleYDenominator" ) ) )
638 {
639 sal_Int32 nVal = 1;
640 if( pDataValues->Value >>= nVal )
641 rSettings.maScaleY = Fraction( rSettings.maScaleY.GetNumerator(), nVal );
642 }
643
644 pDataValues++;
645 }
646 }
647
648 pValues++;
649 }
650
651 // putting the StatusIndicator that we got from the MediaDescriptor into our local FilterData copy
652 if ( rSettings.mxStatusIndicator.is() )
653 {
654 rtl::OUString sStatusIndicator( RTL_CONSTASCII_USTRINGPARAM( "StatusIndicator" ) );
655 int i = rSettings.maFilterData.getLength();
656 rSettings.maFilterData.realloc( i + 1 );
657 rSettings.maFilterData[ i ].Name = sStatusIndicator;
658 rSettings.maFilterData[ i ].Value <<= rSettings.mxStatusIndicator;
659 }
660 }
661
GetGraphic(ExportSettings & rSettings,Graphic & aGraphic,sal_Bool bVectorType)662 bool GraphicExporter::GetGraphic( ExportSettings& rSettings, Graphic& aGraphic, sal_Bool bVectorType )
663 {
664 if( !mpDoc || !mpUnoPage )
665 return false;
666
667 SdrPage* pPage = mpUnoPage->GetSdrPage();
668 if( !pPage )
669 return false;
670
671 VirtualDevice aVDev;
672 const MapMode aMap( mpDoc->GetScaleUnit(), Point(), rSettings.maScaleX, rSettings.maScaleY );
673
674 SdrOutliner& rOutl=mpDoc->GetDrawOutliner(NULL);
675 maOldCalcFieldValueHdl = rOutl.GetCalcFieldValueHdl();
676 rOutl.SetCalcFieldValueHdl( LINK(this, GraphicExporter, CalcFieldValueHdl) );
677 rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor() );
678
679 // #i102251#
680 const sal_uInt32 nOldCntrl(rOutl.GetControlWord());
681 sal_uInt32 nCntrl = nOldCntrl & ~EE_CNTRL_ONLINESPELLING;
682 rOutl.SetControlWord(nCntrl);
683
684 SdrObject* pTempBackgroundShape = 0;
685 std::vector< SdrObject* > aShapes;
686 bool bRet = true;
687
688 // export complete page?
689 if ( !mxShape.is() )
690 {
691 if( rSettings.mbExportOnlyBackground )
692 {
693 const SdrPageProperties* pCorrectProperties = pPage->getCorrectSdrPageProperties();
694
695 if(pCorrectProperties)
696 {
697 pTempBackgroundShape = new SdrRectObj(Rectangle(Point(0,0), pPage->GetSize()));
698 pTempBackgroundShape->SetMergedItemSet(pCorrectProperties->GetItemSet());
699 pTempBackgroundShape->SetMergedItem(XLineStyleItem(XLINE_NONE));
700 pTempBackgroundShape->NbcSetStyleSheet(pCorrectProperties->GetStyleSheet(), true);
701 aShapes.push_back(pTempBackgroundShape);
702 }
703 }
704 else
705 {
706 const Size aSize( pPage->GetSize() );
707
708 // generate a bitmap to convert it to a pixel format.
709 // For gif pictures there can also be a vector format used (bTranslucent)
710 if ( !bVectorType && !rSettings.mbTranslucent )
711 {
712 long nWidthPix = 0;
713 long nHeightPix = 0;
714 if ( rSettings.mnWidth > 0 && rSettings.mnHeight > 0 )
715 {
716 nWidthPix = rSettings.mnWidth;
717 nHeightPix = rSettings.mnHeight;
718 }
719 else
720 {
721 const Size aSizePix( Application::GetDefaultDevice()->LogicToPixel( aSize, aMap ) );
722 if (aSizePix.Width() > MAX_EXT_PIX || aSizePix.Height() > MAX_EXT_PIX)
723 {
724 if (aSizePix.Width() > MAX_EXT_PIX)
725 nWidthPix = MAX_EXT_PIX;
726 else
727 nWidthPix = aSizePix.Width();
728 if (aSizePix.Height() > MAX_EXT_PIX)
729 nHeightPix = MAX_EXT_PIX;
730 else
731 nHeightPix = aSizePix.Height();
732
733 double fWidthDif = aSizePix.Width() / nWidthPix;
734 double fHeightDif = aSizePix.Height() / nHeightPix;
735
736 if (fWidthDif > fHeightDif)
737 nHeightPix = static_cast<long>(aSizePix.Height() / fWidthDif);
738 else
739 nWidthPix = static_cast<long>(aSizePix.Width() / fHeightDif);
740 }
741 else
742 {
743 nWidthPix = aSizePix.Width();
744 nHeightPix = aSizePix.Height();
745 }
746 }
747
748 boost::scoped_ptr< SdrView > pLocalView;
749 if( PTR_CAST( FmFormModel, mpDoc ) )
750 {
751 pLocalView.reset( new FmFormView( PTR_CAST( FmFormModel, mpDoc ), &aVDev ) );
752 }
753 else
754 {
755 pLocalView.reset( new SdrView( mpDoc, &aVDev ) );
756 }
757
758
759 VirtualDevice* pVDev = CreatePageVDev( pPage, nWidthPix, nHeightPix );
760
761 if( pVDev )
762 {
763 aGraphic = pVDev->GetBitmap( Point(), pVDev->GetOutputSize() );
764 aGraphic.SetPrefMapMode( aMap );
765 aGraphic.SetPrefSize( aSize );
766 delete pVDev;
767 }
768 }
769 // create a metafile to export a vector format
770 else
771 {
772 GDIMetaFile aMtf;
773
774 aVDev.SetMapMode( aMap );
775 if( rSettings.mbUseHighContrast )
776 aVDev.SetDrawMode( aVDev.GetDrawMode() | DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT );
777 aVDev.EnableOutput( sal_False );
778 aMtf.Record( &aVDev );
779 Size aNewSize;
780
781 // create a view
782 SdrView* pView;
783
784 if( PTR_CAST( FmFormModel, mpDoc ) )
785 {
786 pView = new FmFormView( PTR_CAST( FmFormModel, mpDoc ), &aVDev );
787 }
788 else
789 {
790 pView = new SdrView( mpDoc, &aVDev );
791 }
792
793 pView->SetBordVisible( sal_False );
794 pView->SetPageVisible( sal_False );
795 pView->ShowSdrPage( pPage );
796
797 if ( pView && pPage )
798 {
799 pView->SetBordVisible( sal_False );
800 pView->SetPageVisible( sal_False );
801 pView->ShowSdrPage( pPage );
802
803 const Point aNewOrg( pPage->GetLftBorder(), pPage->GetUppBorder() );
804 aNewSize = Size( aSize.Width() - pPage->GetLftBorder() - pPage->GetRgtBorder(),
805 aSize.Height() - pPage->GetUppBorder() - pPage->GetLwrBorder() );
806 const Rectangle aClipRect( aNewOrg, aNewSize );
807 MapMode aVMap( aMap );
808
809 aVDev.Push();
810 aVMap.SetOrigin( Point( -aNewOrg.X(), -aNewOrg.Y() ) );
811 aVDev.SetRelativeMapMode( aVMap );
812 aVDev.IntersectClipRegion( aClipRect );
813
814 // Use new StandardCheckVisisbilityRedirector
815 ImplExportCheckVisisbilityRedirector aRedirector( mpCurrentPage );
816
817 pView->CompleteRedraw(&aVDev, Region(Rectangle(Point(), aNewSize)), &aRedirector);
818
819 aVDev.Pop();
820
821 aMtf.Stop();
822 aMtf.WindStart();
823 aMtf.SetPrefMapMode( aMap );
824 aMtf.SetPrefSize( aNewSize );
825
826 // AW: Here the current version was filtering out the META_CLIPREGION_ACTIONs
827 // from the metafile. I asked some other developers why this was done, but no
828 // one knew a direct reason. Since it's in for long time, it may be an old
829 // piece of code. MetaFiles save and load ClipRegions with polygons with preserving
830 // the polygons, so a resolution-indepent roundtrip is supported. Removed this
831 // code since it destroys some MetaFiles where ClipRegions are used. Anyways,
832 // just filtering them out is a hack, at least the encapsulated content would need
833 // to be clipped geometrically.
834 aGraphic = Graphic(aMtf);
835 }
836
837 if ( pView )
838 {
839 pView->HideSdrPage();
840 delete pView;
841 }
842
843 if( rSettings.mbTranslucent )
844 {
845 Size aOutSize;
846 aGraphic = GetBitmapFromMetaFile( aGraphic.GetGDIMetaFile(), sal_True, CalcSize( rSettings.mnWidth, rSettings.mnHeight, aNewSize, aOutSize ) );
847 }
848 }
849 }
850 }
851
852 // export only single shape or shape collection
853 else
854 {
855 // build list of SdrObject
856 if( mxShapes.is() )
857 {
858 Reference< XShape > xShape;
859 const sal_Int32 nCount = mxShapes->getCount();
860
861 for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
862 {
863 mxShapes->getByIndex( nIndex ) >>= xShape;
864 SdrObject* pObj = GetSdrObjectFromXShape( xShape );
865 if( pObj )
866 aShapes.push_back( pObj );
867 }
868 }
869 else
870 {
871 // only one shape
872 SdrObject* pObj = GetSdrObjectFromXShape( mxShape );
873 if( pObj )
874 aShapes.push_back( pObj );
875 }
876
877 if( aShapes.empty() )
878 bRet = false;
879 }
880
881 if( bRet && !aShapes.empty() )
882 {
883 // special treatment for only one SdrGrafObj that has text
884 sal_Bool bSingleGraphic = sal_False;
885
886 if( 1 == aShapes.size() )
887 {
888 if( !bVectorType )
889 {
890 SdrObject* pObj = aShapes.front();
891 if( pObj && pObj->ISA( SdrGrafObj ) && !( (SdrGrafObj*) pObj )->HasText() )
892 {
893 aGraphic = ( (SdrGrafObj*) pObj )->GetTransformedGraphic();
894 if ( aGraphic.GetType() == GRAPHIC_BITMAP )
895 {
896 Size aSizePixel( aGraphic.GetSizePixel() );
897 if( rSettings.mnWidth && rSettings.mnHeight &&
898 ( ( rSettings.mnWidth != aSizePixel.Width() ) ||
899 ( rSettings.mnHeight != aSizePixel.Height() ) ) )
900 {
901 BitmapEx aBmpEx( aGraphic.GetBitmapEx() );
902 // export: use highest quality
903 aBmpEx.Scale( Size( rSettings.mnWidth, rSettings.mnHeight ), BMP_SCALE_LANCZOS );
904 aGraphic = aBmpEx;
905 }
906
907 // #118804# only accept for bitmap graphics, else the
908 // conversion to bitmap will happen anywhere without size control
909 // as evtl. defined in rSettings.mnWidth/mnHeight
910 bSingleGraphic = sal_True;
911 }
912 }
913 }
914 else if( rSettings.mbScrollText )
915 {
916 SdrObject* pObj = aShapes.front();
917 if( pObj && pObj->ISA( SdrTextObj )
918 && ( (SdrTextObj*) pObj )->HasText() )
919 {
920 Rectangle aScrollRectangle;
921 Rectangle aPaintRectangle;
922
923 const boost::scoped_ptr< GDIMetaFile > pMtf(
924 ( (SdrTextObj*) pObj )->GetTextScrollMetaFileAndRectangle(
925 aScrollRectangle, aPaintRectangle ) );
926
927 // take the larger one of the two rectangles (that
928 // should be the bound rect of the retrieved
929 // metafile)
930 Rectangle aTextRect;
931
932 if( aScrollRectangle.IsInside( aPaintRectangle ) )
933 aTextRect = aScrollRectangle;
934 else
935 aTextRect = aPaintRectangle;
936
937 // setup pref size and mapmode
938 pMtf->SetPrefSize( aTextRect.GetSize() );
939
940 // set actual origin (mtf is at actual shape
941 // output position)
942 MapMode aLocalMapMode( aMap );
943 aLocalMapMode.SetOrigin(
944 Point( -aPaintRectangle.Left(),
945 -aPaintRectangle.Top() ) );
946 pMtf->SetPrefMapMode( aLocalMapMode );
947
948 pMtf->AddAction( new MetaCommentAction(
949 "XTEXT_SCROLLRECT", 0,
950 reinterpret_cast<sal_uInt8 const*>(&aScrollRectangle),
951 sizeof( Rectangle ) ) );
952 pMtf->AddAction( new MetaCommentAction(
953 "XTEXT_PAINTRECT", 0,
954 reinterpret_cast<sal_uInt8 const*>(&aPaintRectangle),
955 sizeof( Rectangle ) ) );
956
957 aGraphic = Graphic( *pMtf );
958
959 bSingleGraphic = sal_True;
960 }
961 }
962 }
963
964 if( !bSingleGraphic )
965 {
966 // create a metafile for all shapes
967 VirtualDevice aOut;
968
969 // calculate bound rect for all shapes
970 Rectangle aBound;
971
972 {
973 std::vector< SdrObject* >::iterator aIter = aShapes.begin();
974 const std::vector< SdrObject* >::iterator aEnd = aShapes.end();
975
976 while( aIter != aEnd )
977 {
978 SdrObject* pObj = (*aIter++);
979 Rectangle aR1(pObj->GetCurrentBoundRect());
980 if (aBound.IsEmpty())
981 aBound=aR1;
982 else
983 aBound.Union(aR1);
984 }
985 }
986
987 aOut.EnableOutput( sal_False );
988 aOut.SetMapMode( aMap );
989 if( rSettings.mbUseHighContrast )
990 aOut.SetDrawMode( aVDev.GetDrawMode() | DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT );
991
992 GDIMetaFile aMtf;
993 aMtf.Clear();
994 aMtf.Record( &aOut );
995
996 MapMode aOutMap( aMap );
997 aOutMap.SetOrigin( Point( -aBound.TopLeft().X(), -aBound.TopLeft().Y() ) );
998 aOut.SetRelativeMapMode( aOutMap );
999
1000 sdr::contact::DisplayInfo aDisplayInfo;
1001
1002 if(mpCurrentPage)
1003 {
1004 if(mpCurrentPage->TRG_HasMasterPage() && pPage->IsMasterPage())
1005 {
1006 // MasterPage is processed as another page's SubContent
1007 aDisplayInfo.SetProcessLayers(mpCurrentPage->TRG_GetMasterPageVisibleLayers());
1008 aDisplayInfo.SetSubContentActive(true);
1009 }
1010 }
1011
1012 if(!aShapes.empty())
1013 {
1014 // more effective way to paint a vector of SdrObjects. Hand over the processed page
1015 // to have it in the
1016 sdr::contact::ObjectContactOfObjListPainter aMultiObjectPainter(aOut, aShapes, mpCurrentPage);
1017 ImplExportCheckVisisbilityRedirector aCheckVisibilityRedirector(mpCurrentPage);
1018 aMultiObjectPainter.SetViewObjectContactRedirector(&aCheckVisibilityRedirector);
1019
1020 aMultiObjectPainter.ProcessDisplay(aDisplayInfo);
1021 }
1022
1023 aMtf.Stop();
1024 aMtf.WindStart();
1025
1026 const Size aExtSize( aOut.PixelToLogic( Size( 0, 0 ) ) );
1027 Size aBoundSize( aBound.GetWidth() + ( aExtSize.Width() ),
1028 aBound.GetHeight() + ( aExtSize.Height() ) );
1029
1030 aMtf.SetPrefMapMode( aMap );
1031 aMtf.SetPrefSize( aBoundSize );
1032
1033 if( !bVectorType )
1034 {
1035 Size aOutSize;
1036 aGraphic = GetBitmapFromMetaFile( aMtf, rSettings.mbTranslucent, CalcSize( rSettings.mnWidth, rSettings.mnHeight, aBoundSize, aOutSize ) );
1037 }
1038 else
1039 {
1040 aGraphic = aMtf;
1041 }
1042 }
1043 }
1044
1045 if(pTempBackgroundShape)
1046 {
1047 SdrObject::Free(pTempBackgroundShape);
1048 }
1049
1050 rOutl.SetCalcFieldValueHdl( maOldCalcFieldValueHdl );
1051
1052 // #i102251#
1053 rOutl.SetControlWord(nOldCntrl);
1054
1055 return bRet;
1056
1057 }
1058
1059 // XFilter
filter(const Sequence<PropertyValue> & aDescriptor)1060 sal_Bool SAL_CALL GraphicExporter::filter( const Sequence< PropertyValue >& aDescriptor )
1061 throw(RuntimeException)
1062 {
1063 OGuard aGuard( Application::GetSolarMutex() );
1064
1065 if( NULL == mpUnoPage )
1066 return sal_False;
1067
1068 GraphicFilter* pFilter = GraphicFilter::GetGraphicFilter();
1069
1070 if( NULL == pFilter || NULL == mpUnoPage->GetSdrPage() || NULL == mpDoc )
1071 return sal_False;
1072
1073 // get the arguments from the descriptor
1074 ExportSettings aSettings( mpDoc );
1075 ParseSettings( aDescriptor, aSettings );
1076
1077 const sal_uInt16 nFilter = aSettings.maMediaType.getLength()
1078 ? pFilter->GetExportFormatNumberForMediaType( aSettings.maMediaType )
1079 : pFilter->GetExportFormatNumberForShortName( aSettings.maFilterName );
1080 sal_Bool bVectorType = !pFilter->IsExportPixelFormat( nFilter );
1081
1082 // create the output stuff
1083 Graphic aGraphic;
1084
1085 sal_uInt16 nStatus = GetGraphic( aSettings, aGraphic, bVectorType ) ? GRFILTER_OK : GRFILTER_FILTERERROR;
1086
1087 if( nStatus == GRFILTER_OK )
1088 {
1089 // export graphic only if it has a size
1090 const Size aGraphSize( aGraphic.GetPrefSize() );
1091 if ( ( aGraphSize.Width() == 0 ) || ( aGraphSize.Height() == 0 ) )
1092 {
1093 nStatus = GRFILTER_FILTERERROR;
1094 }
1095 else
1096 {
1097 // now we have a graphic, so export it
1098 if( aSettings.mxGraphicRenderer.is() )
1099 {
1100 // render graphic directly into given renderer
1101 aSettings.mxGraphicRenderer->render( aGraphic.GetXGraphic() );
1102 }
1103 else if( aSettings.mxOutputStream.is() )
1104 {
1105 // TODO: Either utilize optional XSeekable functionality for the
1106 // SvOutputStream, or adapt the graphic filter to not seek anymore.
1107 SvMemoryStream aStream( 1024, 1024 );
1108
1109 nStatus = pFilter->ExportGraphic( aGraphic, String(), aStream, nFilter, &aSettings.maFilterData );
1110
1111 // copy temp stream to XOutputStream
1112 SvOutputStream aOutputStream( aSettings.mxOutputStream );
1113 aStream.Seek(0);
1114 aOutputStream << aStream;
1115 }
1116 else
1117 {
1118 INetURLObject aURLObject( aSettings.maURL.Complete );
1119 DBG_ASSERT( aURLObject.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
1120
1121 nStatus = XOutBitmap::ExportGraphic( aGraphic, aURLObject, *pFilter, nFilter, &aSettings.maFilterData );
1122 }
1123 }
1124 }
1125
1126 if ( aSettings.mxInteractionHandler.is() && ( nStatus != GRFILTER_OK ) )
1127 {
1128 Any aInteraction;
1129 Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::task::XInteractionContinuation > > lContinuations(1);
1130 ::comphelper::OInteractionApprove* pApprove = new ::comphelper::OInteractionApprove();
1131 lContinuations[0] = Reference< XInteractionContinuation >(static_cast< XInteractionContinuation* >(pApprove), UNO_QUERY);
1132
1133 GraphicFilterRequest aErrorCode;
1134 aErrorCode.ErrCode = nStatus;
1135 aInteraction <<= aErrorCode;
1136 aSettings.mxInteractionHandler->handle( framework::InteractionRequest::CreateRequest( aInteraction, lContinuations ) );
1137 }
1138 return nStatus == GRFILTER_OK;
1139 }
1140
cancel()1141 void SAL_CALL GraphicExporter::cancel()
1142 throw(RuntimeException)
1143 {
1144 }
1145
1146 // XExporter
1147
1148 /** the source 'document' could be a XDrawPage, a XShape or a generic XShapes */
setSourceDocument(const Reference<lang::XComponent> & xComponent)1149 void SAL_CALL GraphicExporter::setSourceDocument( const Reference< lang::XComponent >& xComponent )
1150 throw(IllegalArgumentException, RuntimeException)
1151 {
1152 OGuard aGuard( Application::GetSolarMutex() );
1153
1154 mxShapes = NULL;
1155 mpUnoPage = NULL;
1156
1157 try
1158 {
1159 // any break inside this one loop while will throw a IllegalArgumentException
1160 do
1161 {
1162 mxPage = Reference< XDrawPage >::query( xComponent );
1163 mxShapes = Reference< XShapes >::query( xComponent );
1164 mxShape = Reference< XShape >::query( xComponent );
1165
1166 // Step 1: try a generic XShapes
1167 if( !mxPage.is() && !mxShape.is() && mxShapes.is() )
1168 {
1169 // we do not support empty shape collections
1170 if( 0 == mxShapes->getCount() )
1171 break;
1172
1173 // get first shape to detect corresponding page and model
1174 mxShapes->getByIndex(0) >>= mxShape;
1175 }
1176 else
1177 {
1178 mxShapes = NULL;
1179 }
1180
1181 // Step 2: try a shape
1182 if( mxShape.is() )
1183 {
1184 if( NULL == GetSdrObjectFromXShape( mxShape ) )
1185 break;
1186
1187 // get page for this shape
1188 Reference< XChild > xChild( mxShape, UNO_QUERY );
1189 if( !xChild.is() )
1190 break;
1191
1192 Reference< XInterface > xInt;
1193 do
1194 {
1195 xInt = xChild->getParent();
1196 mxPage = Reference< XDrawPage >::query( xInt );
1197 if( !mxPage.is() )
1198 xChild = Reference< XChild >::query( xInt );
1199 }
1200 while( !mxPage.is() && xChild.is() );
1201
1202 if( !mxPage.is() )
1203 break;
1204 }
1205
1206 // Step 3: check the page
1207 if( !mxPage.is() )
1208 break;
1209
1210 mpUnoPage = SvxDrawPage::getImplementation( mxPage );
1211
1212 if( NULL == mpUnoPage || NULL == mpUnoPage->GetSdrPage() )
1213 break;
1214
1215 mpDoc = mpUnoPage->GetSdrPage()->GetModel();
1216
1217 // Step 4: If we got a generic XShapes test all contained shapes
1218 // if they belong to the same XDrawPage
1219
1220 if( mxShapes.is() )
1221 {
1222 SdrPage* pPage = mpUnoPage->GetSdrPage();
1223 SdrObject* pObj;
1224 Reference< XShape > xShape;
1225
1226 sal_Bool bOk = sal_True;
1227
1228 const sal_Int32 nCount = mxShapes->getCount();
1229
1230 // test all but the first shape if they have the same page than
1231 // the first shape
1232 for( sal_Int32 nIndex = 1; bOk && ( nIndex < nCount ); nIndex++ )
1233 {
1234 mxShapes->getByIndex( nIndex ) >>= xShape;
1235 pObj = GetSdrObjectFromXShape( xShape );
1236 bOk = pObj && pObj->GetPage() == pPage;
1237 }
1238
1239 if( !bOk )
1240 break;
1241 }
1242
1243 // no errors so far
1244 return;
1245 }
1246 while( 0 );
1247 }
1248 catch( Exception& )
1249 {
1250 }
1251
1252 throw IllegalArgumentException();
1253 }
1254
1255 // XServiceInfo
getImplementationName()1256 OUString SAL_CALL GraphicExporter::getImplementationName( )
1257 throw(RuntimeException)
1258 {
1259 return GraphicExporter_getImplementationName();
1260 }
1261
supportsService(const OUString & ServiceName)1262 sal_Bool SAL_CALL GraphicExporter::supportsService( const OUString& ServiceName )
1263 throw(RuntimeException)
1264 {
1265 Sequence< OUString > aSeq( GraphicExporter_getSupportedServiceNames() );
1266 sal_Int32 nArgs = aSeq.getLength();
1267 const OUString* pService = aSeq.getConstArray();
1268 while( nArgs-- )
1269 if( *pService++ == ServiceName )
1270 return sal_True;
1271
1272 return sal_False;
1273 }
1274
getSupportedServiceNames()1275 Sequence< OUString > SAL_CALL GraphicExporter::getSupportedServiceNames( )
1276 throw(RuntimeException)
1277 {
1278 return GraphicExporter_getSupportedServiceNames();
1279 }
1280
1281 // XMimeTypeInfo
supportsMimeType(const OUString & MimeTypeName)1282 sal_Bool SAL_CALL GraphicExporter::supportsMimeType( const OUString& MimeTypeName ) throw (RuntimeException)
1283 {
1284 const String aMimeTypeName( MimeTypeName );
1285
1286 GraphicFilter* pFilter = GraphicFilter::GetGraphicFilter();
1287 sal_uInt16 nCount = pFilter->GetExportFormatCount();
1288 sal_uInt16 nFilter;
1289 for( nFilter = 0; nFilter < nCount; nFilter++ )
1290 {
1291 if( aMimeTypeName.Equals( pFilter->GetExportFormatMediaType( nFilter ) ) )
1292 {
1293 return sal_True;
1294 }
1295 }
1296
1297 return sal_False;
1298 }
1299
getSupportedMimeTypeNames()1300 Sequence< OUString > SAL_CALL GraphicExporter::getSupportedMimeTypeNames( ) throw (RuntimeException)
1301 {
1302 GraphicFilter* pFilter = GraphicFilter::GetGraphicFilter();
1303 sal_uInt16 nCount = pFilter->GetExportFormatCount();
1304 sal_uInt16 nFilter;
1305 sal_uInt16 nFound = 0;
1306
1307 Sequence< OUString > aSeq( nCount );
1308 OUString* pStr = aSeq.getArray();
1309
1310 for( nFilter = 0; nFilter < nCount; nFilter++ )
1311 {
1312 OUString aMimeType( pFilter->GetExportFormatMediaType( nFilter ) );
1313 if( aMimeType.getLength() )
1314 {
1315 *pStr++ = aMimeType;
1316 nFound++;
1317 }
1318 }
1319
1320 if( nFound < nCount )
1321 aSeq.realloc( nFound );
1322
1323 return aSeq;
1324 }
1325
SvxGetGraphicForShape(SdrObject & rShape,bool bVector)1326 Graphic SvxGetGraphicForShape( SdrObject& rShape, bool bVector )
1327 {
1328 Graphic aGraphic;
1329 try
1330 {
1331 rtl::Reference< GraphicExporter > xExporter( new GraphicExporter() );
1332 Reference< XComponent > xComp( rShape.getUnoShape(), UNO_QUERY_THROW );
1333 xExporter->setSourceDocument( xComp );
1334 ExportSettings aSettings( rShape.GetModel() );
1335 xExporter->GetGraphic( aSettings, aGraphic, bVector );
1336 }
1337 catch( Exception& )
1338 {
1339 DBG_ERROR("SvxGetGraphicForShape(), exception caught!");
1340 }
1341 return aGraphic;
1342 }
1343
1344