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_svtools.hxx"
26
27 #if defined UNX && defined ALPHA
28 #include <fstream.hxx>
29 #endif
30 #include <vos/mutex.hxx>
31 #include <comphelper/processfactory.hxx>
32 #include <ucbhelper/content.hxx>
33 #include <cppuhelper/implbase1.hxx>
34 #include <tools/urlobj.hxx>
35 #include <vcl/salctype.hxx>
36 #include <vcl/pngread.hxx>
37 #include <vcl/pngwrite.hxx>
38 #include <vcl/svgdata.hxx>
39 #include <vcl/virdev.hxx>
40 #include <vcl/svapp.hxx>
41 #include <osl/file.hxx>
42 #include <svtools/filter.hxx>
43 #include "FilterConfigCache.hxx"
44 #include <svtools/FilterConfigItem.hxx>
45 #include <svtools/fltcall.hxx>
46 #include <svtools/wmf.hxx>
47 #include "gifread.hxx"
48 #include "jpeg.hxx"
49 #include "xbmread.hxx"
50 #include "xpmread.hxx"
51 #include <svl/solar.hrc>
52 #include <svtools/svtools.hrc>
53 #include "sgffilt.hxx"
54 #include "osl/module.hxx"
55 #include <com/sun/star/uno/Reference.h>
56 #include <com/sun/star/awt/Size.hpp>
57 #include <com/sun/star/uno/XInterface.hpp>
58 #include <com/sun/star/uno/XWeak.hpp>
59 #include <com/sun/star/uno/XAggregation.hpp>
60 #ifndef _COM_SUN_STAR_UNO_XTYPEPROVIDER_HPP_
61 #include <com/sun/star/lang/XTypeProvider.hpp>
62 #endif
63 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
64 #include <com/sun/star/io/XActiveDataSource.hpp>
65 #include <com/sun/star/io/XOutputStream.hpp>
66 #include <com/sun/star/svg/XSVGWriter.hpp>
67 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
68 #include <com/sun/star/ucb/CommandAbortedException.hpp>
69 #include <unotools/ucbstreamhelper.hxx>
70 #include <unotools/localfilehelper.hxx>
71 #include <comphelper/processfactory.hxx>
72 #include <rtl/bootstrap.hxx>
73 #include <rtl/instance.hxx>
74 #include <vcl/metaact.hxx>
75 #include <vcl/dibtools.hxx>
76
77 #include "SvFilterOptionsDialog.hxx"
78
79 #define PMGCHUNG_msOG 0x6d734f47 // Microsoft Office Animated GIF
80
81 #if (defined OS2 && !defined ICC)
82
83 #define IMPORT_FUNCTION_NAME "_GraphicImport"
84 #define EXPORT_FUNCTION_NAME "_GraphicExport"
85 #define IMPDLG_FUNCTION_NAME "_DoImportDialog"
86 #define EXPDLG_FUNCTION_NAME "_DoExportDialog"
87
88 #else
89
90 #define IMPORT_FUNCTION_NAME "GraphicImport"
91 #define EXPORT_FUNCTION_NAME "GraphicExport"
92 #define IMPDLG_FUNCTION_NAME "DoImportDialog"
93 #define EXPDLG_FUNCTION_NAME "DoExportDialog"
94
95 #endif
96
97
98 // -----------
99 // - statics -
100 // -----------
101
102 using namespace ::rtl;
103 using namespace ::com::sun::star;
104
105 static List* pFilterHdlList = NULL;
106
getListMutex()107 static ::osl::Mutex& getListMutex()
108 {
109 static ::osl::Mutex s_aListProtection;
110 return s_aListProtection;
111 }
112
113 static GraphicFilter* pGraphicFilter=0;
114
115 // -------------------------
116 // - ImpFilterOutputStream -
117 // -------------------------
118
119 class ImpFilterOutputStream : public ::cppu::WeakImplHelper1< ::com::sun::star::io::XOutputStream >
120 {
121 protected:
122
123 SvStream& mrStm;
124
writeBytes(const::com::sun::star::uno::Sequence<sal_Int8> & rData)125 virtual void SAL_CALL writeBytes( const ::com::sun::star::uno::Sequence< sal_Int8 >& rData ) throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException) { mrStm.Write( rData.getConstArray(), rData.getLength() ); }
flush()126 virtual void SAL_CALL flush() throw (::com::sun::star::io::NotConnectedException, ::com::sun::star::io::BufferSizeExceededException, ::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException) { mrStm.Flush(); }
closeOutput()127 virtual void SAL_CALL closeOutput() throw() {}
128
129 public:
130
ImpFilterOutputStream(SvStream & rStm)131 ImpFilterOutputStream( SvStream& rStm ) : mrStm( rStm ) {}
~ImpFilterOutputStream()132 ~ImpFilterOutputStream() {}
133 };
134
Exists(const INetURLObject & rObj)135 sal_Bool ImplDirEntryHelper::Exists( const INetURLObject& rObj )
136 {
137 sal_Bool bExists = sal_False;
138
139 try
140 {
141 ::rtl::OUString aTitle;
142 ::ucbhelper::Content aCnt( rObj.GetMainURL( INetURLObject::NO_DECODE ),
143 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() );
144
145 bExists = aCnt.isDocument();
146 }
147 catch( ::com::sun::star::ucb::CommandAbortedException& )
148 {
149 DBG_ERRORFILE( "CommandAbortedException" );
150 }
151 catch( ::com::sun::star::ucb::ContentCreationException& )
152 {
153 DBG_ERRORFILE( "ContentCreationException" );
154 }
155 catch( ... )
156 {
157 // DBG_ERRORFILE( "Any other exception" );
158 }
159 return bExists;
160 }
161
162 // -----------------------------------------------------------------------------
163
Kill(const String & rMainUrl)164 void ImplDirEntryHelper::Kill( const String& rMainUrl )
165 {
166 try
167 {
168 ::ucbhelper::Content aCnt( rMainUrl,
169 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() );
170
171 aCnt.executeCommand( ::rtl::OUString::createFromAscii( "delete" ),
172 ::com::sun::star::uno::makeAny( sal_Bool( sal_True ) ) );
173 }
174 catch( ::com::sun::star::ucb::CommandAbortedException& )
175 {
176 DBG_ERRORFILE( "CommandAbortedException" );
177 }
178 catch( ... )
179 {
180 DBG_ERRORFILE( "Any other exception" );
181 }
182 }
183
184 // --------------------
185 // - Helper functions -
186 // --------------------
187
188 //--------------------------------------------------------------------------
189
ImplSearchEntry(sal_uInt8 * pSource,sal_uInt8 * pDest,sal_uLong nComp,sal_uLong nSize)190 sal_uInt8* ImplSearchEntry( sal_uInt8* pSource, sal_uInt8* pDest, sal_uLong nComp, sal_uLong nSize )
191 {
192 while ( nComp-- >= nSize )
193 {
194 sal_uLong i;
195 for ( i = 0; i < nSize; i++ )
196 {
197 if ( ( pSource[i]&~0x20 ) != ( pDest[i]&~0x20 ) )
198 break;
199 }
200 if ( i == nSize )
201 return pSource;
202 pSource++;
203 }
204 return NULL;
205 }
206
207 //--------------------------------------------------------------------------
208
ImpGetExtension(const String & rPath)209 inline String ImpGetExtension( const String &rPath )
210 {
211 String aExt;
212 INetURLObject aURL( rPath );
213 aExt = aURL.GetFileExtension().toAsciiUpperCase();
214 return aExt;
215 }
216
217 /*************************************************************************
218 |*
219 |* ImpPeekGraphicFormat()
220 |*
221 |* Beschreibung:
222 |* Diese Funktion kann zweierlei:
223 |* 1.) Datei anlesen, Dateiformat ermitteln
224 |* Eingabe-prarameter:
225 |* rPath - Dateipfad
226 |* rFormatExtension - Inhalt egal
227 |* bTest - setze sal_False
228 |* Ausgabe-parameter:
229 |* Funkionswert - sal_True wenn Erfolg
230 |* rFormatExtension - Bei Erfolg: uebliche Dateiendung
231 |* des Formats (Grossbuchstaben)
232 |* 2.) Datei anlesen, Dateiformat ueberpruefen
233 |* Eingabe-prarameter:
234 |* rPath - Dateipfad
235 |* rFormatExtension - uebliche Dateiendung des Formats
236 |* (Grossbuchstaben)
237 |* bTest - setze sal_True
238 |* Ausgabe-parameter:
239 |* Funkionswert - sal_False, wenn die Datei bestimmt nicht
240 |* vom uebgebenen Format ist.
241 |* sal_True, wenn die Datei WAHRSCHEINLICH von
242 |* dem Format ist, ODER WENN DAS FORMAT
243 |* DIESER FUNKTION NICHT BEKANNT IST!
244 |*
245 |* Ersterstellung OH 26.05.95
246 |* Letzte Aenderung OH 07.08.95
247 |*
248 *************************************************************************/
249
ImpPeekGraphicFormat(SvStream & rStream,String & rFormatExtension,sal_Bool bTest)250 static sal_Bool ImpPeekGraphicFormat( SvStream& rStream, String& rFormatExtension, sal_Bool bTest )
251 {
252 sal_uInt16 i;
253 sal_uInt8 sFirstBytes[ 256 ];
254 sal_uLong nFirstLong,nSecondLong;
255 sal_uLong nStreamPos = rStream.Tell();
256
257 rStream.Seek( STREAM_SEEK_TO_END );
258 sal_uLong nStreamLen = rStream.Tell() - nStreamPos;
259 rStream.Seek( nStreamPos );
260
261 if ( !nStreamLen )
262 {
263 SvLockBytes* pLockBytes = rStream.GetLockBytes();
264 if ( pLockBytes )
265 pLockBytes->SetSynchronMode( sal_True );
266
267 rStream.Seek( STREAM_SEEK_TO_END );
268 nStreamLen = rStream.Tell() - nStreamPos;
269 rStream.Seek( nStreamPos );
270 }
271 // Die ersten 256 Bytes in einen Buffer laden:
272 if( nStreamLen >= 256 )
273 rStream.Read( sFirstBytes, 256 );
274 else
275 {
276 rStream.Read( sFirstBytes, nStreamLen );
277
278 for( i = (sal_uInt16) nStreamLen; i < 256; i++ )
279 sFirstBytes[ i ]=0;
280 }
281
282 if( rStream.GetError() )
283 return sal_False;
284
285 // Die ersten 8 Bytes in nFirstLong, nSecondLong unterbringen,
286 // Big-Endian:
287 for( i = 0, nFirstLong = 0L, nSecondLong = 0L; i < 4; i++ )
288 {
289 nFirstLong=(nFirstLong<<8)|(sal_uLong)sFirstBytes[i];
290 nSecondLong=(nSecondLong<<8)|(sal_uLong)sFirstBytes[i+4];
291 }
292
293 // Folgende Variable ist nur bei bTest==sal_True interessant. Sie
294 // bleibt sal_False, wenn das Format (rFormatExtension) hier noch nicht
295 // einprogrammiert wurde.
296 sal_Bool bSomethingTested = sal_False;
297
298 // Nun werden die verschieden Formate ueberprueft. Dabei ist die
299 // Reihenfolge nicht egal. Z.b. koennte eine MET-Datei auch durch
300 // den BMP-Test gehen, umgekehrt kann eine BMP-Datei kaum durch den
301 // MET-Test gehen. Also sollte MET vor BMP getestet werden.
302 // Theoretisch waere aber vielleicht auch eine BMP-Datei denkbar,
303 // die durch den MET-Test geht.
304 // Diese Probleme gibt es natuerlich nicht nur bei MET und BMP.
305 // Deshalb wird im Falle der Uberpruefung eines Formats (bTest==sal_True)
306 // nur genau dieses eine Format getestet. Alles andere koennte fatale
307 // Folgen haben, z.B. wenn der Benutzer sagt, es sei BMP-Datei (und es
308 // ist BMP-Datei), und hier wuerde die Datei durch den MET-Test gehen...
309
310 //--------------------------- MET ------------------------------------
311 if( !bTest || ( rFormatExtension.CompareToAscii( "MET", 3 ) == COMPARE_EQUAL ) )
312 {
313 bSomethingTested=sal_True;
314 if( sFirstBytes[2] == 0xd3 )
315 {
316 rStream.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
317 rStream.Seek( nStreamPos );
318 sal_uInt16 nFieldSize;
319 sal_uInt8 nMagic;
320 sal_Bool bOK=sal_True;
321 rStream >> nFieldSize >> nMagic;
322 for (i=0; i<3; i++) {
323 if (nFieldSize<6) { bOK=sal_False; break; }
324 if (nStreamLen < rStream.Tell() + nFieldSize ) { bOK=sal_False; break; }
325 rStream.SeekRel(nFieldSize-3);
326 rStream >> nFieldSize >> nMagic;
327 if (nMagic!=0xd3) { bOK=sal_False; break; }
328 }
329 rStream.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
330 if (bOK && !rStream.GetError()) {
331 rFormatExtension= UniString::CreateFromAscii( "MET", 3 );
332 return sal_True;
333 }
334 }
335 }
336
337 //--------------------------- BMP ------------------------------------
338 if( !bTest || ( rFormatExtension.CompareToAscii( "BMP", 3 ) == COMPARE_EQUAL ) )
339 {
340 sal_uInt8 nOffs;
341
342 bSomethingTested=sal_True;
343
344 // OS/2-Bitmaparray ('BA') koennen wir evtl. auch lesen,
345 // dementspr. muessen wir den Offset anpassen,
346 // um auf die erste Bitmap im Array zu stossen
347 if ( sFirstBytes[0] == 0x42 && sFirstBytes[1] == 0x41 )
348 nOffs = 14;
349 else
350 nOffs = 0;
351
352 // Jetzt testen wir zunaechst auf 'BM'
353 if ( sFirstBytes[0+nOffs]==0x42 && sFirstBytes[1+nOffs]==0x4d )
354 {
355 // unter OS/2 koennen die Reserved-Flags != 0 sein
356 // (was sie eigentlich nicht duerften);
357 // in diesem Fall testen wir die Groesse des BmpInfoHeaders
358 if ( ( sFirstBytes[6+nOffs]==0x00 &&
359 sFirstBytes[7+nOffs]==0x00 &&
360 sFirstBytes[8+nOffs]==0x00 &&
361 sFirstBytes[9+nOffs]==0x00 ) ||
362 sFirstBytes[14+nOffs] == 0x28 ||
363 sFirstBytes[14+nOffs] == 0x0c )
364 {
365 rFormatExtension = UniString::CreateFromAscii( "BMP", 3 );
366 return sal_True;
367 }
368 }
369 }
370
371 //--------------------------- WMF/EMF ------------------------------------
372
373 if( !bTest ||
374 ( rFormatExtension.CompareToAscii( "WMF", 3 ) == COMPARE_EQUAL ) ||
375 ( rFormatExtension.CompareToAscii( "EMF", 3 ) == COMPARE_EQUAL ) )
376 {
377 bSomethingTested = sal_True;
378
379 if ( nFirstLong==0xd7cdc69a || nFirstLong==0x01000900 )
380 {
381 rFormatExtension = UniString::CreateFromAscii( "WMF", 3 );
382 return sal_True;
383 }
384 else if( nFirstLong == 0x01000000 && sFirstBytes[ 40 ] == 0x20 && sFirstBytes[ 41 ] == 0x45 &&
385 sFirstBytes[ 42 ] == 0x4d && sFirstBytes[ 43 ] == 0x46 )
386 {
387 rFormatExtension = UniString::CreateFromAscii( "EMF", 3 );
388 return sal_True;
389 }
390 }
391
392 //--------------------------- PCX ------------------------------------
393 if( !bTest || ( rFormatExtension.CompareToAscii( "PCX", 3 ) == COMPARE_EQUAL ) )
394 {
395 bSomethingTested=sal_True;
396 if (sFirstBytes[0]==0x0a)
397 {
398 sal_uInt8 nVersion=sFirstBytes[1];
399 sal_uInt8 nEncoding=sFirstBytes[2];
400 if( ( nVersion==0 || nVersion==2 || nVersion==3 || nVersion==5 ) && nEncoding<=1 )
401 {
402 rFormatExtension = UniString::CreateFromAscii( "PCX", 3 );
403 return sal_True;
404 }
405 }
406 }
407
408 //--------------------------- TIF ------------------------------------
409 if( !bTest || ( rFormatExtension.CompareToAscii( "TIF", 3 ) == COMPARE_EQUAL ) )
410 {
411 bSomethingTested=sal_True;
412 if ( nFirstLong==0x49492a00 || nFirstLong==0x4d4d002a )
413 {
414 rFormatExtension=UniString::CreateFromAscii( "TIF", 3 );
415 return sal_True;
416 }
417 }
418
419 //--------------------------- GIF ------------------------------------
420 if( !bTest || ( rFormatExtension.CompareToAscii( "GIF", 3 ) == COMPARE_EQUAL ) )
421 {
422 bSomethingTested=sal_True;
423 if ( nFirstLong==0x47494638 && (sFirstBytes[4]==0x37 || sFirstBytes[4]==0x39) && sFirstBytes[5]==0x61 )
424 {
425 rFormatExtension = UniString::CreateFromAscii( "GIF", 3 );
426 return sal_True;
427 }
428 }
429
430 //--------------------------- PNG ------------------------------------
431 if( !bTest || ( rFormatExtension.CompareToAscii( "PNG", 3 ) == COMPARE_EQUAL ) )
432 {
433 bSomethingTested=sal_True;
434 if (nFirstLong==0x89504e47 && nSecondLong==0x0d0a1a0a)
435 {
436 rFormatExtension = UniString::CreateFromAscii( "PNG", 3 );
437 return sal_True;
438 }
439 }
440
441 //--------------------------- JPG ------------------------------------
442 if( !bTest || ( rFormatExtension.CompareToAscii( "JPG", 3 ) == COMPARE_EQUAL ) )
443 {
444 bSomethingTested=sal_True;
445 if ( ( nFirstLong==0xffd8ffe0 && sFirstBytes[6]==0x4a && sFirstBytes[7]==0x46 && sFirstBytes[8]==0x49 && sFirstBytes[9]==0x46 ) ||
446 ( nFirstLong==0xffd8fffe ) || ( 0xffd8ff00 == ( nFirstLong & 0xffffff00 ) ) )
447 {
448 rFormatExtension = UniString::CreateFromAscii( "JPG", 3 );
449 return sal_True;
450 }
451 }
452
453 //--------------------------- SVM ------------------------------------
454 if( !bTest || ( rFormatExtension.CompareToAscii( "SVM", 3 ) == COMPARE_EQUAL ) )
455 {
456 bSomethingTested=sal_True;
457 if( nFirstLong==0x53564744 && sFirstBytes[4]==0x49 )
458 {
459 rFormatExtension = UniString::CreateFromAscii( "SVM", 3 );
460 return sal_True;
461 }
462 else if( sFirstBytes[0]==0x56 && sFirstBytes[1]==0x43 && sFirstBytes[2]==0x4C &&
463 sFirstBytes[3]==0x4D && sFirstBytes[4]==0x54 && sFirstBytes[5]==0x46 )
464 {
465 rFormatExtension = UniString::CreateFromAscii( "SVM", 3 );
466 return sal_True;
467 }
468 }
469
470 //--------------------------- PCD ------------------------------------
471 if( !bTest || ( rFormatExtension.CompareToAscii( "PCD", 3 ) == COMPARE_EQUAL ) )
472 {
473 bSomethingTested = sal_True;
474 if( nStreamLen >= 2055 )
475 {
476 char sBuf[8];
477 rStream.Seek( nStreamPos + 2048 );
478 rStream.Read( sBuf, 7 );
479
480 if( strncmp( sBuf, "PCD_IPI", 7 ) == 0 )
481 {
482 rFormatExtension = UniString::CreateFromAscii( "PCD", 3 );
483 return sal_True;
484 }
485 }
486 }
487
488 //--------------------------- PSD ------------------------------------
489 if( !bTest || ( rFormatExtension.CompareToAscii( "PSD", 3 ) == COMPARE_EQUAL ) )
490 {
491 bSomethingTested = sal_True;
492 if ( ( nFirstLong == 0x38425053 ) && ( (nSecondLong >> 16 ) == 1 ) )
493 {
494 rFormatExtension = UniString::CreateFromAscii( "PSD", 3 );
495 return sal_True;
496 }
497 }
498
499 //--------------------------- EPS ------------------------------------
500 if( !bTest || ( rFormatExtension.CompareToAscii( "EPS", 3 ) == COMPARE_EQUAL ) )
501 {
502 bSomethingTested = sal_True;
503 if ( ( nFirstLong == 0xC5D0D3C6 ) || ( ImplSearchEntry( sFirstBytes, (sal_uInt8*)"%!PS-Adobe", 10, 10 ) &&
504 ImplSearchEntry( &sFirstBytes[15], (sal_uInt8*)"EPS", 3, 3 ) ) )
505 {
506 rFormatExtension = UniString::CreateFromAscii( "EPS", 3 );
507 return sal_True;
508 }
509 }
510
511 //--------------------------- DXF ------------------------------------
512 if( !bTest || ( rFormatExtension.CompareToAscii( "DXF", 3 ) == COMPARE_EQUAL ) )
513 {
514 bSomethingTested=sal_True;
515
516 i=0;
517 while (i<256 && sFirstBytes[i]<=32)
518 i++;
519
520 if (i<256)
521 {
522 if( sFirstBytes[i]=='0' )
523 i++;
524 else
525 i=256;
526 }
527 while( i<256 && sFirstBytes[i]<=32 )
528 i++;
529
530 if (i+7<256)
531 {
532 if (strncmp((char*)(sFirstBytes+i),"SECTION",7)==0)
533 {
534 rFormatExtension = UniString::CreateFromAscii( "DXF", 3 );
535 return sal_True;
536 }
537 }
538
539 if( strncmp( (char*) sFirstBytes, "AutoCAD Binary DXF", 18 ) == 0 )
540 {
541 rFormatExtension = UniString::CreateFromAscii( "DXF", 3 );
542 return sal_True;
543 }
544 }
545
546 //--------------------------- PCT ------------------------------------
547 if( !bTest || ( rFormatExtension.CompareToAscii( "PCT", 3 ) == COMPARE_EQUAL ) )
548 {
549 bSomethingTested = sal_True;
550 sal_uInt8 sBuf[3];
551 // store number format
552 sal_uInt16 oldNumberFormat = rStream.GetNumberFormatInt();
553 sal_uInt32 nOffset; // in ms documents the pict format is used without the first 512 bytes
554 for ( nOffset = 0; ( nOffset <= 512 ) && ( ( nStreamPos + nOffset + 14 ) <= nStreamLen ); nOffset += 512 )
555 {
556 short y1,x1,y2,x2;
557 sal_Bool bdBoxOk = sal_True;
558
559 rStream.Seek( nStreamPos + nOffset);
560 // size of the pict in version 1 pict ( 2bytes) : ignored
561 rStream.SeekRel(2);
562 // bounding box (bytes 2 -> 9)
563 rStream.SetNumberFormatInt(NUMBERFORMAT_INT_BIGENDIAN);
564 rStream >> y1 >> x1 >> y2 >> x2;
565 rStream.SetNumberFormatInt(oldNumberFormat); // reset format
566
567 if (x1 > x2 || y1 > y2 || // bad bdbox
568 (x1 == x2 && y1 == y2) || // 1 pixel picture
569 x2-x1 > 2048 || y2-y1 > 2048 ) // picture anormaly big
570 bdBoxOk = sal_False;
571
572 // read version op
573 rStream.Read( sBuf,3 );
574 // see http://developer.apple.com/legacy/mac/library/documentation/mac/pdf/Imaging_With_QuickDraw/Appendix_A.pdf
575 // normal version 2 - page A23 and A24
576 if ( sBuf[ 0 ] == 0x00 && sBuf[ 1 ] == 0x11 && sBuf[ 2 ] == 0x02)
577 {
578 rFormatExtension = UniString::CreateFromAscii( "PCT", 3 );
579 return sal_True;
580 }
581 // normal version 1 - page A25
582 else if (sBuf[ 0 ] == 0x11 && sBuf[ 1 ] == 0x01 && bdBoxOk) {
583 rFormatExtension = UniString::CreateFromAscii( "PCT", 3 );
584 return sal_True;
585 }
586 // previous code kept in order to do not break any compatibility
587 // probably eroneous
588 else if ( sBuf[ 0 ] == 0x00 && sBuf[ 1 ] == 0x11 && sBuf[ 2 ] == 0x01 && bdBoxOk)
589 {
590 rFormatExtension = UniString::CreateFromAscii( "PCT", 3 );
591 return sal_True;
592 }
593 }
594 }
595
596 //------------------------- PBM + PGM + PPM ---------------------------
597 if( !bTest ||
598 ( rFormatExtension.CompareToAscii( "PBM", 3 ) == COMPARE_EQUAL ) ||
599 ( rFormatExtension.CompareToAscii( "PGM", 3 ) == COMPARE_EQUAL ) ||
600 ( rFormatExtension.CompareToAscii( "PPM", 3 ) == COMPARE_EQUAL ) )
601 {
602 bSomethingTested=sal_True;
603 if ( sFirstBytes[ 0 ] == 'P' )
604 {
605 switch( sFirstBytes[ 1 ] )
606 {
607 case '1' :
608 case '4' :
609 rFormatExtension = UniString::CreateFromAscii( "PBM", 3 );
610 return sal_True;
611
612 case '2' :
613 case '5' :
614 rFormatExtension = UniString::CreateFromAscii( "PGM", 3 );
615 return sal_True;
616
617 case '3' :
618 case '6' :
619 rFormatExtension = UniString::CreateFromAscii( "PPM", 3 );
620 return sal_True;
621 }
622 }
623 }
624
625 //--------------------------- RAS( SUN RasterFile )------------------
626 if( !bTest || ( rFormatExtension.CompareToAscii( "RAS", 3 ) == COMPARE_EQUAL ) )
627 {
628 bSomethingTested=sal_True;
629 if( nFirstLong == 0x59a66a95 )
630 {
631 rFormatExtension = UniString::CreateFromAscii( "RAS", 3 );
632 return sal_True;
633 }
634 }
635
636 //--------------------------- XPM ------------------------------------
637 if( !bTest )
638 {
639 bSomethingTested = sal_True;
640 if( ImplSearchEntry( sFirstBytes, (sal_uInt8*)"/* XPM */", 256, 9 ) )
641 {
642 rFormatExtension = UniString::CreateFromAscii( "XPM", 3 );
643 return sal_True;
644 }
645 }
646 else if( rFormatExtension.CompareToAscii( "XPM", 3 ) == COMPARE_EQUAL )
647 {
648 bSomethingTested = sal_True;
649 return sal_True;
650 }
651
652 //--------------------------- XBM ------------------------------------
653 if( !bTest )
654 {
655 sal_uLong nSize = ( nStreamLen > 2048 ) ? 2048 : nStreamLen;
656 sal_uInt8* pBuf = new sal_uInt8 [ nSize ];
657
658 rStream.Seek( nStreamPos );
659 rStream.Read( pBuf, nSize );
660 sal_uInt8* pPtr = ImplSearchEntry( pBuf, (sal_uInt8*)"#define", nSize, 7 );
661
662 if( pPtr )
663 {
664 if( ImplSearchEntry( pPtr, (sal_uInt8*)"_width", pBuf + nSize - pPtr, 6 ) )
665 {
666 rFormatExtension = UniString::CreateFromAscii( "XBM", 3 );
667 delete[] pBuf;
668 return sal_True;
669 }
670 }
671 delete[] pBuf;
672 }
673 else if( rFormatExtension.CompareToAscii( "XBM", 3 ) == COMPARE_EQUAL )
674 {
675 bSomethingTested = sal_True;
676 return sal_True;
677 }
678
679 //--------------------------- SVG ------------------------------------
680 if( !bTest )
681 {
682 // check for Xml
683 if( ImplSearchEntry( sFirstBytes, (sal_uInt8*)"<?xml", 256, 5 ) // is it xml
684 && ImplSearchEntry( sFirstBytes, (sal_uInt8*)"version", 256, 7 )) // does it have a version (required for xml)
685 {
686 bool bIsSvg(false);
687
688 // check for DOCTYPE svg combination
689 if( ImplSearchEntry( sFirstBytes, (sal_uInt8*)"DOCTYPE", 256, 7 ) // 'DOCTYPE' is there
690 && ImplSearchEntry( sFirstBytes, (sal_uInt8*)"svg", 256, 3 )) // 'svg' is there
691 {
692 bIsSvg = true;
693 }
694
695 // check for svg element in 1st 256 bytes
696 if(!bIsSvg && ImplSearchEntry( sFirstBytes, (sal_uInt8*)"<svg", 256, 4 )) // '<svg'
697 {
698 bIsSvg = true;
699 }
700
701 if(!bIsSvg)
702 {
703 // it's a xml, look for '<svg' in full file. Should not happen too
704 // often since the tests above will handle most cases, but can happen
705 // with Svg files containing big comment headers or Svg as the host
706 // language
707 const sal_uLong nSize((nStreamLen > 2048) ? 2048 : nStreamLen);
708 sal_uInt8* pBuf = new sal_uInt8[nSize];
709
710 rStream.Seek(nStreamPos);
711 rStream.Read(pBuf, nSize);
712
713 if(ImplSearchEntry(pBuf, (sal_uInt8*)"<svg", nSize, 4)) // '<svg'
714 {
715 bIsSvg = true;
716 }
717
718 delete[] pBuf;
719 }
720
721 if(bIsSvg)
722 {
723 rFormatExtension = UniString::CreateFromAscii( "SVG", 3 );
724 return sal_True;
725 }
726 }
727 else
728 {
729 // #119176# Svg files which have no xml header at all have shown up,
730 // detect those, too
731 bool bIsSvg(false);
732
733 // check for svg element in 1st 256 bytes
734 if(ImplSearchEntry( sFirstBytes, (sal_uInt8*)"<svg", 256, 4 )) // '<svg'
735 {
736 bIsSvg = true;
737 }
738
739 if(!bIsSvg)
740 {
741 // look for '<svg' in full file. Should not happen too
742 // often since the tests above will handle most cases, but can happen
743 // with Svg files containing big comment headers or Svg as the host
744 // language
745 const sal_uLong nSize((nStreamLen > 2048) ? 2048 : nStreamLen);
746 sal_uInt8* pBuf = new sal_uInt8[nSize];
747
748 rStream.Seek(nStreamPos);
749 rStream.Read(pBuf, nSize);
750
751 if(ImplSearchEntry(pBuf, (sal_uInt8*)"<svg", nSize, 4)) // '<svg'
752 {
753 bIsSvg = true;
754 }
755
756 delete[] pBuf;
757 }
758
759 if(bIsSvg)
760 {
761 rFormatExtension = UniString::CreateFromAscii( "SVG", 3 );
762 return sal_True;
763 }
764 }
765 }
766 else if( rFormatExtension.CompareToAscii( "SVG", 3 ) == COMPARE_EQUAL )
767 {
768 bSomethingTested = sal_True;
769 return sal_True;
770 }
771
772 //--------------------------- TGA ------------------------------------
773 if( !bTest || ( rFormatExtension.CompareToAscii( "TGA", 3 ) == COMPARE_EQUAL ) )
774 {
775 bSomethingTested = sal_True;
776
777 // just a simple test for the extension
778 if( rFormatExtension.CompareToAscii( "TGA", 3 ) == COMPARE_EQUAL )
779 return sal_True;
780 }
781
782 //--------------------------- SGV ------------------------------------
783 if( !bTest || ( rFormatExtension.CompareToAscii( "SGV", 3 ) == COMPARE_EQUAL ) )
784 {
785 bSomethingTested = sal_True;
786
787 // just a simple test for the extension
788 if( rFormatExtension.CompareToAscii( "SGV", 3 ) == COMPARE_EQUAL )
789 return sal_True;
790 }
791
792 //--------------------------- SGF ------------------------------------
793 if( !bTest || ( rFormatExtension.CompareToAscii( "SGF", 3 ) == COMPARE_EQUAL ) )
794 {
795 bSomethingTested=sal_True;
796 if( sFirstBytes[ 0 ] == 'J' && sFirstBytes[ 1 ] == 'J' )
797 {
798 rFormatExtension = UniString::CreateFromAscii( "SGF", 3 );
799 return sal_True;
800 }
801 }
802
803 return bTest && !bSomethingTested;
804 }
805
806 //--------------------------------------------------------------------------
807
ImpTestOrFindFormat(const String & rPath,SvStream & rStream,sal_uInt16 & rFormat)808 sal_uInt16 GraphicFilter::ImpTestOrFindFormat( const String& rPath, SvStream& rStream, sal_uInt16& rFormat )
809 {
810 sal_uInt16 n = pConfig->GetImportFormatCount();
811
812 // ggf. Filter bzw. Format durch anlesen ermitteln,
813 // oder durch anlesen zusichern, dass das Format stimmt:
814 if( rFormat == GRFILTER_FORMAT_DONTKNOW )
815 {
816 String aFormatExt;
817 if( ImpPeekGraphicFormat( rStream, aFormatExt, sal_False ) )
818 {
819 for( sal_uInt16 i = 0; i < n; i++ )
820 {
821 if( pConfig->GetImportFormatExtension( i ).EqualsIgnoreCaseAscii( aFormatExt ) )
822 {
823 rFormat = i;
824 return GRFILTER_OK;
825 }
826 }
827 }
828 // ggf. Filter anhand der Datei-Endung raussuchen:
829 if( rPath.Len() )
830 {
831 String aExt( ImpGetExtension( rPath ) );
832 for( sal_uInt16 i = 0; i < n; i++ )
833 {
834 if( pConfig->GetImportFormatExtension( i ).EqualsIgnoreCaseAscii( aExt ) )
835 {
836 rFormat = i;
837 return GRFILTER_OK;
838 }
839 }
840 }
841 return GRFILTER_FORMATERROR;
842 }
843 else
844 {
845 String aTmpStr( pConfig->GetImportFormatExtension( rFormat ) );
846 if( !ImpPeekGraphicFormat( rStream, aTmpStr, sal_True ) )
847 return GRFILTER_FORMATERROR;
848 if ( pConfig->GetImportFormatExtension( rFormat ).EqualsIgnoreCaseAscii( "pcd" ) )
849 {
850 sal_Int32 nBase = 2; // default Base0
851 if ( pConfig->GetImportFilterType( rFormat ).EqualsIgnoreCaseAscii( "pcd_Photo_CD_Base4" ) )
852 nBase = 1;
853 else if ( pConfig->GetImportFilterType( rFormat ).EqualsIgnoreCaseAscii( "pcd_Photo_CD_Base16" ) )
854 nBase = 0;
855 String aFilterConfigPath( RTL_CONSTASCII_USTRINGPARAM( "Office.Common/Filter/Graphic/Import/PCD" ) );
856 FilterConfigItem aFilterConfigItem( aFilterConfigPath );
857 aFilterConfigItem.WriteInt32( String( RTL_CONSTASCII_USTRINGPARAM( "Resolution" ) ), nBase );
858 }
859 }
860
861 return GRFILTER_OK;
862 }
863
864 //--------------------------------------------------------------------------
865
ImpGetScaledGraphic(const Graphic & rGraphic,FilterConfigItem & rConfigItem)866 static Graphic ImpGetScaledGraphic( const Graphic& rGraphic, FilterConfigItem& rConfigItem )
867 {
868 Graphic aGraphic;
869 ByteString aResMgrName( "svt", 3 );
870 ResMgr* pResMgr;
871
872 pResMgr = ResMgr::CreateResMgr( aResMgrName.GetBuffer(), Application::GetSettings().GetUILocale() );
873
874 sal_Int32 nLogicalWidth = rConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "LogicalWidth" ) ), 0 );
875 sal_Int32 nLogicalHeight = rConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "LogicalHeight" ) ), 0 );
876
877 if ( rGraphic.GetType() != GRAPHIC_NONE )
878 {
879 sal_Int32 nMode = rConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "ExportMode" ) ), -1 );
880
881 if ( nMode == -1 ) // the property is not there, this is possible, if the graphic filter
882 { // is called via UnoGraphicExporter and not from a graphic export Dialog
883 nMode = 0; // then we are defaulting this mode to 0
884 if ( nLogicalWidth || nLogicalHeight )
885 nMode = 2;
886 }
887
888
889 Size aOriginalSize;
890 Size aPrefSize( rGraphic.GetPrefSize() );
891 MapMode aPrefMapMode( rGraphic.GetPrefMapMode() );
892 if ( aPrefMapMode == MAP_PIXEL )
893 aOriginalSize = Application::GetDefaultDevice()->PixelToLogic( aPrefSize, MAP_100TH_MM );
894 else
895 aOriginalSize = Application::GetDefaultDevice()->LogicToLogic( aPrefSize, aPrefMapMode, MAP_100TH_MM );
896 if ( !nLogicalWidth )
897 nLogicalWidth = aOriginalSize.Width();
898 if ( !nLogicalHeight )
899 nLogicalHeight = aOriginalSize.Height();
900 if( rGraphic.GetType() == GRAPHIC_BITMAP )
901 {
902
903 // Aufloesung wird eingestellt
904 if( nMode == 1 )
905 {
906 Bitmap aBitmap( rGraphic.GetBitmap() );
907 MapMode aMap( MAP_100TH_INCH );
908
909 sal_Int32 nDPI = rConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "Resolution" ) ), 75 );
910 Fraction aFrac( 1, Min( Max( nDPI, sal_Int32( 75 ) ), sal_Int32( 600 ) ) );
911
912 aMap.SetScaleX( aFrac );
913 aMap.SetScaleY( aFrac );
914
915 Size aOldSize = aBitmap.GetSizePixel();
916 aGraphic = rGraphic;
917 aGraphic.SetPrefMapMode( aMap );
918 aGraphic.SetPrefSize( Size( aOldSize.Width() * 100,
919 aOldSize.Height() * 100 ) );
920 }
921 // Groesse wird eingestellt
922 else if( nMode == 2 )
923 {
924 aGraphic = rGraphic;
925 aGraphic.SetPrefMapMode( MapMode( MAP_100TH_MM ) );
926 aGraphic.SetPrefSize( Size( nLogicalWidth, nLogicalHeight ) );
927 }
928 else
929 aGraphic = rGraphic;
930
931 sal_Int32 nColors = rConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "Color" ) ), 0 ); // #92767#
932 if ( nColors ) // graphic conversion necessary ?
933 {
934 BitmapEx aBmpEx( aGraphic.GetBitmapEx() );
935 aBmpEx.Convert( (BmpConversion)nColors ); // the entries in the xml section have the same meaning as
936 aGraphic = aBmpEx; // they have in the BmpConversion enum, so it should be
937 } // allowed to cast them
938 }
939 else
940 {
941 if( ( nMode == 1 ) || ( nMode == 2 ) )
942 {
943 GDIMetaFile aMtf( rGraphic.GetGDIMetaFile() );
944 ::com::sun::star::awt::Size aDefaultSize( 10000, 10000 );
945 Size aNewSize( OutputDevice::LogicToLogic( Size( nLogicalWidth, nLogicalHeight ), MAP_100TH_MM, aMtf.GetPrefMapMode() ) );
946
947 if( aNewSize.Width() && aNewSize.Height() )
948 {
949 const Size aPreferredSize( aMtf.GetPrefSize() );
950 aMtf.Scale( Fraction( aNewSize.Width(), aPreferredSize.Width() ),
951 Fraction( aNewSize.Height(), aPreferredSize.Height() ) );
952 }
953 aGraphic = Graphic( aMtf );
954 }
955 else
956 aGraphic = rGraphic;
957 }
958
959 }
960 else
961 aGraphic = rGraphic;
962
963 delete pResMgr;
964
965 return aGraphic;
966 }
967
ImpCreateFullFilterPath(const String & rPath,const String & rFilterName)968 static String ImpCreateFullFilterPath( const String& rPath, const String& rFilterName )
969 {
970 ::rtl::OUString aPathURL;
971
972 ::osl::FileBase::getFileURLFromSystemPath( rPath, aPathURL );
973 aPathURL += String( '/' );
974
975 ::rtl::OUString aSystemPath;
976 ::osl::FileBase::getSystemPathFromFileURL( aPathURL, aSystemPath );
977 aSystemPath += ::rtl::OUString( rFilterName );
978
979 return String( aSystemPath );
980 }
981
982
983 // --------------------------
984 // - ImpFilterLibCacheEntry -
985 // --------------------------
986
987 class ImpFilterLibCache;
988
989 struct ImpFilterLibCacheEntry
990 {
991 ImpFilterLibCacheEntry* mpNext;
992 osl::Module maLibrary;
993 String maFiltername;
994 PFilterCall mpfnImport;
995 PFilterDlgCall mpfnImportDlg;
996
997 ImpFilterLibCacheEntry( const String& rPathname, const String& rFiltername );
operator ==ImpFilterLibCacheEntry998 int operator==( const String& rFiltername ) const { return maFiltername == rFiltername; }
999
1000 PFilterCall GetImportFunction();
1001 PFilterDlgCall GetImportDlgFunction();
GetExportFunctionImpFilterLibCacheEntry1002 PFilterCall GetExportFunction() { return (PFilterCall) maLibrary.getFunctionSymbol( UniString::CreateFromAscii( EXPORT_FUNCTION_NAME ) ); }
GetExportDlgFunctionImpFilterLibCacheEntry1003 PFilterDlgCall GetExportDlgFunction() { return (PFilterDlgCall) maLibrary.getFunctionSymbol( UniString::CreateFromAscii( EXPDLG_FUNCTION_NAME ) ); }
1004 };
1005
1006 // ------------------------------------------------------------------------
1007
ImpFilterLibCacheEntry(const String & rPathname,const String & rFiltername)1008 ImpFilterLibCacheEntry::ImpFilterLibCacheEntry( const String& rPathname, const String& rFiltername ) :
1009 mpNext ( NULL ),
1010 maLibrary ( rPathname ),
1011 maFiltername ( rFiltername ),
1012 mpfnImport ( NULL ),
1013 mpfnImportDlg ( NULL )
1014 {
1015 }
1016
1017 // ------------------------------------------------------------------------
1018
GetImportFunction()1019 PFilterCall ImpFilterLibCacheEntry::GetImportFunction()
1020 {
1021 if( !mpfnImport )
1022 mpfnImport = (PFilterCall) maLibrary.getFunctionSymbol( UniString::CreateFromAscii( IMPORT_FUNCTION_NAME ) );
1023
1024 return mpfnImport;
1025 }
1026
1027 // ------------------------------------------------------------------------
1028
GetImportDlgFunction()1029 PFilterDlgCall ImpFilterLibCacheEntry::GetImportDlgFunction()
1030 {
1031 if( !mpfnImportDlg )
1032 mpfnImportDlg = (PFilterDlgCall)maLibrary.getFunctionSymbol( UniString::CreateFromAscii( IMPDLG_FUNCTION_NAME ) );
1033
1034 return mpfnImportDlg;
1035 }
1036
1037 // ---------------------
1038 // - ImpFilterLibCache -
1039 // ---------------------
1040
1041 class ImpFilterLibCache
1042 {
1043 ImpFilterLibCacheEntry* mpFirst;
1044 ImpFilterLibCacheEntry* mpLast;
1045
1046 public:
1047 ImpFilterLibCache();
1048 ~ImpFilterLibCache();
1049
1050 ImpFilterLibCacheEntry* GetFilter( const String& rFilterPath, const String& rFiltername );
1051 };
1052
1053 // ------------------------------------------------------------------------
1054
ImpFilterLibCache()1055 ImpFilterLibCache::ImpFilterLibCache() :
1056 mpFirst ( NULL ),
1057 mpLast ( NULL )
1058 {
1059 }
1060
1061 // ------------------------------------------------------------------------
1062
~ImpFilterLibCache()1063 ImpFilterLibCache::~ImpFilterLibCache()
1064 {
1065 ImpFilterLibCacheEntry* pEntry = mpFirst;
1066 while( pEntry )
1067 {
1068 ImpFilterLibCacheEntry* pNext = pEntry->mpNext;
1069 delete pEntry;
1070 pEntry = pNext;
1071 }
1072 }
1073
1074 // ------------------------------------------------------------------------
1075
GetFilter(const String & rFilterPath,const String & rFilterName)1076 ImpFilterLibCacheEntry* ImpFilterLibCache::GetFilter( const String& rFilterPath, const String& rFilterName )
1077 {
1078 ImpFilterLibCacheEntry* pEntry = mpFirst;
1079
1080 while( pEntry )
1081 {
1082 if( *pEntry == rFilterName )
1083 break;
1084 else
1085 pEntry = pEntry->mpNext;
1086 }
1087 if( !pEntry )
1088 {
1089 String aPhysicalName( ImpCreateFullFilterPath( rFilterPath, rFilterName ) );
1090 pEntry = new ImpFilterLibCacheEntry( aPhysicalName, rFilterName );
1091
1092 if ( pEntry->maLibrary.is() )
1093 {
1094 if( !mpFirst )
1095 mpFirst = mpLast = pEntry;
1096 else
1097 mpLast = mpLast->mpNext = pEntry;
1098 }
1099 else
1100 {
1101 delete pEntry;
1102 pEntry = NULL;
1103 }
1104 }
1105 return pEntry;
1106 };
1107
1108 // ------------------------------------------------------------------------
1109
1110 namespace { struct Cache : public rtl::Static<ImpFilterLibCache, Cache> {}; }
1111
1112 // -----------------
1113 // - GraphicFilter -
1114 // -----------------
1115
GraphicFilter(sal_Bool bConfig)1116 GraphicFilter::GraphicFilter( sal_Bool bConfig ) :
1117 bUseConfig ( bConfig ),
1118 nExpGraphHint ( 0 )
1119 {
1120 ImplInit();
1121 }
1122
1123 // ------------------------------------------------------------------------
1124
~GraphicFilter()1125 GraphicFilter::~GraphicFilter()
1126 {
1127 {
1128 ::osl::MutexGuard aGuard( getListMutex() );
1129 pFilterHdlList->Remove( (void*)this );
1130 if ( !pFilterHdlList->Count() )
1131 {
1132 delete pFilterHdlList, pFilterHdlList = NULL;
1133 delete pConfig;
1134 }
1135 }
1136
1137
1138 delete pErrorEx;
1139 }
1140
1141 // ------------------------------------------------------------------------
1142
ImplInit()1143 void GraphicFilter::ImplInit()
1144 {
1145 {
1146 ::osl::MutexGuard aGuard( getListMutex() );
1147
1148 if ( !pFilterHdlList )
1149 {
1150 pFilterHdlList = new List;
1151 pConfig = new FilterConfigCache( bUseConfig );
1152 }
1153 else
1154 pConfig = ((GraphicFilter*)pFilterHdlList->First())->pConfig;
1155
1156 pFilterHdlList->Insert( (void*)this );
1157 }
1158
1159 if( bUseConfig )
1160 {
1161 rtl::OUString url(RTL_CONSTASCII_USTRINGPARAM("$OOO_BASE_DIR/program"));
1162 rtl::Bootstrap::expandMacros(url); //TODO: detect failure
1163 utl::LocalFileHelper::ConvertURLToPhysicalName(url, aFilterPath);
1164 }
1165
1166 pErrorEx = new FilterErrorEx;
1167 bAbort = sal_False;
1168 }
1169
1170 // ------------------------------------------------------------------------
1171
ImplSetError(sal_uLong nError,const SvStream * pStm)1172 sal_uLong GraphicFilter::ImplSetError( sal_uLong nError, const SvStream* pStm )
1173 {
1174 pErrorEx->nFilterError = nError;
1175 pErrorEx->nStreamError = pStm ? pStm->GetError() : ERRCODE_NONE;
1176 return nError;
1177 }
1178 // ------------------------------------------------------------------------
1179
GetImportFormatCount()1180 sal_uInt16 GraphicFilter::GetImportFormatCount()
1181 {
1182 return pConfig->GetImportFormatCount();
1183 }
1184
1185 // ------------------------------------------------------------------------
1186
GetImportFormatNumber(const String & rFormatName)1187 sal_uInt16 GraphicFilter::GetImportFormatNumber( const String& rFormatName )
1188 {
1189 return pConfig->GetImportFormatNumber( rFormatName );
1190 }
1191
1192 // ------------------------------------------------------------------------
1193
GetImportFormatNumberForMediaType(const String & rMediaType)1194 sal_uInt16 GraphicFilter::GetImportFormatNumberForMediaType( const String& rMediaType )
1195 {
1196 return pConfig->GetImportFormatNumberForMediaType( rMediaType );
1197 }
1198
1199 // ------------------------------------------------------------------------
1200
GetImportFormatNumberForShortName(const String & rShortName)1201 sal_uInt16 GraphicFilter::GetImportFormatNumberForShortName( const String& rShortName )
1202 {
1203 return pConfig->GetImportFormatNumberForShortName( rShortName );
1204 }
1205
1206 // ------------------------------------------------------------------------
1207
GetImportFormatNumberForTypeName(const String & rType)1208 sal_uInt16 GraphicFilter::GetImportFormatNumberForTypeName( const String& rType )
1209 {
1210 return pConfig->GetImportFormatNumberForTypeName( rType );
1211 }
1212
1213 // ------------------------------------------------------------------------
1214
GetImportFormatName(sal_uInt16 nFormat)1215 String GraphicFilter::GetImportFormatName( sal_uInt16 nFormat )
1216 {
1217 return pConfig->GetImportFormatName( nFormat );
1218 }
1219
1220 // ------------------------------------------------------------------------
1221
GetImportFormatTypeName(sal_uInt16 nFormat)1222 String GraphicFilter::GetImportFormatTypeName( sal_uInt16 nFormat )
1223 {
1224 return pConfig->GetImportFilterTypeName( nFormat );
1225 }
1226
1227 // ------------------------------------------------------------------------
1228
GetImportFormatMediaType(sal_uInt16 nFormat)1229 String GraphicFilter::GetImportFormatMediaType( sal_uInt16 nFormat )
1230 {
1231 return pConfig->GetImportFormatMediaType( nFormat );
1232 }
1233
1234 // ------------------------------------------------------------------------
1235
GetImportFormatShortName(sal_uInt16 nFormat)1236 String GraphicFilter::GetImportFormatShortName( sal_uInt16 nFormat )
1237 {
1238 return pConfig->GetImportFormatShortName( nFormat );
1239 }
1240
1241 // ------------------------------------------------------------------------
1242
GetImportOSFileType(sal_uInt16)1243 String GraphicFilter::GetImportOSFileType( sal_uInt16 )
1244 {
1245 String aOSFileType;
1246 return aOSFileType;
1247 }
1248
1249 // ------------------------------------------------------------------------
1250
GetImportWildcard(sal_uInt16 nFormat,sal_Int32 nEntry)1251 String GraphicFilter::GetImportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
1252 {
1253 return pConfig->GetImportWildcard( nFormat, nEntry );
1254 }
1255
1256 // ------------------------------------------------------------------------
1257
IsImportPixelFormat(sal_uInt16 nFormat)1258 sal_Bool GraphicFilter::IsImportPixelFormat( sal_uInt16 nFormat )
1259 {
1260 return pConfig->IsImportPixelFormat( nFormat );
1261 }
1262
1263 // ------------------------------------------------------------------------
1264
GetExportFormatCount()1265 sal_uInt16 GraphicFilter::GetExportFormatCount()
1266 {
1267 return pConfig->GetExportFormatCount();
1268 }
1269
1270 // ------------------------------------------------------------------------
1271
GetExportFormatNumber(const String & rFormatName)1272 sal_uInt16 GraphicFilter::GetExportFormatNumber( const String& rFormatName )
1273 {
1274 return pConfig->GetExportFormatNumber( rFormatName );
1275 }
1276
1277 // ------------------------------------------------------------------------
1278
GetExportFormatNumberForMediaType(const String & rMediaType)1279 sal_uInt16 GraphicFilter::GetExportFormatNumberForMediaType( const String& rMediaType )
1280 {
1281 return pConfig->GetExportFormatNumberForMediaType( rMediaType );
1282 }
1283
1284 // ------------------------------------------------------------------------
1285
GetExportFormatNumberForShortName(const String & rShortName)1286 sal_uInt16 GraphicFilter::GetExportFormatNumberForShortName( const String& rShortName )
1287 {
1288 return pConfig->GetExportFormatNumberForShortName( rShortName );
1289 }
1290
1291 // ------------------------------------------------------------------------
1292
GetExportFormatNumberForTypeName(const String & rType)1293 sal_uInt16 GraphicFilter::GetExportFormatNumberForTypeName( const String& rType )
1294 {
1295 return pConfig->GetExportFormatNumberForTypeName( rType );
1296 }
1297
1298 // ------------------------------------------------------------------------
1299
GetExportFormatName(sal_uInt16 nFormat)1300 String GraphicFilter::GetExportFormatName( sal_uInt16 nFormat )
1301 {
1302 return pConfig->GetExportFormatName( nFormat );
1303 }
1304
1305 // ------------------------------------------------------------------------
1306
GetExportFormatTypeName(sal_uInt16 nFormat)1307 String GraphicFilter::GetExportFormatTypeName( sal_uInt16 nFormat )
1308 {
1309 return pConfig->GetExportFilterTypeName( nFormat );
1310 }
1311
1312 // ------------------------------------------------------------------------
1313
GetExportFormatMediaType(sal_uInt16 nFormat)1314 String GraphicFilter::GetExportFormatMediaType( sal_uInt16 nFormat )
1315 {
1316 return pConfig->GetExportFormatMediaType( nFormat );
1317 }
1318
1319 // ------------------------------------------------------------------------
1320
GetExportFormatShortName(sal_uInt16 nFormat)1321 String GraphicFilter::GetExportFormatShortName( sal_uInt16 nFormat )
1322 {
1323 return pConfig->GetExportFormatShortName( nFormat );
1324 }
1325
1326 // ------------------------------------------------------------------------
1327
GetExportOSFileType(sal_uInt16)1328 String GraphicFilter::GetExportOSFileType( sal_uInt16 )
1329 {
1330 String aOSFileType;
1331 return aOSFileType;
1332 }
1333
1334 // ------------------------------------------------------------------------
1335
GetExportWildcard(sal_uInt16 nFormat,sal_Int32 nEntry)1336 String GraphicFilter::GetExportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry )
1337 {
1338 return pConfig->GetExportWildcard( nFormat, nEntry );
1339 }
1340
1341 // ------------------------------------------------------------------------
1342
IsExportPixelFormat(sal_uInt16 nFormat)1343 sal_Bool GraphicFilter::IsExportPixelFormat( sal_uInt16 nFormat )
1344 {
1345 return pConfig->IsExportPixelFormat( nFormat );
1346 }
1347
1348 // ------------------------------------------------------------------------
1349
CanImportGraphic(const INetURLObject & rPath,sal_uInt16 nFormat,sal_uInt16 * pDeterminedFormat)1350 sal_uInt16 GraphicFilter::CanImportGraphic( const INetURLObject& rPath,
1351 sal_uInt16 nFormat, sal_uInt16* pDeterminedFormat )
1352 {
1353 sal_uInt16 nRetValue = GRFILTER_FORMATERROR;
1354 DBG_ASSERT( rPath.GetProtocol() != INET_PROT_NOT_VALID, "GraphicFilter::CanImportGraphic() : ProtType == INET_PROT_NOT_VALID" );
1355
1356 String aMainUrl( rPath.GetMainURL( INetURLObject::NO_DECODE ) );
1357 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aMainUrl, STREAM_READ | STREAM_SHARE_DENYNONE );
1358 if ( pStream )
1359 {
1360 nRetValue = CanImportGraphic( aMainUrl, *pStream, nFormat, pDeterminedFormat );
1361 delete pStream;
1362 }
1363 return nRetValue;
1364 }
1365
1366 // ------------------------------------------------------------------------
1367
CanImportGraphic(const String & rMainUrl,SvStream & rIStream,sal_uInt16 nFormat,sal_uInt16 * pDeterminedFormat)1368 sal_uInt16 GraphicFilter::CanImportGraphic( const String& rMainUrl, SvStream& rIStream,
1369 sal_uInt16 nFormat, sal_uInt16* pDeterminedFormat )
1370 {
1371 sal_uLong nStreamPos = rIStream.Tell();
1372 sal_uInt16 nRes = ImpTestOrFindFormat( rMainUrl, rIStream, nFormat );
1373
1374 rIStream.Seek(nStreamPos);
1375
1376 if( nRes==GRFILTER_OK && pDeterminedFormat!=NULL )
1377 *pDeterminedFormat = nFormat;
1378
1379 return (sal_uInt16) ImplSetError( nRes, &rIStream );
1380 }
1381
1382 // ------------------------------------------------------------------------
1383 //SJ: TODO, we need to create a GraphicImporter component
ImportGraphic(Graphic & rGraphic,const INetURLObject & rPath,sal_uInt16 nFormat,sal_uInt16 * pDeterminedFormat,sal_uInt32 nImportFlags)1384 sal_uInt16 GraphicFilter::ImportGraphic( Graphic& rGraphic, const INetURLObject& rPath,
1385 sal_uInt16 nFormat, sal_uInt16 * pDeterminedFormat, sal_uInt32 nImportFlags )
1386 {
1387 sal_uInt16 nRetValue = GRFILTER_FORMATERROR;
1388 DBG_ASSERT( rPath.GetProtocol() != INET_PROT_NOT_VALID, "GraphicFilter::ImportGraphic() : ProtType == INET_PROT_NOT_VALID" );
1389
1390 String aMainUrl( rPath.GetMainURL( INetURLObject::NO_DECODE ) );
1391 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aMainUrl, STREAM_READ | STREAM_SHARE_DENYNONE );
1392 if ( pStream )
1393 {
1394 nRetValue = ImportGraphic( rGraphic, aMainUrl, *pStream, nFormat, pDeterminedFormat, nImportFlags );
1395 delete pStream;
1396 }
1397 return nRetValue;
1398 }
1399
ImportGraphic(Graphic & rGraphic,const String & rPath,SvStream & rIStream,sal_uInt16 nFormat,sal_uInt16 * pDeterminedFormat,sal_uInt32 nImportFlags)1400 sal_uInt16 GraphicFilter::ImportGraphic( Graphic& rGraphic, const String& rPath, SvStream& rIStream,
1401 sal_uInt16 nFormat, sal_uInt16* pDeterminedFormat, sal_uInt32 nImportFlags )
1402 {
1403 return ImportGraphic( rGraphic, rPath, rIStream, nFormat, pDeterminedFormat, nImportFlags, NULL );
1404 }
1405
1406 //-------------------------------------------------------------------------
1407
ImportGraphic(Graphic & rGraphic,const String & rPath,SvStream & rIStream,sal_uInt16 nFormat,sal_uInt16 * pDeterminedFormat,sal_uInt32 nImportFlags,com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue> * pFilterData)1408 sal_uInt16 GraphicFilter::ImportGraphic( Graphic& rGraphic, const String& rPath, SvStream& rIStream,
1409 sal_uInt16 nFormat, sal_uInt16* pDeterminedFormat, sal_uInt32 nImportFlags,
1410 com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >* pFilterData )
1411 {
1412 String aFilterName;
1413 sal_uLong nStmBegin;
1414 sal_uInt16 nStatus;
1415 GraphicReader* pContext = rGraphic.GetContext();
1416 GfxLinkType eLinkType = GFX_LINK_TYPE_NONE;
1417 sal_Bool bDummyContext = ( pContext == (GraphicReader*) 1 );
1418 const sal_Bool bLinkSet = rGraphic.IsLink();
1419 FilterConfigItem* pFilterConfigItem = NULL;
1420
1421 Size aPreviewSizeHint( 0, 0 );
1422 sal_Bool bAllowPartialStreamRead = sal_False;
1423 sal_Bool bCreateNativeLink = sal_True;
1424
1425 ResetLastError();
1426
1427 if ( pFilterData )
1428 {
1429 sal_Int32 i;
1430 for ( i = 0; i < pFilterData->getLength(); i++ )
1431 {
1432 if ( (*pFilterData)[ i ].Name.equalsAscii( "PreviewSizeHint" ) )
1433 {
1434 awt::Size aSize;
1435 if ( (*pFilterData)[ i ].Value >>= aSize )
1436 {
1437 aPreviewSizeHint = Size( aSize.Width, aSize.Height );
1438 if ( aSize.Width || aSize.Height )
1439 nImportFlags |= GRFILTER_I_FLAGS_FOR_PREVIEW;
1440 else
1441 nImportFlags &=~GRFILTER_I_FLAGS_FOR_PREVIEW;
1442 }
1443 }
1444 else if ( (*pFilterData)[ i ].Name.equalsAscii( "AllowPartialStreamRead" ) )
1445 {
1446 (*pFilterData)[ i ].Value >>= bAllowPartialStreamRead;
1447 if ( bAllowPartialStreamRead )
1448 nImportFlags |= GRFILTER_I_FLAGS_ALLOW_PARTIAL_STREAMREAD;
1449 else
1450 nImportFlags &=~GRFILTER_I_FLAGS_ALLOW_PARTIAL_STREAMREAD;
1451 }
1452 else if ( (*pFilterData)[ i ].Name.equalsAscii( "CreateNativeLink" ) )
1453 {
1454 (*pFilterData)[ i ].Value >>= bCreateNativeLink;
1455 }
1456 }
1457 }
1458
1459 if( !pContext || bDummyContext )
1460 {
1461 if( bDummyContext )
1462 {
1463 rGraphic.SetContext( NULL );
1464 nStmBegin = 0;
1465 }
1466 else
1467 nStmBegin = rIStream.Tell();
1468
1469 bAbort = sal_False;
1470 nStatus = ImpTestOrFindFormat( rPath, rIStream, nFormat );
1471 // Falls Pending, geben wir GRFILTER_OK zurueck,
1472 // um mehr Bytes anzufordern
1473 if( rIStream.GetError() == ERRCODE_IO_PENDING )
1474 {
1475 rGraphic.SetContext( (GraphicReader*) 1 );
1476 rIStream.ResetError();
1477 rIStream.Seek( nStmBegin );
1478 return (sal_uInt16) ImplSetError( GRFILTER_OK );
1479 }
1480
1481 rIStream.Seek( nStmBegin );
1482
1483 if( ( nStatus != GRFILTER_OK ) || rIStream.GetError() )
1484 return (sal_uInt16) ImplSetError( ( nStatus != GRFILTER_OK ) ? nStatus : GRFILTER_OPENERROR, &rIStream );
1485
1486 if( pDeterminedFormat )
1487 *pDeterminedFormat = nFormat;
1488
1489 aFilterName = pConfig->GetImportFilterName( nFormat );
1490 }
1491 else
1492 {
1493 if( pContext && !bDummyContext )
1494 aFilterName = pContext->GetUpperFilterName();
1495
1496 nStmBegin = 0;
1497 nStatus = GRFILTER_OK;
1498 }
1499
1500 // read graphic
1501 if ( pConfig->IsImportInternalFilter( nFormat ) )
1502 {
1503 if( aFilterName.EqualsIgnoreCaseAscii( IMP_GIF ) )
1504 {
1505 if( rGraphic.GetContext() == (GraphicReader*) 1 )
1506 rGraphic.SetContext( NULL );
1507
1508 if( !ImportGIF( rIStream, rGraphic ) )
1509 nStatus = GRFILTER_FILTERERROR;
1510 else
1511 eLinkType = GFX_LINK_TYPE_NATIVE_GIF;
1512 }
1513 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_PNG ) )
1514 {
1515 if ( rGraphic.GetContext() == (GraphicReader*) 1 )
1516 rGraphic.SetContext( NULL );
1517
1518 vcl::PNGReader aPNGReader( rIStream );
1519
1520 // ignore animation for previews and set preview size
1521 if( aPreviewSizeHint.Width() || aPreviewSizeHint.Height() )
1522 {
1523 // position the stream at the end of the image if requested
1524 if( !bAllowPartialStreamRead )
1525 aPNGReader.GetChunks();
1526 }
1527 else
1528 {
1529 // check if this PNG contains a GIF chunk!
1530 const std::vector< vcl::PNGReader::ChunkData >& rChunkData = aPNGReader.GetChunks();
1531 std::vector< vcl::PNGReader::ChunkData >::const_iterator aIter( rChunkData.begin() );
1532 std::vector< vcl::PNGReader::ChunkData >::const_iterator aEnd ( rChunkData.end() );
1533 while( aIter != aEnd )
1534 {
1535 // Microsoft Office is storing Animated GIFs in following chunk
1536 if ( aIter->nType == PMGCHUNG_msOG )
1537 {
1538 sal_uInt32 nChunkSize = aIter->aData.size();
1539 if ( nChunkSize > 11 )
1540 {
1541 const std::vector< sal_uInt8 >& rData = aIter->aData;
1542 SvMemoryStream aIStrm( (void*)&rData[ 11 ], nChunkSize - 11, STREAM_READ );
1543 ImportGIF( aIStrm, rGraphic );
1544 eLinkType = GFX_LINK_TYPE_NATIVE_PNG;
1545 break;
1546 }
1547 }
1548 aIter++;
1549 }
1550 }
1551
1552 if ( eLinkType == GFX_LINK_TYPE_NONE )
1553 {
1554 BitmapEx aBmpEx( aPNGReader.Read( aPreviewSizeHint ) );
1555 if ( aBmpEx.IsEmpty() )
1556 nStatus = GRFILTER_FILTERERROR;
1557 else
1558 {
1559 rGraphic = aBmpEx;
1560 eLinkType = GFX_LINK_TYPE_NATIVE_PNG;
1561 }
1562 }
1563 }
1564 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_JPEG ) )
1565 {
1566 if( rGraphic.GetContext() == (GraphicReader*) 1 )
1567 rGraphic.SetContext( NULL );
1568
1569 // set LOGSIZE flag always, if not explicitly disabled
1570 // (see #90508 and #106763)
1571 if( 0 == ( nImportFlags & GRFILTER_I_FLAGS_DONT_SET_LOGSIZE_FOR_JPEG ) )
1572 nImportFlags |= GRFILTER_I_FLAGS_SET_LOGSIZE_FOR_JPEG;
1573
1574 if( !ImportJPEG( rIStream, rGraphic, NULL, nImportFlags ) )
1575 nStatus = GRFILTER_FILTERERROR;
1576 else
1577 eLinkType = GFX_LINK_TYPE_NATIVE_JPG;
1578 }
1579 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_SVG ) )
1580 {
1581 if( rGraphic.GetContext() == (GraphicReader*) 1 )
1582 rGraphic.SetContext( NULL );
1583
1584 const sal_uInt32 nStmPos(rIStream.Tell());
1585 const sal_uInt32 nStmLen(rIStream.Seek(STREAM_SEEK_TO_END) - nStmPos);
1586 bool bOkay(false);
1587
1588 if(nStmLen)
1589 {
1590 SvgDataArray aNewData(new sal_uInt8[nStmLen]);
1591
1592 rIStream.Seek(nStmPos);
1593 rIStream.Read(aNewData.get(), nStmLen);
1594
1595 if(!rIStream.GetError())
1596 {
1597 SvgDataPtr aSvgDataPtr(
1598 new SvgData(
1599 aNewData,
1600 nStmLen,
1601 rPath));
1602
1603 rGraphic = Graphic(aSvgDataPtr);
1604 bOkay = true;
1605 }
1606 }
1607
1608 if(bOkay)
1609 {
1610 eLinkType = GFX_LINK_TYPE_NATIVE_SVG;
1611 }
1612 else
1613 {
1614 nStatus = GRFILTER_FILTERERROR;
1615 }
1616 }
1617 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_XBM ) )
1618 {
1619 if( rGraphic.GetContext() == (GraphicReader*) 1 )
1620 rGraphic.SetContext( NULL );
1621
1622 if( !ImportXBM( rIStream, rGraphic ) )
1623 nStatus = GRFILTER_FILTERERROR;
1624 }
1625 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_XPM ) )
1626 {
1627 if( rGraphic.GetContext() == (GraphicReader*) 1 )
1628 rGraphic.SetContext( NULL );
1629
1630 if( !ImportXPM( rIStream, rGraphic ) )
1631 nStatus = GRFILTER_FILTERERROR;
1632 }
1633 else if ( aFilterName.EqualsIgnoreCaseAscii( IMP_BMP )
1634 || aFilterName.EqualsIgnoreCaseAscii( IMP_SVMETAFILE ) )
1635 {
1636 // SV interne Importfilter fuer Bitmaps und MetaFiles
1637 rIStream >> rGraphic;
1638
1639 if( rIStream.GetError() )
1640 {
1641 nStatus = GRFILTER_FORMATERROR;
1642 }
1643 else
1644 {
1645 if ( aFilterName.EqualsIgnoreCaseAscii( IMP_BMP ) )
1646 {
1647 // #15508# added BMP type (checked, works)
1648 eLinkType = GFX_LINK_TYPE_NATIVE_BMP;
1649 }
1650 }
1651 }
1652 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_WMF ) ||
1653 aFilterName.EqualsIgnoreCaseAscii( IMP_EMF ) )
1654 {
1655 GDIMetaFile aMtf;
1656 if( !ConvertWMFToGDIMetaFile( rIStream, aMtf, NULL ) )
1657 nStatus = GRFILTER_FORMATERROR;
1658 else
1659 {
1660 rGraphic = aMtf;
1661 eLinkType = GFX_LINK_TYPE_NATIVE_WMF;
1662 }
1663 }
1664 else if( aFilterName.EqualsIgnoreCaseAscii( IMP_SVSGF )
1665 || aFilterName.EqualsIgnoreCaseAscii( IMP_SVSGV ) )
1666 {
1667 sal_uInt16 nVersion;
1668 unsigned char nTyp = CheckSgfTyp( rIStream, nVersion );
1669
1670 switch( nTyp )
1671 {
1672 case SGF_BITIMAGE:
1673 {
1674 SvMemoryStream aTempStream;
1675 if( aTempStream.GetError() )
1676 return GRFILTER_OPENERROR;
1677
1678 if( !SgfBMapFilter( rIStream, aTempStream ) )
1679 nStatus = GRFILTER_FILTERERROR;
1680 else
1681 {
1682 aTempStream.Seek( 0L );
1683 aTempStream >> rGraphic;
1684
1685 if( aTempStream.GetError() )
1686 nStatus = GRFILTER_FILTERERROR;
1687 }
1688 }
1689 break;
1690
1691 case SGF_SIMPVECT:
1692 {
1693 GDIMetaFile aMtf;
1694 if( !SgfVectFilter( rIStream, aMtf ) )
1695 nStatus = GRFILTER_FILTERERROR;
1696 else
1697 rGraphic = Graphic( aMtf );
1698 }
1699 break;
1700
1701 case SGF_STARDRAW:
1702 {
1703 if( nVersion != SGV_VERSION )
1704 nStatus = GRFILTER_VERSIONERROR;
1705 else
1706 {
1707 GDIMetaFile aMtf;
1708 if( !SgfSDrwFilter( rIStream, aMtf,
1709 INetURLObject(aFilterPath) ) )
1710 {
1711 nStatus = GRFILTER_FILTERERROR;
1712 }
1713 else
1714 rGraphic = Graphic( aMtf );
1715 }
1716 }
1717 break;
1718
1719 default:
1720 {
1721 nStatus = GRFILTER_FORMATERROR;
1722 }
1723 break;
1724 }
1725 }
1726 else
1727 nStatus = GRFILTER_FILTERERROR;
1728 }
1729 else
1730 {
1731 ImpFilterLibCacheEntry* pFilter = NULL;
1732
1733 // find first filter in filter pathes
1734 xub_StrLen i, nTokenCount = aFilterPath.GetTokenCount( ';' );
1735 ImpFilterLibCache &rCache = Cache::get();
1736 for( i = 0; ( i < nTokenCount ) && ( pFilter == NULL ); i++ )
1737 pFilter = rCache.GetFilter( aFilterPath.GetToken(i), aFilterName );
1738 if( !pFilter )
1739 nStatus = GRFILTER_FILTERERROR;
1740 else
1741 {
1742 PFilterCall pFunc = pFilter->GetImportFunction();
1743
1744 if( !pFunc )
1745 nStatus = GRFILTER_FILTERERROR;
1746 else
1747 {
1748 String aShortName;
1749 if( nFormat != GRFILTER_FORMAT_DONTKNOW )
1750 {
1751 aShortName = GetImportFormatShortName( nFormat ).ToUpperAscii();
1752 if ( ( pFilterConfigItem == NULL ) && aShortName.EqualsAscii( "PCD" ) )
1753 {
1754 String aFilterConfigPath( RTL_CONSTASCII_USTRINGPARAM( "Office.Common/Filter/Graphic/Import/PCD" ) );
1755 pFilterConfigItem = new FilterConfigItem( aFilterConfigPath );
1756 }
1757 }
1758 if( !(*pFunc)( rIStream, rGraphic, pFilterConfigItem, sal_False ) )
1759 nStatus = GRFILTER_FORMATERROR;
1760 else
1761 {
1762 // try to set link type if format matches
1763 if( nFormat != GRFILTER_FORMAT_DONTKNOW )
1764 {
1765 if( aShortName.CompareToAscii( TIF_SHORTNAME ) == COMPARE_EQUAL )
1766 eLinkType = GFX_LINK_TYPE_NATIVE_TIF;
1767 else if( aShortName.CompareToAscii( MET_SHORTNAME ) == COMPARE_EQUAL )
1768 eLinkType = GFX_LINK_TYPE_NATIVE_MET;
1769 else if( aShortName.CompareToAscii( PCT_SHORTNAME ) == COMPARE_EQUAL )
1770 eLinkType = GFX_LINK_TYPE_NATIVE_PCT;
1771 }
1772 }
1773 }
1774 }
1775 }
1776
1777 if( nStatus == GRFILTER_OK && bCreateNativeLink && ( eLinkType != GFX_LINK_TYPE_NONE ) && !rGraphic.GetContext() && !bLinkSet )
1778 {
1779 const sal_uLong nStmEnd = rIStream.Tell();
1780 const sal_uLong nBufSize = nStmEnd - nStmBegin;
1781
1782 if( nBufSize )
1783 {
1784 sal_uInt8* pBuf=0;
1785 try
1786 {
1787 pBuf = new sal_uInt8[ nBufSize ];
1788 }
1789 catch (std::bad_alloc)
1790 {
1791 nStatus = GRFILTER_TOOBIG;
1792 }
1793
1794 if( nStatus == GRFILTER_OK )
1795 {
1796 rIStream.Seek( nStmBegin );
1797 rIStream.Read( pBuf, nBufSize );
1798 rGraphic.SetLink( GfxLink( pBuf, nBufSize, eLinkType, sal_True ) );
1799 }
1800 }
1801 }
1802
1803 // Set error code or try to set native buffer
1804 if( nStatus != GRFILTER_OK )
1805 {
1806 if( bAbort )
1807 nStatus = GRFILTER_ABORT;
1808
1809 ImplSetError( nStatus, &rIStream );
1810 rIStream.Seek( nStmBegin );
1811 rGraphic.Clear();
1812 }
1813
1814 delete pFilterConfigItem;
1815 return nStatus;
1816 }
1817
1818
1819 // ------------------------------------------------------------------------
1820
ExportGraphic(const Graphic & rGraphic,const INetURLObject & rPath,sal_uInt16 nFormat,const uno::Sequence<beans::PropertyValue> * pFilterData)1821 sal_uInt16 GraphicFilter::ExportGraphic( const Graphic& rGraphic, const INetURLObject& rPath,
1822 sal_uInt16 nFormat, const uno::Sequence< beans::PropertyValue >* pFilterData )
1823 {
1824 sal_uInt16 nRetValue = GRFILTER_FORMATERROR;
1825 DBG_ASSERT( rPath.GetProtocol() != INET_PROT_NOT_VALID, "GraphicFilter::ExportGraphic() : ProtType == INET_PROT_NOT_VALID" );
1826 sal_Bool bAlreadyExists = ImplDirEntryHelper::Exists( rPath );
1827
1828 String aMainUrl( rPath.GetMainURL( INetURLObject::NO_DECODE ) );
1829 SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aMainUrl, STREAM_WRITE | STREAM_TRUNC );
1830 if ( pStream )
1831 {
1832 nRetValue = ExportGraphic( rGraphic, aMainUrl, *pStream, nFormat, pFilterData );
1833 delete pStream;
1834
1835 if( ( GRFILTER_OK != nRetValue ) && !bAlreadyExists )
1836 ImplDirEntryHelper::Kill( aMainUrl );
1837 }
1838 return nRetValue;
1839 }
1840
1841 // ------------------------------------------------------------------------
1842
ExportGraphic(const Graphic & rGraphic,const String & rPath,SvStream & rOStm,sal_uInt16 nFormat,const uno::Sequence<beans::PropertyValue> * pFilterData)1843 sal_uInt16 GraphicFilter::ExportGraphic( const Graphic& rGraphic, const String& rPath,
1844 SvStream& rOStm, sal_uInt16 nFormat, const uno::Sequence< beans::PropertyValue >* pFilterData )
1845 {
1846 sal_uInt16 nFormatCount = GetExportFormatCount();
1847
1848 ResetLastError();
1849 nExpGraphHint = 0;
1850
1851 if( nFormat == GRFILTER_FORMAT_DONTKNOW )
1852 {
1853 INetURLObject aURL( rPath );
1854 String aExt( aURL.GetFileExtension().toAsciiUpperCase() );
1855
1856
1857 for( sal_uInt16 i = 0; i < nFormatCount; i++ )
1858 {
1859 if ( pConfig->GetExportFormatExtension( i ).EqualsIgnoreCaseAscii( aExt ) )
1860 {
1861 nFormat=i;
1862 break;
1863 }
1864 }
1865 }
1866 if( nFormat >= nFormatCount )
1867 return (sal_uInt16) ImplSetError( GRFILTER_FORMATERROR );
1868
1869 FilterConfigItem aConfigItem( (uno::Sequence< beans::PropertyValue >*)pFilterData );
1870 String aFilterName( pConfig->GetExportFilterName( nFormat ) );
1871
1872 bAbort = sal_False;
1873 sal_uInt16 nStatus = GRFILTER_OK;
1874 GraphicType eType;
1875 Graphic aGraphic( rGraphic );
1876
1877 aGraphic = ImpGetScaledGraphic( rGraphic, aConfigItem );
1878 eType = aGraphic.GetType();
1879
1880 if( pConfig->IsExportPixelFormat( nFormat ) )
1881 {
1882 if( eType != GRAPHIC_BITMAP )
1883 {
1884 Size aSizePixel;
1885 sal_uLong nColorCount,nBitsPerPixel,nNeededMem,nMaxMem;
1886 VirtualDevice aVirDev;
1887
1888 // Maximalen Speicherbedarf fuer das Bildes holen:
1889 // if( GetOptionsConfig() )
1890 // nMaxMem = (UINT32)GetOptionsConfig()->ReadKey( "VEC-TO-PIX-MAX-KB", "1024" ).ToInt32();
1891 // else
1892 nMaxMem = 1024;
1893
1894 nMaxMem *= 1024; // In Bytes
1895
1896 // Berechnen, wie gross das Bild normalerweise werden wuerde:
1897 aSizePixel=aVirDev.LogicToPixel(aGraphic.GetPrefSize(),aGraphic.GetPrefMapMode());
1898
1899 // Berechnen, wieviel Speicher das Bild benoetigen wuerde:
1900 nColorCount=aVirDev.GetColorCount();
1901 if (nColorCount<=2) nBitsPerPixel=1;
1902 else if (nColorCount<=4) nBitsPerPixel=2;
1903 else if (nColorCount<=16) nBitsPerPixel=4;
1904 else if (nColorCount<=256) nBitsPerPixel=8;
1905 else if (nColorCount<=65536) nBitsPerPixel=16;
1906 else nBitsPerPixel=24;
1907 nNeededMem=((sal_uLong)aSizePixel.Width()*(sal_uLong)aSizePixel.Height()*nBitsPerPixel+7)/8;
1908
1909 // ggf. Groesse des Bildes einschraenken:
1910 if (nMaxMem<nNeededMem)
1911 {
1912 double fFak=sqrt(((double)nMaxMem)/((double)nNeededMem));
1913 aSizePixel.Width()=(sal_uLong)(((double)aSizePixel.Width())*fFak);
1914 aSizePixel.Height()=(sal_uLong)(((double)aSizePixel.Height())*fFak);
1915 }
1916
1917 aVirDev.SetMapMode(MapMode(MAP_PIXEL));
1918 aVirDev.SetOutputSizePixel(aSizePixel);
1919 Graphic aGraphic2=aGraphic;
1920 aGraphic2.Draw(&aVirDev,Point(0,0),aSizePixel); // Gemein: dies aendert den MapMode
1921 aVirDev.SetMapMode(MapMode(MAP_PIXEL));
1922 aGraphic=Graphic(aVirDev.GetBitmap(Point(0,0),aSizePixel));
1923 }
1924 }
1925 if( rOStm.GetError() )
1926 nStatus = GRFILTER_IOERROR;
1927 if( GRFILTER_OK == nStatus )
1928 {
1929 if ( pConfig->IsExportInternalFilter( nFormat ) )
1930 {
1931 if( aFilterName.EqualsIgnoreCaseAscii( EXP_BMP ) )
1932 {
1933 Bitmap aBmp( aGraphic.GetBitmap() );
1934 sal_Int32 nColorRes = aConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "Colors" ) ), 0 );
1935 if ( nColorRes && ( nColorRes <= (sal_uInt16)BMP_CONVERSION_24BIT) )
1936 {
1937 if( !aBmp.Convert( (BmpConversion) nColorRes ) )
1938 aBmp = aGraphic.GetBitmap();
1939 }
1940 ResMgr* pResMgr = CREATERESMGR( svt );
1941 sal_Bool bRleCoding = aConfigItem.ReadBool( String( RTL_CONSTASCII_USTRINGPARAM( "RLE_Coding" ) ), sal_True );
1942 // Wollen wir RLE-Kodiert speichern?
1943 WriteDIB(aBmp, rOStm, bRleCoding, true);
1944 delete pResMgr;
1945
1946 if( rOStm.GetError() )
1947 nStatus = GRFILTER_IOERROR;
1948 }
1949 else if( aFilterName.EqualsIgnoreCaseAscii( EXP_SVMETAFILE ) )
1950 {
1951 sal_Int32 nVersion = aConfigItem.ReadInt32( String( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ), 0 ) ;
1952 if ( nVersion )
1953 rOStm.SetVersion( nVersion );
1954
1955 // #119735# just use GetGDIMetaFile, it will create a bufferd version of contained bitmap now automatically
1956 GDIMetaFile aMTF(aGraphic.GetGDIMetaFile());
1957
1958 aMTF.Write( rOStm );
1959
1960 if( rOStm.GetError() )
1961 nStatus = GRFILTER_IOERROR;
1962 }
1963 else if ( aFilterName.EqualsIgnoreCaseAscii( EXP_WMF ) )
1964 {
1965 // #119735# just use GetGDIMetaFile, it will create a bufferd version of contained bitmap now automatically
1966 if ( !ConvertGDIMetaFileToWMF( aGraphic.GetGDIMetaFile(), rOStm, &aConfigItem ) )
1967 nStatus = GRFILTER_FORMATERROR;
1968
1969 if( rOStm.GetError() )
1970 nStatus = GRFILTER_IOERROR;
1971 }
1972 else if ( aFilterName.EqualsIgnoreCaseAscii( EXP_EMF ) )
1973 {
1974 // #119735# just use GetGDIMetaFile, it will create a bufferd version of contained bitmap now automatically
1975 if ( !ConvertGDIMetaFileToEMF( aGraphic.GetGDIMetaFile(), rOStm, &aConfigItem ) )
1976 nStatus = GRFILTER_FORMATERROR;
1977
1978 if( rOStm.GetError() )
1979 nStatus = GRFILTER_IOERROR;
1980 }
1981 else if( aFilterName.EqualsIgnoreCaseAscii( EXP_JPEG ) )
1982 {
1983 bool bExportedGrayJPEG = false;
1984 if( !ExportJPEG( rOStm, aGraphic, pFilterData, &bExportedGrayJPEG ) )
1985 nStatus = GRFILTER_FORMATERROR;
1986 nExpGraphHint = bExportedGrayJPEG ? GRFILTER_OUTHINT_GREY : 0;
1987
1988 if( rOStm.GetError() )
1989 nStatus = GRFILTER_IOERROR;
1990 }
1991 else if ( aFilterName.EqualsIgnoreCaseAscii( EXP_PNG ) )
1992 {
1993 vcl::PNGWriter aPNGWriter( aGraphic.GetBitmapEx(), pFilterData );
1994 if ( pFilterData )
1995 {
1996 sal_Int32 k, j, i = 0;
1997 for ( i = 0; i < pFilterData->getLength(); i++ )
1998 {
1999 if ( (*pFilterData)[ i ].Name.equalsAscii( "AdditionalChunks" ) )
2000 {
2001 com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue > aAdditionalChunkSequence;
2002 if ( (*pFilterData)[ i ].Value >>= aAdditionalChunkSequence )
2003 {
2004 for ( j = 0; j < aAdditionalChunkSequence.getLength(); j++ )
2005 {
2006 if ( aAdditionalChunkSequence[ j ].Name.getLength() == 4 )
2007 {
2008 sal_uInt32 nChunkType = 0;
2009 for ( k = 0; k < 4; k++ )
2010 {
2011 nChunkType <<= 8;
2012 nChunkType |= (sal_uInt8)aAdditionalChunkSequence[ j ].Name[ k ];
2013 }
2014 com::sun::star::uno::Sequence< sal_Int8 > aByteSeq;
2015 if ( aAdditionalChunkSequence[ j ].Value >>= aByteSeq )
2016 {
2017 std::vector< vcl::PNGWriter::ChunkData >& rChunkData = aPNGWriter.GetChunks();
2018 if ( rChunkData.size() )
2019 {
2020 sal_uInt32 nChunkLen = aByteSeq.getLength();
2021
2022 vcl::PNGWriter::ChunkData aChunkData;
2023 aChunkData.nType = nChunkType;
2024 if ( nChunkLen )
2025 {
2026 aChunkData.aData.resize( nChunkLen );
2027 rtl_copyMemory( &aChunkData.aData[ 0 ], aByteSeq.getConstArray(), nChunkLen );
2028 }
2029 std::vector< vcl::PNGWriter::ChunkData >::iterator aIter = rChunkData.end() - 1;
2030 rChunkData.insert( aIter, aChunkData );
2031 }
2032 }
2033 }
2034 }
2035 }
2036 }
2037 }
2038 }
2039 aPNGWriter.Write( rOStm );
2040
2041 if( rOStm.GetError() )
2042 nStatus = GRFILTER_IOERROR;
2043 }
2044 else if( aFilterName.EqualsIgnoreCaseAscii( EXP_SVG ) )
2045 {
2046 bool bDone(false);
2047
2048 // do we have a native SVG RenderGraphic, whose data can be written directly?
2049 const SvgDataPtr aSvgDataPtr(rGraphic.getSvgData());
2050
2051 if(aSvgDataPtr.get() && aSvgDataPtr->getSvgDataArrayLength())
2052 {
2053 rOStm.Write(aSvgDataPtr->getSvgDataArray().get(), aSvgDataPtr->getSvgDataArrayLength());
2054
2055 if( rOStm.GetError() )
2056 {
2057 nStatus = GRFILTER_IOERROR;
2058 }
2059 else
2060 {
2061 bDone = true;
2062 }
2063 }
2064
2065 if( !bDone )
2066 {
2067 // do the normal GDIMetaFile export instead
2068 try
2069 {
2070 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
2071
2072 if( xMgr.is() )
2073 {
2074 ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XDocumentHandler > xSaxWriter( xMgr->createInstance(
2075 ::rtl::OUString::createFromAscii( "com.sun.star.xml.sax.Writer" ) ), ::com::sun::star::uno::UNO_QUERY );
2076
2077 com::sun::star::uno::Sequence< com::sun::star::uno::Any > aArguments( 1 );
2078 aArguments[ 0 ] <<= aConfigItem.GetFilterData();
2079 ::com::sun::star::uno::Reference< ::com::sun::star::svg::XSVGWriter > xSVGWriter( xMgr->createInstanceWithArguments(
2080 ::rtl::OUString::createFromAscii( "com.sun.star.svg.SVGWriter" ), aArguments ), ::com::sun::star::uno::UNO_QUERY );
2081
2082 if( xSaxWriter.is() && xSVGWriter.is() )
2083 {
2084 ::com::sun::star::uno::Reference< ::com::sun::star::io::XActiveDataSource > xActiveDataSource(
2085 xSaxWriter, ::com::sun::star::uno::UNO_QUERY );
2086
2087 if( xActiveDataSource.is() )
2088 {
2089 const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xStmIf(
2090 static_cast< ::cppu::OWeakObject* >( new ImpFilterOutputStream( rOStm ) ) );
2091
2092 SvMemoryStream aMemStm( 65535, 65535 );
2093
2094 aMemStm.SetCompressMode( COMPRESSMODE_FULL );
2095
2096 // #119735# just use GetGDIMetaFile, it will create a bufferd version of contained bitmap now automatically
2097 ( (GDIMetaFile&) aGraphic.GetGDIMetaFile() ).Write( aMemStm );
2098
2099 xActiveDataSource->setOutputStream( ::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream >(
2100 xStmIf, ::com::sun::star::uno::UNO_QUERY ) );
2101 ::com::sun::star::uno::Sequence< sal_Int8 > aMtfSeq( (sal_Int8*) aMemStm.GetData(), aMemStm.Tell() );
2102 xSVGWriter->write( xSaxWriter, aMtfSeq );
2103 }
2104 }
2105 }
2106 }
2107 catch( ::com::sun::star::uno::Exception& )
2108 {
2109 nStatus = GRFILTER_IOERROR;
2110 }
2111 }
2112 }
2113 else
2114 nStatus = GRFILTER_FILTERERROR;
2115 }
2116 else
2117 {
2118 xub_StrLen i, nTokenCount = aFilterPath.GetTokenCount( ';' );
2119 for ( i = 0; i < nTokenCount; i++ )
2120 {
2121 String aPhysicalName( ImpCreateFullFilterPath( aFilterPath.GetToken( i ), aFilterName ) );
2122 osl::Module aLibrary( aPhysicalName );
2123
2124 PFilterCall pFunc = (PFilterCall) aLibrary.getFunctionSymbol( UniString::CreateFromAscii( EXPORT_FUNCTION_NAME ) );
2125 // Dialog in DLL ausfuehren
2126 if( pFunc )
2127 {
2128 if ( !(*pFunc)( rOStm, aGraphic, &aConfigItem, sal_False ) )
2129 nStatus = GRFILTER_FORMATERROR;
2130 break;
2131 }
2132 else
2133 nStatus = GRFILTER_FILTERERROR;
2134 }
2135 }
2136 }
2137 if( nStatus != GRFILTER_OK )
2138 {
2139 if( bAbort )
2140 nStatus = GRFILTER_ABORT;
2141
2142 ImplSetError( nStatus, &rOStm );
2143 }
2144 return nStatus;
2145 }
2146
2147 // ------------------------------------------------------------------------
2148
Setup(sal_uInt16)2149 sal_Bool GraphicFilter::Setup( sal_uInt16 )
2150 {
2151 return sal_False;
2152 }
2153
2154 /* ------------------------------------------------------------------------
2155 No Import filter has a dialog, so
2156 the following two methods are obsolete */
2157
HasImportDialog(sal_uInt16)2158 sal_Bool GraphicFilter::HasImportDialog( sal_uInt16 )
2159 {
2160 return sal_True;
2161 // return pConfig->IsImportDialog( nFormat );
2162 }
2163
2164 // ------------------------------------------------------------------------
2165
DoImportDialog(Window *,sal_uInt16)2166 sal_Bool GraphicFilter::DoImportDialog( Window*, sal_uInt16 )
2167 {
2168 return sal_True;
2169 }
2170
2171 // ------------------------------------------------------------------------
2172
HasExportDialog(sal_uInt16 nFormat)2173 sal_Bool GraphicFilter::HasExportDialog( sal_uInt16 nFormat )
2174 {
2175 return pConfig->IsExportDialog( nFormat );
2176 }
2177
2178 // ------------------------------------------------------------------------
2179
DoExportDialog(Window * pWindow,sal_uInt16 nFormat)2180 sal_Bool GraphicFilter::DoExportDialog( Window* pWindow, sal_uInt16 nFormat )
2181 {
2182 return DoExportDialog( pWindow, nFormat, FUNIT_MM );
2183 }
2184
DoExportDialog(Window *,sal_uInt16 nFormat,FieldUnit)2185 sal_Bool GraphicFilter::DoExportDialog( Window*, sal_uInt16 nFormat, FieldUnit )
2186 {
2187 sal_Bool bRet = sal_False;
2188 com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
2189 xSMgr( ::comphelper::getProcessServiceFactory() );
2190
2191 uno::Reference< com::sun::star::uno::XInterface > xFilterOptionsDialog
2192 ( xSMgr->createInstance( rtl::OUString::createFromAscii( "com.sun.star.svtools.SvFilterOptionsDialog" ) ),
2193 com::sun::star::uno::UNO_QUERY );
2194 if ( xFilterOptionsDialog.is() )
2195 {
2196 com::sun::star::uno::Reference< com::sun::star::ui::dialogs::XExecutableDialog > xExecutableDialog
2197 ( xFilterOptionsDialog, ::com::sun::star::uno::UNO_QUERY );
2198 com::sun::star::uno::Reference< com::sun::star::beans::XPropertyAccess > xPropertyAccess
2199 ( xFilterOptionsDialog, ::com::sun::star::uno::UNO_QUERY );
2200 if ( xExecutableDialog.is() && xPropertyAccess.is() )
2201 {
2202 com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aMediaDescriptor( 1 );
2203 aMediaDescriptor[ 0 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "FilterName" ) );
2204 rtl::OUString aStr( pConfig->GetExportInternalFilterName( nFormat ) );
2205 aMediaDescriptor[ 0 ].Value <<= aStr;
2206 xPropertyAccess->setPropertyValues( aMediaDescriptor );
2207 bRet = xExecutableDialog->execute() == com::sun::star::ui::dialogs::ExecutableDialogResults::OK;
2208 }
2209 }
2210 return bRet;
2211 }
2212
2213 // ------------------------------------------------------------------------
2214
GetLastError() const2215 const FilterErrorEx& GraphicFilter::GetLastError() const
2216 {
2217 return *pErrorEx;
2218 }
2219
2220 // ------------------------------------------------------------------------
2221
ResetLastError()2222 void GraphicFilter::ResetLastError()
2223 {
2224 pErrorEx->nFilterError = pErrorEx->nStreamError = 0UL;
2225 }
2226
2227 // ------------------------------------------------------------------------
2228
GetFilterCallback() const2229 const Link GraphicFilter::GetFilterCallback() const
2230 {
2231 const Link aLink( LINK( this, GraphicFilter, FilterCallback ) );
2232 return aLink;
2233 }
2234
2235 // ------------------------------------------------------------------------
2236
IMPL_LINK(GraphicFilter,FilterCallback,ConvertData *,pData)2237 IMPL_LINK( GraphicFilter, FilterCallback, ConvertData*, pData )
2238 {
2239 long nRet = 0L;
2240
2241 if( pData )
2242 {
2243 sal_uInt16 nFormat = GRFILTER_FORMAT_DONTKNOW;
2244 ByteString aShortName;
2245 switch( pData->mnFormat )
2246 {
2247 case( CVT_BMP ): aShortName = BMP_SHORTNAME; break;
2248 case( CVT_GIF ): aShortName = GIF_SHORTNAME; break;
2249 case( CVT_JPG ): aShortName = JPG_SHORTNAME; break;
2250 case( CVT_MET ): aShortName = MET_SHORTNAME; break;
2251 case( CVT_PCT ): aShortName = PCT_SHORTNAME; break;
2252 case( CVT_PNG ): aShortName = PNG_SHORTNAME; break;
2253 case( CVT_SVM ): aShortName = SVM_SHORTNAME; break;
2254 case( CVT_TIF ): aShortName = TIF_SHORTNAME; break;
2255 case( CVT_WMF ): aShortName = WMF_SHORTNAME; break;
2256 case( CVT_EMF ): aShortName = EMF_SHORTNAME; break;
2257 case( CVT_SVG ): aShortName = SVG_SHORTNAME; break;
2258
2259 default:
2260 break;
2261 }
2262 if( GRAPHIC_NONE == pData->maGraphic.GetType() || pData->maGraphic.GetContext() ) // Import
2263 {
2264 // Import
2265 nFormat = GetImportFormatNumberForShortName( String( aShortName.GetBuffer(), RTL_TEXTENCODING_UTF8 ) );
2266 nRet = ImportGraphic( pData->maGraphic, String(), pData->mrStm ) == 0;
2267 }
2268 else if( aShortName.Len() )
2269 {
2270 // Export
2271 nFormat = GetExportFormatNumberForShortName( String( aShortName.GetBuffer(), RTL_TEXTENCODING_UTF8 ) );
2272 nRet = ExportGraphic( pData->maGraphic, String(), pData->mrStm, nFormat ) == 0;
2273 }
2274 }
2275 return nRet;
2276 }
2277
2278 // ------------------------------------------------------------------------
2279
GetGraphicFilter()2280 GraphicFilter* GraphicFilter::GetGraphicFilter()
2281 {
2282 if( !pGraphicFilter )
2283 {
2284 pGraphicFilter = new GraphicFilter;
2285 pGraphicFilter->GetImportFormatCount();
2286 }
2287 return pGraphicFilter;
2288 }
2289
LoadGraphic(const String & rPath,const String & rFilterName,Graphic & rGraphic,GraphicFilter * pFilter,sal_uInt16 * pDeterminedFormat)2290 int GraphicFilter::LoadGraphic( const String &rPath, const String &rFilterName,
2291 Graphic& rGraphic, GraphicFilter* pFilter,
2292 sal_uInt16* pDeterminedFormat )
2293 {
2294 if ( !pFilter )
2295 pFilter = GetGraphicFilter();
2296
2297 const sal_uInt16 nFilter = rFilterName.Len() && pFilter->GetImportFormatCount()
2298 ? pFilter->GetImportFormatNumber( rFilterName )
2299 : GRFILTER_FORMAT_DONTKNOW;
2300
2301 SvStream* pStream = NULL;
2302 INetURLObject aURL( rPath );
2303
2304 if ( aURL.HasError() || INET_PROT_NOT_VALID == aURL.GetProtocol() )
2305 {
2306 aURL.SetSmartProtocol( INET_PROT_FILE );
2307 aURL.SetSmartURL( rPath );
2308 }
2309 else if ( INET_PROT_FILE != aURL.GetProtocol() )
2310 {
2311 pStream = ::utl::UcbStreamHelper::CreateStream( rPath, STREAM_READ );
2312 }
2313
2314 int nRes = GRFILTER_OK;
2315 if ( !pStream )
2316 nRes = pFilter->ImportGraphic( rGraphic, aURL, nFilter, pDeterminedFormat );
2317 else
2318 nRes = pFilter->ImportGraphic( rGraphic, rPath, *pStream, nFilter, pDeterminedFormat );
2319
2320 #ifdef DBG_UTIL
2321 if( nRes )
2322 DBG_WARNING2( "GrafikFehler [%d] - [%s]", nRes, rPath.GetBuffer() );
2323 #endif
2324
2325 return nRes;
2326 }
2327
