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