?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sfx2 / source / view / viewfrm.cxx
blob8f406833a5a8ef81d952ad75c6a0b7137922d966
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: viewfrm.cxx,v $
10 * $Revision: 1.136.8.1 $
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_sfx2.hxx"
33
34 #include <stdio.h>
35
36 #include <sfx2/viewfrm.hxx>
37 #include <com/sun/star/document/MacroExecMode.hpp>
38 #include <com/sun/star/frame/XLoadable.hpp>
39 #include <com/sun/star/frame/XLayoutManager.hpp>
40
41 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
42 #include <toolkit/unohlp.hxx>
43 #endif
44 #ifndef _SPLITWIN_HXX //autogen
45 #include <vcl/splitwin.hxx>
46 #endif
47 #include <svtools/moduleoptions.hxx>
48 #include <svtools/intitem.hxx>
49 #include <svtools/stritem.hxx>
50 #include <svtools/eitem.hxx>
51 #include <svtools/slstitm.hxx>
52 #include <svtools/whiter.hxx>
53 #include <svtools/undo.hxx>
54 #ifndef _MSGBOX_HXX //autogen
55 #include <vcl/msgbox.hxx>
56 #endif
57 #include <svtools/sfxecode.hxx>
58 #include <svtools/ehdl.hxx>
59 #include <com/sun/star/container/XIndexAccess.hpp>
60 #include <com/sun/star/frame/XFramesSupplier.hpp>
61 #include <com/sun/star/frame/FrameSearchFlag.hpp>
62 #include <com/sun/star/frame/XFrame.hpp>
63 #include <com/sun/star/frame/XFrames.hpp>
64 #include <com/sun/star/frame/XFramesSupplier.hpp>
65 #include <com/sun/star/awt/XWindow.hpp>
66 #include <com/sun/star/frame/XController.hpp>
67 #include <com/sun/star/frame/XModel.hpp>
68 #include <com/sun/star/util/XURLTransformer.hpp>
69 #include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>
70 #include <com/sun/star/document/MacroExecMode.hpp>
71 #include <com/sun/star/document/UpdateDocMode.hpp>
72 #include <com/sun/star/beans/XPropertySet.hpp>
73 #include <com/sun/star/uri/XUriReferenceFactory.hpp>
74 #include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
75 #include <com/sun/star/embed/XStorage.hpp>
76 #include <com/sun/star/embed/EmbedStates.hpp>
77 #include <rtl/ustrbuf.hxx>
78
79 #include <unotools/localfilehelper.hxx>
80 #include <unotools/ucbhelper.hxx>
81 #include <comphelper/processfactory.hxx>
82 #include <comphelper/configurationhelper.hxx>
83
84 #include <com/sun/star/uno/Reference.h>
85 #include <com/sun/star/ucb/XContent.hpp>
86
87 #include <basic/basmgr.hxx>
88 #include <basic/sbmod.hxx>
89 #include <basic/sbmeth.hxx>
90 #include <basic/sbx.hxx>
91 #include <comphelper/storagehelper.hxx>
92 #include <svtools/asynclink.hxx>
93 #include <svtools/sharecontrolfile.hxx>
94
95 using namespace ::com::sun::star;
96 using namespace ::com::sun::star::uno;
97 using namespace ::com::sun::star::ucb;
98 using namespace ::com::sun::star::frame;
99 using namespace ::com::sun::star::lang;
100 namespace css = ::com::sun::star;
101
102 #ifndef GCC
103 #endif
104
105 // wg. ViewFrame::Current
106 #include "appdata.hxx"
107 #include <sfx2/app.hxx>
108 #include <sfx2/objface.hxx>
109 #include "openflag.hxx"
110 #include "objshimp.hxx"
111 #include <sfx2/viewsh.hxx>
112 #include <sfx2/objsh.hxx>
113 #include <sfx2/bindings.hxx>
114 #include <sfx2/dispatch.hxx>
115 #include "arrdecl.hxx"
116 #include "sfxtypes.hxx"
117 #include <sfx2/request.hxx>
118 #include <sfx2/docfac.hxx>
119 #include <sfx2/ipclient.hxx>
120 #include "sfxresid.hxx"
121 #include "appbas.hxx"
122 #include <sfx2/objitem.hxx>
123 #include "viewfac.hxx"
124 #include <sfx2/event.hxx>
125 #include "fltfnc.hxx"
126 #include <sfx2/docfile.hxx>
127 #include <sfx2/module.hxx>
128 #include <sfx2/msgpool.hxx>
129 #include <sfx2/topfrm.hxx>
130 #include "viewimp.hxx"
131 #include <sfx2/sfxbasecontroller.hxx>
132 #include <sfx2/sfx.hrc>
133 #include "view.hrc"
134 #include <sfx2/frmdescr.hxx>
135 #include <sfx2/sfxuno.hxx>
136 #include <sfx2/progress.hxx>
137 #include "workwin.hxx"
138 #include "helper.hxx"
139 #include "macro.hxx"
140 #include "minfitem.hxx"
141 #include "../appl/app.hrc"
142 //-------------------------------------------------------------------------
143 DBG_NAME(SfxViewFrame)
144
145 #define SfxViewFrame
146 #include "sfxslots.hxx"
147
148 //-------------------------------------------------------------------------
149
150 SFX_IMPL_INTERFACE(SfxViewFrame,SfxShell,SfxResId(0))
151 {
152 SFX_CHILDWINDOW_REGISTRATION( SID_BROWSER );
153 SFX_CHILDWINDOW_REGISTRATION( SID_RECORDING_FLOATWINDOW );
154
155 SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_FULLSCREEN | SFX_VISIBILITY_FULLSCREEN, SfxResId(RID_FULLSCREENTOOLBOX) );
156 SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_APPLICATION | SFX_VISIBILITY_STANDARD, SfxResId(RID_ENVTOOLBOX) );
157 }
158
159 TYPEINIT2(SfxViewFrame,SfxShell,SfxListener);
160 TYPEINIT1(SfxViewFrameItem, SfxPoolItem);
161
162 //=========================================================================
163
164 struct SfxViewFrame_Impl
165 {
166 SvBorder aBorder;
167 Size aMargin;
168 Size aSize;
169 String aViewData;
170 String aFrameTitle;
171 TypeId aLastType;
172 String aActualURL;
173 String aActualPresentationURL;
174 SfxFrame* pFrame;
175 SfxCancelManager* pCancelMgr;
176 svtools::AsynchronLink* pReloader;
177 //SfxInPlaceFrame* pIPFrame;
178 Window* pWindow;
179 SfxViewFrame* pActiveChild;
180 SfxViewFrame* pParentViewFrame;
181 SfxObjectShell* pImportShell;
182 Window* pFocusWin;
183 SfxMacro* pMacro;
184 sal_uInt16 nDocViewNo;
185 sal_uInt16 nCurViewId;
186 sal_Bool bResizeInToOut:1;
187 sal_Bool bDontOverwriteResizeInToOut:1;
188 sal_Bool bObjLocked:1;
189 sal_Bool bRestoreView:1;
190 sal_Bool bSetViewFrameLocked:1;
191 sal_Bool bReloading:1;
192 sal_Bool bIsDowning:1;
193 sal_Bool bInCtor:1;
194 sal_Bool bModal:1;
195 sal_Bool bEnabled:1;
196 sal_Bool bEventFlag:1;
197 sal_Bool bWindowWasEnabled:1;
198
199 SfxViewFrame_Impl()
200 : pReloader(0 )
201 , pMacro( 0 )
202 , bWindowWasEnabled(sal_True)
203 {}
204
205 ~SfxViewFrame_Impl()
206 {
207 delete pReloader;
208 delete pCancelMgr;
209 }
210 };
211
212 //-------------------------------------------------------------------------
213 void SfxViewFrame::SetDowning_Impl()
214 {
215 pImp->bIsDowning = sal_True;
216 }
217
218 //-------------------------------------------------------------------------
219 sal_Bool SfxViewFrame::IsDowning_Impl() const
220 {
221 return pImp->bIsDowning;
222 }
223
224
225 //-------------------------------------------------------------------------
226 void SfxViewFrame::SetSetViewFrameAllowed_Impl( sal_Bool bSet )
227 {
228 pImp->bSetViewFrameLocked = !bSet;
229 };
230
231 //-------------------------------------------------------------------------
232 sal_Bool SfxViewFrame::IsSetViewFrameAllowed_Impl() const
233 {
234 return !pImp->bSetViewFrameLocked;
235 }
236
237 //-------------------------------------------------------------------------
238 void SfxViewFrame::SetImportingObjectShell_Impl( SfxObjectShell* pSh )
239 {
240 pImp->pImportShell = pSh;
241 }
242
243 //--------------------------------------------------------------------
244 SfxObjectShell* SfxViewFrame::GetImportingObjectShell_Impl() const
245 {
246 return pImp->pImportShell;
247 }
248
249
250 class SfxViewNotificatedFrameList_Impl :
251 public SfxListener, public SfxViewFrameArr_Impl
252 {
253 public:
254
255 void InsertViewFrame( SfxViewFrame* pFrame )
256 {
257 StartListening( *pFrame );
258 C40_INSERT( SfxViewFrame, pFrame, Count() );
259 }
260 void Notify( SfxBroadcaster& rBC, const SfxHint& rHint );
261 };
262
263 //-------------------------------------------------------------------------
264 void SfxViewNotificatedFrameList_Impl::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
265 {
266 if ( rHint.IsA(TYPE(SfxSimpleHint)) )
267 {
268 switch( ( (SfxSimpleHint&) rHint ).GetId() )
269 {
270 case SFX_HINT_DYING:
271 SfxViewFrame* pFrame = (SfxViewFrame*) &rBC;
272 if( pFrame )
273 {
274 sal_uInt16 nPos = C40_GETPOS( SfxViewFrame, pFrame );
275 if( nPos != USHRT_MAX )
276 Remove( nPos );
277 }
278 break;
279 }
280 }
281 }
282
283 //-------------------------------------------------------------------------
284
285 long ReloadDecouple_Impl( void* pObj, void* pArg )
286 {
287 ((SfxViewFrame*) pObj)->ExecReload_Impl( *(SfxRequest*)pArg );
288 return 0;
289 }
290
291 void SfxViewFrame::ExecReload_Impl( SfxRequest& rReq, sal_Bool bAsync )
292 {
293 if( bAsync )
294 {
295 if( !pImp->pReloader )
296 pImp->pReloader = new svtools::AsynchronLink(
297 Link( this, ReloadDecouple_Impl ) );
298 pImp->pReloader->Call( new SfxRequest( rReq ) );
299 }
300 else ExecReload_Impl( rReq );
301 }
302
303 void SfxViewFrame::ExecReload_Impl( SfxRequest& rReq )
304 {
305 SfxFrame *pParent = GetFrame()->GetParentFrame();
306 if ( rReq.GetSlot() == SID_RELOAD )
307 {
308 // Bei CTRL-Reload den aktiven Frame reloaden
309 SfxViewFrame* pActFrame = this;
310 while ( pActFrame )
311 pActFrame = pActFrame->GetActiveChildFrame_Impl();
312
313 if ( pActFrame )
314 {
315 sal_uInt16 nModifier = rReq.GetModifier();
316 if ( nModifier & KEY_MOD1 )
317 {
318 pActFrame->ExecReload_Impl( rReq );
319 return;
320 }
321 }
322
323 // Wenn nur ein Reload der Graphiken eines oder mehrerer ChildFrames
324 // gemacht werden soll
325 SfxFrame *pFrame = GetFrame();
326 if ( pParent == pFrame && pFrame->GetChildFrameCount() )
327 {
328 sal_Bool bReloadAvailable = sal_False;
329 SfxFrameIterator aIter( *pFrame, sal_False );
330 SfxFrame *pChild = aIter.FirstFrame();
331 while ( pChild )
332 {
333 SfxFrame *pNext = aIter.NextFrame( *pChild );
334 SfxObjectShell *pShell = pChild->GetCurrentDocument();
335 if( pShell && pShell->Get_Impl()->bReloadAvailable )
336 {
337 bReloadAvailable = sal_True;
338 pChild->GetCurrentViewFrame()->ExecuteSlot( rReq );
339 }
340 pChild = pNext;
341 }
342
343 // Der TopLevel-Frame selbst het keine Graphiken!
344 if ( bReloadAvailable )
345 return;
346 }
347 }
348 else
349 {
350 // Bei CTRL-Edit den TopFrame bearbeiten
351 sal_uInt16 nModifier = rReq.GetModifier();
352
353 if ( ( nModifier & KEY_MOD1 ) && pParent )
354 {
355 SfxViewFrame *pTop = GetTopViewFrame();
356 pTop->ExecReload_Impl( rReq );
357 return;
358 }
359 }
360
361 SfxObjectShell* pSh = GetObjectShell();
362 sal_Bool bWasReadonly = pSh->IsReadOnly();
363
364 switch ( rReq.GetSlot() )
365 {
366 case SID_EDITDOC:
367 {
368 if ( GetFrame()->HasComponent() )
369 break;
370
371 // Wg. Doppeltbelegung in Toolboxen (mit/ohne Ctrl) ist es auch
372 // m"oglich, da\s der Slot zwar enabled ist, aber Ctrl-Click
373 // trotzdem nicht geht!
374 if( !pSh || !pSh->HasName() || !(pSh->Get_Impl()->nLoadedFlags & SFX_LOADED_MAINDOCUMENT ))
375 break;
376
377 SFX_ITEMSET_ARG( pSh->GetMedium()->GetItemSet(), pItem, SfxBoolItem, SID_VIEWONLY, sal_False );
378 if ( pItem && pItem->GetValue() )
379 {
380 SfxMedium* pMed = pSh->GetMedium();
381 SfxApplication* pApp = SFX_APP();
382 SfxAllItemSet aSet( pApp->GetPool() );
383 aSet.Put( SfxStringItem( SID_FILE_NAME, pMed->GetURLObject().GetMainURL(INetURLObject::NO_DECODE) ) );
384 aSet.Put( SfxBoolItem( SID_TEMPLATE, sal_True ) );
385 aSet.Put( SfxStringItem( SID_TARGETNAME, String::CreateFromAscii("_blank") ) );
386 SFX_ITEMSET_ARG( pMed->GetItemSet(), pReferer, SfxStringItem, SID_REFERER, sal_False );
387 if ( pReferer )
388 aSet.Put( *pReferer );
389 SFX_ITEMSET_ARG( pSh->GetMedium()->GetItemSet(), pVersionItem, SfxInt16Item, SID_VERSION, sal_False );
390 if ( pVersionItem )
391 aSet.Put( *pVersionItem );
392
393 if( pMed->GetFilter() )
394 {
395 aSet.Put( SfxStringItem( SID_FILTER_NAME, pMed->GetFilter()->GetFilterName() ) );
396 SFX_ITEMSET_ARG( pMed->GetItemSet(), pOptions, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False );
397 if ( pOptions )
398 aSet.Put( *pOptions );
399 }
400
401 GetDispatcher()->Execute( SID_OPENDOC, SFX_CALLMODE_ASYNCHRON, aSet );
402 return;
403 }
404
405 sal_uInt16 nOpenMode;
406 sal_Bool bNeedsReload = sal_False;
407 if ( !pSh->IsReadOnly() )
408 {
409 // Speichern und Readonly Reloaden
410 if( pSh->IsModified() )
411 {
412 if ( !pSh->PrepareClose() )
413 {
414 rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), sal_False ) );
415 return;
416 }
417 else bNeedsReload = sal_True;
418 }
419 nOpenMode = SFX_STREAM_READONLY;
420 }
421 else
422 {
423 nOpenMode = SFX_STREAM_READWRITE;
424 pSh->SetReadOnlyUI( sal_False );
425
426 // if only the view was in the readonly mode then there is no need to do the reload
427 if ( !pSh->IsReadOnly() )
428 return;
429 }
430
431 // Parameter auswerten
432 // sal_Bool bReload = sal_True;
433 if ( rReq.IsAPI() )
434 {
435 // per API steuern ob r/w oder r/o
436 SFX_REQUEST_ARG(rReq, pEditItem, SfxBoolItem, SID_EDITDOC, sal_False);
437 if ( pEditItem )
438 nOpenMode = pEditItem->GetValue() ? SFX_STREAM_READWRITE : SFX_STREAM_READONLY;
439 }
440
441 // doing
442 if( pSh )
443 {
444 SfxMedium* pMed = pSh->GetMedium();
445 String aTemp;
446 utl::LocalFileHelper::ConvertPhysicalNameToURL( pMed->GetPhysicalName(), aTemp );
447 INetURLObject aPhysObj( aTemp );
448 SFX_ITEMSET_ARG( pSh->GetMedium()->GetItemSet(),
449 pVersionItem, SfxInt16Item, SID_VERSION, sal_False );
450
451 INetURLObject aMedObj( pMed->GetName() );
452
453 // the logic below is following, if the document seems not to need to be reloaded and the physical name is different
454 // to the logical one, then on file system it can be checked that the copy is still newer than the original and no document reload is required
455 if ( ( !bNeedsReload && ( (aMedObj.GetProtocol() == INET_PROT_FILE &&
456 aMedObj.getFSysPath(INetURLObject::FSYS_DETECT) != aPhysObj.getFSysPath(INetURLObject::FSYS_DETECT) &&
457 !::utl::UCBContentHelper::IsYounger( aMedObj.GetMainURL( INetURLObject::NO_DECODE ), aPhysObj.GetMainURL( INetURLObject::NO_DECODE ) ))
458 || pMed->IsRemote() ) )
459 || pVersionItem )
460 {
461 sal_Bool bOK = sal_False;
462 if ( !pVersionItem )
463 {
464 sal_Bool bHasStorage = pMed->HasStorage_Impl();
465 // switching edit mode could be possible without reload
466 if ( bHasStorage && pMed->GetStorage() == pSh->GetStorage() )
467 {
468 // TODO/LATER: faster creation of copy
469 if ( !pSh->ConnectTmpStorage_Impl( pMed->GetStorage(), pMed ) )
470 return;
471 }
472
473 pMed->CloseAndRelease();
474 pMed->GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, !( nOpenMode & STREAM_WRITE ) ) );
475 pMed->SetOpenMode( nOpenMode, pMed->IsDirect() );
476
477 pMed->CompleteReOpen();
478 if ( nOpenMode & STREAM_WRITE )
479 pMed->LockOrigFileOnDemand( sal_False, sal_True );
480
481 // LockOrigFileOnDemand might set the readonly flag itself, it should be set back
482 pMed->GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, !( nOpenMode & STREAM_WRITE ) ) );
483
484 if ( !pMed->GetErrorCode() )
485 bOK = sal_True;
486 }
487
488 if( !bOK )
489 {
490 ErrCode nErr = pMed->GetErrorCode();
491 if ( pVersionItem )
492 nErr = ERRCODE_IO_ACCESSDENIED;
493 else
494 {
495 pMed->ResetError();
496 pMed->SetOpenMode( SFX_STREAM_READONLY, pMed->IsDirect() );
497 pMed->ReOpen();
498 pSh->DoSaveCompleted( pMed );
499 }
500
501 // r/o-Doc kann nicht in Editmode geschaltet werden?
502 rReq.Done( sal_False );
503
504 SFX_REQUEST_ARG( rReq, pFSetItem, SfxBoolItem, SID_EDIT_FRAMESET, sal_False);
505 if ( nOpenMode == SFX_STREAM_READWRITE && !rReq.IsAPI() )
506 {
507 // dem ::com::sun::star::sdbcx::User anbieten, als Vorlage zu oeffnen
508 QueryBox aBox( &GetWindow(), SfxResId(MSG_QUERY_OPENASTEMPLATE) );
509 if ( !pFSetItem && RET_YES == aBox.Execute() )
510 {
511 SfxApplication* pApp = SFX_APP();
512 SfxAllItemSet aSet( pApp->GetPool() );
513 aSet.Put( SfxStringItem( SID_FILE_NAME, pMed->GetName() ) );
514 SFX_ITEMSET_ARG( pMed->GetItemSet(), pReferer, SfxStringItem, SID_REFERER, sal_False );
515 if ( pReferer )
516 aSet.Put( *pReferer );
517 aSet.Put( SfxBoolItem( SID_TEMPLATE, sal_True ) );
518 if ( pVersionItem )
519 aSet.Put( *pVersionItem );
520
521 if( pMed->GetFilter() )
522 {
523 aSet.Put( SfxStringItem( SID_FILTER_NAME, pMed->GetFilter()->GetFilterName() ) );
524 SFX_ITEMSET_ARG( pMed->GetItemSet(), pOptions,
525 SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False );
526 if ( pOptions )
527 aSet.Put( *pOptions );
528 }
529
530 GetDispatcher()->Execute( SID_OPENDOC, SFX_CALLMODE_ASYNCHRON, aSet );
531 return;
532 }
533 else
534 nErr = 0;
535 }
536
537 ErrorHandler::HandleError( nErr );
538 rReq.SetReturnValue(
539 SfxBoolItem( rReq.GetSlot(), sal_False ) );
540 return;
541 }
542 else
543 {
544 pSh->DoSaveCompleted( pMed );
545 pSh->Broadcast( SfxSimpleHint(SFX_HINT_MODECHANGED) );
546 rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), sal_True ) );
547 rReq.Done( sal_True );
548 // if( nOpenMode == SFX_STREAM_READONLY )
549 // pMed->Close();
550
551 // ReloadForEdit bei Framesets schaltet auch FramesetEditmode
552 sal_Bool bIsReadonly = GetObjectShell()->IsReadOnly();
553 if ( bIsReadonly != bWasReadonly && !GetFrame()->GetParentFrame() )
554 {
555 SfxBoolItem aItem( SID_EDIT_FRAMESET, !bIsReadonly );
556 GetDispatcher()->Execute( SID_EDIT_FRAMESET,
557 SFX_CALLMODE_RECORD, &aItem, 0L );
558 pSh->Broadcast( SfxSimpleHint( SFX_HINT_TITLECHANGED ) );
559 }
560 return;
561 }
562 }
563
564 /*
565 if ( !bReload )
566 {
567 // Es soll nicht reloaded werden
568 SfxErrorContext aEc( ERRCODE_SFX_NODOCRELOAD );
569 ErrorHandler::HandleError( ERRCODE_SFX_NODOCRELOAD );
570 rReq.SetReturnValue(
571 SfxBoolItem( rReq.GetSlot(), sal_False ) );
572 return;
573 }
574 */
575 // Ansonsten ( lokal und arbeiten auf Kopie ) muss gereloaded
576 // werden.
577 }
578
579 rReq.AppendItem( SfxBoolItem( SID_FORCERELOAD, sal_True) );
580 rReq.AppendItem( SfxBoolItem( SID_SILENT, sal_True ));
581 }
582
583 case SID_RELOAD:
584 {
585 // Wg. Doppeltbelegung in Toolboxen (mit/ohne Ctrl) ist es auch
586 // m"oglich, da\s der Slot zwar enabled ist, aber Ctrl-Click
587 // trotzdem nicht geht!
588 if ( !pSh || !pSh->CanReload_Impl() )
589 break;
590 SfxApplication* pApp = SFX_APP();
591 SFX_REQUEST_ARG(rReq, pForceReloadItem, SfxBoolItem,
592 SID_FORCERELOAD, sal_False);
593 if( pForceReloadItem && !pForceReloadItem->GetValue() &&
594 !pSh->GetMedium()->IsExpired() )
595 return;
596 if( pImp->bReloading || pSh->IsInModalMode() )
597 return;
598
599 // AutoLoad ist ggf. verboten
600 SFX_REQUEST_ARG(rReq, pAutoLoadItem, SfxBoolItem, SID_AUTOLOAD, sal_False);
601 if ( pAutoLoadItem && pAutoLoadItem->GetValue() &&
602 GetFrame()->IsAutoLoadLocked_Impl() )
603 return;
604
605 SfxObjectShellLock xOldObj( pSh );
606 pImp->bReloading = sal_True;
607 SFX_REQUEST_ARG(rReq, pURLItem, SfxStringItem,
608 SID_FILE_NAME, sal_False);
609 // editierbar "offnen?
610 sal_Bool bForEdit = !pSh->IsReadOnly();
611 if ( rReq.GetSlot() == SID_EDITDOC )
612 bForEdit = !bForEdit;
613
614 // ggf. beim User nachfragen
615 sal_Bool bDo = ( GetViewShell()->PrepareClose() != FALSE );
616 SFX_REQUEST_ARG(rReq, pSilentItem, SfxBoolItem, SID_SILENT, sal_False);
617 if ( bDo && GetFrame()->DocIsModified_Impl() &&
618 !rReq.IsAPI() && ( !pSilentItem || !pSilentItem->GetValue() ) )
619 {
620 QueryBox aBox( &GetWindow(), SfxResId(MSG_QUERY_LASTVERSION) );
621 bDo = ( RET_YES == aBox.Execute() );
622 }
623
624 if ( bDo )
625 {
626 SfxMedium *pMedium = xOldObj->GetMedium();
627
628 // Frameset abziehen, bevor FramesetView evtl. verschwindet
629 String aURL = pURLItem ? pURLItem->GetValue() :
630 pMedium->GetName();
631
632 sal_Bool bHandsOff =
633 ( pMedium->GetURLObject().GetProtocol() == INET_PROT_FILE && !xOldObj->IsDocShared() );
634
635 // bestehende SfxMDIFrames f"ur dieses Doc leeren
636 // eigenes Format oder R/O jetzt editierbar "offnen?
637 SfxViewNotificatedFrameList_Impl aFrames;
638 SfxObjectShellLock xNewObj;
639 sal_Bool bRestoreView = ( pURLItem == NULL );
640 TypeId aOldType = xOldObj->Type();
641
642 SfxViewFrame *pView = GetFirst(xOldObj);
643 while(pView)
644 {
645 if( bHandsOff )
646 pView->GetDispatcher()->LockUI_Impl(sal_True);
647 aFrames.InsertViewFrame( pView );
648 pView->GetBindings().ENTERREGISTRATIONS();
649
650 // RestoreView nur wenn keine neue Datei geladen
651 // (Client-Pull-Reloading)
652 pView = /*bHandsOff ? (SfxTopViewFrame*) GetFirst(
653 xOldObj, TYPE(SfxTopViewFrame) ) :*/
654 (SfxTopViewFrame*)GetNext( *pView, xOldObj,
655 TYPE( SfxTopViewFrame ) );
656 }
657
658 DELETEZ( xOldObj->Get_Impl()->pReloadTimer );
659
660 SfxItemSet* pNewSet = 0;
661 const SfxFilter *pFilter = pMedium->GetFilter();
662 if( pURLItem )
663 {
664 pNewSet = new SfxAllItemSet( pApp->GetPool() );
665 pNewSet->Put( *pURLItem );
666
667 // Filter Detection
668 SfxMedium aMedium( pURLItem->GetValue(), SFX_STREAM_READWRITE );
669 SfxFilterMatcher().GuessFilter( aMedium, &pFilter );
670 if ( pFilter )
671 pNewSet->Put( SfxStringItem( SID_FILTER_NAME, pFilter->GetName() ) );
672 pNewSet->Put( *aMedium.GetItemSet() );
673 }
674 else
675 {
676 pNewSet = new SfxAllItemSet( *pMedium->GetItemSet() );
677 pNewSet->ClearItem( SID_VIEW_ID );
678 pNewSet->ClearItem( SID_USER_DATA );
679 pNewSet->ClearItem( SID_STREAM );
680 pNewSet->ClearItem( SID_INPUTSTREAM );
681 pNewSet->Put( SfxStringItem( SID_FILTER_NAME, pMedium->GetFilter()->GetName() ) );
682
683 // let the current security settings be checked again
684 pNewSet->Put( SfxUInt16Item( SID_MACROEXECMODE, document::MacroExecMode::USE_CONFIG ) );
685
686 if ( rReq.GetSlot() == SID_EDITDOC || !bForEdit )
687 // edit mode is switched or reload of readonly document
688 pNewSet->Put( SfxBoolItem( SID_DOC_READONLY, !bForEdit ) );
689 else
690 // Reload of file opened for writing
691 pNewSet->ClearItem( SID_DOC_READONLY );
692 }
693
694 // Falls eine salvagede Datei vorliegt, nicht nochmals die
695 // OrigURL mitschicken, denn die Tempdate ist nach Reload
696 // ungueltig
697 SFX_ITEMSET_ARG( pNewSet, pSalvageItem, SfxStringItem, SID_DOC_SALVAGE, sal_False);
698 if( pSalvageItem )
699 {
700 aURL = pSalvageItem->GetValue();
701 pNewSet->ClearItem( SID_DOC_SALVAGE );
702 }
703
704 // TODO/LATER: Temporary solution, the SfxMedium must know the original URL as aLogicName
705 // SfxMedium::Transfer_Impl() will be vorbidden then.
706 if ( xOldObj->IsDocShared() )
707 pNewSet->Put( SfxStringItem( SID_FILE_NAME, xOldObj->GetSharedFileURL() ) );
708
709 //pNewMedium = new SfxMedium( aURL, nMode, pMedium->IsDirect(), bUseFilter ? pMedium->GetFilter() : 0, pNewSet );
710 //pNewSet = pNewMedium->GetItemSet();
711 if ( pURLItem )
712 pNewSet->Put( SfxStringItem( SID_REFERER, pMedium->GetName() ) );
713 else
714 pNewSet->Put( SfxStringItem( SID_REFERER, String() ) );
715
716 xOldObj->CancelTransfers();
717
718 // eigentliches Reload
719 //pNewSet->Put( SfxFrameItem ( SID_DOCFRAME, GetFrame() ) );
720
721 if ( pSilentItem && pSilentItem->GetValue() )
722 pNewSet->Put( SfxBoolItem( SID_SILENT, sal_True ) );
723
724 SFX_ITEMSET_ARG(pNewSet, pInteractionItem, SfxUnoAnyItem, SID_INTERACTIONHANDLER, FALSE);
725 SFX_ITEMSET_ARG(pNewSet, pMacroExecItem , SfxUInt16Item, SID_MACROEXECMODE , FALSE);
726 SFX_ITEMSET_ARG(pNewSet, pDocTemplateItem, SfxUInt16Item, SID_UPDATEDOCMODE , FALSE);
727
728 if (!pInteractionItem)
729 {
730 Reference < ::com::sun::star::task::XInteractionHandler > xHdl( ::comphelper::getProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.comp.uui.UUIInteractionHandler")), UNO_QUERY );
731 if (xHdl.is())
732 pNewSet->Put( SfxUnoAnyItem(SID_INTERACTIONHANDLER,::com::sun::star::uno::makeAny(xHdl)) );
733 }
734
735 if (!pMacroExecItem)
736 pNewSet->Put( SfxUInt16Item(SID_MACROEXECMODE,::com::sun::star::document::MacroExecMode::USE_CONFIG) );
737 if (!pDocTemplateItem)
738 pNewSet->Put( SfxUInt16Item(SID_UPDATEDOCMODE,::com::sun::star::document::UpdateDocMode::ACCORDING_TO_CONFIG) );
739
740 xOldObj->SetModified( sal_False );
741 // Altes Dok nicht cachen! Gilt nicht, wenn anderes
742 // Doc geladen wird.
743
744 SFX_ITEMSET_ARG( pMedium->GetItemSet(), pSavedOptions, SfxStringItem, SID_FILE_FILTEROPTIONS, sal_False);
745 SFX_ITEMSET_ARG( pMedium->GetItemSet(), pSavedReferer, SfxStringItem, SID_REFERER, sal_False);
746
747 if( !pURLItem || pURLItem->GetValue() == xOldObj->GetMedium()->GetName() )
748 xOldObj->Get_Impl()->bForbidCaching = sal_True;
749
750 sal_Bool bHasStorage = pMedium->HasStorage_Impl();
751 if( bHandsOff )
752 {
753 if ( bHasStorage && pMedium->GetStorage() == xOldObj->GetStorage() )
754 {
755 // TODO/LATER: faster creation of copy
756 if ( !xOldObj->ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )
757 return;
758 }
759
760 pMedium->CloseAndRelease();
761 }
762
763 xNewObj = SfxObjectShell::CreateObject( pFilter->GetServiceName(), SFX_CREATE_MODE_STANDARD );
764 try
765 {
766 uno::Sequence < beans::PropertyValue > aProps;
767 TransformItems( SID_OPENDOC, *pNewSet, aProps );
768 uno::Reference < frame::XLoadable > xLoad( xNewObj->GetModel(), uno::UNO_QUERY );
769 xLoad->load( aProps );
770 }
771 catch ( uno::Exception& )
772 {
773 xNewObj->DoClose();
774 xNewObj = 0;
775 }
776
777 DELETEZ( pNewSet );
778
779 if( !xNewObj.Is() )
780 {
781 if( bHandsOff )
782 {
783 // back to old medium
784 pMedium->ReOpen();
785 pMedium->LockOrigFileOnDemand( sal_False, sal_True );
786
787 xOldObj->DoSaveCompleted( pMedium );
788 }
789
790 // r/o-Doc couldn't be switched to writing mode
791 if ( bForEdit && SID_EDITDOC == rReq.GetSlot() )
792 {
793 // ask user for opening as template
794 QueryBox aBox( &GetWindow(), SfxResId(MSG_QUERY_OPENASTEMPLATE) );
795 if ( RET_YES == aBox.Execute() )
796 {
797 SfxAllItemSet aSet( pApp->GetPool() );
798 aSet.Put( SfxStringItem( SID_FILE_NAME, pMedium->GetName() ) );
799 aSet.Put( SfxStringItem( SID_TARGETNAME, String::CreateFromAscii("_blank") ) );
800 if ( pSavedOptions )
801 aSet.Put( *pSavedOptions );
802 if ( pSavedReferer )
803 aSet.Put( *pSavedReferer );
804 aSet.Put( SfxBoolItem( SID_TEMPLATE, sal_True ) );
805 if( pFilter )
806 aSet.Put( SfxStringItem( SID_FILTER_NAME, pFilter->GetFilterName() ) );
807 GetDispatcher()->Execute( SID_OPENDOC, SFX_CALLMODE_ASYNCHRON, aSet );
808 }
809 }
810 else
811 {
812 // an error handling should be done here?!
813 // if ( !pSilentItem || !pSilentItem->GetValue() )
814 // ErrorHandler::HandleError( nLoadError );
815 }
816 }
817 else
818 {
819 if ( xNewObj->IsDocShared() )
820 {
821 // the file is shared but the closing can chang the sharing control file
822 xOldObj->DoNotCleanShareControlFile();
823 }
824
825 xNewObj->GetMedium()->GetItemSet()->ClearItem( SID_RELOAD );
826 xNewObj->GetMedium()->GetItemSet()->ClearItem( SID_SILENT );
827 UpdateDocument_Impl();
828 }
829
830 SfxViewFrame* pThis = (SfxViewFrame*)this;
831 sal_Bool bDeleted = aFrames.C40_GETPOS( SfxViewFrame, pThis ) == USHRT_MAX;
832
833 if( !bDeleted )
834 {
835 GetBindings().Invalidate( SID_RELOAD );
836 pImp->bReloading = sal_False;
837 }
838
839 // neues Doc in die bestehenden SfxMDIFrames einsetzen; wenn
840 // das Reload geklappt hat, mu\s in diesem Frame kein Dokument
841 // eingesetzt werden, weil das schon vom LoadEnvironment
842 // gemacht wurde
843 if ( xNewObj.Is() && xNewObj->Type() != aOldType )
844 // RestoreView nur, wenn gleicher Dokumenttyp
845 bRestoreView = sal_False;
846
847 const sal_uInt16 nCount = aFrames.Count();
848 for(sal_uInt16 i = 0; i < nCount; ++i)
849 {
850 SfxViewFrame *pCurrView = aFrames.GetObject( i );
851 if ( xNewObj.Is() )
852 {
853 //if( /*!bHandsOff &&*/ this != pView )
854 pCurrView->ReleaseObjectShell_Impl( bRestoreView );
855 pCurrView->SetRestoreView_Impl( bRestoreView );
856 //if( pView != this || !xNewObj.Is() )
857 {
858 SfxFrame *pFrame = pCurrView->GetFrame();
859 pFrame->InsertDocument(xNewObj.Is() ? xNewObj : xOldObj );
860 }
861 }
862
863 pCurrView->GetBindings().LEAVEREGISTRATIONS();
864 pCurrView->GetDispatcher()->LockUI_Impl( sal_False );
865 }
866
867 if ( xNewObj.Is() )
868 {
869 // Propagate document closure.
870 SFX_APP()->NotifyEvent( SfxEventHint( SFX_EVENT_CLOSEDOC, GlobalEventConfig::GetEventName( STR_EVENT_CLOSEDOC ), xOldObj ) );
871 }
872
873 // als erledigt recorden
874 rReq.Done( sal_True );
875 rReq.SetReturnValue(SfxBoolItem(rReq.GetSlot(), sal_True));
876 if( !bDeleted )
877 {
878 Notify( *GetObjectShell(), SfxSimpleHint(
879 SFX_HINT_TITLECHANGED ));
880 }
881 return;
882 }
883 else
884 {
885 // als nicht erledigt recorden
886 rReq.Done();
887 rReq.SetReturnValue(SfxBoolItem(rReq.GetSlot(), sal_False));
888 pImp->bReloading = sal_False;
889 return;
890 }
891 }
892 }
893 }
894
895 //-------------------------------------------------------------------------
896 void SfxViewFrame::StateReload_Impl( SfxItemSet& rSet )
897 {
898 SfxObjectShell* pSh = GetObjectShell();
899 if ( !pSh )
900 // Ich bin gerade am Reloaden und Yielde so vor mich hin ...
901 return;
902
903 GetFrame()->GetParentFrame();
904 SfxWhichIter aIter( rSet );
905 for ( sal_uInt16 nWhich = aIter.FirstWhich(); nWhich; nWhich = aIter.NextWhich() )
906 {
907 if ( GetFrame()->HasComponent() )
908 {
909 // Wenn die Komponente es nicht selbst dispatched, dann
910 // macht es auch keinen Sinn!
911 rSet.DisableItem( nWhich );
912 continue;
913 }
914
915 switch ( nWhich )
916 {
917 case SID_EDITDOC:
918 {
919 if ( !pSh || !pSh->HasName() || !( pSh->Get_Impl()->nLoadedFlags & SFX_LOADED_MAINDOCUMENT )
920 || pSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
921 rSet.DisableItem( SID_EDITDOC );
922 else
923 {
924 SFX_ITEMSET_ARG( pSh->GetMedium()->GetItemSet(), pItem, SfxBoolItem, SID_EDITDOC, sal_False );
925 if ( pItem && !pItem->GetValue() )
926 rSet.DisableItem( SID_EDITDOC );
927 else
928 rSet.Put( SfxBoolItem( nWhich, !pSh->IsReadOnly() ) );
929 }
930 break;
931 }
932
933 case SID_RELOAD:
934 {
935 SfxFrame* pFrame = GetTopFrame();
936 SfxViewFrame *pView = pFrame->GetCurrentViewFrame();
937 if ( pView && pView->GetViewShell() &&
938 pView->GetViewShell()->IsImplementedAsFrameset_Impl() &&
939 pView->GetViewShell()->GetInterface()->GetSlot( nWhich ) )
940 {
941 // Hack f"ur Explorer: Reload wird an der ViewShell ausgef"uhrt
942 pView->GetViewShell()->GetSlotState( nWhich, 0, &rSet );
943 break;
944 }
945
946 if ( !pSh || !pSh->CanReload_Impl() || pSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
947 rSet.DisableItem(nWhich);
948 else
949 {
950 // Wenn irgendein ChildFrame reloadable ist, wird der Slot
951 // enabled, damit man CTRL-Reload machen kann
952 sal_Bool bReloadAvailable = sal_False;
953 SfxFrameIterator aFrameIter( *pFrame, sal_True );
954 for( SfxFrame* pNextFrame = aFrameIter.FirstFrame();
955 pFrame;
956 pNextFrame = pNextFrame ?
957 aFrameIter.NextFrame( *pNextFrame ) : 0 )
958 {
959 SfxObjectShell *pShell = pFrame->GetCurrentDocument();
960 if( pShell && pShell->Get_Impl()->bReloadAvailable )
961 {
962 bReloadAvailable = sal_True;
963 break;
964 }
965 pFrame = pNextFrame;
966 }
967
968 rSet.Put( SfxBoolItem( nWhich, bReloadAvailable));
969 }
970
971 break;
972 }
973 }
974 }
975 }
976
977
978 //--------------------------------------------------------------------
979 void SfxViewFrame::ExecHistory_Impl( SfxRequest &rReq )
980 {
981 // gibt es an der obersten Shell einen Undo-Manager?
982 SfxShell *pSh = GetDispatcher()->GetShell(0);
983 SfxUndoManager* pShUndoMgr = pSh->GetUndoManager();
984 sal_Bool bOK = sal_False;
985 if ( pShUndoMgr )
986 {
987 switch ( rReq.GetSlot() )
988 {
989 case SID_CLEARHISTORY:
990 pShUndoMgr->Clear();
991 bOK = sal_True;
992 break;
993
994 case SID_UNDO:
995 pShUndoMgr->Undo(0);
996 GetBindings().InvalidateAll(sal_False);
997 bOK = sal_True;
998 break;
999
1000 case SID_REDO:
1001 pShUndoMgr->Redo(0);
1002 GetBindings().InvalidateAll(sal_False);
1003 bOK = sal_True;
1004 break;
1005
1006 case SID_REPEAT:
1007 if ( pSh->GetRepeatTarget() )
1008 pShUndoMgr->Repeat( *pSh->GetRepeatTarget(), 0);
1009 bOK = sal_True;
1010 break;
1011 }
1012 }
1013 else if ( GetViewShell() )
1014 {
1015 // der SW hat eigenes Undo an der ::com::sun::star::sdbcx::View
1016 const SfxPoolItem *pRet = GetViewShell()->ExecuteSlot( rReq );
1017 if ( pRet )
1018 bOK = ((SfxBoolItem*)pRet)->GetValue();
1019 }
1020
1021 rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), bOK ) );
1022 rReq.Done();
1023 }
1024
1025 //--------------------------------------------------------------------
1026 void SfxViewFrame::StateHistory_Impl( SfxItemSet &rSet )
1027 {
1028 // Undo-Manager suchen
1029 SfxShell *pSh = GetDispatcher()->GetShell(0);
1030 if ( !pSh )
1031 // Ich bin gerade am Reloaden und Yielde so vor mich hin ...
1032 return;
1033
1034 SfxUndoManager *pShUndoMgr = pSh->GetUndoManager();
1035 if ( !pShUndoMgr )
1036 {
1037 // der SW hat eigenes Undo an der ::com::sun::star::sdbcx::View
1038 SfxWhichIter aIter( rSet );
1039 SfxViewShell *pViewSh = GetViewShell();
1040 if( !pViewSh ) return;
1041 for ( sal_uInt16 nSID = aIter.FirstWhich(); nSID; nSID = aIter.NextWhich() )
1042 pViewSh->GetSlotState( nSID, 0, &rSet );
1043 return;
1044 }
1045
1046 if ( pShUndoMgr->GetUndoActionCount() == 0 &&
1047 pShUndoMgr->GetRedoActionCount() == 0 &&
1048 pShUndoMgr->GetRepeatActionCount() == 0 )
1049 rSet.DisableItem( SID_CLEARHISTORY );
1050
1051 if ( pShUndoMgr && pShUndoMgr->GetUndoActionCount() )
1052 {
1053 String aTmp( SfxResId( STR_UNDO ) );
1054 aTmp += pShUndoMgr->GetUndoActionComment(0);
1055 rSet.Put( SfxStringItem( SID_UNDO, aTmp ) );
1056 }
1057 else
1058 rSet.DisableItem( SID_UNDO );
1059
1060 if ( pShUndoMgr && pShUndoMgr->GetRedoActionCount() )
1061 {
1062 String aTmp( SfxResId(STR_REDO) );
1063 aTmp += pShUndoMgr->GetRedoActionComment(0);
1064 rSet.Put( SfxStringItem( SID_REDO, aTmp ) );
1065 }
1066 else
1067 rSet.DisableItem( SID_REDO );
1068 SfxRepeatTarget *pTarget = pSh->GetRepeatTarget();
1069 if ( pShUndoMgr && pTarget && pShUndoMgr->GetRepeatActionCount() &&
1070 pShUndoMgr->CanRepeat(*pTarget, 0) )
1071 {
1072 String aTmp( SfxResId(STR_REPEAT) );
1073 aTmp += pShUndoMgr->GetRepeatActionComment(*pTarget, 0);
1074 rSet.Put( SfxStringItem( SID_REPEAT, aTmp ) );
1075 }
1076 else
1077 rSet.DisableItem( SID_REPEAT );
1078 }
1079
1080 //--------------------------------------------------------------------
1081 void SfxViewFrame::SetObjectShell_Impl
1082 (
1083 SfxObjectShell& rObjSh, // eine initialisierte SfxObjectShell,
1084 FASTBOOL bDefaultView // sal_True: nicht restaurieren
1085 )
1086
1087 /* [Beschreibung]
1088
1089 Diese Methode setzt eine <SfxObjectShell> in den SfxViewFrame ein.
1090
1091 Zuvor mu\s die vorherige SfxObjectShell, insofern schein eine gesetzt
1092 wurde, mit der Methode ReleaseObjectShell() entfernt worden sein. Somit
1093 kann durch Aufruf von ReleaseObjectShell() und SetObjectShell() die
1094 SfxObjectShell ausgetauscht werden.
1095
1096
1097 [Querverweise]
1098
1099 <SfxViewFrame::ReleaseObjectShell()>
1100 */
1101
1102 {
1103 DBG_CHKTHIS(SfxViewFrame, 0);
1104 DBG_ASSERT( !xObjSh.Is(), "old feature used: only one Object per View!" );
1105
1106 GetFrame()->ReleasingComponent_Impl( sal_False );
1107
1108 // Doc einsetzen
1109 xObjSh = &rObjSh;
1110 if ( xObjSh.Is() && xObjSh->IsPreview() )
1111 SetQuietMode_Impl( sal_True );
1112
1113 GetFrame()->SetFrameType_Impl( GetFrameType() & ~SFXFRAME_FRAMESET );
1114
1115 // Modulshell einf"ugen
1116 SfxModule* pModule = xObjSh->GetModule();
1117 if( pModule )
1118 pDispatcher->InsertShell_Impl( *pModule, 1 );
1119
1120 pDispatcher->Push( rObjSh );
1121 pDispatcher->Flush();
1122 StartListening( rObjSh );
1123
1124 rObjSh.ViewAssigned();
1125 pDispatcher->SetReadOnly_Impl( rObjSh.IsReadOnly() );
1126
1127 const SfxMedium *pMedium = GetObjectShell()->GetMedium();
1128 SFX_ITEMSET_ARG(
1129 pMedium->GetItemSet(), pHiddenItem, SfxBoolItem, SID_HIDDEN, sal_False );
1130 if ( !pHiddenItem || !pHiddenItem->GetValue() )
1131 {
1132 LockObjectShell_Impl(sal_True);
1133 GetDocNumber_Impl();
1134 }
1135
1136 // ::com::sun::star::sdbcx::View erzeugen
1137 if ( bDefaultView )
1138 SetRestoreView_Impl( sal_False );
1139
1140 // So darf man es nicht machen, da LaodWindows hierueber laeuft. Kann meiner Meinung nach
1141 // auch nur beim Reload mit Dokumenttypwechsel passieren.
1142 /* if ( xObjSh->Type() != pImp->aLastType )
1143 SetRestoreView_Impl( sal_False ); */
1144
1145 SwitchToViewShell_Impl( !IsRestoreView_Impl() ? (sal_uInt16) 0 : GetCurViewId() );
1146 rObjSh.PostActivateEvent_Impl( this );
1147 if ( Current() == this )
1148 SFX_APP()->NotifyEvent(SfxEventHint(SFX_EVENT_ACTIVATEDOC, GlobalEventConfig::GetEventName( STR_EVENT_ACTIVATEDOC ), &rObjSh ) );
1149
1150 Notify( rObjSh, SfxSimpleHint(SFX_HINT_TITLECHANGED) );
1151 Notify( rObjSh, SfxSimpleHint(SFX_HINT_DOCCHANGED) );
1152
1153 // Zur Sicherheit, aber eigentlich sollte jetzt nichts mehr passieren
1154 // ( kein erzwungenes Update )
1155 if ( SfxViewFrame::Current() == this )
1156 GetDispatcher()->Update_Impl();
1157 }
1158
1159 //--------------------------------------------------------------------
1160 void SfxViewFrame::ReleaseObjectShell_Impl( sal_Bool bStoreView )
1161
1162 /* [Beschreibung]
1163
1164 Diese Methode entleert den SfxViewFrame, d.h. nimmt die <SfxObjectShell>
1165 vom Dispatcher und beendet seine <SfxListener>-Beziehung zu dieser
1166 SfxObjectShell (wodurch sie sich ggf. selbst zerst"ort).
1167
1168 Somit kann durch Aufruf von ReleaseObjectShell() und SetObjectShell()
1169 die SfxObjectShell ausgetauscht werden.
1170
1171 Zwischen RealeaseObjectShell() und SetObjectShell() darf die Kontrolle
1172 nicht an das ::com::sun::star::chaos::System abgegeben werden.
1173
1174
1175 [Querverweise]
1176
1177 <SfxViewFrame::SetObjectShell(SfxObjectShell&)>
1178 */
1179 {
1180 DBG_CHKTHIS(SfxViewFrame, 0);
1181 DBG_ASSERT( xObjSh.Is(), "no SfxObjectShell to release!" );
1182
1183 GetFrame()->ReleasingComponent_Impl( sal_True );
1184 if ( GetWindow().HasChildPathFocus( sal_True ) )
1185 {
1186 DBG_ASSERT( !GetActiveChildFrame_Impl(), "Wrong active child frame!" );
1187 GetWindow().GrabFocus();
1188 }
1189
1190 SfxViewShell *pDyingViewSh = GetViewShell();
1191 if ( pDyingViewSh )
1192 {
1193 SetRestoreView_Impl( bStoreView );
1194 if ( bStoreView )
1195 pDyingViewSh->WriteUserData( GetViewData_Impl(), sal_True );
1196
1197 // Jetzt alle SubShells wechhauen
1198 pDyingViewSh->PushSubShells_Impl( sal_False );
1199 sal_uInt16 nLevel = pDispatcher->GetShellLevel( *pDyingViewSh );
1200 if ( nLevel && nLevel != USHRT_MAX )
1201 {
1202 // Es gibt immer nocht SubShells
1203 SfxShell *pSubShell = pDispatcher->GetShell( nLevel-1 );
1204 if ( pSubShell == pDyingViewSh->GetSubShell() )
1205 //"Echte" Subshells nicht deleten
1206 pDispatcher->Pop( *pSubShell, SFX_SHELL_POP_UNTIL );
1207 else
1208 pDispatcher->Pop( *pSubShell, SFX_SHELL_POP_UNTIL | SFX_SHELL_POP_DELETE );
1209 }
1210 pDispatcher->Pop( *pDyingViewSh );
1211 pDispatcher->Flush();
1212 pDyingViewSh->DisconnectAllClients();
1213 SetViewShell_Impl(0);
1214 delete pDyingViewSh;
1215 }
1216 #ifdef DBG_UTIL
1217 else
1218 DBG_ERROR("Keine Shell");
1219 #endif
1220
1221 if ( xObjSh.Is() )
1222 {
1223 pImp->aLastType = xObjSh->Type();
1224 pDispatcher->Pop( *xObjSh );
1225 SfxModule* pModule = xObjSh->GetModule();
1226 if( pModule )
1227 pDispatcher->RemoveShell_Impl( *pModule );
1228 pDispatcher->Flush();
1229 EndListening( *xObjSh );
1230
1231 Notify( *xObjSh, SfxSimpleHint(SFX_HINT_TITLECHANGED) );
1232 Notify( *xObjSh, SfxSimpleHint(SFX_HINT_DOCCHANGED) );
1233
1234 if ( 1 == xObjSh->GetOwnerLockCount() && pImp->bObjLocked && xObjSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
1235 xObjSh->DoClose();
1236 SfxObjectShellRef xDyingObjSh = xObjSh;
1237 xObjSh.Clear();
1238 if( ( GetFrameType() & SFXFRAME_HASTITLE ) && pImp->nDocViewNo )
1239 xDyingObjSh->GetNoSet_Impl().ReleaseIndex(pImp->nDocViewNo-1);
1240 if ( pImp->bObjLocked )
1241 {
1242 xDyingObjSh->OwnerLock( sal_False );
1243 pImp->bObjLocked = sal_False;
1244 }
1245 }
1246
1247 GetDispatcher()->SetDisableFlags( 0 );
1248 }
1249
1250 //-------------------------------------------------------------------------
1251
1252 String SfxViewFrame::UpdateTitle()
1253
1254 /* [Beschreibung]
1255
1256 Mit dieser Methode kann der SfxMDIFrame gezwungen werden, sich sofort
1257 den neuen Titel vom der <SfxObjectShell> zu besorgen.
1258
1259 [Anmerkung]
1260
1261 Dies ist z.B. dann notwendig, wenn man der SfxObjectShell als SfxListener
1262 zuh"ort und dort auf den <SfxSimpleHint> SFX_HINT_TITLECHANGED reagieren
1263 m"ochte, um dann die Titel seiner Views abzufragen. Diese Views (SfxMDIFrames)
1264 jedoch sind ebenfalls SfxListener und da die Reihenfolge der Benachrichtigung
1265 nicht feststeht, mu\s deren Titel-Update vorab erzwungen werden.
1266
1267
1268 [Beispiel]
1269
1270 void SwDocShell::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1271 {
1272 if ( rHint.IsA(TYPE(SfxSimpleHint)) )
1273 {
1274 switch( ( (SfxSimpleHint&) rHint ).GetId() )
1275 {
1276 case SFX_HINT_TITLECHANGED:
1277 for ( SfxMDIFrame *pMDI = (SfxMDIFrame*)
1278 SfxViewFrame::GetFirst(this, TYPE(SfxMDIFrame));
1279 pMDI;
1280 pMDI = (SfxMDIFrame*)
1281 SfxViewFrame::GetNext(this, TYPE(SfxMDIFrame));
1282 {
1283 pMDI->UpdateTitle();
1284 ... pMDI->GetName() ...
1285 }
1286 break;
1287 ...
1288 }
1289 }
1290 }
1291 */
1292
1293 {
1294 SfxObjectShell *pObjSh = GetObjectShell();
1295 if ( !pObjSh )
1296 return String();
1297
1298 // if ( pObjSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
1299 // // kein UpdateTitle mit Embedded-ObjectShell
1300 // return String();
1301
1302 const SfxMedium *pMedium = pObjSh->GetMedium();
1303 String aURL;
1304 GetFrame(); // -Wall required??
1305 if ( pObjSh->HasName() )
1306 {
1307 INetURLObject aTmp( pMedium->GetName() );
1308 aURL = aTmp.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
1309 }
1310
1311 if ( aURL != pImp->aActualURL )
1312 // URL hat sich ge"andert
1313 pImp->aActualURL = aURL;
1314
1315 // gibt es noch eine weitere View?
1316 sal_uInt16 nViews=0;
1317 for ( SfxViewFrame *pView= GetFirst(pObjSh);
1318 pView && nViews<2;
1319 pView = GetNext(*pView,pObjSh) )
1320 if ( ( pView->GetFrameType() & SFXFRAME_HASTITLE ) &&
1321 !IsDowning_Impl())
1322 nViews++;
1323
1324 // Titel des Fensters
1325 String aTitle;
1326 if ( nViews == 2 || pImp->nDocViewNo > 1 )
1327 // dann die Nummer dranh"angen
1328 aTitle = pObjSh->UpdateTitle( NULL, pImp->nDocViewNo );
1329 else
1330 aTitle = pObjSh->UpdateTitle();
1331
1332 // Name des SbxObjects
1333 String aSbxName = pObjSh->SfxShell::GetName();
1334 if ( IsVisible_Impl() )
1335 {
1336 aSbxName += ':';
1337 aSbxName += String::CreateFromInt32(pImp->nDocViewNo);
1338 }
1339
1340 SetName( aSbxName );
1341 pImp->aFrameTitle = aTitle;
1342 GetBindings().Invalidate( SID_FRAMETITLE );
1343 GetBindings().Invalidate( SID_CURRENT_URL );
1344 return aTitle;
1345 }
1346
1347
1348 //--------------------------------------------------------------------
1349 sal_Bool SfxViewFrame::Close()
1350 {
1351 DBG_CHKTHIS(SfxViewFrame, 0);
1352
1353 DBG_ASSERT( GetFrame()->IsClosing_Impl() || !GetFrame()->GetFrameInterface().is(), "ViewFrame closed too early!" );
1354
1355 // Wenn bis jetzt noch nicht gespeichert wurde, sollen eingebettete Objekte
1356 // auch nicht mehr automatisch gespeichert werden!
1357 if ( GetViewShell() )
1358 GetViewShell()->DiscardClients_Impl();
1359 Broadcast( SfxSimpleHint(SFX_HINT_DYING) );
1360
1361 return sal_True;
1362 }
1363
1364 //--------------------------------------------------------------------
1365
1366 void SfxViewFrame::DoActivate( sal_Bool bUI, SfxViewFrame* pOldFrame )
1367 {
1368 DBG_CHKTHIS(SfxViewFrame, 0);
1369 SFX_APP();
1370
1371 #ifdef WIN
1372 pSfxApp->TestFreeResources_Impl();
1373 #endif
1374
1375 pDispatcher->DoActivate_Impl( bUI, pOldFrame );
1376
1377 // Wenn ich einen parent habe und dieser ist kein parent des alten
1378 // ViewFrames, erh"alt er ein ParentActivate
1379 if ( bUI )
1380 {
1381 /*
1382 SfxMedium* pMed = GetObjectShell() ? GetObjectShell()->GetMedium() : NULL;
1383 if( pMed )
1384 {
1385 SFX_ITEMSET_ARG(
1386 pMed->GetItemSet(), pInterceptorItem, SfxSlotInterceptorItem,
1387 SID_INTERCEPTOR, sal_False );
1388 if( pInterceptorItem )
1389 {
1390 SfxSlotInterceptor* pInter = pInterceptorItem->GetValue();
1391 if( !pInter->GetBindings() )
1392 pInter->SetBindings( &GetBindings() );
1393 pInter->Activate( sal_True );
1394 }
1395 }
1396 */
1397 SfxViewFrame *pFrame = GetParentViewFrame();
1398 while ( pFrame )
1399 {
1400 if ( !pOldFrame || !pOldFrame->GetFrame()->IsParent( pFrame->GetFrame() ) )
1401 pFrame->pDispatcher->DoParentActivate_Impl();
1402 pFrame = pFrame->GetParentViewFrame();
1403 }
1404 }
1405 }
1406
1407 //--------------------------------------------------------------------
1408 void SfxViewFrame::DoDeactivate(sal_Bool bUI, SfxViewFrame* pNewFrame )
1409 {
1410 DBG_CHKTHIS(SfxViewFrame, 0);
1411 SFX_APP();
1412 pDispatcher->DoDeactivate_Impl( bUI, pNewFrame );
1413
1414 // Wenn ich einen parent habe und dieser ist kein parent des neuen
1415 // ViewFrames, erh"alt er ein ParentDeactivate
1416 if ( bUI )
1417 {
1418 // if ( GetFrame()->GetWorkWindow_Impl() )
1419 // GetFrame()->GetWorkWindow_Impl()->SaveStatus_Impl();
1420 /*
1421 SfxMedium* pMed = GetObjectShell() ? GetObjectShell()->GetMedium() : NULL;
1422 if( pMed )
1423 {
1424 SFX_ITEMSET_ARG(
1425 pMed->GetItemSet(), pInterceptorItem, SfxSlotInterceptorItem,
1426 SID_INTERCEPTOR, sal_False );
1427 if( pInterceptorItem )
1428 pInterceptorItem->GetValue()->Activate( sal_False );
1429 }
1430 */
1431 SfxViewFrame *pFrame = GetParentViewFrame();
1432 while ( pFrame )
1433 {
1434 if ( !pNewFrame || !pNewFrame->GetFrame()->IsParent( pFrame->GetFrame() ) )
1435 pFrame->pDispatcher->DoParentDeactivate_Impl();
1436 pFrame = pFrame->GetParentViewFrame();
1437 }
1438 }
1439 #ifdef WIN
1440 pSfxApp->TestFreeResources_Impl();
1441 #endif
1442 }
1443
1444 //------------------------------------------------------------------------
1445 void SfxViewFrame::InvalidateBorderImpl( const SfxViewShell* pSh )
1446 {
1447 if( pSh && !nAdjustPosPixelLock )
1448 {
1449 if ( GetViewShell() && GetWindow().IsVisible() )
1450 {
1451 if ( GetFrame()->IsInPlace() )
1452 {
1453 /*
1454 Size aSize( GetViewShell()->GetWindow()->GetSizePixel() );
1455
1456 //Size aBorderSz( pEnv->GetBorderWin()->GetHatchBorderPixel() );
1457 Point aOfs; //( aBorderSz.Width(), aBorderSz.Height() );
1458
1459 DoAdjustPosSizePixel( GetViewShell(), aOfs, aSize );*/
1460 return;
1461 }
1462
1463 if ( GetViewShell()->UseObjectSize() )
1464 {
1465 // Zun"achst die Gr"o\se des MDI-Fensters berechnen
1466
1467 DoAdjustPosSizePixel( GetViewShell(), Point(),
1468 GetViewShell()->GetWindow()->GetSizePixel() );
1469
1470 // Da nach einem InnerResize die Position des EditFensters und
1471 // damit auch der Tools nocht stimmt, mu\s nun noch einmal von
1472 // au\sen resized werden !
1473
1474 ForceOuterResize_Impl(sal_True);
1475 }
1476
1477 DoAdjustPosSizePixel( (SfxViewShell *) GetViewShell(), Point(),
1478 GetWindow().GetOutputSizePixel() );
1479 if ( GetViewShell()->UseObjectSize() )
1480 ForceOuterResize_Impl(sal_False);
1481 }
1482 }
1483 }
1484
1485 //------------------------------------------------------------------------
1486 sal_Bool SfxViewFrame::SetBorderPixelImpl
1487 (
1488 const SfxViewShell* /*pSh*/,
1489 const SvBorder& rBorder
1490 )
1491
1492 {
1493 pImp->aBorder = rBorder;
1494 return sal_True;
1495 }
1496
1497 //------------------------------------------------------------------------
1498 const SvBorder& SfxViewFrame::GetBorderPixelImpl
1499 (
1500 const SfxViewShell* /*pSh*/
1501 ) const
1502
1503 {
1504 return pImp->aBorder;
1505 }
1506
1507 //--------------------------------------------------------------------
1508 void SfxViewFrame::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1509 {
1510 {DBG_CHKTHIS(SfxViewFrame, 0);}
1511 if ( !xObjSh.Is() )
1512 return;
1513
1514 if ( rHint.IsA(TYPE(SfxSimpleHint)) )
1515 {
1516 switch( ( (SfxSimpleHint&) rHint ).GetId() )
1517 {
1518 case SFX_HINT_MODECHANGED:
1519 {
1520 // r/o Umschaltung?
1521 SfxBindings& rBind = GetBindings();
1522 rBind.Invalidate( SID_RELOAD );
1523 SfxDispatcher *pDispat = GetDispatcher();
1524 sal_Bool bWasReadOnly = pDispat->GetReadOnly_Impl();
1525 sal_Bool bIsReadOnly = xObjSh->IsReadOnly();
1526 if ( !bWasReadOnly != !bIsReadOnly )
1527 {
1528 // Dann auch TITLE_CHANGED
1529 UpdateTitle();
1530 rBind.Invalidate( SID_FILE_NAME );
1531 rBind.Invalidate( SID_DOCINFO_TITLE );
1532 rBind.Invalidate( SID_EDITDOC );
1533
1534 pDispat->GetBindings()->InvalidateAll(sal_True);
1535 pDispat->SetReadOnly_Impl( bIsReadOnly );
1536
1537 // Dispatcher-Update nur erzwingen, wenn es nicht sowieso
1538 // demn"achst kommt, anderenfalls ist Zappelei oder gar
1539 // GPF m"oglich, da Writer z.B. gerne mal im Resize irgendwelche
1540 // Aktionen t"atigt, die ein SetReadOnlyUI am Dispatcher zur
1541 // Folge haben!
1542 if ( pDispat->IsUpdated_Impl() )
1543 pDispat->Update_Impl(sal_True);
1544 }
1545
1546 Enable( !xObjSh->IsInModalMode() );
1547 break;
1548 }
1549
1550 case SFX_HINT_TITLECHANGED:
1551 {
1552 UpdateTitle();
1553 SfxBindings& rBind = GetBindings();
1554 rBind.Invalidate( SID_FILE_NAME );
1555 rBind.Invalidate( SID_DOCINFO_TITLE );
1556 rBind.Invalidate( SID_EDITDOC );
1557 rBind.Invalidate( SID_RELOAD );
1558 break;
1559 }
1560
1561 case SFX_HINT_DYING:
1562 case SFX_HINT_DEINITIALIZING:
1563 // when the Object is being deleted, destroy the view too
1564 if ( xObjSh.Is() )
1565 ReleaseObjectShell_Impl();
1566 else
1567 GetFrame()->DoClose();
1568 break;
1569
1570 }
1571 }
1572 else if ( rHint.IsA(TYPE(SfxEventHint)) )
1573 {
1574 // Wenn das Document asynchron geladen wurde, wurde der Dispatcher
1575 // auf ReadOnly gesetzt, was zur"?ckgenommen werden mu\s, wenn
1576 // das Document selbst nicht ReadOnly ist und das Laden fertig ist.
1577 switch ( ((SfxEventHint&)rHint).GetEventId() )
1578 {
1579 case SFX_EVENT_MODIFYCHANGED:
1580 {
1581 SfxBindings& rBind = GetBindings();
1582 rBind.Invalidate( SID_DOC_MODIFIED );
1583 rBind.Invalidate( SID_SAVEDOC );
1584 rBind.Invalidate( SID_RELOAD );
1585 rBind.Invalidate( SID_EDITDOC );
1586 break;
1587 }
1588
1589 case SFX_EVENT_OPENDOC:
1590 case SFX_EVENT_CREATEDOC:
1591 {
1592 SfxBindings& rBind = GetBindings();
1593 rBind.Invalidate( SID_RELOAD );
1594 rBind.Invalidate( SID_EDITDOC );
1595 if ( !xObjSh->IsReadOnly() )
1596 {
1597 // Im Gegensatz zu oben (TITLE_CHANGED) mu\s das UI nicht
1598 // upgedated werden, da es nicht gehidet war!
1599
1600 // #i21560# InvalidateAll() causes the assertion
1601 // 'SfxBindings::Invalidate while in update" when
1602 // the sfx slot SID_BASICIDE_APPEAR is executed
1603 // via API from another thread (Java).
1604 // According to MBA this call is not necessary anymore,
1605 // because each document has its own SfxBindings.
1606 //
1607 //GetDispatcher()->GetBindings()->InvalidateAll(sal_True);
1608 }
1609
1610 break;
1611 }
1612
1613 case SFX_EVENT_TOGGLEFULLSCREENMODE:
1614 {
1615 if ( GetFrame()->OwnsBindings_Impl() )
1616 GetBindings().GetDispatcher_Impl()->Update_Impl( sal_True );
1617 break;
1618 }
1619 }
1620 }
1621 }
1622
1623 //------------------------------------------------------------------------
1624 void SfxViewFrame::Construct_Impl( SfxObjectShell *pObjSh )
1625 {
1626 pImp->pFrame->DocumentInserted( pObjSh );
1627 pImp->bInCtor = sal_True;
1628 pImp->pParentViewFrame = 0;
1629 pImp->bResizeInToOut = sal_True;
1630 pImp->bDontOverwriteResizeInToOut = sal_False;
1631 pImp->pImportShell = 0;
1632 pImp->bObjLocked = sal_False;
1633 pImp->bEventFlag = sal_True;
1634 pImp->pFocusWin = 0;
1635 pImp->pActiveChild = NULL;
1636 pImp->bRestoreView = sal_False;
1637 pImp->nCurViewId = 0;
1638 pImp->bSetViewFrameLocked = sal_False;
1639 pImp->bReloading = sal_False;
1640 pImp->bIsDowning = sal_False;
1641 pImp->bModal = sal_False;
1642 pImp->bEnabled = sal_True;
1643 pImp->nDocViewNo = 0;
1644 pImp->aMargin = Size( -1, -1 );
1645 pImp->pCancelMgr = 0;
1646 pImp->pWindow = 0;
1647
1648 SetPool( &SFX_APP()->GetPool() );
1649 pDispatcher = new SfxDispatcher(this);
1650 if ( !GetBindings().GetDispatcher() )
1651 GetBindings().SetDispatcher( pDispatcher );
1652
1653 xObjSh = pObjSh;
1654 if ( xObjSh.Is() && xObjSh->IsPreview() )
1655 SetQuietMode_Impl( sal_True );
1656
1657 GetFrame()->SetFrameType_Impl( GetFrameType() & ~SFXFRAME_FRAMESET );
1658 if ( pObjSh )
1659 {
1660 pDispatcher->Push( *SFX_APP() );
1661 SfxModule* pModule = xObjSh->GetModule();
1662 if( pModule )
1663 pDispatcher->Push( *pModule );
1664 pDispatcher->Push( *this );
1665 pDispatcher->Push( *pObjSh );
1666 pDispatcher->Flush();
1667 StartListening( *pObjSh );
1668 pObjSh->ViewAssigned();
1669 Notify( *pObjSh, SfxSimpleHint(SFX_HINT_TITLECHANGED) );
1670 Notify( *pObjSh, SfxSimpleHint(SFX_HINT_DOCCHANGED) );
1671 pDispatcher->SetReadOnly_Impl( pObjSh->IsReadOnly() );
1672 }
1673 else
1674 {
1675 pDispatcher->Push( *SFX_APP() );
1676 pDispatcher->Push( *this );
1677 pDispatcher->Flush();
1678 }
1679
1680 SfxViewFrame *pThis = this; // wegen der kranken Array-Syntax
1681 SfxViewFrameArr_Impl &rViewArr = SFX_APP()->GetViewFrames_Impl();
1682 rViewArr.C40_INSERT(SfxViewFrame, pThis, rViewArr.Count() );
1683 pImp->bInCtor = sal_False;
1684 }
1685
1686 //------------------------------------------------------------------------
1687 SfxViewFrame::SfxViewFrame( SfxObjectShell &rObjShell, SfxBindings &rBindings,
1688 SfxFrame* pParent, sal_uInt32 nType )
1689 :
1690 pImp( new SfxViewFrame_Impl ),
1691 pDispatcher(0),
1692 pBindings(&rBindings),
1693 nAdjustPosPixelLock( 0 )
1694 {
1695 DBG_CTOR(SfxViewFrame, 0);
1696
1697 SetFrame_Impl( pParent );
1698 pImp->pFrame->SetCurrentViewFrame_Impl( this );
1699 GetFrame()->SetFrameType_Impl( GetFrameType() | nType );
1700 Construct_Impl( &rObjShell );
1701 }
1702
1703 //------------------------------------------------------------------------
1704 SfxViewFrame::SfxViewFrame(const SfxViewFrame &rCopy, SfxBindings &rBindings,
1705 SfxFrame *pFrame )
1706 :
1707 pImp( new SfxViewFrame_Impl ),
1708 pDispatcher(0),
1709 pBindings(&rBindings),
1710 nAdjustPosPixelLock( 0 )
1711 {
1712 DBG_CTOR(SfxViewFrame, 0);
1713
1714 SetFrame_Impl( pFrame );
1715 pImp->pFrame->SetCurrentViewFrame_Impl( this );
1716 GetFrame()->SetFrameType_Impl( rCopy.GetFrameType() );
1717 Construct_Impl( rCopy.GetObjectShell() );
1718 }
1719
1720 SfxViewFrame::SfxViewFrame( SfxBindings& rBindings, SfxFrame *pFrame,
1721 SfxObjectShell *pDoc, sal_uInt32 nType )
1722 : pImp( new SfxViewFrame_Impl )
1723 , pDispatcher(0)
1724 , pBindings(&rBindings)
1725 , nAdjustPosPixelLock( 0 )
1726 {
1727 DBG_CTOR(SfxViewFrame, 0);
1728
1729 SetFrame_Impl( pFrame );
1730 pImp->pFrame->SetCurrentViewFrame_Impl( this );
1731 GetFrame()->SetFrameType_Impl( GetFrameType() | nType );
1732 Construct_Impl( pDoc);
1733 }
1734
1735 //------------------------------------------------------------------------
1736 SfxViewFrame::~SfxViewFrame()
1737 {
1738 DBG_DTOR(SfxViewFrame, 0);
1739
1740 if ( GetFrame() && GetFrame()->GetCurrentViewFrame() == this )
1741 GetFrame()->SetCurrentViewFrame_Impl( NULL );
1742
1743 SfxObjectShell* pSh = pImp->pImportShell;
1744 if( pSh )
1745 pSh->AbortImport();
1746
1747 // von Frame-Liste abmelden
1748 SfxApplication *pSfxApp = SFX_APP();
1749 SfxViewFrameArr_Impl &rFrames = pSfxApp->GetViewFrames_Impl();
1750 const SfxViewFrame *pThis = this;
1751 rFrames.Remove( rFrames.GetPos(pThis) );
1752
1753 // Member l"oschen
1754 KillDispatcher_Impl();
1755
1756 delete pImp;
1757 }
1758
1759 //------------------------------------------------------------------------
1760 void SfxViewFrame::KillDispatcher_Impl()
1761
1762 // Dispatcher abr"aumen und l"oschen
1763
1764 {
1765 DBG_CHKTHIS(SfxViewFrame, 0);
1766
1767 SfxModule* pModule = xObjSh.Is() ? xObjSh->GetModule() : 0;
1768 if ( xObjSh.Is() )
1769 ReleaseObjectShell_Impl();
1770 if ( pDispatcher )
1771 {
1772 if( pModule )
1773 pDispatcher->Pop( *pModule, SFX_SHELL_POP_UNTIL );
1774 else
1775 pDispatcher->Pop( *this );
1776 DELETEZ(pDispatcher);
1777 }
1778 }
1779
1780 //------------------------------------------------------------------------
1781 SfxViewFrame* SfxViewFrame::Current()
1782 {
1783 return SfxApplication::Is_Impl() ? SFX_APP()->Get_Impl()->pViewFrame : NULL;
1784 }
1785
1786 //--------------------------------------------------------------------
1787 sal_uInt16 SfxViewFrame::Count(TypeId aType)
1788
1789 /* [Beschreibung]
1790
1791 Liefert die Anzahl der sichtbaren <SfxViewFrame>-Instanzen vom Typ
1792 'aType' bzw. aller sichtbaren, falls 'aType==0' (default).
1793 */
1794
1795 {
1796 SfxApplication *pSfxApp = SFX_APP();
1797 SfxViewFrameArr_Impl& rFrames = pSfxApp->GetViewFrames_Impl();
1798 const sal_uInt16 nCount = rFrames.Count();
1799 sal_uInt16 nFound = 0;
1800 for ( sal_uInt16 i = 0; i < nCount; ++i )
1801 {
1802 SfxViewFrame *pFrame = rFrames[i];
1803 if ( ( !aType || pFrame->IsA(aType) ) &&
1804 pFrame->IsVisible_Impl() )
1805 ++nFound;
1806 }
1807 return nFound;
1808 }
1809
1810 //--------------------------------------------------------------------
1811 // returns the first window of spec. type viewing the specified doc.
1812 SfxViewFrame* SfxViewFrame::GetFirst
1813 (
1814 const SfxObjectShell* pDoc,
1815 TypeId aType,
1816 sal_Bool bOnlyIfVisible
1817 )
1818 {
1819 SfxApplication *pSfxApp = SFX_APP();
1820 SfxViewFrameArr_Impl &rFrames = pSfxApp->GetViewFrames_Impl();
1821
1822 // search for a SfxDocument of the specified type
1823 for ( sal_uInt16 nPos = 0; nPos < rFrames.Count(); ++nPos )
1824 {
1825 SfxViewFrame *pFrame = rFrames.GetObject(nPos);
1826 if ( ( !pDoc || pDoc == pFrame->GetObjectShell() ) &&
1827 ( !aType || pFrame->IsA(aType) ) &&
1828 ( !bOnlyIfVisible || pFrame->IsVisible_Impl()) )
1829 return pFrame;
1830 }
1831
1832 return 0;
1833 }
1834 //--------------------------------------------------------------------
1835
1836 // returns thenext window of spec. type viewing the specified doc.
1837 SfxViewFrame* SfxViewFrame::GetNext
1838 (
1839 const SfxViewFrame& rPrev,
1840 const SfxObjectShell* pDoc,
1841 TypeId aType,
1842 sal_Bool bOnlyIfVisible
1843 )
1844 {
1845 SfxApplication *pSfxApp = SFX_APP();
1846 SfxViewFrameArr_Impl &rFrames = pSfxApp->GetViewFrames_Impl();
1847
1848 // refind the specified predecessor
1849 sal_uInt16 nPos;
1850 for ( nPos = 0; nPos < rFrames.Count(); ++nPos )
1851 if ( rFrames.GetObject(nPos) == &rPrev )
1852 break;
1853
1854 // search for a Frame of the specified type
1855 for ( ++nPos; nPos < rFrames.Count(); ++nPos )
1856 {
1857 SfxViewFrame *pFrame = rFrames.GetObject(nPos);
1858 if ( ( !pDoc || pDoc == pFrame->GetObjectShell() ) &&
1859 ( !aType || pFrame->IsA(aType) ) &&
1860 ( !bOnlyIfVisible || pFrame->IsVisible_Impl()) )
1861 return pFrame;
1862 }
1863 return 0;
1864 }
1865
1866 void SfxViewFrame::CloseHiddenFrames_Impl()
1867 {
1868 SfxApplication *pSfxApp = SFX_APP();
1869 SfxViewFrameArr_Impl &rFrames = pSfxApp->GetViewFrames_Impl();
1870 for ( sal_uInt16 nPos=0; nPos<rFrames.Count(); )
1871 {
1872 SfxViewFrame *pFrame = rFrames.GetObject(nPos);
1873 if ( !pFrame->IsVisible_Impl() )
1874 pFrame->DoClose();
1875 else
1876 nPos++;
1877 }
1878 }
1879
1880 //--------------------------------------------------------------------
1881 SfxProgress* SfxViewFrame::GetProgress() const
1882 {
1883 SfxObjectShell *pObjSh = GetObjectShell();
1884 return pObjSh ? pObjSh->GetProgress() : 0;
1885 }
1886
1887 //--------------------------------------------------------------------
1888 void SfxViewFrame::ShowStatusText( const String& /*rText*/)
1889 {
1890 /* OBSOLETE: If this is used, framework/uielement/progressbarwrapper.[h|c]xx &
1891 framework/uielement/statusindicatorinterfacewrapper.[h|c]xx must be
1892 extended to support a new interface to support ShowStatusText/HideStatusText
1893 SfxWorkWindow* pWorkWin = GetFrame()->GetWorkWindow_Impl();
1894 SfxStatusBarManager *pMgr = pWorkWin->GetStatusBarManager_Impl();
1895 if ( pMgr )
1896 {
1897 pMgr->GetStatusBar()->HideItems();
1898 pMgr->GetStatusBar()->SetText( rText );
1899 }
1900 */
1901 }
1902
1903 //--------------------------------------------------------------------
1904 void SfxViewFrame::HideStatusText()
1905 {
1906 /* OBSOLETE: If this is used, framework/uielement/progressbarwrapper.[h|c]xx &
1907 framework/uielement/statusindicatorinterfacewrapper.[h|c]xx must be
1908 extended to support a new interface to support ShowStatusText/HideStatusText
1909 SfxWorkWindow* pWorkWin = GetFrame()->GetWorkWindow_Impl();
1910 SfxStatusBarManager *pMgr = pWorkWin->GetStatusBarManager_Impl();
1911 if ( pMgr )
1912 pMgr->GetStatusBar()->ShowItems();
1913 */
1914 }
1915
1916
1917 //--------------------------------------------------------------------
1918 #ifdef ENABLE_INIMANAGER//MUSTINI
1919 SfxIniManager* SfxViewFrame::GetIniManager() const
1920 {
1921 /* SfxIniManager *pIniMgr = GetObjectShell()
1922 ? GetObjectShell()->GetFactory().GetIniManager()
1923 : 0;
1924 if ( !pIniMgr )*/ //!
1925 return SFX_APP()->GetAppIniManager();
1926 // return pIniMgr;
1927 }
1928 #endif
1929
1930 //--------------------------------------------------------------------
1931 void SfxViewFrame::DoAdjustPosSizePixel //! teilen in Inner.../Outer...
1932 (
1933 SfxViewShell* pSh,
1934 const Point& rPos,
1935 const Size& rSize
1936 )
1937 {
1938 DBG_CHKTHIS(SfxViewFrame, 0);
1939
1940 // Components benutzen diese Methode nicht!
1941 if( pSh && pSh->GetWindow() && !nAdjustPosPixelLock )
1942 {
1943 nAdjustPosPixelLock++;
1944 if ( pImp->bResizeInToOut )
1945 pSh->InnerResizePixel( rPos, rSize );
1946 else
1947 pSh->OuterResizePixel( rPos, rSize );
1948 nAdjustPosPixelLock--;
1949 }
1950 }
1951
1952 //========================================================================
1953
1954 int SfxViewFrameItem::operator==( const SfxPoolItem &rItem ) const
1955 {
1956 return PTR_CAST(SfxViewFrameItem, &rItem)->pFrame== pFrame;
1957 }
1958
1959 //--------------------------------------------------------------------
1960 String SfxViewFrameItem::GetValueText() const
1961 {
1962 return String();
1963 }
1964
1965 //--------------------------------------------------------------------
1966 SfxPoolItem* SfxViewFrameItem::Clone( SfxItemPool *) const
1967 {
1968 return new SfxViewFrameItem( pFrame);
1969 }
1970
1971 //--------------------------------------------------------------------
1972 void SfxViewFrame::SetViewShell_Impl( SfxViewShell *pVSh )
1973
1974 /* [Beschreibung]
1975
1976 Interne Methode zum setzen der jeweils aktuellen <SfxViewShell>-Instanz,
1977 die in diesem SfxViewFrame aktiv ist.
1978 */
1979
1980 {
1981 SfxShell::SetViewShell_Impl( pVSh );
1982
1983 // Hack: InPlaceMode
1984 if ( pVSh && !pVSh->UseObjectSize() )
1985 pImp->bResizeInToOut = sal_False;
1986 }
1987
1988 //--------------------------------------------------------------------
1989 /*
1990 Beschreibung:
1991 Der ParentViewFrame ist der ViewFrame des Containers bei internem InPlace
1992 */
1993
1994 void SfxViewFrame::SetParentViewFrame_Impl(SfxViewFrame *pFrame)
1995 {
1996 pImp->pParentViewFrame = pFrame;
1997 }
1998
1999 //--------------------------------------------------------------------
2000 /*
2001 Beschreibung:
2002 Der ParentViewFrame ist der ViewFrame des Containers bei internem InPlace
2003 */
2004
2005 //TODO/LATER: is it still necessary? is there a replacement for GetParentViewFrame_Impl?
2006 SfxViewFrame* SfxViewFrame::GetParentViewFrame_Impl() const
2007 {
2008 return pImp->pParentViewFrame;
2009 }
2010
2011 //--------------------------------------------------------------------
2012 void SfxViewFrame::ForceOuterResize_Impl(sal_Bool bOn)
2013 {
2014 if ( !pImp->bDontOverwriteResizeInToOut )
2015 pImp->bResizeInToOut = !bOn;
2016 }
2017
2018 void SfxViewFrame::ForceInnerResize_Impl(sal_Bool bOn)
2019 {
2020 pImp->bDontOverwriteResizeInToOut = bOn;
2021 }
2022
2023 //--------------------------------------------------------------------
2024 sal_Bool SfxViewFrame::IsResizeInToOut_Impl() const
2025 {
2026 return pImp->bResizeInToOut;
2027 }
2028 //--------------------------------------------------------------------
2029 void SfxViewFrame::DoAdjustPosSize( SfxViewShell *pSh,
2030 const Point rPos, const Size &rSize )
2031 {
2032 DBG_CHKTHIS(SfxViewFrame, 0);
2033 if( pSh && !nAdjustPosPixelLock && pSh->UseObjectSize())
2034 {
2035 Window *pWindow = pSh->GetWindow();
2036 Point aPos = pWindow->LogicToPixel(rPos);
2037 Size aSize = pWindow->LogicToPixel(rSize);
2038 DoAdjustPosSizePixel(pSh, aPos, aSize);
2039 }
2040 }
2041
2042 //--------------------------------------------------------------------
2043 void SfxViewFrame::GetDocNumber_Impl()
2044 {
2045 DBG_ASSERT( GetObjectShell(), "Kein Dokument!" );
2046 GetObjectShell()->SetNamedVisibility_Impl();
2047 pImp->nDocViewNo = GetObjectShell()->GetNoSet_Impl().GetFreeIndex()+1;
2048 }
2049
2050 //--------------------------------------------------------------------
2051
2052 void SfxViewFrame::Enable( sal_Bool bEnable )
2053 {
2054 if ( bEnable != pImp->bEnabled )
2055 {
2056 pImp->bEnabled = bEnable;
2057
2058 // e.g. InPlace-Frames have a parent...
2059 SfxViewFrame *pParent = GetParentViewFrame_Impl();
2060 if ( pParent )
2061 {
2062 pParent->Enable( bEnable );
2063 }
2064 else
2065 {
2066 Window *pWindow = &GetFrame()->GetTopFrame()->GetWindow();
2067 if ( !bEnable )
2068 pImp->bWindowWasEnabled = pWindow->IsInputEnabled();
2069 if ( !bEnable || pImp->bWindowWasEnabled )
2070 pWindow->EnableInput( bEnable, TRUE );
2071 }
2072
2073 // cursor and focus
2074 SfxViewShell* pViewSh = GetViewShell();
2075 if ( bEnable )
2076 {
2077 // show cursor
2078 if ( pViewSh )
2079 pViewSh->ShowCursor();
2080 }
2081 else
2082 {
2083 // hide cursor
2084 if ( pViewSh )
2085 pViewSh->ShowCursor(sal_False);
2086 }
2087 /*
2088 if ( !bEnable )
2089 GetBindings().ENTERREGISTRATIONS();
2090 GetDispatcher()->Lock( !bEnable );
2091 if ( bEnable )
2092 GetBindings().LEAVEREGISTRATIONS();
2093 */
2094 }
2095 }
2096
2097 //--------------------------------------------------------------------
2098 void SfxViewFrame::Show()
2099
2100 /* [Beschreibung]
2101
2102 Diese Methode macht das Frame-Window sichtbar und ermittelt vorher
2103 den Fenstername. Au\serdem wird das Dokument festgehalten. Man darf
2104 i.d.R. nie das Window direkt showen!
2105 */
2106
2107 {
2108 // zuerst locken damit in UpdateTitle() gilt: IsVisible() == sal_True (:#)
2109 if ( xObjSh.Is() )
2110 {
2111 xObjSh->GetMedium()->GetItemSet()->ClearItem( SID_HIDDEN );
2112 if ( !pImp->bObjLocked )
2113 LockObjectShell_Impl( sal_True );
2114
2115 // Doc-Shell Titel-Nummer anpassen, get unique view-no
2116 if ( 0 == pImp->nDocViewNo && !(GetFrameType() & SFXFRAME_PLUGIN ) )
2117 {
2118 GetDocNumber_Impl();
2119 UpdateTitle();
2120 }
2121 }
2122 else
2123 UpdateTitle();
2124
2125 // Frame-Window anzeigen, aber nur wenn der ViewFrame kein eigenes Window
2126 // hat oder wenn er keine Component enth"alt
2127 if ( &GetWindow() == &GetFrame()->GetWindow() || !GetFrame()->HasComponent() )
2128 GetWindow().Show();
2129 GetFrame()->GetWindow().Show();
2130
2131 /* SfxViewFrame* pCurrent = SfxViewFrame::Current();
2132 if ( GetFrame()->GetFrameInterface()->isActive() &&
2133 pCurrent != this &&
2134 ( !pCurrent || pCurrent->GetParentViewFrame_Impl() != this ) &&
2135 !GetActiveChildFrame_Impl() )
2136 MakeActive_Impl( FALSE );*/
2137 if ( xObjSh.Is() && xObjSh->Get_Impl()->bHiddenLockedByAPI )
2138 {
2139 xObjSh->Get_Impl()->bHiddenLockedByAPI = FALSE;
2140 xObjSh->OwnerLock(FALSE);
2141 }
2142 }
2143
2144 //--------------------------------------------------------------------
2145 sal_Bool SfxViewFrame::IsVisible_Impl() const
2146 {
2147 //Window *pWin = pImp->bInCtor ? 0 : &GetWindow();
2148 //return GetFrame()->HasComponent() || pImp->bObjLocked || ( pWin && pWin->IsVisible() );
2149 return pImp->bObjLocked;
2150 }
2151
2152 //--------------------------------------------------------------------
2153 void SfxViewFrame::Hide()
2154 {
2155 GetWindow().Hide();
2156 if ( pImp->bObjLocked )
2157 LockObjectShell_Impl( sal_False );
2158 }
2159
2160 //--------------------------------------------------------------------
2161 void SfxViewFrame::LockObjectShell_Impl( sal_Bool bLock )
2162 {
2163 DBG_ASSERT( pImp->bObjLocked != bLock, "Falscher Locked-Status!" );
2164
2165 DBG_ASSERT( GetObjectShell(), "Kein Dokument!" );
2166 GetObjectShell()->OwnerLock(bLock);
2167 pImp->bObjLocked = bLock;
2168 }
2169
2170 //--------------------------------------------------------------------
2171 void SfxViewFrame::MakeActive_Impl( BOOL bGrabFocus )
2172 {
2173 if ( GetViewShell() && !GetFrame()->IsClosing_Impl() )
2174 {
2175 if ( IsVisible_Impl() )
2176 {
2177 if ( GetViewShell() )
2178 {
2179 BOOL bPreview = FALSE;
2180 if ( GetObjectShell()->IsPreview() )
2181 {
2182 bPreview = TRUE;
2183 }
2184 else
2185 {
2186 SfxViewFrame* pParent = GetParentViewFrame();
2187 if ( pParent )
2188 pParent->SetActiveChildFrame_Impl( this );
2189 }
2190
2191 SfxViewFrame* pCurrent = SfxViewFrame::Current();
2192 css::uno::Reference< css::frame::XFrame > xFrame = GetFrame()->GetFrameInterface();
2193 if ( !bPreview )
2194 {
2195 SetViewFrame( this );
2196 GetBindings().SetActiveFrame( css::uno::Reference< css::frame::XFrame >() );
2197 uno::Reference< frame::XFramesSupplier > xSupp( xFrame, uno::UNO_QUERY );
2198 if ( xSupp.is() )
2199 xSupp->setActiveFrame( uno::Reference < frame::XFrame >() );
2200
2201 css::uno::Reference< css::awt::XWindow > xContainerWindow = xFrame->getContainerWindow();
2202 Window* pWindow = VCLUnoHelper::GetWindow(xContainerWindow);
2203 if (pWindow && pWindow->HasChildPathFocus() && bGrabFocus)
2204 {
2205 SfxInPlaceClient *pCli = GetViewShell()->GetUIActiveClient();
2206 if ( ( !pCli || !pCli->IsObjectUIActive() ) &&
2207 ( !pCurrent || pCurrent->GetParentViewFrame_Impl() != this ) )
2208 GetFrame()->GrabFocusOnComponent_Impl();
2209 }
2210 }
2211 else
2212 {
2213 GetBindings().SetDispatcher( GetDispatcher() );
2214 GetBindings().SetActiveFrame( ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > () );
2215 GetDispatcher()->Update_Impl( FALSE );
2216 }
2217 }
2218 }
2219 }
2220 }
2221
2222 //--------------------------------------------------------------------
2223
2224 SfxViewShell* SfxViewFrame::CreateView_Impl( sal_uInt16 nViewId )
2225
2226 /* [Beschreibung]
2227
2228 Erzeugt eine SfxViewShell f"ur diesen SfxViewFrame. Wird auch aus
2229 <SfxObjectShell::LoadWindows_Impl()>
2230 gerufen.
2231 */
2232
2233 {
2234 DBG_ASSERT( GetObjectShell(), "Kein Dokument!" );
2235
2236 LockAdjustPosSizePixel();
2237
2238 // passende ::com::sun::star::sdbcx::View-Factory suchen
2239 SfxObjectFactory &rDocFact = GetObjectShell()->GetFactory();
2240 sal_uInt16 nNewNo = nViewId ? USHRT_MAX : 0;
2241 for ( sal_uInt16 nNo = 0;
2242 nNo < rDocFact.GetViewFactoryCount();
2243 ++nNo )
2244 {
2245 sal_uInt16 nFoundId = rDocFact.GetViewFactory(nNo).GetOrdinal();
2246 if ( nNewNo == USHRT_MAX )
2247 {
2248 if ( nViewId == nFoundId )
2249 nNewNo = nNo;
2250 }
2251 }
2252
2253 // per Factory erzeugen
2254 GetBindings().ENTERREGISTRATIONS();
2255 SfxViewFactory &rViewFactory = rDocFact.GetViewFactory( nNewNo );
2256 SfxViewShell *pViewShell = rViewFactory.CreateInstance(this, 0);
2257 SetViewShell_Impl(pViewShell);
2258 UnlockAdjustPosSizePixel();
2259
2260 if ( GetWindow().IsReallyVisible() )
2261 DoAdjustPosSizePixel(pViewShell, Point(), GetWindow().GetOutputSizePixel());
2262
2263 // erste jetzt anzeigen (ausser wenn MTs BASIC-IDE mal wieder keins hat)
2264 Window *pViewWin = pViewShell->GetWindow();
2265 if ( pViewWin && pViewShell->IsShowView_Impl() )
2266 pViewWin->Show();
2267
2268 // Dispatcher
2269 GetDispatcher()->Push( *pViewShell );
2270 if ( pViewShell->GetSubShell() )
2271 GetDispatcher()->Push( *pViewShell->GetSubShell() );
2272 pViewShell->PushSubShells_Impl();
2273
2274 #if defined SFX_HINT_VIEWCREATED
2275 GetObjectShell()->Broadcast( SfxSimpleHint( SFX_HINT_VIEWCREATED ) );
2276 #endif
2277
2278 GetBindings().LEAVEREGISTRATIONS();
2279
2280 DBG_ASSERT( SFX_APP()->GetViewFrames_Impl().Count() == SFX_APP()->GetViewShells_Impl().Count(), "Inconsistent view arrays!" );
2281 return pViewShell;
2282 }
2283
2284 //-------------------------------------------------------------------------
2285 SfxViewFrame* SfxViewFrame::SearchViewFrame( SfxViewFrame *pViewFrame,
2286 const String& rName )
2287 {
2288 if ( !pViewFrame )
2289 pViewFrame = SfxViewFrame::Current();
2290 if ( !pViewFrame )
2291 return NULL;
2292 SfxFrame *pFrame = pViewFrame->GetFrame()->SearchFrame( rName );
2293 if ( !pFrame )
2294 return NULL;
2295
2296 // Der Frame ist selbst ein ViewFrame oder enth"alt einen
2297 /*
2298 pViewFrame = PTR_CAST( SfxViewFrame, pFrame );
2299 if ( !pViewFrame && pFrame->GetChildFrameCount() )
2300 pViewFrame = PTR_CAST( SfxViewFrame, pFrame->GetChildFrame(0) );
2301 */
2302 return pFrame->GetCurrentViewFrame();
2303 }
2304
2305 //-------------------------------------------------------------------------
2306
2307 void SfxViewFrame::SetQuietMode_Impl( sal_Bool bOn )
2308 {
2309 GetDispatcher()->SetQuietMode_Impl( bOn );
2310 }
2311
2312 //-------------------------------------------------------------------------
2313
2314 SfxObjectShell* SfxViewFrame::GetObjectShell()
2315 {
2316 return xObjSh;
2317 }
2318
2319 void SfxViewFrame::SetMargin_Impl( const Size& rMargin )
2320 {
2321 pImp->aMargin = rMargin;
2322 }
2323
2324 const Size& SfxViewFrame::GetMargin_Impl() const
2325 {
2326 return pImp->aMargin;
2327 }
2328
2329 void SfxViewFrame::SetActiveChildFrame_Impl( SfxViewFrame *pViewFrame )
2330 {
2331 if ( pViewFrame != pImp->pActiveChild )
2332 {
2333 if ( !pImp->pActiveChild )
2334 GetDispatcher()->LockUI_Impl( sal_False );
2335
2336 pImp->pActiveChild = pViewFrame;
2337
2338 Reference< XFramesSupplier > xFrame( GetFrame()->GetFrameInterface(), UNO_QUERY );
2339 Reference< XFrame > xActive;
2340 if ( pViewFrame )
2341 xActive = pViewFrame->GetFrame()->GetFrameInterface();
2342
2343 if ( xFrame.is() ) // PB: #74432# xFrame cann be NULL
2344 xFrame->setActiveFrame( xActive );
2345 }
2346 }
2347
2348 SfxViewFrame* SfxViewFrame::GetActiveChildFrame_Impl() const
2349 {
2350 SfxViewFrame *pViewFrame = pImp->pActiveChild;
2351 /*
2352 if ( !pViewFrame )
2353 {
2354 // Wenn es keinen aktiven ChildFrame gibt, irgendeinen nehmen
2355 for ( sal_uInt16 n=0; n<GetChildFrameCount(); n++ )
2356 {
2357 pViewFrame =
2358 PTR_CAST( SfxViewFrame, GetChildFrame(n)->GetChildFrame(0) );
2359 if ( pViewFrame )
2360 break;
2361 }
2362 }
2363
2364 pImp->pActiveChild = pViewFrame;
2365 */
2366 return pViewFrame;
2367 }
2368
2369 //--------------------------------------------------------------------
2370
2371 sal_Bool SfxViewFrame::SwitchToViewShell_Impl
2372 (
2373 sal_uInt16 nViewId, /* > 0
2374 Registrierungs-Id der ::com::sun::star::sdbcx::View, auf die umge-
2375 schaltet werden soll, bzw. die erstmalig
2376 erzeugt werden soll.
2377
2378 == 0
2379 Es soll die Default-::com::sun::star::sdbcx::View verwendet werden. */
2380
2381 sal_Bool bIsIndex /* sal_True
2382 'nViewId' ist keine Registrations-Id sondern
2383 ein ::com::sun::star::sdbcx::Index in die f"ur die in diesem
2384 <SfxViewFrame> dargestellte <SfxObjectShell>.
2385 */
2386 )
2387
2388 /* [Beschreibung]
2389
2390 Interne Methode zum Umschalten auf eine andere <SfxViewShell>-Subklasse,
2391 die in diesem SfxMDIFrame erzeugt werden soll. Existiert noch
2392 keine SfxViewShell in diesem SfxMDIFrame, so wird erstmalig eine
2393 erzeugt.
2394
2395
2396 [R"uckgabewert]
2397
2398 sal_Bool sal_True
2399 die angeforderte SfxViewShell wurde erzeugt
2400 und eine ggf. bestehende gel"oscht
2401
2402 sal_False
2403 die angeforderte SfxViewShell konnte nicht
2404 erzeugt werden, die bestehende SfxViewShell
2405 existiert daher weiterhin
2406 */
2407
2408 {
2409 try{
2410 DBG_ASSERT( GetObjectShell(), "Kein Dokument!" );
2411
2412 SfxObjectFactory &rDocFact = GetObjectShell()->GetFactory();
2413
2414 // find index of old and new ViewShell
2415 sal_uInt16 nOldNo = USHRT_MAX, nNewNo = USHRT_MAX;
2416 bIsIndex |= 0 == nViewId;
2417 for ( sal_uInt16 nNo = 0; nNo < rDocFact.GetViewFactoryCount(); ++nNo )
2418 {
2419 sal_uInt16 nFoundId = rDocFact.GetViewFactory(nNo).GetOrdinal();
2420 if ( nNewNo == USHRT_MAX )
2421 {
2422 if ( bIsIndex && nViewId == nNo )
2423 {
2424 nNewNo = nNo;
2425 nViewId = nFoundId; // for nViewId == 0
2426 }
2427 else if ( !bIsIndex && nViewId == nFoundId )
2428 nNewNo = nNo;
2429 }
2430 if ( pImp->nCurViewId == nFoundId )
2431 nOldNo = nNo;
2432 }
2433
2434 if ( nNewNo == USHRT_MAX )
2435 {
2436 // unknown ID -> fall back to default
2437 sal_uInt16 nFoundId = rDocFact.GetViewFactory(0).GetOrdinal();
2438 nNewNo = 0;
2439 nViewId = nFoundId;
2440 if ( pImp->nCurViewId == nFoundId )
2441 nOldNo = 0;
2442 }
2443
2444 SfxViewShell *pSh = GetViewShell();
2445
2446 DBG_ASSERT( !pSh || nOldNo != USHRT_MAX, "old shell id not found" );
2447
2448 // does a ViewShell exist already?
2449 SfxViewShell *pOldSh = pSh;
2450 if ( pOldSh )
2451 {
2452 // ask wether it can be closed
2453 if ( !pOldSh->PrepareClose() )
2454 return sal_False;
2455
2456 // remove SubShells from Dispatcher before switching to new ViewShell
2457 pOldSh->PushSubShells_Impl( sal_False );
2458 sal_uInt16 nLevel = pDispatcher->GetShellLevel( *pOldSh );
2459 if ( nLevel )
2460 {
2461 SfxShell *pSubShell = pDispatcher->GetShell( nLevel-1 );
2462 if ( pSubShell == pOldSh->GetSubShell() )
2463 //"real" SubShells are not deleted
2464 pDispatcher->Pop( *pSubShell, SFX_SHELL_POP_UNTIL );
2465 else
2466 // SubShells only known to Dispatcher must be deleted
2467 pDispatcher->Pop( *pSubShell, SFX_SHELL_POP_UNTIL | SFX_SHELL_POP_DELETE );
2468 }
2469
2470 pDispatcher->Pop( *pOldSh );
2471 GetBindings().Invalidate( nOldNo + SID_VIEWSHELL0 );
2472 }
2473
2474 // remember ViewID
2475 pImp->nCurViewId = nViewId;
2476 GetBindings().Invalidate( nNewNo + SID_VIEWSHELL0 );
2477
2478 // create new ViewShell
2479 SfxViewFactory &rViewFactory = rDocFact.GetViewFactory( nNewNo );
2480 LockAdjustPosSizePixel();
2481
2482 GetBindings().ENTERREGISTRATIONS();
2483 pSh = rViewFactory.CreateInstance(this, pOldSh);
2484
2485 Window *pEditWin = pSh->GetWindow();
2486 DBG_ASSERT( !pEditWin || !pEditWin->IsReallyVisible(), "don`t show your ViewShell`s Window by yourself!" );
2487
2488 // by setting the ViewShell it is prevented that disposing the Controller will destroy this ViewFrame also
2489 GetDispatcher()->SetDisableFlags( 0 );
2490 SetViewShell_Impl(pSh);
2491
2492 Reference < ::com::sun::star::awt::XWindow > xWindow(
2493 GetFrame()->GetWindow().GetComponentInterface(), UNO_QUERY );
2494 Reference < XFrame > xFrame( GetFrame()->GetFrameInterface() );
2495 if ( !pSh->GetController().is() )
2496 pSh->SetController( new SfxBaseController( pSh ) );
2497 Reference < XController > xController( pSh->GetController() );
2498 xFrame->setComponent( xWindow, xController );
2499
2500 xController->attachFrame( xFrame );
2501 Reference < XModel > xModel( GetObjectShell()->GetModel() );
2502 if ( xModel.is() )
2503 {
2504 xController->attachModel( xModel );
2505 xModel->connectController( xController );
2506 xModel->setCurrentController( xController );
2507 }
2508
2509 GetDispatcher()->Push( *pSh );
2510 if ( pSh->GetSubShell() )
2511 GetDispatcher()->Push( *pSh->GetSubShell() );
2512 pSh->PushSubShells_Impl();
2513 GetDispatcher()->Flush();
2514
2515 if ( pImp->bRestoreView && pImp->aViewData.Len() )
2516 {
2517 // restore view data if required
2518 pSh->ReadUserData( pImp->aViewData, sal_True );
2519 pImp->bRestoreView = sal_False;
2520 }
2521
2522 // create UI elements before size is set
2523 if ( SfxViewFrame::Current() == this )
2524 GetDispatcher()->Update_Impl( sal_True );
2525
2526 // allow resize events to be processed
2527 UnlockAdjustPosSizePixel();
2528
2529 Window* pFrameWin = &GetWindow();
2530 if ( pFrameWin != &GetFrame()->GetWindow() )
2531 pFrameWin->Show();
2532
2533 if ( GetWindow().IsReallyVisible() )
2534 DoAdjustPosSizePixel( pSh, Point(), GetWindow().GetOutputSizePixel() );
2535
2536 if ( pEditWin && pSh->IsShowView_Impl() )
2537 pEditWin->Show();
2538
2539 GetBindings().LEAVEREGISTRATIONS();
2540 delete pOldSh;
2541 }
2542 catch ( com::sun::star::uno::Exception& )
2543 {
2544 // the SfxCode is not able to cope with exceptions thrown while creating views
2545 // the code will crash in the stack unwinding procedure, so we shouldn't let exceptions go through here
2546 DBG_ERROR("Exception in SwitchToViewShell_Impl - urgent issue. Please contact development!");
2547 }
2548
2549 DBG_ASSERT( SFX_APP()->GetViewFrames_Impl().Count() == SFX_APP()->GetViewShells_Impl().Count(), "Inconsistent view arrays!" );
2550 return sal_True;
2551 }
2552 //--------------------------------------------------------------------
2553
2554 void SfxViewFrame::SetViewData_Impl( sal_uInt16 nViewId, const String &rViewData )
2555 {
2556 pImp->bRestoreView = sal_True;
2557 pImp->nCurViewId = nViewId;
2558 pImp->aViewData = rViewData;
2559 }
2560
2561 //-------------------------------------------------------------------------
2562 String& SfxViewFrame::GetViewData_Impl()
2563 {
2564 return pImp->aViewData;
2565 }
2566
2567 //-------------------------------------------------------------------------
2568 sal_Bool SfxViewFrame::IsRestoreView_Impl() const
2569 {
2570 return pImp->bRestoreView;
2571 }
2572
2573 //-------------------------------------------------------------------------
2574 void SfxViewFrame::SetRestoreView_Impl( sal_Bool bOn )
2575 {
2576 pImp->bRestoreView = bOn;
2577 }
2578
2579 //-------------------------------------------------------------------------
2580 sal_uInt16 SfxViewFrame::GetCurViewId() const
2581 {
2582 return pImp->nCurViewId;
2583 }
2584
2585 //-------------------------------------------------------------------------
2586 void SfxViewFrame::ExecView_Impl
2587 (
2588 SfxRequest& rReq // der auszuf"uhrende <SfxRequest>
2589 )
2590
2591 /* [Beschreibung]
2592
2593 Interne Methode zum Ausf"uhren der f"ur die <SfxShell> Subklasse
2594 SfxViewFrame in der <SVIDL> beschriebenen Slots.
2595 */
2596
2597 {
2598 DBG_CHKTHIS(SfxViewFrame, 0);
2599
2600 // Wenn gerade die Shells ausgetauscht werden...
2601 if ( !GetObjectShell() || !GetViewShell() )
2602 return;
2603
2604 switch ( rReq.GetSlot() )
2605 {
2606 case SID_TERMINATE_INPLACEACTIVATION :
2607 {
2608 SfxInPlaceClient* pClient = GetViewShell()->GetUIActiveClient();
2609 if ( pClient )
2610 pClient->DeactivateObject();
2611 break;
2612 }
2613
2614 case SID_FILLFRAME:
2615 {
2616 // Bei Mail etc. k"onnen die Frames nicht angesprochen werden
2617 SfxFrame *pParent = GetFrame()->GetParentFrame();
2618 if ( pParent && pParent->GetCurrentViewFrame()->
2619 GetViewShell()->IsImplementedAsFrameset_Impl() )
2620 break;
2621
2622 SfxViewFrame *pRet = NULL;
2623 SFX_REQUEST_ARG(
2624 rReq, pItem, SfxStringItem, SID_FILLFRAME, sal_False );
2625 if ( pItem )
2626 {
2627 String aName( pItem->GetValue() );
2628 sal_uInt16 nFrame = (sal_uInt16) aName.ToInt32();
2629 if ( nFrame == 0 )
2630 nFrame = USHRT_MAX;
2631
2632 SfxFrameIterator aIter( *GetFrame(), sal_False );
2633 SfxFrame *pFrame = aIter.FirstFrame();
2634 sal_uInt16 nActFrame = 1;
2635 while ( pFrame )
2636 {
2637 SfxViewFrame *pView = pFrame->GetCurrentViewFrame();
2638 if (
2639 nActFrame == nFrame ||
2640 (
2641 pView &&
2642 aName.CompareIgnoreCaseToAscii( pView->SfxShell::GetName() ) == COMPARE_EQUAL
2643 )
2644 )
2645 {
2646 pRet = pView;
2647 break;
2648 }
2649
2650 pFrame = aIter.NextFrame( *pFrame );
2651 nActFrame++;
2652 }
2653 }
2654
2655 rReq.SetReturnValue( SfxObjectItem( SID_DOCFRAME, pRet ) );
2656 break;
2657 }
2658
2659 case SID_VIEWSHELL:
2660 {
2661 const SfxPoolItem *pItem = 0;
2662 if ( rReq.GetArgs() &&
2663 SFX_ITEM_SET == rReq.GetArgs()->GetItemState( SID_VIEWSHELL, sal_False, &pItem ) )
2664 rReq.SetReturnValue( SfxBoolItem(0, SwitchToViewShell_Impl(
2665 (sal_uInt16)((const SfxUInt16Item*) pItem)->GetValue()) ));
2666 break;
2667 }
2668
2669 case SID_VIEWSHELL0:
2670 case SID_VIEWSHELL1:
2671 case SID_VIEWSHELL2:
2672 case SID_VIEWSHELL3:
2673 case SID_VIEWSHELL4:
2674 {
2675 rReq.SetReturnValue( SfxBoolItem(0,
2676 SwitchToViewShell_Impl( rReq.GetSlot() - SID_VIEWSHELL0, sal_True ) ) );
2677 break;
2678 }
2679
2680 case SID_NEWWINDOW:
2681 {
2682 // Hack. demnaechst virtuelle Funktion
2683 if ( !GetViewShell()->NewWindowAllowed() && !GetObjectShell()->HasName() )
2684 return;
2685
2686 // ViewData bei FrameSets rekursiv holen
2687 GetFrame()->GetViewData_Impl();
2688 SfxMedium *pMed = GetObjectShell()->GetMedium();
2689 String aUserData;
2690 GetViewShell()->WriteUserData( aUserData, sal_True );
2691 if ( !GetViewShell()->NewWindowAllowed() )
2692 {
2693 SFX_REQUEST_ARG( rReq, pFrameItem, SfxUnoAnyItem, SID_FILLFRAME, sal_False );
2694 SfxFrame *pFrame = NULL;
2695 Reference < XFrame > xFrame;
2696 if ( pFrameItem )
2697 {
2698 pFrameItem->GetValue() >>= xFrame;
2699 pFrame = SfxTopFrame::Create( xFrame );
2700 }
2701 else
2702 pFrame = SfxTopFrame::Create();
2703
2704 SfxAllItemSet aSet( SFX_APP()->GetPool() );
2705 SFX_REQUEST_ARG( rReq, pHiddenItem, SfxBoolItem, SID_HIDDEN, sal_False );
2706 if ( pHiddenItem )
2707 aSet.Put( *pHiddenItem );
2708
2709 SFX_ITEMSET_ARG( pMed->GetItemSet(), pRefererItem, SfxStringItem, SID_REFERER, sal_False );
2710 SfxStringItem aReferer( SID_REFERER, DEFINE_CONST_UNICODE( "private:user" ) );
2711 if ( !pRefererItem )
2712 pRefererItem = &aReferer;
2713
2714 aSet.Put( SfxStringItem( SID_FILE_NAME, pMed->GetName() ) );
2715 aSet.Put( SfxStringItem( SID_USER_DATA, aUserData ) );
2716 aSet.Put( SfxUInt16Item( SID_VIEW_ID, GetCurViewId() ) );
2717 aSet.Put( *pRefererItem );
2718 if( pMed->GetFilter() )
2719 aSet.Put( SfxStringItem( SID_FILTER_NAME, pMed->GetFilter()->GetFilterName()) );
2720 aSet.Put( SfxFrameItem ( SID_DOCFRAME, pFrame ) );
2721 if ( xFrame.is() )
2722 GetDispatcher()->Execute( SID_OPENDOC, SFX_CALLMODE_SYNCHRON, aSet );
2723 else
2724 GetDispatcher()->Execute( SID_OPENDOC, SFX_CALLMODE_ASYNCHRON, aSet );
2725 }
2726 else
2727 {
2728 pMed->GetItemSet()->Put( SfxStringItem( SID_USER_DATA, aUserData ) );
2729
2730 BOOL bHidden = FALSE;
2731 SFX_REQUEST_ARG( rReq, pHiddenItem, SfxBoolItem, SID_HIDDEN, sal_False );
2732 if ( pHiddenItem )
2733 bHidden = pHiddenItem->GetValue();
2734 SFX_REQUEST_ARG( rReq, pFrameItem, SfxUnoAnyItem, SID_FILLFRAME, sal_False );
2735 if ( pFrameItem )
2736 {
2737 Reference < XFrame > xFrame;
2738 pFrameItem->GetValue() >>= xFrame;
2739 SfxFrame* pFrame = SfxTopFrame::Create( xFrame );
2740 pMed->GetItemSet()->ClearItem( SID_HIDDEN );
2741 pFrame->InsertDocument( GetObjectShell() );
2742 if ( !bHidden )
2743 xFrame->getContainerWindow()->setVisible( sal_True );
2744 }
2745 else
2746 {
2747 SfxAllItemSet aSet( GetPool() );
2748 aSet.Put( SfxBoolItem( SID_OPEN_NEW_VIEW, TRUE ) );
2749 SfxFrame* pFrame = SfxTopFrame::Create( GetObjectShell(), GetCurViewId(), bHidden, &aSet );
2750 if ( bHidden )
2751 pFrame->GetCurrentViewFrame()->LockObjectShell_Impl( TRUE );
2752 }
2753 }
2754
2755 rReq.Done();
2756 break;
2757 }
2758
2759 case SID_OBJECT:
2760 {
2761 SFX_REQUEST_ARG( rReq, pItem, SfxUInt16Item, SID_OBJECT, sal_False );
2762
2763 SfxViewShell *pViewShell = GetViewShell();
2764 if ( pViewShell && pItem )
2765 {
2766 pViewShell->DoVerb( pItem->GetValue() );
2767 rReq.Done();
2768 break;;
2769 }
2770 }
2771 }
2772 }
2773
2774 //-------------------------------------------------------------------------
2775 /* TODO as96863:
2776 This method try to collect informations about the count of currently open documents.
2777 But the algorithm is implemented very simple ...
2778 E.g. hidden documents should be ignored here ... but they are counted.
2779 TODO: export special helper "framework::FrameListAnalyzer" within the framework module
2780 and use it here.
2781 */
2782 sal_Bool impl_maxOpenDocCountReached()
2783 {
2784 static ::rtl::OUString SERVICE_DESKTOP = ::rtl::OUString::createFromAscii("com.sun.star.frame.Desktop");
2785
2786 try
2787 {
2788 css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = ::comphelper::getProcessServiceFactory();
2789 css::uno::Any aVal = ::comphelper::ConfigurationHelper::readDirectKey(
2790 xSMGR,
2791 ::rtl::OUString::createFromAscii("org.openoffice.Office.Common/"),
2792 ::rtl::OUString::createFromAscii("Misc"),
2793 ::rtl::OUString::createFromAscii("MaxOpenDocuments"),
2794 ::comphelper::ConfigurationHelper::E_READONLY);
2795
2796 // NIL means: count of allowed documents = infinite !
2797 if ( ! aVal.hasValue())
2798 return sal_False;
2799
2800 sal_Int32 nOpenDocs = 0;
2801 sal_Int32 nMaxDocs = 0;
2802 aVal >>= nMaxDocs;
2803
2804 css::uno::Reference< css::frame::XFramesSupplier > xDesktop(xSMGR->createInstance(SERVICE_DESKTOP), css::uno::UNO_QUERY_THROW);
2805 css::uno::Reference< css::container::XIndexAccess > xCont (xDesktop->getFrames() , css::uno::UNO_QUERY_THROW);
2806
2807 sal_Int32 c = xCont->getCount();
2808 sal_Int32 i = 0;
2809
2810 for (i=0; i<c; ++i)
2811 {
2812 try
2813 {
2814 css::uno::Reference< css::frame::XFrame > xFrame;
2815 xCont->getByIndex(i) >>= xFrame;
2816 if ( ! xFrame.is())
2817 continue;
2818
2819 // a) do not count the help window
2820 if (xFrame->getName().equalsAscii("OFFICE_HELP_TASK"))
2821 continue;
2822
2823 // b) count all other frames
2824 ++nOpenDocs;
2825 }
2826 catch(const css::uno::Exception&)
2827 // A IndexOutOfBoundException can happen in multithreaded environments,
2828 // where any other thread can change this container !
2829 { continue; }
2830 }
2831
2832 return (nOpenDocs >= nMaxDocs);
2833 }
2834 catch(const css::uno::Exception&)
2835 {}
2836
2837 // Any internal error is no reason to stop opening documents !
2838 // Limitation of opening documents is a special "nice to have" feature.
2839 // Otherwhise it can happen, that NO document will be opened ...
2840 return sal_False;
2841 }
2842
2843 //-------------------------------------------------------------------------
2844 void SfxViewFrame::StateView_Impl
2845 (
2846 SfxItemSet& rSet /* leeres <SfxItemSet> mit <Which-Ranges>,
2847 welche die Ids der zu erfragenden
2848 Slots beschreiben. */
2849 )
2850
2851 /* [Beschreibung]
2852
2853 Diese interne Methode liefert in 'rSet' die Status der f"ur die
2854 <SfxShell> Subklasse SfxViewFrame in der <SVIDL> beschriebenen <Slots>.
2855
2856 In 'rSet' sind dabei genau die vom SFx als ung"ultig erkannten
2857 Slot-Ids als Which-ranges enthalten. Falls der an dieser Shell gesetzte
2858 <SfxItemPool> f"ur einzelne Slot-Ids ein Mapping hat, werden die
2859 entsprechenden Which-Ids verwendet, so da\s Items ggf. direkt mit
2860 einer mit Which-Ids arbeitenden Core-::com::sun::star::script::Engine ausgetauscht werden
2861 k"onnen.
2862 */
2863
2864 {
2865 DBG_CHKTHIS(SfxViewFrame, 0);
2866
2867 SfxObjectShell *pDocSh = GetObjectShell();
2868
2869 if ( !pDocSh )
2870 // Ich bin gerade am Reloaden und Yielde so vor mich hin ...
2871 return;
2872
2873 const sal_uInt16 *pRanges = rSet.GetRanges();
2874 DBG_ASSERT(pRanges, "Set ohne Bereich");
2875 while ( *pRanges )
2876 {
2877 for ( sal_uInt16 nWhich = *pRanges++; nWhich <= *pRanges; ++nWhich )
2878 {
2879 switch(nWhich)
2880 {
2881 case SID_VIEWSHELL:
2882 {
2883 rSet.Put( SfxUInt16Item( nWhich, pImp->nCurViewId ) );
2884 break;
2885 }
2886
2887 case SID_VIEWSHELL0:
2888 case SID_VIEWSHELL1:
2889 case SID_VIEWSHELL2:
2890 case SID_VIEWSHELL3:
2891 case SID_VIEWSHELL4:
2892 {
2893 sal_uInt16 nViewNo = nWhich - SID_VIEWSHELL0;
2894 if ( GetObjectShell()->GetFactory().GetViewFactoryCount() >
2895 nViewNo && !GetObjectShell()->IsInPlaceActive() )
2896 {
2897 SfxViewFactory &rViewFactory =
2898 GetObjectShell()->GetFactory().GetViewFactory(nViewNo);
2899 rSet.Put( SfxBoolItem(
2900 nWhich, pImp->nCurViewId == rViewFactory.GetOrdinal() ) );
2901 }
2902 else
2903 rSet.DisableItem( nWhich );
2904 break;
2905 }
2906 case SID_FRAMETITLE:
2907 {
2908 if( GetFrameType() & SFXFRAME_HASTITLE )
2909 rSet.Put( SfxStringItem(
2910 SID_FRAMETITLE, pImp->aFrameTitle) );
2911 else
2912 rSet.DisableItem( nWhich );
2913 break;
2914 }
2915
2916 case SID_NEWWINDOW:
2917 {
2918 if ( !GetViewShell()->NewWindowAllowed() /* && !pDocSh->HasName() */ )
2919 rSet.DisableItem( nWhich );
2920 else
2921 {
2922 if (impl_maxOpenDocCountReached())
2923 rSet.DisableItem( nWhich );
2924 }
2925 break;
2926 }
2927 }
2928 }
2929 }
2930 }
2931
2932 //-------------------------------------------------------------------------
2933 void SfxViewFrame::GetState_Impl( SfxItemSet &rSet )
2934 {
2935 if ( GetViewShell() && GetViewShell()->GetVerbs().getLength() && !GetObjectShell()->IsInPlaceActive() )
2936 {
2937 uno::Any aAny;
2938 aAny <<= GetViewShell()->GetVerbs();
2939 rSet.Put( SfxUnoAnyItem( USHORT( SID_OBJECT ), aAny ) );
2940 }
2941 else
2942 rSet.DisableItem( SID_OBJECT );
2943 }
2944
2945 //-------------------------------------------------------------------------
2946 void SfxViewFrame::ToTop()
2947 {
2948 GetFrame()->Appear();
2949 }
2950
2951 //-------------------------------------------------------------------------
2952 SfxViewFrame* SfxViewFrame::GetParentViewFrame() const
2953 /*
2954 Beschreibung:
2955 Der ParentViewFrame ist der ViewFrame des ParentFrames
2956 */
2957 {
2958 SfxFrame *pFrame = GetFrame()->GetParentFrame();
2959 return pFrame ? pFrame->GetCurrentViewFrame() : NULL;
2960 }
2961
2962 //-------------------------------------------------------------------------
2963 SfxFrame* SfxViewFrame::GetFrame() const
2964 /*
2965 Beschreibung:
2966 GetFrame liefert den Frame, in dem sich der ViewFrame befindet
2967 */
2968 {
2969 return pImp->pFrame;
2970 }
2971
2972 //-------------------------------------------------------------------------
2973 void SfxViewFrame::SetFrame_Impl( SfxFrame *pFrame )
2974 {
2975 pImp->pFrame = pFrame;
2976 }
2977
2978 //-------------------------------------------------------------------------
2979 SfxViewFrame* SfxViewFrame::GetTopViewFrame() const
2980 {
2981 return GetFrame()->GetTopFrame()->GetCurrentViewFrame();
2982 }
2983
2984 //-------------------------------------------------------------------------
2985
2986 SfxCancelManager *SfxViewFrame::GetCancelManager() const
2987
2988 /* <H3>Description</H3>
2989
2990 Returns a pointer to the <SfxCancelManager> of the top-view-frame of
2991 this view-frame.
2992 */
2993
2994 {
2995 return GetTopViewFrame()->GetFrame()->GetCancelManager();
2996 }
2997
2998 void SfxViewFrame::SetWindow_Impl( Window *pWin )
2999 {
3000 pImp->pWindow = pWin;
3001 }
3002
3003 Window& SfxViewFrame::GetWindow() const
3004 {
3005 return pImp->pWindow ? *pImp->pWindow : GetFrame()->GetWindow();
3006 }
3007
3008 sal_Bool SfxViewFrame::DoClose()
3009 {
3010 return GetFrame()->DoClose();
3011 }
3012
3013 String SfxViewFrame::GetActualPresentationURL_Impl() const
3014 {
3015 if ( xObjSh.Is() )
3016 return xObjSh->GetMedium()->GetName();
3017 return pImp->aActualPresentationURL;
3018 }
3019
3020 void SfxViewFrame::SetModalMode( sal_Bool bModal )
3021 {
3022 pImp->bModal = bModal;
3023 if ( xObjSh.Is() )
3024 {
3025 for ( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( xObjSh );
3026 !bModal && pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, xObjSh ) )
3027 bModal = pFrame->pImp->bModal;
3028 xObjSh->SetModalMode_Impl( bModal );
3029 }
3030 }
3031
3032 BOOL SfxViewFrame::IsInModalMode() const
3033 {
3034 return pImp->bModal || GetFrame()->GetWindow().IsInModalMode();
3035 }
3036
3037 void SfxViewFrame::Resize( BOOL bForce )
3038 {
3039 Size aSize = GetWindow().GetOutputSizePixel();
3040 if ( bForce || aSize != pImp->aSize )
3041 {
3042 pImp->aSize = aSize;
3043 SfxViewShell *pShell = GetViewShell();
3044 if ( pShell )
3045 {
3046 if ( GetFrame()->IsInPlace() )
3047 {
3048 Point aPoint = GetWindow().GetPosPixel();
3049 DoAdjustPosSizePixel( pShell, aPoint, aSize );
3050 }
3051 else
3052 {
3053 if ( pShell->UseObjectSize() )
3054 ForceOuterResize_Impl(TRUE);
3055 DoAdjustPosSizePixel( pShell, Point(), aSize );
3056 if ( pShell->UseObjectSize() )
3057 ForceOuterResize_Impl(FALSE);
3058 }
3059 }
3060 }
3061 }
3062
3063 #define LINE_SEP 0x0A
3064
3065 void CutLines( ::rtl::OUString& rStr, sal_Int32 nStartLine, sal_Int32 nLines, BOOL bEraseTrailingEmptyLines )
3066 {
3067 sal_Int32 nStartPos = 0;
3068 sal_Int32 nEndPos = 0;
3069 sal_Int32 nLine = 0;
3070 while ( nLine < nStartLine )
3071 {
3072 nStartPos = rStr.indexOf( LINE_SEP, nStartPos );
3073 if( nStartPos == -1 )
3074 break;
3075 nStartPos++; // nicht das \n.
3076 nLine++;
3077 }
3078
3079 DBG_ASSERTWARNING( nStartPos != STRING_NOTFOUND, "CutLines: Startzeile nicht gefunden!" );
3080
3081 if ( nStartPos != -1 )
3082 {
3083 nEndPos = nStartPos;
3084 for ( sal_Int32 i = 0; i < nLines; i++ )
3085 nEndPos = rStr.indexOf( LINE_SEP, nEndPos+1 );
3086
3087 if ( nEndPos == -1 ) // kann bei letzter Zeile passieren
3088 nEndPos = rStr.getLength();
3089 else
3090 nEndPos++;
3091
3092 ::rtl::OUString aEndStr = rStr.copy( nEndPos );
3093 rStr = rStr.copy( 0, nStartPos );
3094 rStr += aEndStr;
3095 }
3096 if ( bEraseTrailingEmptyLines )
3097 {
3098 sal_Int32 n = nStartPos;
3099 sal_Int32 nLen = rStr.getLength();
3100 while ( ( n < nLen ) && ( rStr.getStr()[ n ] == LINE_SEP ) )
3101 n++;
3102
3103 if ( n > nStartPos )
3104 {
3105 ::rtl::OUString aEndStr = rStr.copy( n );
3106 rStr = rStr.copy( 0, nStartPos );
3107 rStr += aEndStr;
3108 }
3109 }
3110 }
3111
3112 /*
3113 add new recorded dispatch macro script into the application global basic lib container
3114 It generates a new unique id for it and insert the macro by using this number as name for
3115 the modul
3116 */
3117 void SfxViewFrame::AddDispatchMacroToBasic_Impl( const ::rtl::OUString& sMacro )
3118 {
3119 /*
3120 // get lib and modul name from dialog
3121 SfxModule *pMod = GetObjectShell()->GetModule();
3122 SfxRequest aReq( SID_BASICCHOOSER, SFX_CALLMODE_SYNCHRON, pMod->GetPool() );
3123 const SfxPoolItem* pRet = pMod->ExecuteSlot( aReq );
3124 if ( pRet )
3125 ::rtl::OUString = ((SfxStringItem*)pRet)->GetValue();
3126 */
3127 if ( !sMacro.getLength() )
3128 return;
3129
3130 SfxApplication* pSfxApp = SFX_APP();
3131 SfxRequest aReq( SID_BASICCHOOSER, SFX_CALLMODE_SYNCHRON, pSfxApp->GetPool() );
3132 aReq.AppendItem( SfxBoolItem(SID_RECORDMACRO,TRUE) );
3133 const SfxPoolItem* pRet = SFX_APP()->ExecuteSlot( aReq );
3134 String aScriptURL;
3135 if ( pRet )
3136 aScriptURL = ((SfxStringItem*)pRet)->GetValue();
3137 if ( aScriptURL.Len() )
3138 {
3139 // parse scriptURL
3140 String aLibName;
3141 String aModuleName;
3142 String aMacroName;
3143 String aLocation;
3144 Reference< XMultiServiceFactory > xSMgr = ::comphelper::getProcessServiceFactory();
3145 Reference< com::sun::star::uri::XUriReferenceFactory > xFactory( xSMgr->createInstance(
3146 ::rtl::OUString::createFromAscii( "com.sun.star.uri.UriReferenceFactory" ) ), UNO_QUERY );
3147 if ( xFactory.is() )
3148 {
3149 Reference< com::sun::star::uri::XVndSunStarScriptUrl > xUrl( xFactory->parse( aScriptURL ), UNO_QUERY );
3150 if ( xUrl.is() )
3151 {
3152 // get name
3153 ::rtl::OUString aName = xUrl->getName();
3154 sal_Unicode cTok = '.';
3155 sal_Int32 nIndex = 0;
3156 aLibName = aName.getToken( 0, cTok, nIndex );
3157 if ( nIndex != -1 )
3158 aModuleName = aName.getToken( 0, cTok, nIndex );
3159 if ( nIndex != -1 )
3160 aMacroName = aName.getToken( 0, cTok, nIndex );
3161
3162 // get location
3163 ::rtl::OUString aLocKey = ::rtl::OUString::createFromAscii( "location" );
3164 if ( xUrl->hasParameter( aLocKey ) )
3165 aLocation = xUrl->getParameter( aLocKey );
3166 }
3167 }
3168
3169 pSfxApp->EnterBasicCall();
3170
3171 BasicManager* pBasMgr = 0;
3172 if ( aLocation.EqualsIgnoreCaseAscii( "application" ) )
3173 {
3174 // application basic
3175 pBasMgr = pSfxApp->GetBasicManager();
3176 }
3177 else if ( aLocation.EqualsIgnoreCaseAscii( "document" ) )
3178 {
3179 pBasMgr = GetObjectShell()->GetBasicManager();
3180 }
3181
3182 ::rtl::OUString aOUSource;
3183 if ( pBasMgr)
3184 {
3185 StarBASIC* pBasic = pBasMgr->GetLib( aLibName );
3186 if ( pBasic )
3187 {
3188 SbModule* pModule = pBasic->FindModule( aModuleName );
3189 if ( pModule )
3190 {
3191 SbMethod* pMethod = (SbMethod*)pModule->GetMethods()->Find( aMacroName, SbxCLASS_METHOD );
3192 aOUSource = pModule->GetSource32();
3193 USHORT nStart, nEnd;
3194 pMethod->GetLineRange( nStart, nEnd );
3195 ULONG nlStart = nStart;
3196 ULONG nlEnd = nEnd;
3197 CutLines( aOUSource, nlStart-1, nlEnd-nlStart+1, TRUE );
3198 }
3199 }
3200 }
3201
3202 // open lib container and break operation if it couldn't be opened
3203 com::sun::star::uno::Reference< com::sun::star::script::XLibraryContainer > xLibCont;
3204 if ( aLocation.EqualsIgnoreCaseAscii( "application" ) )
3205 {
3206 xLibCont = SFX_APP()->GetBasicContainer();
3207 }
3208 else if ( aLocation.EqualsIgnoreCaseAscii( "document" ) )
3209 {
3210 xLibCont = GetObjectShell()->GetBasicContainer();
3211 }
3212
3213 if(!xLibCont.is())
3214 {
3215 DBG_ERRORFILE("couldn't get access to the basic lib container. Adding of macro isn't possible.");
3216 return;
3217 }
3218
3219 // get LibraryContainer
3220 com::sun::star::uno::Any aTemp;
3221 com::sun::star::uno::Reference< com::sun::star::container::XNameAccess > xRoot(
3222 xLibCont,
3223 com::sun::star::uno::UNO_QUERY);
3224
3225 ::rtl::OUString sLib( aLibName );
3226 com::sun::star::uno::Reference< com::sun::star::container::XNameAccess > xLib;
3227 if(xRoot->hasByName(sLib))
3228 {
3229 // library must be loaded
3230 aTemp = xRoot->getByName(sLib);
3231 xLibCont->loadLibrary(sLib);
3232 aTemp >>= xLib;
3233 }
3234 else
3235 {
3236 xLib = com::sun::star::uno::Reference< com::sun::star::container::XNameAccess >(
3237 xLibCont->createLibrary(sLib),
3238 com::sun::star::uno::UNO_QUERY);
3239 }
3240
3241 // pack the macro as direct usable "sub" routine
3242 ::rtl::OUString sCode;
3243 ::rtl::OUStringBuffer sRoutine(10000);
3244 ::rtl::OUString sMacroName( aMacroName );
3245 BOOL bReplace = FALSE;
3246
3247 // get module
3248 ::rtl::OUString sModule( aModuleName );
3249 if(xLib->hasByName(sModule))
3250 {
3251 if ( aOUSource.getLength() )
3252 {
3253 sRoutine.append( aOUSource );
3254 }
3255 else
3256 {
3257 aTemp = xLib->getByName(sModule);
3258 aTemp >>= sCode;
3259 sRoutine.append( sCode );
3260 }
3261
3262 bReplace = TRUE;
3263 }
3264
3265 // append new method
3266 sRoutine.appendAscii("\nsub " );
3267 sRoutine.append (sMacroName );
3268 sRoutine.appendAscii("\n" );
3269 sRoutine.append (sMacro );
3270 sRoutine.appendAscii("\nend sub\n");
3271
3272 // create the modul inside the library and insert the macro routine
3273 aTemp <<= sRoutine.makeStringAndClear();
3274 if ( bReplace )
3275 {
3276 com::sun::star::uno::Reference< com::sun::star::container::XNameContainer > xModulCont(
3277 xLib,
3278 com::sun::star::uno::UNO_QUERY);
3279 xModulCont->replaceByName(sModule,aTemp);
3280 }
3281 else
3282 {
3283 com::sun::star::uno::Reference< com::sun::star::container::XNameContainer > xModulCont(
3284 xLib,
3285 com::sun::star::uno::UNO_QUERY);
3286 xModulCont->insertByName(sModule,aTemp);
3287 }
3288
3289 // #i17355# update the Basic IDE
3290 for ( SfxViewShell* pViewShell = SfxViewShell::GetFirst(); pViewShell; pViewShell = SfxViewShell::GetNext( *pViewShell ) )
3291 {
3292 if ( pViewShell->GetName().EqualsAscii( "BasicIDE" ) )
3293 {
3294 SfxViewFrame* pViewFrame = pViewShell->GetViewFrame();
3295 SfxDispatcher* pDispat = pViewFrame ? pViewFrame->GetDispatcher() : NULL;
3296 if ( pDispat )
3297 {
3298 SfxMacroInfoItem aInfoItem( SID_BASICIDE_ARG_MACROINFO, pBasMgr, aLibName, aModuleName, String(), String() );
3299 pDispat->Execute( SID_BASICIDE_UPDATEMODULESOURCE, SFX_CALLMODE_SYNCHRON, &aInfoItem, 0L );
3300 }
3301 }
3302 }
3303
3304 pSfxApp->LeaveBasicCall();
3305 }
3306 else
3307 {
3308 // add code for "session only" macro
3309 }
3310
3311 /*
3312 FILE* pFile = fopen( "macro.bas", "a" );
3313 fprintf( pFile, "%s", ::rtl::OUStringToOString(sBuffer.makeStringAndClear(),RTL_TEXTENCODING_UTF8).getStr() );
3314 fclose ( pFile );
3315 */
3316 }
3317
3318 void SfxViewFrame::MiscExec_Impl( SfxRequest& rReq )
3319 {
3320 DBG_MEMTEST();
3321 FASTBOOL bDone = FALSE;
3322 switch ( rReq.GetSlot() )
3323 {
3324 case SID_STOP_RECORDING :
3325 case SID_RECORDMACRO :
3326 {
3327 // try to find any active recorder on this frame
3328 ::rtl::OUString sProperty = rtl::OUString::createFromAscii("DispatchRecorderSupplier");
3329 com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xFrame(
3330 GetFrame()->GetFrameInterface(),
3331 com::sun::star::uno::UNO_QUERY);
3332
3333 com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(xFrame,com::sun::star::uno::UNO_QUERY);
3334 com::sun::star::uno::Any aProp = xSet->getPropertyValue(sProperty);
3335 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier > xSupplier;
3336 aProp >>= xSupplier;
3337 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
3338 if (xSupplier.is())
3339 xRecorder = xSupplier->getDispatchRecorder();
3340
3341 BOOL bIsRecording = xRecorder.is();
3342 SFX_REQUEST_ARG( rReq, pItem, SfxBoolItem, SID_RECORDMACRO, sal_False);
3343 if ( pItem && pItem->GetValue() == bIsRecording )
3344 return;
3345
3346 if ( xRecorder.is() )
3347 {
3348 // disable active recording
3349 aProp <<= com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier >();
3350 xSet->setPropertyValue(sProperty,aProp);
3351
3352 SFX_REQUEST_ARG( rReq, pRecordItem, SfxBoolItem, FN_PARAM_1, sal_False);
3353 if ( !pRecordItem || !pRecordItem->GetValue() )
3354 // insert script into basic library container of application
3355 AddDispatchMacroToBasic_Impl(xRecorder->getRecordedMacro());
3356
3357 xRecorder->endRecording();
3358 xRecorder = NULL;
3359 GetBindings().SetRecorder_Impl( xRecorder );
3360
3361 SetChildWindow( SID_RECORDING_FLOATWINDOW, FALSE );
3362 if ( rReq.GetSlot() != SID_RECORDMACRO )
3363 GetBindings().Invalidate( SID_RECORDMACRO );
3364 }
3365 else if ( rReq.GetSlot() == SID_RECORDMACRO )
3366 {
3367 // enable recording
3368 com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > xFactory(
3369 ::comphelper::getProcessServiceFactory(),
3370 com::sun::star::uno::UNO_QUERY);
3371
3372 xRecorder = com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder >(
3373 xFactory->createInstance(rtl::OUString::createFromAscii("com.sun.star.frame.DispatchRecorder")),
3374 com::sun::star::uno::UNO_QUERY);
3375
3376 xSupplier = com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier >(
3377 xFactory->createInstance(rtl::OUString::createFromAscii("com.sun.star.frame.DispatchRecorderSupplier")),
3378 com::sun::star::uno::UNO_QUERY);
3379
3380 xSupplier->setDispatchRecorder(xRecorder);
3381 xRecorder->startRecording(xFrame);
3382 aProp <<= xSupplier;
3383 xSet->setPropertyValue(sProperty,aProp);
3384 GetBindings().SetRecorder_Impl( xRecorder );
3385 SetChildWindow( SID_RECORDING_FLOATWINDOW, TRUE );
3386 }
3387
3388 rReq.Done();
3389 break;
3390 }
3391
3392 case SID_TOGGLESTATUSBAR:
3393 {
3394 com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xFrame(
3395 GetFrame()->GetFrameInterface(),
3396 com::sun::star::uno::UNO_QUERY);
3397
3398 Reference< com::sun::star::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
3399 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
3400 if ( xPropSet.is() )
3401 {
3402 try
3403 {
3404 Any aValue = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )));
3405 aValue >>= xLayoutManager;
3406 }
3407 catch ( Exception& )
3408 {
3409 }
3410 }
3411
3412 if ( xLayoutManager.is() )
3413 {
3414 rtl::OUString aStatusbarResString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" ));
3415 // Parameter auswerten
3416 SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, rReq.GetSlot(), FALSE);
3417 BOOL bShow( TRUE );
3418 if ( !pShowItem )
3419 bShow = xLayoutManager->isElementVisible( aStatusbarResString );
3420 else
3421 bShow = pShowItem->GetValue();
3422
3423 if ( bShow )
3424 {
3425 xLayoutManager->createElement( aStatusbarResString );
3426 xLayoutManager->showElement( aStatusbarResString );
3427 }
3428 else
3429 xLayoutManager->hideElement( aStatusbarResString );
3430
3431 if ( !pShowItem )
3432 rReq.AppendItem( SfxBoolItem( SID_TOGGLESTATUSBAR, bShow ) );
3433 }
3434 rReq.Done();
3435 break;
3436 }
3437
3438 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
3439 case SID_WIN_FULLSCREEN:
3440 {
3441 SFX_REQUEST_ARG(rReq, pItem, SfxBoolItem, rReq.GetSlot(), FALSE);
3442 SfxTopViewFrame *pTop= PTR_CAST( SfxTopViewFrame, GetTopViewFrame() );
3443 if ( pTop )
3444 {
3445 WorkWindow* pWork = (WorkWindow*) pTop->GetTopFrame_Impl()->GetTopWindow_Impl();
3446 if ( pWork )
3447 {
3448 com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xFrame(
3449 GetFrame()->GetFrameInterface(),
3450 com::sun::star::uno::UNO_QUERY);
3451
3452 Reference< ::com::sun::star::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
3453 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
3454 if ( xPropSet.is() )
3455 {
3456 try
3457 {
3458 Any aValue = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )));
3459 aValue >>= xLayoutManager;
3460 }
3461 catch ( Exception& )
3462 {
3463 }
3464 }
3465
3466 BOOL bNewFullScreenMode = pItem ? pItem->GetValue() : !pWork->IsFullScreenMode();
3467 if ( bNewFullScreenMode != pWork->IsFullScreenMode() )
3468 {
3469 Reference< ::com::sun::star::beans::XPropertySet > xLMPropSet( xLayoutManager, UNO_QUERY );
3470 if ( xLMPropSet.is() )
3471 {
3472 try
3473 {
3474 xLMPropSet->setPropertyValue(
3475 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "HideCurrentUI" )),
3476 makeAny( bNewFullScreenMode ));
3477 }
3478 catch ( ::com::sun::star::beans::UnknownPropertyException& )
3479 {
3480 }
3481 }
3482 pWork->ShowFullScreenMode( bNewFullScreenMode );
3483 pWork->SetMenuBarMode( bNewFullScreenMode ? MENUBAR_MODE_HIDE : MENUBAR_MODE_NORMAL );
3484 GetFrame()->GetWorkWindow_Impl()->SetFullScreen_Impl( bNewFullScreenMode );
3485 if ( !pItem )
3486 rReq.AppendItem( SfxBoolItem( SID_WIN_FULLSCREEN, bNewFullScreenMode ) );
3487 rReq.Done();
3488 }
3489 else
3490 rReq.Ignore();
3491 }
3492 }
3493 else
3494 rReq.Ignore();
3495
3496 GetDispatcher()->Update_Impl( TRUE );
3497 break;
3498 }
3499 }
3500
3501 if ( bDone )
3502 rReq.Done();
3503 }
3504
3505 void SfxViewFrame::MiscState_Impl(SfxItemSet &rSet)
3506 {
3507 DBG_MEMTEST();
3508
3509 const USHORT *pRanges = rSet.GetRanges();
3510 DBG_ASSERT(pRanges && *pRanges, "Set ohne Bereich");
3511 while ( *pRanges )
3512 {
3513 for(USHORT nWhich = *pRanges++; nWhich <= *pRanges; ++nWhich)
3514 {
3515 switch(nWhich)
3516 {
3517 case SID_CURRENT_URL:
3518 {
3519 // Bei internem InPlace den ContainerFrame nehmen
3520 SfxViewFrame *pFrame = this;
3521 if ( pFrame->GetParentViewFrame_Impl() )
3522 pFrame = pFrame->GetParentViewFrame_Impl();
3523 rSet.Put( SfxStringItem( nWhich, pFrame->GetActualPresentationURL_Impl() ) );
3524 break;
3525 }
3526
3527 case SID_RECORDMACRO :
3528 {
3529 const char* pName = GetObjectShell()->GetFactory().GetShortName();
3530 if ( strcmp(pName,"swriter") && strcmp(pName,"scalc") )
3531 {
3532 rSet.DisableItem( nWhich );
3533 break;
3534 }
3535
3536 ::rtl::OUString sProperty = rtl::OUString::createFromAscii("DispatchRecorderSupplier");
3537 com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(
3538 GetFrame()->GetFrameInterface(),
3539 com::sun::star::uno::UNO_QUERY);
3540
3541 com::sun::star::uno::Any aProp = xSet->getPropertyValue(sProperty);
3542 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier > xSupplier;
3543 if ( aProp >>= xSupplier )
3544 rSet.Put( SfxBoolItem( nWhich, xSupplier.is() ) );
3545 else
3546 rSet.DisableItem( nWhich );
3547 break;
3548 }
3549
3550 case SID_STOP_RECORDING :
3551 {
3552 const char* pName = GetObjectShell()->GetFactory().GetShortName();
3553 if ( strcmp(pName,"swriter") && strcmp(pName,"scalc") )
3554 {
3555 rSet.DisableItem( nWhich );
3556 break;
3557 }
3558
3559 ::rtl::OUString sProperty = rtl::OUString::createFromAscii("DispatchRecorderSupplier");
3560 com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(
3561 GetFrame()->GetFrameInterface(),
3562 com::sun::star::uno::UNO_QUERY);
3563
3564 com::sun::star::uno::Any aProp = xSet->getPropertyValue(sProperty);
3565 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier > xSupplier;
3566 if ( !(aProp >>= xSupplier) || !xSupplier.is() )
3567 rSet.DisableItem( nWhich );
3568 break;
3569 }
3570
3571 case SID_TOGGLESTATUSBAR:
3572 {
3573 com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
3574 com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(
3575 GetFrame()->GetFrameInterface(),
3576 com::sun::star::uno::UNO_QUERY);
3577 com::sun::star::uno::Any aProp = xSet->getPropertyValue(
3578 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )) );
3579
3580 if ( !( aProp >>= xLayoutManager ))
3581 rSet.Put( SfxBoolItem( nWhich, FALSE ));
3582 else
3583 {
3584 rtl::OUString aStatusbarResString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" ));
3585 BOOL bShow = xLayoutManager->isElementVisible( aStatusbarResString );
3586 rSet.Put( SfxBoolItem( nWhich, bShow ));
3587 }
3588 break;
3589 }
3590
3591 case SID_WIN_FULLSCREEN:
3592 {
3593 SfxTopViewFrame *pTop= PTR_CAST( SfxTopViewFrame, GetTopViewFrame() );
3594 if ( pTop )
3595 {
3596 WorkWindow* pWork = (WorkWindow*) pTop->GetTopFrame_Impl()->GetTopWindow_Impl();
3597 if ( pWork )
3598 {
3599 rSet.Put( SfxBoolItem( nWhich, pWork->IsFullScreenMode() ) );
3600 break;
3601 }
3602 }
3603
3604 rSet.DisableItem( nWhich );
3605 break;
3606 }
3607
3608 case SID_FORMATMENUSTATE :
3609 {
3610 DBG_ERROR("Outdated slot!");
3611 rSet.DisableItem( nWhich );
3612 break;
3613 }
3614
3615 default:
3616 //! DBG_ASSERT(FALSE, "Falscher Server fuer GetState");
3617 break;
3618 }
3619 }
3620
3621 ++pRanges;
3622 }
3623 }
3624
3625 void SfxViewFrame::ChildWindowExecute( SfxRequest &rReq )
3626
3627 /* [Beschreibung]
3628
3629 Diese Methode kann in der Execute-Methode f"ur das ein- und ausschalten
3630 von Child-Windows eingesetzt werden, um dieses inkl. API-Anbindung zu
3631 implementieren.
3632
3633 Einfach in der IDL als 'ExecuteMethod' eintragen.
3634 */
3635
3636 {
3637 // Parameter auswerten
3638 USHORT nSID = rReq.GetSlot();
3639
3640 SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, nSID, FALSE);
3641 if ( nSID == SID_VIEW_DATA_SOURCE_BROWSER )
3642 {
3643 if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::E_SDATABASE))
3644 return;
3645 Reference < XFrame > xFrame = GetFrame()->GetTopFrame()->GetFrameInterface();
3646 Reference < XFrame > xBeamer( xFrame->findFrame( DEFINE_CONST_UNICODE("_beamer"), FrameSearchFlag::CHILDREN ) );
3647 BOOL bShow = FALSE;
3648 BOOL bHasChild = xBeamer.is();
3649 bShow = pShowItem ? pShowItem->GetValue() : !bHasChild;
3650 if ( pShowItem )
3651 {
3652 if( bShow == bHasChild )
3653 return;
3654 }
3655 else
3656 rReq.AppendItem( SfxBoolItem( nSID, bShow ) );
3657
3658 if ( !bShow )
3659 {
3660 SetChildWindow( SID_BROWSER, FALSE );
3661 }
3662 else
3663 {
3664 ::com::sun::star::util::URL aTargetURL;
3665 aTargetURL.Complete = ::rtl::OUString::createFromAscii(".component:DB/DataSourceBrowser");
3666 Reference < ::com::sun::star::util::XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer" )), UNO_QUERY );
3667 xTrans->parseStrict( aTargetURL );
3668
3669 Reference < XDispatchProvider > xProv( xFrame, UNO_QUERY );
3670 Reference < ::com::sun::star::frame::XDispatch > xDisp;
3671 if ( xProv.is() )
3672 xDisp = xProv->queryDispatch( aTargetURL, ::rtl::OUString::createFromAscii("_beamer"), 31 );
3673 if ( xDisp.is() )
3674 {
3675 Sequence < ::com::sun::star::beans::PropertyValue > aArgs(1);
3676 ::com::sun::star::beans::PropertyValue* pArg = aArgs.getArray();
3677 pArg[0].Name = rtl::OUString::createFromAscii("Referer");
3678 pArg[0].Value <<= ::rtl::OUString::createFromAscii("private:user");
3679 xDisp->dispatch( aTargetURL, aArgs );
3680 }
3681 }
3682
3683 rReq.Done();
3684 return;
3685 }
3686
3687 BOOL bShow = FALSE;
3688 BOOL bHasChild = HasChildWindow(nSID);
3689 bShow = pShowItem ? pShowItem->GetValue() : !bHasChild;
3690
3691 // ausf"uhren
3692 if ( !pShowItem || bShow != bHasChild )
3693 ToggleChildWindow( nSID );
3694
3695 GetBindings().Invalidate( nSID );
3696 GetDispatcher()->Update_Impl( TRUE );
3697
3698 // ggf. recorden
3699 if ( nSID == SID_HYPERLINK_DIALOG || nSID == SID_SEARCH_DLG )
3700 {
3701 rReq.Ignore();
3702 }
3703 else
3704 {
3705 rReq.AppendItem( SfxBoolItem( nSID, bShow ) );
3706 rReq.Done();
3707 }
3708 }
3709
3710 //--------------------------------------------------------------------
3711
3712 void SfxViewFrame::ChildWindowState( SfxItemSet& rState )
3713
3714 /* [Beschreibung]
3715
3716 Diese Methode kann in der Status-Methode f"ur das Ein- und Ausschalt-
3717 Zustand von Child-Windows eingesetzt werden, um dieses zu implementieren.
3718
3719 Einfach in der IDL als 'StateMethod' eintragen.
3720 */
3721
3722 {
3723 SfxWhichIter aIter( rState );
3724 for ( USHORT nSID = aIter.FirstWhich(); nSID; nSID = aIter.NextWhich() )
3725 {
3726 if ( nSID == SID_VIEW_DATA_SOURCE_BROWSER )
3727 {
3728 rState.Put( SfxBoolItem( nSID, HasChildWindow( SID_BROWSER ) ) );
3729 }
3730 else if ( nSID == SID_HYPERLINK_DIALOG )
3731 {
3732 const SfxPoolItem* pDummy = NULL;
3733 SfxItemState eState = GetDispatcher()->QueryState( SID_HYPERLINK_SETLINK, pDummy );
3734 if ( SFX_ITEM_DISABLED == eState )
3735 rState.DisableItem(nSID);
3736 else
3737 {
3738 if ( KnowsChildWindow(nSID) )
3739 rState.Put( SfxBoolItem( nSID, HasChildWindow(nSID)) );
3740 else
3741 rState.DisableItem(nSID);
3742 }
3743 }
3744 else if ( nSID == SID_BROWSER )
3745 {
3746 Reference < XFrame > xFrame = GetFrame()->GetTopFrame()->GetFrameInterface()->
3747 findFrame( DEFINE_CONST_UNICODE("_beamer"), FrameSearchFlag::CHILDREN );
3748 if ( !xFrame.is() )
3749 rState.DisableItem( nSID );
3750 else if ( KnowsChildWindow(nSID) )
3751 rState.Put( SfxBoolItem( nSID, HasChildWindow(nSID) ) );
3752 }
3753 else if ( KnowsChildWindow(nSID) )
3754 rState.Put( SfxBoolItem( nSID, HasChildWindow(nSID) ) );
3755 else
3756 rState.DisableItem(nSID);
3757 }
3758 }
3759
3760 //--------------------------------------------------------------------
3761 SfxWorkWindow* SfxViewFrame::GetWorkWindow_Impl( USHORT /*nId*/ )
3762 {
3763 SfxWorkWindow* pWork = 0;
3764 pWork = GetFrame()->GetWorkWindow_Impl();
3765 return pWork;
3766 }
3767
3768 /*
3769 void SfxViewFrame::SetChildWindow(USHORT nId, BOOL bOn)
3770 {
3771 SetChildWindow( nId, bOn, TRUE );
3772 }*/
3773
3774 void SfxViewFrame::SetChildWindow(USHORT nId, BOOL bOn, BOOL bSetFocus )
3775 {
3776 SfxWorkWindow* pWork = GetWorkWindow_Impl( nId );
3777 if ( pWork )
3778 pWork->SetChildWindow_Impl( nId, bOn, bSetFocus );
3779 }
3780
3781 //--------------------------------------------------------------------
3782
3783 void SfxViewFrame::ToggleChildWindow(USHORT nId)
3784 {
3785 SfxWorkWindow* pWork = GetWorkWindow_Impl( nId );
3786 if ( pWork )
3787 pWork->ToggleChildWindow_Impl( nId, TRUE );
3788 }
3789
3790 //--------------------------------------------------------------------
3791
3792 BOOL SfxViewFrame::HasChildWindow( USHORT nId )
3793 {
3794 SfxWorkWindow* pWork = GetWorkWindow_Impl( nId );
3795 return pWork ? pWork->HasChildWindow_Impl(nId) : FALSE;
3796 }
3797
3798 //--------------------------------------------------------------------
3799
3800 BOOL SfxViewFrame::KnowsChildWindow( USHORT nId )
3801 {
3802 SfxWorkWindow* pWork = GetWorkWindow_Impl( nId );
3803 return pWork ? pWork->KnowsChildWindow_Impl(nId) : FALSE;
3804 }
3805
3806 //--------------------------------------------------------------------
3807
3808 void SfxViewFrame::ShowChildWindow( USHORT nId, BOOL bVisible )
3809 {
3810 SfxWorkWindow* pWork = GetWorkWindow_Impl( nId );
3811 if ( pWork )
3812 {
3813 GetDispatcher()->Update_Impl(sal_True);
3814 pWork->ShowChildWindow_Impl(nId, bVisible, TRUE );
3815 }
3816 }
3817
3818 //--------------------------------------------------------------------
3819
3820 SfxChildWindow* SfxViewFrame::GetChildWindow(USHORT nId)
3821 {
3822 SfxWorkWindow* pWork = GetWorkWindow_Impl( nId );
3823 return pWork ? pWork->GetChildWindow_Impl(nId) : NULL;
3824 }
3825
3826 SfxMacro* SfxViewFrame::GetRecordingMacro_Impl()
3827 {
3828 return pImp->pMacro;
3829 }
3830
3831 void SfxViewFrame::UpdateDocument_Impl()
3832 {
3833 SfxObjectShell* pDoc = GetObjectShell();
3834 if ( pDoc->IsLoadingFinished() )
3835 pDoc->CheckSecurityOnLoading_Impl();
3836
3837 // check if document depends on a template
3838 pDoc->UpdateFromTemplate_Impl();
3839 }
3840
3841 BOOL SfxViewFrame::ClearEventFlag_Impl()
3842 {
3843 if ( pImp->bEventFlag )
3844 {
3845 pImp->bEventFlag = FALSE;
3846 return TRUE;
3847 }
3848 else
3849 return FALSE;
3850 }
3851
3852 SfxViewFrame* SfxViewFrame::CreateViewFrame( SfxObjectShell& rDoc, sal_uInt16 nViewId, sal_Bool bHidden )
3853 {
3854 SfxItemSet *pSet = rDoc.GetMedium()->GetItemSet();
3855 if ( nViewId )
3856 pSet->Put( SfxUInt16Item( SID_VIEW_ID, nViewId ) );
3857 if ( bHidden )
3858 pSet->Put( SfxBoolItem( SID_HIDDEN, sal_True ) );
3859
3860 SfxFrame *pFrame = SfxTopFrame::Create( &rDoc, 0, bHidden );
3861 return pFrame->GetCurrentViewFrame();
3862 }
3863
3864 void SfxViewFrame::SetViewFrame( SfxViewFrame* pFrame )
3865 {
3866 SFX_APP()->SetViewFrame_Impl( pFrame );
3867 }
vba interoperability for OOo