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 // MARKER(update_precomp.py): autogen include statement, do not remove
23 #include "precompiled_sfx2.hxx"
24
25 #include <vcl/wrkwin.hxx>
26 #include <vcl/msgbox.hxx>
27 #include <tools/urlobj.hxx>
28 #include <tools/stream.hxx>
29 #include <sot/formats.hxx>
30 #include <svtools/filter.hxx>
31 #include <svtools/linkpolicy.hxx>
32 #include <sfx2/lnkbase.hxx>
33 #include <sfx2/app.hxx>
34 #include <sfx2/progress.hxx>
35 #include <sfx2/docfilt.hxx>
36 #include <sfx2/filedlghelper.hxx>
37 #include <sot/exchange.hxx>
38 #include <com/sun/star/uno/Any.hxx>
39 #include <com/sun/star/uno/Sequence.hxx>
40 #include <sfx2/docfac.hxx>
41 #include <com/sun/star/document/XTypeDetection.hpp>
42 #include <comphelper/mediadescriptor.hxx>
43 #include <comphelper/processfactory.hxx>
44 #include <sfx2/linkmgr.hxx>
45 #include <sfx2/opengrf.hxx>
46 #include "sfx2/sfxresid.hxx"
47 #include "fileobj.hxx"
48 #include "app.hrc"
49 #include <vcl/dibtools.hxx>
50
51 namespace css = ::com::sun::star;
52
53 #define FILETYPE_TEXT 1
54 #define FILETYPE_GRF 2
55 #define FILETYPE_OBJECT 3
56
57 struct Impl_DownLoadData
58 {
59 Graphic aGrf;
60 Timer aTimer;
61
Impl_DownLoadDataImpl_DownLoadData62 Impl_DownLoadData( const Link& rLink )
63 {
64 aTimer.SetTimeout( 100 );
65 aTimer.SetTimeoutHdl( rLink );
66 aGrf.SetDefaultType();
67 }
~Impl_DownLoadDataImpl_DownLoadData68 ~Impl_DownLoadData()
69 {
70 aTimer.Stop();
71 }
72 };
73
74 // --------------------------------------------------------------------------
75
76
SvFileObject()77 SvFileObject::SvFileObject() :
78 pDownLoadData( NULL ), pOldParent( NULL ), nType( FILETYPE_TEXT )
79 {
80 bLoadAgain = sal_True;
81 bSynchron = bLoadError = bWaitForData = bDataReady = bNativFormat =
82 bClearMedium = bStateChangeCalled = bInCallDownLoad = sal_False;
83 }
84
85
~SvFileObject()86 SvFileObject::~SvFileObject()
87 {
88 if ( xMed.Is() )
89 {
90 xMed->SetDataAvailableLink( Link() );
91 xMed->SetDoneLink( Link() );
92 xMed.Clear();
93 }
94 delete pDownLoadData;
95 }
96
97
GetData(::com::sun::star::uno::Any & rData,const String & rMimeType,sal_Bool bGetSynchron)98 sal_Bool SvFileObject::GetData( ::com::sun::star::uno::Any & rData,
99 const String & rMimeType,
100 sal_Bool bGetSynchron )
101 {
102 sal_uIntPtr nFmt = SotExchange::GetFormatStringId( rMimeType );
103 switch( nType )
104 {
105 case FILETYPE_TEXT:
106 if( FORMAT_FILE == nFmt )
107 {
108 // das Medium muss in der Applikation geoffnet werden, um die
109 // relativen Datei Links aufzuloesen!!!! Wird ueber den
110 // LinkManager und damit von dessen Storage erledigt.
111 rData <<= rtl::OUString( sFileNm );
112 }
113 break;
114
115 case FILETYPE_GRF:
116 if( !bLoadError )
117 {
118 SfxMediumRef xTmpMed;
119
120 if( FORMAT_GDIMETAFILE == nFmt || FORMAT_BITMAP == nFmt ||
121 SOT_FORMATSTR_ID_SVXB == nFmt )
122 {
123 Graphic aGrf;
124
125 //JP 15.07.98: Bug 52959
126 // falls das Nativformat doch erwuenscht ist, muss am
127 // Ende das Flag zurueckgesetzt werden.
128 // wird einzig und allein im sw/ndgrf.cxx benutzt, wenn der Link vom
129 // GraphicNode entfernt wird.
130 sal_Bool bOldNativFormat = bNativFormat;
131 //!!?? bNativFormat = 0 != (ASPECT_ICON & pSvData->GetAspect());
132
133 // falls gedruckt werden soll, warten wir bis die
134 // Daten vorhanden sind
135 if( bGetSynchron )
136 {
137 // testhalber mal ein LoadFile rufen um das nach-
138 // laden ueberahaupt anzustossen
139 if( !xMed.Is() )
140 LoadFile_Impl();
141
142 if( !bInCallDownLoad )
143 {
144 xTmpMed = xMed;
145 while( bWaitForData )
146 Application::Reschedule();
147
148 xMed = xTmpMed;
149 bClearMedium = sal_True;
150 }
151 }
152
153 if( pDownLoadData ||
154 ( !bWaitForData && ( xMed.Is() || // wurde als URL geladen
155 ( bSynchron && LoadFile_Impl() && xMed.Is() ) )) )
156 {
157 // falls
158
159 // falls es uebers Internet gesogen wurde, nicht
160 // wieder versuchen
161 if( !bGetSynchron )
162 bLoadAgain = !xMed->IsRemote();
163 bLoadError = !GetGraphic_Impl( aGrf, xMed->GetInStream() );
164 }
165 else if( !LoadFile_Impl() ||
166 !GetGraphic_Impl( aGrf, xMed.Is() ? xMed->GetInStream() : 0 ))
167 {
168 if( !xMed.Is() )
169 break;
170 aGrf.SetDefaultType();
171 }
172
173 if( SOT_FORMATSTR_ID_SVXB != nFmt )
174 nFmt = (bLoadError || GRAPHIC_BITMAP == aGrf.GetType())
175 ? FORMAT_BITMAP
176 : FORMAT_GDIMETAFILE;
177
178 SvMemoryStream aMemStm( 0, 65535 );
179 switch ( nFmt )
180 {
181 case SOT_FORMATSTR_ID_SVXB:
182 if( GRAPHIC_NONE != aGrf.GetType() )
183 {
184 aMemStm.SetVersion( SOFFICE_FILEFORMAT_50 );
185 aMemStm << aGrf;
186 }
187 break;
188
189 case FORMAT_BITMAP:
190 {
191 const Bitmap aBitmap(aGrf.GetBitmap());
192
193 if(!aBitmap.IsEmpty())
194 {
195 WriteDIB(aBitmap, aMemStm, false, true);
196 }
197
198 break;
199 }
200
201 default:
202 if( aGrf.GetGDIMetaFile().GetActionCount() )
203 {
204 GDIMetaFile aMeta( aGrf.GetGDIMetaFile() );
205 aMeta.Write( aMemStm );
206 }
207 }
208 rData <<= css::uno::Sequence< sal_Int8 >( (sal_Int8*) aMemStm.GetData(),
209 aMemStm.Seek( STREAM_SEEK_TO_END ) );
210
211 bNativFormat = bOldNativFormat;
212
213 // alles fertig?
214 if( xMed.Is() && !bSynchron && bClearMedium )
215 {
216 xMed.Clear();
217 bClearMedium = sal_False;
218 }
219 }
220 }
221 break;
222 case FILETYPE_OBJECT:
223 // TODO/LATER: possibility to insert a new object
224 rData <<= rtl::OUString( sFileNm );
225 break;
226 }
227 return sal_True/*0 != aTypeList.Count()*/;
228 }
229
230
231
232
Connect(sfx2::SvBaseLink * pLink)233 sal_Bool SvFileObject::Connect( sfx2::SvBaseLink* pLink )
234 {
235 if( !pLink || !pLink->GetLinkManager() )
236 return sal_False;
237
238 // teste doch mal, ob nicht ein anderer Link mit der gleichen
239 // Verbindung schon existiert
240 pLink->GetLinkManager()->GetDisplayNames( pLink, 0, &sFileNm, 0, &sFilter );
241
242 if( OBJECT_CLIENT_GRF == pLink->GetObjType() )
243 {
244 SfxObjectShellRef pShell = pLink->GetLinkManager()->GetPersist();
245 if( pShell.Is() )
246 {
247 if( pShell->IsAbortingImport() )
248 return sal_False;
249
250 if( pShell->GetMedium() )
251 sReferer = pShell->GetMedium()->GetName();
252 }
253 }
254
255 switch( pLink->GetObjType() )
256 {
257 case OBJECT_CLIENT_GRF:
258 nType = FILETYPE_GRF;
259 bSynchron = pLink->IsSynchron();
260 break;
261
262 case OBJECT_CLIENT_FILE:
263 nType = FILETYPE_TEXT;
264 break;
265
266 case OBJECT_CLIENT_OLE:
267 nType = FILETYPE_OBJECT;
268 // TODO/LATER: introduce own type to be used for exchanging
269 break;
270
271 default:
272 return sal_False;
273 }
274
275 SetUpdateTimeout( 0 );
276
277 // und jetzt bei diesem oder gefundenem Pseudo-Object anmelden
278 AddDataAdvise( pLink, SotExchange::GetFormatMimeType( pLink->GetContentType()), 0 );
279 return sal_True;
280 }
281
282
LoadFile_Impl()283 sal_Bool SvFileObject::LoadFile_Impl()
284 {
285 // wir sind noch im Laden!!
286 if( bWaitForData || !bLoadAgain || xMed.Is() || pDownLoadData )
287 return sal_False;
288
289 // The name is document content, so the shared policy decides before the
290 // fetch (see svtools/linkpolicy.hxx). The question is the LinkManager's
291 // existing one, asked at most once per document.
292 if( !::svt::linkpolicy::mayLoadDocumentReference( sFileNm ) )
293 {
294 bLoadAgain = sal_False;
295 return sal_False;
296 }
297
298 // z.Z. nur auf die aktuelle DocShell
299 xMed = new SfxMedium( sFileNm, STREAM_STD_READ, sal_True );
300 SvLinkSource::StreamToLoadFrom aStreamToLoadFrom =
301 getStreamToLoadFrom();
302 xMed->setStreamToLoadFrom(
303 aStreamToLoadFrom.m_xInputStreamToLoadFrom,
304 aStreamToLoadFrom.m_bIsReadOnly);
305 // setStreamToLoadFrom(0,0);
306 if( sReferer.Len() )
307 xMed->SetReferer( sReferer );
308
309 if( !bSynchron )
310 {
311 bLoadAgain = bDataReady = bInNewData = sal_False;
312 bWaitForData = sal_True;
313
314 SfxMediumRef xTmpMed = xMed;
315 xMed->SetDataAvailableLink( STATIC_LINK( this, SvFileObject, LoadGrfNewData_Impl ) );
316 bInCallDownLoad = sal_True;
317 xMed->DownLoad( STATIC_LINK( this, SvFileObject, LoadGrfReady_Impl ) );
318 bInCallDownLoad = sal_False;
319
320 bClearMedium = !xMed.Is();
321 if( bClearMedium )
322 xMed = xTmpMed; // falls gleich im DownLoad schon schluss ist
323 return bDataReady;
324 }
325
326 bWaitForData = sal_True;
327 bDataReady = bInNewData = sal_False;
328 xMed->DownLoad();
329 bLoadAgain = !xMed->IsRemote();
330 bWaitForData = sal_False;
331
332 // Grafik ist fertig, also DataChanged von der Statusaederung schicken:
333 SendStateChg_Impl( xMed->GetInStream() && xMed->GetInStream()->GetError()
334 ? sfx2::LinkManager::STATE_LOAD_ERROR : sfx2::LinkManager::STATE_LOAD_OK );
335 return sal_True;
336 }
337
338
GetGraphic_Impl(Graphic & rGrf,SvStream * pStream)339 sal_Bool SvFileObject::GetGraphic_Impl( Graphic& rGrf, SvStream* pStream )
340 {
341 // A second way out: with no stream and no medium the filter opens sFileNm
342 // itself. Ask here too; the answer is remembered per document.
343 if( !::svt::linkpolicy::mayLoadDocumentReference( sFileNm ) )
344 return sal_False;
345
346 GraphicFilter* pGF = GraphicFilter::GetGraphicFilter();
347
348 const sal_uInt16 nFilter = sFilter.Len() && pGF->GetImportFormatCount()
349 ? pGF->GetImportFormatNumber( sFilter )
350 : GRFILTER_FORMAT_DONTKNOW;
351
352 String aEmptyStr;
353 int nRes;
354
355 // vermeiden, dass ein native Link angelegt wird
356 if( ( !pStream || !pDownLoadData ) && !rGrf.IsLink() &&
357 !rGrf.GetContext() && !bNativFormat )
358 rGrf.SetLink( GfxLink() );
359
360 if( !pStream )
361 nRes = xMed.Is() ? GRFILTER_OPENERROR
362 : pGF->ImportGraphic( rGrf, INetURLObject(sFileNm),
363 nFilter );
364 else if( !pDownLoadData )
365 {
366 pStream->Seek( STREAM_SEEK_TO_BEGIN );
367
368 // #123042# for e.g. SVG the path is needed, see same TaskID in svx for more info
369 nRes = pGF->ImportGraphic( rGrf, sFileNm, *pStream, nFilter );
370 }
371 else
372 {
373 nRes = pGF->ImportGraphic( pDownLoadData->aGrf, aEmptyStr,
374 *pStream, nFilter );
375
376 if( pDownLoadData )
377 {
378 rGrf = pDownLoadData->aGrf;
379 if( GRAPHIC_NONE == rGrf.GetType() )
380 rGrf.SetDefaultType();
381
382
383 if( !pDownLoadData->aGrf.GetContext() )
384 {
385 xMed->SetDataAvailableLink( Link() );
386 // xMed->SetDoneLink( Link() );
387 delete pDownLoadData, pDownLoadData = 0;
388 bDataReady = sal_True;
389 bWaitForData = sal_False;
390 }
391 else if( sal_False )
392 {
393 // Timer aufsetzen, um zurueck zukehren
394 pDownLoadData->aTimer.Start();
395 }
396 }
397 }
398
399 if( pStream && ERRCODE_IO_PENDING == pStream->GetError() )
400 pStream->ResetError();
401
402 #ifdef DBG_UTIL
403 if( nRes )
404 {
405 if( xMed.Is() && !pStream )
406 {
407 DBG_WARNING3( "GrafikFehler [%d] - [%s] URL[%s]",
408 nRes,
409 xMed->GetPhysicalName().GetBuffer(),
410 sFileNm.GetBuffer() );
411 }
412 else
413 {
414 DBG_WARNING2( "GrafikFehler [%d] - [%s]",
415 nRes, sFileNm.GetBuffer() );
416 }
417 }
418 #endif
419
420 return GRFILTER_OK == nRes;
421 }
422
423 /** detect the filter of the given file
424
425 @param _rURL
426 specifies the URL of the file which filter is to detected.<br/>
427 If the URL doesn't denote a valid (existent and accessible) file, the
428 request is silently dropped.
429 */
impl_getFilter(const String & _rURL)430 String impl_getFilter( const String& _rURL )
431 {
432 String sFilter;
433 if ( _rURL.Len() == 0 )
434 return sFilter;
435
436 try
437 {
438 css::uno::Reference< ::com::sun::star::document::XTypeDetection > xTypeDetection(
439 ::comphelper::getProcessServiceFactory()->createInstance(
440 ::rtl::OUString::createFromAscii("com.sun.star.document.TypeDetection") ),
441 css::uno::UNO_QUERY );
442 if ( xTypeDetection.is() )
443 {
444 ::comphelper::MediaDescriptor aDescr;
445 aDescr[ ::comphelper::MediaDescriptor::PROP_URL() ] <<= ::rtl::OUString( _rURL );
446 css::uno::Sequence< css::beans::PropertyValue > aDescrList =
447 aDescr.getAsConstPropertyValueList();
448 ::rtl::OUString sType = xTypeDetection->queryTypeByDescriptor( aDescrList, sal_True );
449 if ( sType.getLength() )
450 {
451 css::uno::Reference< css::container::XNameAccess > xTypeCont( xTypeDetection,
452 css::uno::UNO_QUERY );
453 if ( xTypeCont.is() )
454 {
455 ::comphelper::SequenceAsHashMap lTypeProps( xTypeCont->getByName( sType ) );
456 sFilter = lTypeProps.getUnpackedValueOrDefault(
457 ::rtl::OUString::createFromAscii("PreferredFilter"), ::rtl::OUString() );
458 }
459 }
460 }
461 }
462 catch( const css::uno::Exception& )
463 {
464 }
465
466 return sFilter;
467 }
468
Edit(Window * pParent,sfx2::SvBaseLink * pLink,const Link & rEndEditHdl)469 void SvFileObject::Edit( Window* pParent, sfx2::SvBaseLink* pLink, const Link& rEndEditHdl )
470 {
471 aEndEditLink = rEndEditHdl;
472 String sFile, sRange, sTmpFilter;
473 if( pLink && pLink->GetLinkManager() )
474 {
475 pLink->GetLinkManager()->GetDisplayNames( pLink, 0, &sFile, &sRange, &sTmpFilter );
476
477 switch( pLink->GetObjType() )
478 {
479 case OBJECT_CLIENT_GRF:
480 {
481 nType = FILETYPE_GRF; // falls noch nicht gesetzt
482
483 SvxOpenGraphicDialog aDlg(SfxResId(RID_SVXSTR_EDITGRFLINK));
484 aDlg.EnableLink(sal_False);
485 aDlg.SetPath( sFile, sal_True );
486 aDlg.SetCurrentFilter( sTmpFilter );
487
488 if( !aDlg.Execute() )
489 {
490 sFile = aDlg.GetPath();
491 sFile += ::sfx2::cTokenSeperator;
492 sFile += ::sfx2::cTokenSeperator;
493 sFile += aDlg.GetCurrentFilter();
494
495 if ( aEndEditLink.IsSet() )
496 aEndEditLink.Call( &sFile );
497 }
498 else
499 sFile.Erase();
500 }
501 break;
502
503 case OBJECT_CLIENT_OLE:
504 {
505 nType = FILETYPE_OBJECT; // if not set already
506 pOldParent = Application::GetDefDialogParent();
507 Application::SetDefDialogParent( pParent );
508
509 ::sfx2::FileDialogHelper* pFileDlg =
510 pLink->GetFileDialog( (SFXWB_INSERT | WB_3DLOOK), String() );
511 pFileDlg->StartExecuteModal( LINK( this, SvFileObject, DialogClosedHdl ) );
512 }
513 break;
514
515 case OBJECT_CLIENT_FILE:
516 {
517 nType = FILETYPE_TEXT; // if not set already
518 pOldParent = Application::GetDefDialogParent();
519 Application::SetDefDialogParent( pParent );
520
521 String sFactory;
522 SfxObjectShell* pShell = pLink->GetLinkManager()->GetPersist();
523 if ( pShell )
524 sFactory = pShell->GetFactory().GetFactoryName();
525
526 ::sfx2::FileDialogHelper* pFileDlg =
527 pLink->GetFileDialog( (SFXWB_INSERT | WB_3DLOOK), sFactory );
528 pFileDlg->StartExecuteModal( LINK( this, SvFileObject, DialogClosedHdl ) );
529 }
530 break;
531
532 default:
533 sFile.Erase();
534 }
535 }
536 }
537
IMPL_STATIC_LINK(SvFileObject,LoadGrfReady_Impl,void *,EMPTYARG)538 IMPL_STATIC_LINK( SvFileObject, LoadGrfReady_Impl, void*, EMPTYARG )
539 {
540 // wenn wir von hier kommen, kann es kein Fehler mehr sein
541 pThis->bLoadError = sal_False;
542 pThis->bWaitForData = sal_False;
543 pThis->bInCallDownLoad = sal_False;
544
545 if( !pThis->bInNewData && !pThis->bDataReady )
546 {
547 // Grafik ist fertig, also DataChanged von der Status-
548 // aederung schicken:
549 pThis->bDataReady = sal_True;
550 pThis->SendStateChg_Impl( sfx2::LinkManager::STATE_LOAD_OK );
551
552 // und dann nochmal die Daten senden
553 pThis->NotifyDataChanged();
554 }
555
556 if( pThis->bDataReady )
557 {
558 pThis->bLoadAgain = sal_True;
559 if( pThis->xMed.Is() )
560 {
561 pThis->xMed->SetDataAvailableLink( Link() );
562 pThis->xMed->SetDoneLink( Link() );
563
564 Application::PostUserEvent(
565 STATIC_LINK( pThis, SvFileObject, DelMedium_Impl ),
566 new SfxMediumRef( pThis->xMed ));
567 pThis->xMed.Clear();
568 }
569 if( pThis->pDownLoadData )
570 delete pThis->pDownLoadData, pThis->pDownLoadData = 0;
571 }
572
573 return 0;
574 }
575
IMPL_STATIC_LINK(SvFileObject,DelMedium_Impl,SfxMediumRef *,pDelMed)576 IMPL_STATIC_LINK( SvFileObject, DelMedium_Impl, SfxMediumRef*, pDelMed )
577 {
578 (void)pThis;
579 delete pDelMed;
580 return 0;
581 }
582
IMPL_STATIC_LINK(SvFileObject,LoadGrfNewData_Impl,void *,EMPTYARG)583 IMPL_STATIC_LINK( SvFileObject, LoadGrfNewData_Impl, void*, EMPTYARG )
584 {
585 // wenn wir von hier kommen, kann es kein Fehler mehr sein
586 if( pThis->bInNewData )
587 return 0;
588
589 pThis->bInNewData = sal_True;
590 pThis->bLoadError = sal_False;
591
592 if( !pThis->pDownLoadData )
593 {
594 pThis->pDownLoadData = new Impl_DownLoadData(
595 STATIC_LINK( pThis, SvFileObject, LoadGrfNewData_Impl ) );
596
597 // Null-Link setzen, damit keine temporaeren Grafiken
598 // rausgeswapt werden; der Filter prueft, ob schon
599 // ein Link gesetzt ist => falls dies zutrifft, wird
600 // _kein_ neuer Link gesetzt; der Link muss hier gesetzt werden,
601 // (bevor das erste Mal gefiltert wird), um zu verhindern,
602 // dass der Kontext zurueckgesetzt wird (aynchrones Laden)
603 if( !pThis->bNativFormat )
604 {
605 static GfxLink aDummyLink;
606 pThis->pDownLoadData->aGrf.SetLink( aDummyLink );
607 }
608 }
609
610 pThis->NotifyDataChanged();
611
612 SvStream* pStrm = pThis->xMed.Is() ? pThis->xMed->GetInStream() : 0;
613 if( pStrm && pStrm->GetError() )
614 {
615 if( ERRCODE_IO_PENDING == pStrm->GetError() )
616 pStrm->ResetError();
617
618 // im DataChanged ein DataReady?
619 else if( pThis->bWaitForData && pThis->pDownLoadData )
620 {
621 pThis->bLoadError = sal_True;
622 }
623 }
624
625 if( pThis->bDataReady )
626 {
627 // Grafik ist fertig, also DataChanged von der Status-
628 // aederung schicken:
629 pThis->SendStateChg_Impl( pStrm->GetError() ? sfx2::LinkManager::STATE_LOAD_ERROR : sfx2::LinkManager::STATE_LOAD_OK );
630 }
631
632 pThis->bInNewData = sal_False;
633 return 0;
634 }
635
IMPL_LINK(SvFileObject,DialogClosedHdl,sfx2::FileDialogHelper *,_pFileDlg)636 IMPL_LINK( SvFileObject, DialogClosedHdl, sfx2::FileDialogHelper*, _pFileDlg )
637 {
638 String sFile;
639 Application::SetDefDialogParent( pOldParent );
640
641 if ( FILETYPE_TEXT == nType || FILETYPE_OBJECT == nType )
642 {
643 if ( _pFileDlg && _pFileDlg->GetError() == ERRCODE_NONE )
644 {
645 String sURL( _pFileDlg->GetPath() );
646 sFile = sURL;
647 sFile += ::sfx2::cTokenSeperator;
648 sFile += ::sfx2::cTokenSeperator;
649 sFile += impl_getFilter( sURL );
650 }
651 }
652 else
653 {
654 DBG_ERRORFILE( "SvFileObject::DialogClosedHdl(): wrong file type" );
655 }
656
657 if ( aEndEditLink.IsSet() )
658 aEndEditLink.Call( &sFile );
659 return 0;
660 }
661
662 /* [Beschreibung]
663
664 Die Methode stellt fest, ob aus einem DDE-Object die Daten gelesen
665 werden kann.
666 Zurueckgegeben wird:
667 ERRCODE_NONE wenn sie komplett gelesen wurde
668 ERRCODE_SO_PENDING wenn sie noch nicht komplett gelesen wurde
669 ERRCODE_SO_FALSE sonst
670 */
IsPending() const671 sal_Bool SvFileObject::IsPending() const
672 {
673 return FILETYPE_GRF == nType && !bLoadError &&
674 ( pDownLoadData || bWaitForData );
675 }
IsDataComplete() const676 sal_Bool SvFileObject::IsDataComplete() const
677 {
678 sal_Bool bRet = sal_False;
679 if( FILETYPE_GRF != nType )
680 bRet = sal_True;
681 else if( !bLoadError && ( !bWaitForData && !pDownLoadData ))
682 {
683 SvFileObject* pThis = (SvFileObject*)this;
684 if( bDataReady ||
685 ( bSynchron && pThis->LoadFile_Impl() && xMed.Is() ) )
686 bRet = sal_True;
687 else
688 {
689 INetURLObject aUrl( sFileNm );
690 if( aUrl.HasError() ||
691 INET_PROT_NOT_VALID == aUrl.GetProtocol() )
692 bRet = sal_True;
693 }
694 }
695 return bRet;
696 }
697
698
699
CancelTransfers()700 void SvFileObject::CancelTransfers()
701 {
702 // und aus dem Cache austragen, wenn man mitten im Laden ist
703 if( !bDataReady )
704 {
705 // nicht noch mal aufsetzen
706 bLoadAgain = sal_False;
707 bDataReady = bLoadError = bWaitForData = sal_True;
708 SendStateChg_Impl( sfx2::LinkManager::STATE_LOAD_ABORT );
709 }
710 }
711
712
SendStateChg_Impl(sfx2::LinkManager::LinkState nState)713 void SvFileObject::SendStateChg_Impl( sfx2::LinkManager::LinkState nState )
714 {
715 if( !bStateChangeCalled && HasDataLinks() )
716 {
717 css::uno::Any aAny;
718 aAny <<= rtl::OUString::valueOf( (sal_Int32)nState );
719 DataChanged( SotExchange::GetFormatName(
720 sfx2::LinkManager::RegisterStatusInfoId()), aAny );
721 bStateChangeCalled = sal_True;
722 }
723 }
724