?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sc / source / ui / unoobj / scdetect.cxx
blob24564c3b94fc779d65dad8a900626fc05b41e000
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: scdetect.cxx,v $
10 * $Revision: 1.24 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34 #include "scdetect.hxx"
35
36 #include <framework/interaction.hxx>
37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
38 #include <com/sun/star/beans/PropertyValue.hpp>
39 #include <com/sun/star/frame/XFrame.hpp>
40 #include <com/sun/star/frame/XModel.hpp>
41 #include <com/sun/star/awt/XWindow.hpp>
42 #include <com/sun/star/lang/XUnoTunnel.hpp>
43 #ifndef _UNOTOOLS_PROCESSFACTORY_HXX
44 #include <comphelper/processfactory.hxx>
45 #endif
46 #include <com/sun/star/beans/PropertyValue.hpp>
47 #include <com/sun/star/container/XNameAccess.hpp>
48 #include <com/sun/star/io/XInputStream.hpp>
49 #include <com/sun/star/task/XInteractionHandler.hpp>
50 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
51 #include <com/sun/star/ucb/CommandAbortedException.hpp>
52 #include <com/sun/star/ucb/InteractiveAppException.hpp>
53 #include <com/sun/star/ucb/XContent.hpp>
54 #include <com/sun/star/packages/zip/ZipIOException.hpp>
55
56
57 #include <framework/interaction.hxx>
58
59 #ifndef _TOOLKIT_UNOHLP_HXX
60 #include <toolkit/helper/vclunohelper.hxx>
61 #endif
62 #include <ucbhelper/simpleinteractionrequest.hxx>
63
64 #include <svtools/parhtml.hxx>
65 #include <rtl/ustring.h>
66 #include <rtl/logfile.hxx>
67 #include <svtools/itemset.hxx>
68 #include <vcl/window.hxx>
69 #include <svtools/eitem.hxx>
70 #include <svtools/stritem.hxx>
71 #include <tools/urlobj.hxx>
72 #include <vos/mutex.hxx>
73 #include <svtools/sfxecode.hxx>
74 #include <svtools/ehdl.hxx>
75 #include <sot/storinfo.hxx>
76 #include <vcl/svapp.hxx>
77 #include <sfx2/sfxsids.hrc>
78 #include <sfx2/request.hxx>
79 #include <sfx2/docfile.hxx>
80 #include <sfx2/docfilt.hxx>
81 #include <sfx2/fcontnr.hxx>
82 #include <sfx2/app.hxx>
83 #include <sfx2/brokenpackageint.hxx>
84 #include <sot/storage.hxx>
85
86 using namespace ::com::sun::star;
87 using namespace ::com::sun::star::uno;
88 using namespace ::com::sun::star::io;
89 using namespace ::com::sun::star::frame;
90 using namespace ::com::sun::star::task;
91 using namespace ::com::sun::star::beans;
92 using namespace ::com::sun::star::lang;
93 using namespace ::com::sun::star::ucb;
94 using ::rtl::OUString;
95
96 ScFilterDetect::ScFilterDetect( const REFERENCE < ::com::sun::star::lang::XMultiServiceFactory >& /* xFactory */ )
97 {
98 }
99
100 ScFilterDetect::~ScFilterDetect()
101 {
102 }
103
104 static const sal_Char __FAR_DATA pFilterSc50[] = "StarCalc 5.0";
105 static const sal_Char __FAR_DATA pFilterSc50Temp[] = "StarCalc 5.0 Vorlage/Template";
106 static const sal_Char __FAR_DATA pFilterSc40[] = "StarCalc 4.0";
107 static const sal_Char __FAR_DATA pFilterSc40Temp[] = "StarCalc 4.0 Vorlage/Template";
108 static const sal_Char __FAR_DATA pFilterSc30[] = "StarCalc 3.0";
109 static const sal_Char __FAR_DATA pFilterSc30Temp[] = "StarCalc 3.0 Vorlage/Template";
110 static const sal_Char __FAR_DATA pFilterSc10[] = "StarCalc 1.0";
111 static const sal_Char __FAR_DATA pFilterXML[] = "StarOffice XML (Calc)";
112 static const sal_Char __FAR_DATA pFilterAscii[] = "Text - txt - csv (StarCalc)";
113 static const sal_Char __FAR_DATA pFilterLotus[] = "Lotus";
114 static const sal_Char __FAR_DATA pFilterQPro6[] = "Quattro Pro 6.0";
115 static const sal_Char __FAR_DATA pFilterExcel4[] = "MS Excel 4.0";
116 static const sal_Char __FAR_DATA pFilterEx4Temp[] = "MS Excel 4.0 Vorlage/Template";
117 static const sal_Char __FAR_DATA pFilterExcel5[] = "MS Excel 5.0/95";
118 static const sal_Char __FAR_DATA pFilterEx5Temp[] = "MS Excel 5.0/95 Vorlage/Template";
119 static const sal_Char __FAR_DATA pFilterExcel95[] = "MS Excel 95";
120 static const sal_Char __FAR_DATA pFilterEx95Temp[] = "MS Excel 95 Vorlage/Template";
121 static const sal_Char __FAR_DATA pFilterExcel97[] = "MS Excel 97";
122 static const sal_Char __FAR_DATA pFilterEx97Temp[] = "MS Excel 97 Vorlage/Template";
123 static const sal_Char __FAR_DATA pFilterDBase[] = "dBase";
124 static const sal_Char __FAR_DATA pFilterDif[] = "DIF";
125 static const sal_Char __FAR_DATA pFilterSylk[] = "SYLK";
126 static const sal_Char __FAR_DATA pFilterHtml[] = "HTML (StarCalc)";
127 static const sal_Char __FAR_DATA pFilterHtmlWeb[] = "calc_HTML_WebQuery";
128 static const sal_Char __FAR_DATA pFilterRtf[] = "Rich Text Format (StarCalc)";
129
130
131 static BOOL lcl_MayBeAscii( SvStream& rStream )
132 {
133 // ASCII/CSV is considered possible if there are no null bytes, or a Byte
134 // Order Mark is present, or if, for Unicode UCS2/UTF-16, all null bytes
135 // are on either even or uneven byte positions.
136
137 rStream.Seek(STREAM_SEEK_TO_BEGIN);
138
139 const size_t nBufSize = 2048;
140 sal_uInt16 aBuffer[ nBufSize ];
141 sal_uInt8* pByte = reinterpret_cast<sal_uInt8*>(aBuffer);
142 ULONG nBytesRead = rStream.Read( pByte, nBufSize*2);
143
144 if ( nBytesRead >= 2 && (aBuffer[0] == 0xfffe || aBuffer[0] == 0xfeff) )
145 {
146 // Unicode BOM file may contain null bytes.
147 return TRUE;
148 }
149
150 const sal_uInt16* p = aBuffer;
151 sal_uInt16 nMask = 0xffff;
152 nBytesRead /= 2;
153 while( nBytesRead-- && nMask )
154 {
155 sal_uInt16 nVal = *p++ & nMask;
156 if (!(nVal & 0x00ff))
157 nMask &= 0xff00;
158 if (!(nVal & 0xff00))
159 nMask &= 0x00ff;
160 }
161
162 return nMask != 0;
163 }
164
165 static BOOL lcl_MayBeDBase( SvStream& rStream )
166 {
167 // Look for dbf marker, see connectivity/source/inc/dbase/DTable.hxx
168 // DBFType for values.
169 const BYTE nValidMarks[] = {
170 0x03, 0x04, 0x05, 0x30, 0x43, 0xB3, 0x83, 0x8b, 0x8e, 0xf5 };
171 BYTE nMark;
172 rStream.Seek(STREAM_SEEK_TO_BEGIN);
173 rStream >> nMark;
174 bool bValidMark = false;
175 for (size_t i=0; i < sizeof(nValidMarks)/sizeof(nValidMarks[0]) && !bValidMark; ++i)
176 {
177 if (nValidMarks[i] == nMark)
178 bValidMark = true;
179 }
180 if ( !bValidMark )
181 return FALSE;
182
183 const size_t nHeaderBlockSize = 32;
184 // Empty dbf is >= 32*2+1 bytes in size.
185 const size_t nEmptyDbf = nHeaderBlockSize * 2 + 1;
186
187 rStream.Seek(STREAM_SEEK_TO_END);
188 ULONG nSize = rStream.Tell();
189 if ( nSize < nEmptyDbf )
190 return FALSE;
191
192 // length of header starts at 8
193 rStream.Seek(8);
194 USHORT nHeaderLen;
195 rStream >> nHeaderLen;
196
197 if ( nHeaderLen < nEmptyDbf || nSize < nHeaderLen )
198 return FALSE;
199
200 // Last byte of header must be 0x0d, this is how it's specified.
201 // #i9581#,#i26407# but some applications don't follow the specification
202 // and pad the header with one byte 0x00 to reach an
203 // even boundary. Some (#i88577# ) even pad more or pad using a 0x1a ^Z
204 // control character (#i8857#). This results in:
205 // Last byte of header must be 0x0d on 32 bytes boundary.
206 USHORT nBlocks = (nHeaderLen - 1) / nHeaderBlockSize;
207 BYTE nEndFlag = 0;
208 while ( nBlocks > 1 && nEndFlag != 0x0d ) {
209 rStream.Seek( nBlocks-- * nHeaderBlockSize );
210 rStream >> nEndFlag;
211 }
212
213 return ( 0x0d == nEndFlag );
214 }
215
216 #if 0
217 static BOOL lcl_IsAnyXMLFilter( const SfxFilter* pFilter )
218 {
219 if ( !pFilter )
220 return FALSE;
221
222 // TRUE for XML file or template
223 // (template filter has no internal name -> allow configuration key names)
224
225 String aName(pFilter->GetFilterName());
226 return aName.EqualsAscii(pFilterXML) ||
227 aName.EqualsAscii("calc_StarOffice_XML_Calc") ||
228 aName.EqualsAscii("calc_StarOffice_XML_Calc_Template");
229 }
230 #endif
231
232 ::rtl::OUString SAL_CALL ScFilterDetect::detect( ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& lDescriptor ) throw( ::com::sun::star::uno::RuntimeException )
233 {
234 REFERENCE< XInputStream > xStream;
235 REFERENCE< XContent > xContent;
236 REFERENCE< XInteractionHandler > xInteraction;
237 String aURL;
238 ::rtl::OUString sTemp;
239 String aTypeName; // a name describing the type (from MediaDescriptor, usually from flat detection)
240 String aPreselectedFilterName; // a name describing the filter to use (from MediaDescriptor, usually from UI action)
241
242 ::rtl::OUString aDocumentTitle; // interesting only if set in this method
243
244 // opening as template is done when a parameter tells to do so and a template filter can be detected
245 // (otherwise no valid filter would be found) or if the detected filter is a template filter and
246 // there is no parameter that forbids to open as template
247 sal_Bool bOpenAsTemplate = sal_False;
248 sal_Bool bWasReadOnly = sal_False, bReadOnly = sal_False;
249
250 sal_Bool bRepairPackage = sal_False;
251 sal_Bool bRepairAllowed = sal_False;
252
253 // now some parameters that can already be in the array, but may be overwritten or new inserted here
254 // remember their indices in the case new values must be added to the array
255 sal_Int32 nPropertyCount = lDescriptor.getLength();
256 sal_Int32 nIndexOfFilterName = -1;
257 sal_Int32 nIndexOfInputStream = -1;
258 sal_Int32 nIndexOfContent = -1;
259 sal_Int32 nIndexOfReadOnlyFlag = -1;
260 sal_Int32 nIndexOfTemplateFlag = -1;
261 sal_Int32 nIndexOfDocumentTitle = -1;
262
263 for( sal_Int32 nProperty=0; nProperty<nPropertyCount; ++nProperty )
264 {
265 // extract properties
266 if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("URL")) )
267 {
268 lDescriptor[nProperty].Value >>= sTemp;
269 aURL = sTemp;
270 }
271 else if( !aURL.Len() && lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("FileName")) )
272 {
273 lDescriptor[nProperty].Value >>= sTemp;
274 aURL = sTemp;
275 }
276 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("TypeName")) )
277 {
278 lDescriptor[nProperty].Value >>= sTemp;
279 aTypeName = sTemp;
280 }
281 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("FilterName")) )
282 {
283 lDescriptor[nProperty].Value >>= sTemp;
284 aPreselectedFilterName = sTemp;
285
286 // if the preselected filter name is not correct, it must be erased after detection
287 // remember index of property to get access to it later
288 nIndexOfFilterName = nProperty;
289 }
290 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("InputStream")) )
291 nIndexOfInputStream = nProperty;
292 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("ReadOnly")) )
293 nIndexOfReadOnlyFlag = nProperty;
294 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("UCBContent")) )
295 nIndexOfContent = nProperty;
296 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("AsTemplate")) )
297 {
298 lDescriptor[nProperty].Value >>= bOpenAsTemplate;
299 nIndexOfTemplateFlag = nProperty;
300 }
301 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("InteractionHandler")) )
302 lDescriptor[nProperty].Value >>= xInteraction;
303 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("RapairPackage")) )
304 lDescriptor[nProperty].Value >>= bRepairPackage;
305 else if( lDescriptor[nProperty].Name == OUString(RTL_CONSTASCII_USTRINGPARAM("DocumentTitle")) )
306 nIndexOfDocumentTitle = nProperty;
307 }
308
309 // can't check the type for external filters, so set the "dont" flag accordingly
310 ::vos::OGuard aGuard( Application::GetSolarMutex() );
311 //SfxFilterFlags nMust = SFX_FILTER_IMPORT, nDont = SFX_FILTER_NOTINSTALLED;
312
313 SfxAllItemSet *pSet = new SfxAllItemSet( SFX_APP()->GetPool() );
314 TransformParameters( SID_OPENDOC, lDescriptor, *pSet );
315 SFX_ITEMSET_ARG( pSet, pItem, SfxBoolItem, SID_DOC_READONLY, FALSE );
316
317 bWasReadOnly = pItem && pItem->GetValue();
318
319 const SfxFilter* pFilter = 0;
320 String aPrefix = String::CreateFromAscii( "private:factory/" );
321 if( aURL.Match( aPrefix ) == aPrefix.Len() )
322 {
323 String aPattern( aPrefix );
324 aPattern += String::CreateFromAscii("scalc");
325 if ( aURL.Match( aPattern ) >= aPattern.Len() )
326 pFilter = SfxFilter::GetDefaultFilterFromFactory( aURL );
327 }
328 else
329 {
330 // container for Calc filters
331 SfxFilterMatcher aMatcher( String::CreateFromAscii("scalc") );
332 if ( aPreselectedFilterName.Len() )
333 pFilter = SfxFilter::GetFilterByName( aPreselectedFilterName );
334 else if( aTypeName.Len() )
335 pFilter = aMatcher.GetFilter4EA( aTypeName );
336
337 // ctor of SfxMedium uses owner transition of ItemSet
338 SfxMedium aMedium( aURL, bWasReadOnly ? STREAM_STD_READ : STREAM_STD_READWRITE, FALSE, NULL, pSet );
339 aMedium.UseInteractionHandler( TRUE );
340
341 BOOL bIsStorage = aMedium.IsStorage();
342 if ( aMedium.GetErrorCode() == ERRCODE_NONE )
343 {
344 // remember input stream and content and put them into the descriptor later
345 // should be done here since later the medium can switch to a version
346 xStream.set(aMedium.GetInputStream());
347 xContent.set(aMedium.GetContent());
348 bReadOnly = aMedium.IsReadOnly();
349
350 // maybe that IsStorage() already created an error!
351 if ( bIsStorage )
352 {
353 uno::Reference < embed::XStorage > xStorage(aMedium.GetStorage());
354 if ( aMedium.GetLastStorageCreationState() != ERRCODE_NONE )
355 {
356 // error during storage creation means _here_ that the medium
357 // is broken, but we can not handle it in medium since unpossibility
358 // to create a storage does not _always_ means that the medium is broken
359 aMedium.SetError( aMedium.GetLastStorageCreationState(), ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
360 if ( xInteraction.is() )
361 {
362 OUString empty;
363 try
364 {
365 InteractiveAppException xException( empty,
366 REFERENCE< XInterface >(),
367 InteractionClassification_ERROR,
368 aMedium.GetError() );
369
370 REFERENCE< XInteractionRequest > xRequest(
371 new ucbhelper::SimpleInteractionRequest( makeAny( xException ),
372 ucbhelper::CONTINUATION_APPROVE ) );
373 xInteraction->handle( xRequest );
374 }
375 catch ( Exception & ) {};
376 }
377 }
378 else if ( xStorage.is() )
379 {
380 try
381 {
382 String aFilterName;
383 if ( pFilter )
384 aFilterName = pFilter->GetName();
385 aTypeName = SfxFilter::GetTypeFromStorage( xStorage, pFilter ? pFilter->IsOwnTemplateFormat() : FALSE, &aFilterName );
386 }
387 catch( lang::WrappedTargetException& aWrap )
388 {
389 packages::zip::ZipIOException aZipException;
390
391 // repairing is done only if this type is requested from outside
392 if ( ( aWrap.TargetException >>= aZipException ) && aTypeName.Len() )
393 {
394 if ( xInteraction.is() )
395 {
396 // the package is broken one
397 aDocumentTitle = aMedium.GetURLObject().getName(
398 INetURLObject::LAST_SEGMENT,
399 true,
400 INetURLObject::DECODE_WITH_CHARSET );
401
402 if ( !bRepairPackage )
403 {
404 // ask the user whether he wants to try to repair
405 RequestPackageReparation* pRequest = new RequestPackageReparation( aDocumentTitle );
406 uno::Reference< task::XInteractionRequest > xRequest ( pRequest );
407
408 xInteraction->handle( xRequest );
409
410 bRepairAllowed = pRequest->isApproved();
411 }
412
413 if ( !bRepairAllowed )
414 {
415 // repair either not allowed or not successful
416 NotifyBrokenPackage* pNotifyRequest = new NotifyBrokenPackage( aDocumentTitle );
417 uno::Reference< task::XInteractionRequest > xRequest ( pNotifyRequest );
418 xInteraction->handle( xRequest );
419 }
420 }
421
422 if ( !bRepairAllowed )
423 aTypeName.Erase();
424 }
425 }
426 catch( uno::RuntimeException& )
427 {
428 throw;
429 }
430 catch( uno::Exception& )
431 {
432 aTypeName.Erase();
433 }
434
435 if ( aTypeName.Len() )
436 pFilter = SfxFilterMatcher( String::CreateFromAscii("scalc") ).GetFilter4EA( aTypeName );
437
438 }
439 }
440 else
441 {
442 SvStream* pStream = aMedium.GetInStream();
443 const SfxFilter* pPreselectedFilter = pFilter;
444 pFilter = 0;
445 if ( pStream )
446 {
447 SotStorageRef aStorage = new SotStorage ( pStream, FALSE );
448 if ( !aStorage->GetError() )
449 {
450 // Excel-5: detect through contained streams
451 // there are some "excel" formats from 3rd party vendors that need to be distinguished
452 String aStreamName(RTL_CONSTASCII_STRINGPARAM("Workbook"));
453 BOOL bExcel97Stream = ( aStorage->IsStream( aStreamName ) );
454
455 aStreamName = String(RTL_CONSTASCII_STRINGPARAM("Book"));
456 BOOL bExcel5Stream = ( aStorage->IsStream( aStreamName ) );
457 if ( bExcel97Stream || bExcel5Stream )
458 {
459 if ( bExcel97Stream )
460 {
461 String aOldName;
462 BOOL bIsCalcFilter = TRUE;
463 if ( pPreselectedFilter )
464 {
465 // cross filter; now this should be a type detection only, not a filter detection
466 // we can simulate it by preserving the preselected filter if the type matches
467 // example: Excel filters for Writer
468 aOldName = pPreselectedFilter->GetFilterName();
469 bIsCalcFilter = pPreselectedFilter->GetServiceName().EqualsAscii("com.sun.star.sheet.SpreadsheetDocument");
470 }
471
472 if ( aOldName.EqualsAscii(pFilterEx97Temp) || !bIsCalcFilter )
473 {
474 // Excel 97 template selected -> keep selection
475 }
476 else if ( bExcel5Stream &&
477 ( aOldName.EqualsAscii(pFilterExcel5) || aOldName.EqualsAscii(pFilterEx5Temp) ||
478 aOldName.EqualsAscii(pFilterExcel95) || aOldName.EqualsAscii(pFilterEx95Temp) ) )
479 {
480 // dual format file and Excel 5 selected -> keep selection
481 }
482 else
483 {
484 // else use Excel 97 filter
485 pFilter = aMatcher.GetFilter4FilterName( String::CreateFromAscii(pFilterExcel97) );
486 }
487 }
488 else if ( bExcel5Stream )
489 {
490 String aOldName;
491 BOOL bIsCalcFilter = TRUE;
492 if ( pPreselectedFilter )
493 {
494 // cross filter; now this should be a type detection only, not a filter detection
495 // we can simulate it by preserving the preselected filter if the type matches
496 // example: Excel filters for Writer
497 aOldName = pPreselectedFilter->GetFilterName();
498 bIsCalcFilter = pPreselectedFilter->GetServiceName().EqualsAscii("com.sun.star.sheet.SpreadsheetDocument");
499 }
500
501 if ( aOldName.EqualsAscii(pFilterExcel95) || aOldName.EqualsAscii(pFilterEx95Temp) ||
502 aOldName.EqualsAscii(pFilterEx5Temp) || !bIsCalcFilter )
503 {
504 // Excel 95 oder Vorlage (5 oder 95) eingestellt -> auch gut
505 }
506 else if ( aOldName.EqualsAscii(pFilterEx97Temp) )
507 {
508 // #101923# auto detection has found template -> return Excel5 template
509 pFilter = aMatcher.GetFilter4FilterName( String::CreateFromAscii(pFilterEx5Temp) );
510 }
511 else
512 {
513 // sonst wird als Excel 5-Datei erkannt
514 pFilter = aMatcher.GetFilter4FilterName( String::CreateFromAscii(pFilterExcel5) );
515 }
516 }
517 }
518 }
519 else
520 {
521 SvStream &rStr = *pStream;
522
523 // Tabelle mit Suchmustern
524 // Bedeutung der Sequenzen
525 // 0x00??: genau Byte 0x?? muss an dieser Stelle stehen
526 // 0x0100: ein Byte ueberlesen (don't care)
527 // 0x02nn: ein Byte aus 0xnn Alternativen folgt
528 // 0x8000: Erkennung abgeschlossen
529 //
530
531 #define M_DC 0x0100
532 #define M_ALT(ANZ) (0x0200+(ANZ))
533 #define M_ENDE 0x8000
534
535 static const UINT16 pLotus[] = // Lotus 1/1A/2
536 { 0x0000, 0x0000, 0x0002, 0x0000,
537 M_ALT(2), 0x0004, 0x0006,
538 0x0004, M_ENDE };
539
540 static const UINT16 pLotusNew[] = // Lotus >= 9.7
541 { 0x0000, 0x0000, M_DC, 0x0000, // Rec# + Len (0x1a)
542 M_ALT(3), 0x0003, 0x0004, 0x0005, // File Revision Code 97->ME
543 0x0010, 0x0004, 0x0000, 0x0000,
544 M_ENDE };
545
546 static const UINT16 pExcel1[] = // Excel BIFF2, BIFF3, BIFF4
547 { 0x09, // lobyte of BOF rec ID (0x0009, 0x0209, 0x0409)
548 M_ALT(3), 0x00, 0x02, 0x04, // hibyte of BOF rec ID (0x0009, 0x0209, 0x0409)
549 M_ALT(3), 4, 6, 8, // lobyte of BOF rec size (4, 6, 8, 16)
550 0x00, // hibyte of BOF rec size (4, 6, 8, 16)
551 M_DC, M_DC, // any version
552 M_ALT(3), 0x10, 0x20, 0x40, // lobyte of data type (0x0010, 0x0020, 0x0040)
553 0x00, // hibyte of data type (0x0010, 0x0020, 0x0040)
554 M_ENDE };
555
556 static const UINT16 pExcel2[] = // Excel BIFF4 Workspace
557 { 0x09, // lobyte of BOF rec ID (0x0409)
558 0x04, // hibyte of BOF rec ID (0x0409)
559 M_ALT(3), 4, 6, 8, // lobyte of BOF rec size (4, 6, 8, 16)
560 0x00, // hibyte of BOF rec size (4, 6, 8, 16)
561 M_DC, M_DC, // any version
562 0x00, // lobyte of data type (0x0100)
563 0x01, // hibyte of data type (0x0100)
564 M_ENDE };
565
566 static const UINT16 pExcel3[] = // #i23425# Excel BIFF5, BIFF7, BIFF8 (simple book stream)
567 { 0x09, // lobyte of BOF rec ID (0x0809)
568 0x08, // hibyte of BOF rec ID (0x0809)
569 M_ALT(4), 4, 6, 8, 16, // lobyte of BOF rec size
570 0x00, // hibyte of BOF rec size
571 M_DC, M_DC, // any version
572 M_ALT(5), 0x05, 0x06, 0x10, 0x20, 0x40, // lobyte of data type
573 0x00, // hibyte of data type
574 M_ENDE };
575
576 static const UINT16 pSc10[] = // StarCalc 1.0 Dokumente
577 { 'B', 'l', 'a', 'i', 's', 'e', '-', 'T', 'a', 'b', 'e', 'l', 'l',
578 'e', 0x000A, 0x000D, 0x0000, // Sc10CopyRight[16]
579 M_DC, M_DC, M_DC, M_DC, M_DC, M_DC, M_DC, M_DC, M_DC, M_DC, M_DC,
580 M_DC, M_DC, // Sc10CopyRight[29]
581 M_ALT(2), 0x0065, 0x0066, // Versionsnummer 101 oder 102
582 0x0000,
583 M_ENDE };
584
585 static const UINT16 pLotus2[] = // Lotus >3
586 { 0x0000, 0x0000, 0x001A, 0x0000, // Rec# + Len (26)
587 M_ALT(2), 0x0000, 0x0002, // File Revision Code
588 0x0010,
589 0x0004, 0x0000, // File Revision Subcode
590 M_ENDE };
591
592 static const UINT16 pQPro[] =
593 { 0x0000, 0x0000, 0x0002, 0x0000,
594 M_ALT(4), 0x0001, 0x0002, // WB1, WB2
595 0x0006, 0x0007, // QPro 6/7 (?)
596 0x0010,
597 M_ENDE };
598
599 static const UINT16 pDIF1[] = // DIF mit CR-LF
600 {
601 'T', 'A', 'B', 'L', 'E',
602 M_DC, M_DC,
603 '0', ',', '1',
604 M_DC, M_DC,
605 '\"',
606 M_ENDE };
607
608 static const UINT16 pDIF2[] = // DIF mit CR oder LF
609 {
610 'T', 'A', 'B', 'L', 'E',
611 M_DC,
612 '0', ',', '1',
613 M_DC,
614 '\"',
615 M_ENDE };
616
617 static const UINT16 pSylk[] = // Sylk
618 {
619 'I', 'D', ';',
620 M_ALT(3), 'P', 'N', 'E', // 'P' plus undocumented Excel extensions 'N' and 'E'
621 M_ENDE };
622
623 static const UINT16 *ppFilterPatterns[] = // Arrays mit Suchmustern
624 {
625 pLotus,
626 pExcel1,
627 pExcel2,
628 pExcel3,
629 pSc10,
630 pDIF1,
631 pDIF2,
632 pSylk,
633 pLotusNew,
634 pLotus2,
635 pQPro
636 };
637 const UINT16 nFilterCount = sizeof(ppFilterPatterns) / sizeof(ppFilterPatterns[0]);
638
639 static const sal_Char* const pFilterName[] = // zugehoerige Filter
640 {
641 pFilterLotus,
642 pFilterExcel4,
643 pFilterExcel4,
644 pFilterExcel4,
645 pFilterSc10,
646 pFilterDif,
647 pFilterDif,
648 pFilterSylk,
649 pFilterLotus,
650 pFilterLotus,
651 pFilterQPro6
652 };
653
654 // const UINT16 nByteMask = 0xFF;
655
656 // suchen Sie jetzt!
657 // ... realisiert ueber 'Mustererkennung'
658
659 BYTE nAkt;
660 BOOL bSync; // Datei und Muster stimmen ueberein
661 USHORT nFilter; // Zaehler ueber alle Filter
662 const UINT16 *pSearch; // aktuelles Musterwort
663
664 for ( nFilter = 0 ; nFilter < nFilterCount ; nFilter++ )
665 {
666 rStr.Seek( 0 ); // am Anfang war alles Uebel...
667 rStr >> nAkt;
668 pSearch = ppFilterPatterns[ nFilter ];
669 bSync = TRUE;
670 while( !rStr.IsEof() && bSync )
671 {
672 register UINT16 nMuster = *pSearch;
673
674 if( nMuster < 0x0100 )
675 { // direkter Byte-Vergleich
676 if( ( BYTE ) nMuster != nAkt )
677 bSync = FALSE;
678 }
679 else if( nMuster & M_DC )
680 { // don't care
681 }
682 else if( nMuster & M_ALT(0) )
683 { // alternative Bytes
684 BYTE nAnzAlt = ( BYTE ) nMuster;
685 bSync = FALSE; // zunaechst unsynchron
686 while( nAnzAlt > 0 )
687 {
688 pSearch++;
689 if( ( BYTE ) *pSearch == nAkt )
690 bSync = TRUE; // jetzt erst Synchronisierung
691 nAnzAlt--;
692 }
693 }
694 else if( nMuster & M_ENDE )
695 { // Format detected
696 if ( pFilterName[nFilter] == pFilterExcel4 && pPreselectedFilter &&
697 ( (pPreselectedFilter)->GetFilterName().EqualsAscii(pFilterEx4Temp) || pPreselectedFilter->GetTypeName().EqualsAscii("calc_MS_Excel_40") ) )
698 {
699 // Excel 4 erkannt, Excel 4 Vorlage eingestellt -> auch gut
700 // oder Excel 4 Filter anderer Applikation (simulated type detection!)
701 }
702 else
703 { // gefundenen Filter einstellen
704 pFilter = aMatcher.GetFilter4FilterName( String::CreateFromAscii(pFilterName[ nFilter ]) );
705 }
706 bSync = FALSE; // leave inner loop
707 nFilter = nFilterCount; // leave outer loop
708 }
709 else
710 { // Tabellenfehler
711 DBG_ERROR( "-ScApplication::DetectFilter(): Fehler in Mustertabelle");
712 }
713
714 pSearch++;
715 rStr >> nAkt;
716 }
717 }
718
719 if ( pPreselectedFilter && !pFilter )
720 {
721 // further checks for filters only if they are preselected: ASCII, HTML, RTF, DBase
722 // without the preselection other filters (Writer) take precedence
723 // DBase can't be detected reliably, so it also needs preselection
724 if ( pPreselectedFilter->GetFilterName().EqualsAscii(pFilterAscii) && lcl_MayBeAscii( rStr ) )
725 {
726 // Text filter is accepted if preselected
727 pFilter = pPreselectedFilter;
728 }
729 else
730 {
731 // get file header
732 rStr.Seek( 0 );
733 const int nTrySize = 80;
734 ByteString aHeader;
735 for ( int j = 0; j < nTrySize && !rStr.IsEof(); j++ )
736 {
737 sal_Char c;
738 rStr >> c;
739 aHeader += c;
740 }
741 aHeader += '\0';
742
743 if ( HTMLParser::IsHTMLFormat( aHeader.GetBuffer() ) )
744 {
745 // test for HTML
746 if ( pPreselectedFilter->GetName().EqualsAscii(pFilterHtml) )
747 {
748 pFilter = pPreselectedFilter;
749 }
750 else
751 {
752 pFilter = aMatcher.GetFilter4FilterName( String::CreateFromAscii(pFilterHtmlWeb) );
753 }
754 }
755 else if ( aHeader.CompareTo( "{\\rtf", 5 ) == COMPARE_EQUAL )
756 {
757 // test for RTF
758 pFilter = aMatcher.GetFilter4FilterName( String::CreateFromAscii(pFilterRtf) );
759 }
760 else if ( pPreselectedFilter->GetName().EqualsAscii(pFilterDBase) && lcl_MayBeDBase( rStr ) )
761 pFilter = pPreselectedFilter;
762 }
763 }
764 }
765 }
766 }
767 }
768 }
769
770 if ( nIndexOfInputStream == -1 && xStream.is() )
771 {
772 // if input stream wasn't part of the descriptor, now it should be, otherwise the content would be opend twice
773 lDescriptor.realloc( nPropertyCount + 1 );
774 lDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("InputStream");
775 lDescriptor[nPropertyCount].Value <<= xStream;
776 nPropertyCount++;
777 }
778
779 if ( nIndexOfContent == -1 && xContent.is() )
780 {
781 // if input stream wasn't part of the descriptor, now it should be, otherwise the content would be opend twice
782 lDescriptor.realloc( nPropertyCount + 1 );
783 lDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("UCBContent");
784 lDescriptor[nPropertyCount].Value <<= xContent;
785 nPropertyCount++;
786 }
787
788 if ( bReadOnly != bWasReadOnly )
789 {
790 if ( nIndexOfReadOnlyFlag == -1 )
791 {
792 lDescriptor.realloc( nPropertyCount + 1 );
793 lDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("ReadOnly");
794 lDescriptor[nPropertyCount].Value <<= bReadOnly;
795 nPropertyCount++;
796 }
797 else
798 lDescriptor[nIndexOfReadOnlyFlag].Value <<= bReadOnly;
799 }
800
801 if ( !bRepairPackage && bRepairAllowed )
802 {
803 lDescriptor.realloc( nPropertyCount + 1 );
804 lDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("RepairPackage");
805 lDescriptor[nPropertyCount].Value <<= bRepairAllowed;
806 nPropertyCount++;
807
808 bOpenAsTemplate = sal_True;
809
810 // TODO/LATER: set progress bar that should be used
811 }
812
813 if ( bOpenAsTemplate )
814 {
815 if ( nIndexOfTemplateFlag == -1 )
816 {
817 lDescriptor.realloc( nPropertyCount + 1 );
818 lDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("AsTemplate");
819 lDescriptor[nPropertyCount].Value <<= bOpenAsTemplate;
820 nPropertyCount++;
821 }
822 else
823 lDescriptor[nIndexOfTemplateFlag].Value <<= bOpenAsTemplate;
824 }
825
826 if ( aDocumentTitle.getLength() )
827 {
828 // the title was set here
829 if ( nIndexOfDocumentTitle == -1 )
830 {
831 lDescriptor.realloc( nPropertyCount + 1 );
832 lDescriptor[nPropertyCount].Name = ::rtl::OUString::createFromAscii("DocumentTitle");
833 lDescriptor[nPropertyCount].Value <<= aDocumentTitle;
834 nPropertyCount++;
835 }
836 else
837 lDescriptor[nIndexOfDocumentTitle].Value <<= aDocumentTitle;
838 }
839
840 if ( pFilter )
841 aTypeName = pFilter->GetTypeName();
842 else
843 aTypeName.Erase();
844 return aTypeName;
845 }
846
847 SFX_IMPL_SINGLEFACTORY( ScFilterDetect )
848
849 /* XServiceInfo */
850 UNOOUSTRING SAL_CALL ScFilterDetect::getImplementationName() throw( UNORUNTIMEEXCEPTION )
851 {
852 return impl_getStaticImplementationName();
853 }
854 \
855 /* XServiceInfo */
856 sal_Bool SAL_CALL ScFilterDetect::supportsService( const UNOOUSTRING& sServiceName ) throw( UNORUNTIMEEXCEPTION )
857 {
858 UNOSEQUENCE< UNOOUSTRING > seqServiceNames(getSupportedServiceNames());
859 const UNOOUSTRING* pArray = seqServiceNames.getConstArray();
860 for ( sal_Int32 nCounter=0; nCounter<seqServiceNames.getLength(); nCounter++ )
861 {
862 if ( pArray[nCounter] == sServiceName )
863 {
864 return sal_True ;
865 }
866 }
867 return sal_False ;
868 }
869
870 /* XServiceInfo */
871 UNOSEQUENCE< UNOOUSTRING > SAL_CALL ScFilterDetect::getSupportedServiceNames() throw( UNORUNTIMEEXCEPTION )
872 {
873 return impl_getStaticSupportedServiceNames();
874 }
875
876 /* Helper for XServiceInfo */
877 UNOSEQUENCE< UNOOUSTRING > ScFilterDetect::impl_getStaticSupportedServiceNames()
878 {
879 UNOMUTEXGUARD aGuard( UNOMUTEX::getGlobalMutex() );
880 UNOSEQUENCE< UNOOUSTRING > seqServiceNames( 1 );
881 seqServiceNames.getArray() [0] = UNOOUSTRING::createFromAscii( "com.sun.star.frame.ExtendedTypeDetection" );
882 return seqServiceNames ;
883 }
884
885 /* Helper for XServiceInfo */
886 UNOOUSTRING ScFilterDetect::impl_getStaticImplementationName()
887 {
888 return UNOOUSTRING::createFromAscii( "com.sun.star.comp.calc.FormatDetector" );
889 }
890
891 /* Helper for registry */
892 UNOREFERENCE< UNOXINTERFACE > SAL_CALL ScFilterDetect::impl_createInstance( const UNOREFERENCE< UNOXMULTISERVICEFACTORY >& xServiceManager ) throw( UNOEXCEPTION )
893 {
894 return UNOREFERENCE< UNOXINTERFACE >( *new ScFilterDetect( xServiceManager ) );
895 }
896
vba interoperability for OOo