?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.2.6.1, tag libreoffice-5.2.6.1
[LibreOffice.git] / embedserv / source / embed / docholder.cxx
blobdea93c1bc433b3f039725e1f634940e11a58bed4
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19 #ifdef _MSC_VER
20 #pragma warning(disable : 4917 4555)
21 #endif
22
23
24 #include "xwin.hxx"
25 #include "docholder.hxx"
26 #include "embeddoc.hxx"
27 #include "intercept.hxx"
28 #include "syswinwrapper.hxx"
29 #include "iipaobj.hxx"
30
31 #include "common.h"
32 #include <windows.h>
33 #include <com/sun/star/awt/XTopWindow.hpp>
34 #include <com/sun/star/awt/PosSize.hpp>
35 #include <com/sun/star/awt/XView.hpp>
36 #include <com/sun/star/awt/Toolkit.hpp>
37 #include <com/sun/star/awt/XSystemChildFactory.hpp>
38 #include <com/sun/star/awt/XSystemDependentWindowPeer.hpp>
39 #include <com/sun/star/awt/XSystemDependentMenuPeer.hpp>
40 #include <com/sun/star/awt/WindowAttribute.hpp>
41 #include <com/sun/star/awt/XWindow.hpp>
42 #include <com/sun/star/beans/XPropertySet.hpp>
43 #include <com/sun/star/bridge/XBridgeSupplier2.hpp>
44 #include <com/sun/star/bridge/ModelDependent.hpp>
45 #include <com/sun/star/container/XNameAccess.hpp>
46 #include <com/sun/star/document/MacroExecMode.hpp>
47 #include <com/sun/star/embed/EmbedMapUnits.hpp>
48 #include <com/sun/star/embed/XVisualObject.hpp>
49 #include <com/sun/star/frame/XComponentLoader.hpp>
50 #include <com/sun/star/frame/Frame.hpp>
51 #include <com/sun/star/frame/XModel.hpp>
52 #include <com/sun/star/frame/Desktop.hpp>
53 #include <com/sun/star/frame/XFramesSupplier.hpp>
54 #include <com/sun/star/frame/FrameSearchFlag.hpp>
55 #include <com/sun/star/frame/XStatusListener.hpp>
56 #include <com/sun/star/frame/XDispatchProviderInterception.hpp>
57 #include <com/sun/star/lang/SystemDependent.hpp>
58 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
59 #include <com/sun/star/task/InteractionHandler.hpp>
60 #include <com/sun/star/ui/XUIElement.hpp>
61 #include <com/sun/star/util/XCloseBroadcaster.hpp>
62 #include <com/sun/star/util/XCloseAble.hpp>
63 #include <com/sun/star/util/XModifyBroadcaster.hpp>
64 #include <comphelper/processfactory.hxx>
65 #include <osl/diagnose.h>
66 #include <rtl/process.h>
67
68 using namespace ::com::sun::star;
69
70 extern OUString getFilterNameFromGUID_Impl( GUID* );
71
72 // add mutex locking ???
73
74 DocumentHolder::DocumentHolder(
75 const uno::Reference<lang::XMultiServiceFactory >& xFactory,
76 const ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl >& xOleAccess )
77 :
78 m_bAllowInPlace(true),
79 m_pIOleIPSite(0),
80 m_pIOleIPFrame(0),
81 m_pIOleIPUIWindow(0),
82 m_pCHatchWin(0),
83 m_xOleAccess( xOleAccess ),
84 m_pInterceptor(0),
85 m_xFactory( xFactory ),
86 m_bOnDeactivate(false),
87 m_hWndxWinParent(NULL),
88 m_hWndxWinCont(NULL),
89 m_nMenuHandle(NULL),
90 m_nMenuShared(NULL),
91 m_nOLEMenu(NULL),
92 m_nMacroExecMode( document::MacroExecMode::USE_CONFIG ),
93 m_bLink( sal_False )
94 {
95 uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory));
96 xDesktop->addTerminateListener( (frame::XTerminateListener*)this );
97 }
98
99
100 DocumentHolder::~DocumentHolder()
101 {
102 delete m_pCHatchWin;
103
104 ClearInterceptorInternally();
105 }
106
107
108 void DocumentHolder::LoadDocInFrame( sal_Bool bPluginMode )
109 {
110 uno::Reference<frame::XComponentLoader> xComponentLoader(
111 m_xFrame,uno::UNO_QUERY);
112 if( xComponentLoader.is() && m_xDocument.is() )
113 {
114 uno::Reference< task::XInteractionHandler2 > xHandler(
115 task::InteractionHandler::createWithParent(comphelper::getComponentContext(m_xFactory), 0) );
116
117 sal_Int32 nLen = 3;
118 uno::Sequence<beans::PropertyValue> aSeq( nLen );
119
120 aSeq[0] = beans::PropertyValue(
121 OUString("Model"),
122 -1,
123 uno::Any(uno::Reference<uno::XInterface>(m_xDocument, uno::UNO_QUERY)),
124 beans::PropertyState_DIRECT_VALUE);
125
126 aSeq[1] = beans::PropertyValue(
127 OUString("ReadOnly"),
128 -1,
129 uno::Any(false),
130 beans::PropertyState_DIRECT_VALUE);
131
132 aSeq[2] = beans::PropertyValue(
133 OUString("NoAutoSave"),
134 -1,
135 uno::Any(true),
136 beans::PropertyState_DIRECT_VALUE);
137
138 if ( bPluginMode )
139 {
140 aSeq.realloc( ++nLen );
141 aSeq[nLen-1] = beans::PropertyValue(
142 OUString("PluginMode"),
143 -1,
144 uno::Any((sal_Int16) 3),
145 beans::PropertyState_DIRECT_VALUE);
146 }
147
148 aSeq.realloc( nLen+=2 );
149 aSeq[nLen-2] = beans::PropertyValue(
150 OUString("InteractionHandler"),
151 -1,
152 uno::Any(xHandler),
153 beans::PropertyState_DIRECT_VALUE);
154
155 aSeq[nLen-1] = beans::PropertyValue(
156 OUString("MacroExecutionMode"),
157 -1,
158 uno::Any(m_nMacroExecMode),
159 beans::PropertyState_DIRECT_VALUE);
160
161 xComponentLoader->loadComponentFromURL(
162 OUString("private:object"),
163 OUString("_self"),
164 0,
165 aSeq);
166
167 uno::Sequence< beans::PropertyValue > aResArgs = m_xDocument->getArgs();
168 for ( int nInd = 0; nInd < aResArgs.getLength(); nInd++ )
169 if ( aResArgs[nInd].Name == "MacroExecutionMode" )
170 {
171 aResArgs[nInd].Value >>= m_nMacroExecMode;
172 break;
173 }
174 }
175 }
176
177 void DocumentHolder::OnPosRectChanged(LPRECT lpRect) const
178 {
179 lpRect->left += m_aBorder.left;
180 lpRect->right -= m_aBorder.right;
181 lpRect->top += m_aBorder.top;
182 lpRect->bottom -= m_aBorder.bottom;
183 if(m_pIOleIPSite)
184 m_pIOleIPSite->OnPosRectChange(lpRect);
185 }
186
187
188 void DocumentHolder::DisableInplaceActivation(BOOL b)
189 {
190 m_bAllowInPlace = ! b;
191 }
192
193 BOOL DocumentHolder::isActive() const
194 {
195 return m_pIOleIPSite != 0;
196 }
197
198 HRESULT DocumentHolder::InPlaceActivate(
199 LPOLECLIENTSITE pActiveSite,
200 BOOL fIncludeUI)
201 {
202 m_bOnDeactivate = false;
203
204 if(!m_bAllowInPlace)
205 return ERROR;
206
207 HRESULT hr;
208 HWND hWndSite;
209 RECT rcPos;
210 RECT rcClip;
211 OLEINPLACEFRAMEINFO frameInfo;
212
213 if (NULL==pActiveSite)
214 return ResultFromScode(E_INVALIDARG);
215
216 if (NULL!=m_pIOleIPSite)
217 {
218 if (fIncludeUI)
219 UIActivate();
220
221 return NOERROR;
222 }
223
224 if ( !m_xDocument.is() )
225 return ERROR;
226
227 //1. Initialization, obtaining interfaces, OnInPlaceActivate.
228 hr=pActiveSite->QueryInterface(
229 IID_IOleInPlaceSite,
230 (void**) &m_pIOleIPSite);
231
232 if (FAILED(hr))
233 return hr;
234
235 hr=m_pIOleIPSite->CanInPlaceActivate();
236
237 if (NOERROR!=hr)
238 {
239 m_pIOleIPSite->Release(), m_pIOleIPSite=NULL;
240 return ResultFromScode(E_FAIL);
241 }
242
243 m_pIOleIPSite->OnInPlaceActivate();
244
245 //2. Get the site window
246 //3. and determine container frame and
247 // document window for tools and menus, as well
248 // as frameInfo for accelerators
249 m_pIOleIPSite->GetWindow(&hWndSite);
250
251 frameInfo.cb=sizeof(OLEINPLACEFRAMEINFO);
252 m_pIOleIPSite->GetWindowContext(
253 &m_pIOleIPFrame,&m_pIOleIPUIWindow,&rcPos,&rcClip,&frameInfo);
254
255 // initialize the office as, with hwnd as parentwindow
256 uno::Any aAny;
257 uno::Sequence<sal_Int8> aProcessIdent(16);
258 rtl_getGlobalProcessId((sal_uInt8*)aProcessIdent.getArray());
259
260 try
261 {
262 if(!m_xEditWindow.is())
263 { // determine XWindow and window handle of parent
264 HWND hWndxWinParent(0);
265 uno::Reference<awt::XWindow> xWin;
266
267 uno::Reference<awt::XToolkit2> xToolkit =
268 awt::Toolkit::create(comphelper::getComponentContext(m_xFactory));
269
270 // create system window wrapper for hwnd
271 if( !m_pCHatchWin )
272 m_pCHatchWin = new winwrap::CHatchWin(
273 m_hInstance,this);
274
275 if(m_pCHatchWin->Init(hWndSite,/*ID_HATCHWINDOW*/2000, NULL)) {
276 m_pCHatchWin->RectsSet(&rcPos,&rcClip); //set visible area
277 hWndxWinParent = m_pCHatchWin->Window();
278 ShowWindow(hWndxWinParent,SW_SHOW); //Make visible.
279 }
280 else {
281 // no success initializing hatch window
282 delete m_pCHatchWin, m_pCHatchWin = 0;
283 hWndxWinParent = hWndSite;
284 }
285
286 xWin.set(
287 xToolkit->createSystemChild(
288 uno::Any(sal_Int32(hWndxWinParent)),
289 aProcessIdent,
290 lang::SystemDependent::SYSTEM_WIN32),
291 uno::UNO_QUERY);
292
293 if(xWin.is()) {
294 xWin->setPosSize(
295 m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0,
296 m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0,
297 rcPos.right-rcPos.left,
298 rcPos.bottom - rcPos.top,
299 awt::PosSize::POSSIZE);
300 xWin->setVisible(sal_True);
301
302 m_xEditWindow = xWin;
303 m_hWndxWinParent = hWndxWinParent;
304 }
305 else
306 return ERROR;
307 }
308 else {
309 if(m_hWndxWinParent) {
310 SetParent(m_hWndxWinParent,hWndSite);
311 ShowWindow(m_hWndxWinParent,SW_SHOW); //Make visible.
312 }
313
314 if ( !m_xFrame.is() )
315 // initially set size to "empty", this guarantees that the final resize
316 // is always executed (will be done by "SetObjectRects" after getting internal border)
317 m_xEditWindow->setPosSize(
318 0,
319 0,
320 0,
321 0,
322 awt::PosSize::POSSIZE);
323 m_xEditWindow->setVisible(sal_True);
324 }
325
326 if(m_xContainerWindow.is()) {
327 if(m_hWndxWinCont) {
328 if(m_pIOleIPFrame) {
329 HWND hWndCont;
330 m_pIOleIPFrame->GetWindow(&hWndCont);
331 SetParent(m_hWndxWinCont,hWndCont);
332 ShowWindow(m_hWndxWinCont,SW_SHOW);
333 }
334 }
335 m_xContainerWindow->setVisible(true);
336 }
337
338 if(m_xFrame.is())
339 m_xFrame->activate();
340 else {
341 // create frame and initialize it with the created window
342 m_xFrame = frame::Frame::create( comphelper::getComponentContext(m_xFactory) );
343 m_xFrame->initialize(m_xEditWindow);
344
345 m_xFrame->registerDispatchProviderInterceptor( CreateNewInterceptor() );
346
347 m_xLayoutManager.set( m_xFrame->getLayoutManager(), uno::UNO_QUERY );
348
349 if(m_xLayoutManager.is())
350 m_xLayoutManager->setDockingAreaAcceptor(this);
351
352 // load the model into the frame
353 LoadDocInFrame( sal_True );
354
355 uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory));
356 xDesktop->getFrames()->append(m_xFrame);
357
358 // determine the menuhandle to get menuitems.
359 if(m_xLayoutManager.is()) {
360 uno::Reference< css::ui::XUIElement > xUIEl(
361 m_xLayoutManager->getElement(
362 OUString(
363 "private:resource/menubar/menubar")));
364 OSL_ENSURE(xUIEl.is(),"no menubar");
365 uno::Reference<awt::XSystemDependentMenuPeer> xSDMP(
366 xUIEl->getRealInterface(),
367 uno::UNO_QUERY);
368 aAny = xSDMP->getMenuHandle(
369 aProcessIdent,lang::SystemDependent::SYSTEM_WIN32);
370 sal_Int64 tmp;
371 if( aAny >>= tmp )
372 m_nMenuHandle = HMENU(tmp);
373 m_xLayoutManager->hideElement(
374 OUString(
375 "private:resource/menubar/menubar" ));
376 }
377 }
378
379 // TODO/cd: Workaround for status indicator bug. It always makes the
380 // document window visible, when someone tries to use the status
381 // indicator. As we save our document when we get the deactivation
382 // from OLE this conflict to hide floating windows.
383 if(m_xLayoutManager.is())
384 m_xLayoutManager->setVisible(true);
385
386 // get document border and resize rects according to border
387 GetDocumentBorder( &m_aBorder );
388 SetObjectRects( &rcPos, &rcClip );
389
390 if ( m_xOleAccess.is() )
391 {
392 LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument();
393 if ( aDocLock.GetEmbedDocument() )
394 aDocLock.GetEmbedDocument()->ShowObject();
395 }
396
397 // setTitle(m_aDocumentNamePart);
398 if (fIncludeUI)
399 hr=UIActivate();
400
401 m_pIOleIPSite->DiscardUndoState();
402 }
403 catch( const uno::Exception& )
404 {
405 hr = ERROR;
406 }
407
408 return hr;
409 }
410
411
412 void DocumentHolder::InPlaceDeactivate()
413 {
414 m_bOnDeactivate = true;
415
416 UIDeactivate();
417 if(m_xFrame.is()) m_xFrame->deactivate();
418
419 if(m_xEditWindow.is()) {
420 m_xEditWindow->setVisible(false);
421 ShowWindow(m_hWndxWinParent,SW_HIDE);
422 SetParent(m_hWndxWinParent,0);
423 }
424
425 if(m_xContainerWindow.is()) {
426 m_xContainerWindow->setVisible(false);
427 ShowWindow(m_hWndxWinCont,SW_HIDE);
428 SetParent(m_hWndxWinCont,0);
429 }
430
431 // TODO/cd: Workaround for status indicator bug. It always makes the
432 // document window visible, when someone tries to use the status
433 // indicator. As we save our document when we get the deactivation
434 // from OLE this conflict to hide floating windows.
435 if (m_xLayoutManager.is())
436 m_xLayoutManager->setVisible(false);
437
438 if (NULL!=m_pIOleIPSite)
439 m_pIOleIPSite->OnInPlaceDeactivate();
440
441 if(m_pIOleIPFrame) m_pIOleIPFrame->Release(); m_pIOleIPFrame = 0;
442 if(m_pIOleIPUIWindow) m_pIOleIPUIWindow->Release(); m_pIOleIPUIWindow = 0;
443 if(m_pIOleIPSite) m_pIOleIPSite->Release(); m_pIOleIPSite = 0;
444
445 if ( m_xOleAccess.is() )
446 {
447 LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument();
448 if ( aDocLock.GetEmbedDocument() )
449 {
450 aDocLock.GetEmbedDocument()->SaveObject();
451 }
452 }
453
454 return;
455 }
456
457
458 HRESULT DocumentHolder::UIActivate()
459 {
460 // 1. Call IOleInPlaceSite::UIActivate
461 if (NULL!=m_pIOleIPSite)
462 m_pIOleIPSite->OnUIActivate();
463
464 //2. Critical for accelerators to work initially.
465 SetFocus(m_pCHatchWin->Window());
466 // if(m_xEditWindow.is()) m_xEditWindow->setFocus();
467
468 //3. Set the active object
469
470 OLECHAR starOffice[] = {'S','t','a','r','O','f','f','i','c','e',0};
471 CComPtr< IOleInPlaceActiveObject > pObj = new CIIAObj( this );
472
473 if (NULL!=m_pIOleIPFrame)
474 m_pIOleIPFrame->SetActiveObject(
475 pObj, starOffice );
476
477 if (NULL!=m_pIOleIPUIWindow)
478 m_pIOleIPUIWindow->SetActiveObject(
479 pObj, starOffice );
480
481 //4. Create the shared menu.
482 InPlaceMenuCreate();
483
484 return NOERROR;
485 }
486
487 void DocumentHolder::UIDeactivate()
488 {
489 //1. Remove the shared menu.
490 InPlaceMenuDestroy();
491
492 if (NULL!=m_pIOleIPFrame)
493 m_pIOleIPFrame->SetActiveObject(NULL, NULL);
494
495 if (NULL!=m_pIOleIPUIWindow)
496 m_pIOleIPUIWindow->SetActiveObject(NULL, NULL);
497
498 //3. Call IOleInPlaceSite::OnUIDeactivate
499 if (NULL!=m_pIOleIPSite)
500 m_pIOleIPSite->OnUIDeactivate(FALSE);
501
502 return;
503 }
504
505 void CopyToOLEMenu(HMENU hOrig,WORD origPos,HMENU hDest,WORD destPos)
506 {
507 HMENU subMenu(NULL);
508 UINT uTemp = MF_BYPOSITION | MF_POPUP;
509 char buffer[256];
510
511 subMenu = GetSubMenu(hOrig,origPos);
512 GetMenuString(hOrig,origPos,buffer,256,MF_BYPOSITION);
513 InsertMenu(hDest,destPos,uTemp,
514 reinterpret_cast<UINT_PTR>(subMenu),LPCTSTR(buffer));
515
516 MENUITEMINFOW mi;
517 memset(&mi,0,sizeof(mi));
518 mi.cbSize = sizeof(mi);
519 mi.fMask = MIIM_DATA;
520 if(GetMenuItemInfoW(hOrig,origPos,TRUE,&mi))
521 SetMenuItemInfoW(hDest,(WORD)destPos,TRUE,&mi);
522 }
523
524 BOOL DocumentHolder::InPlaceMenuCreate()
525 {
526 HMENU hMenu;
527 OLEMENUGROUPWIDTHS mgw;
528
529 for (UINT i=0; i<6; i++)
530 mgw.width[i]=0;
531
532 //We already have popup menu handles in m_pFR->m_phMenu[]
533
534 //Create the new shared menu and let container do its thing
535 hMenu=CreateMenu();
536 m_pIOleIPFrame->InsertMenus(hMenu,&mgw);
537
538 int count = GetMenuItemCount(m_nMenuHandle);
539 int help = count-1;
540
541 // start with 1, because we don't include "File"
542 WORD pos = (WORD)mgw.width[0];
543 CopyToOLEMenu(m_nMenuHandle,1,hMenu,pos);
544 mgw.width[1] = 1;
545
546 // insert object menu here
547 pos = ((WORD)(mgw.width[0] + mgw.width[1] + mgw.width[2]));
548 for(WORD i = 2; i < help-1; ++i,++pos)
549 CopyToOLEMenu(m_nMenuHandle,i,hMenu,pos);
550 mgw.width[3] = help - 3;
551
552 // insert help menu
553 pos = (WORD)(mgw.width[0] + mgw.width[1] + mgw.width[2] +
554 mgw.width[3] + mgw.width[4]);
555 CopyToOLEMenu(m_nMenuHandle,WORD(help),hMenu,pos);
556 mgw.width[5] = 1;
557
558 m_nMenuShared = hMenu;
559 m_nOLEMenu = OleCreateMenuDescriptor(m_nMenuShared,&mgw);
560
561 uno::Reference<awt::XSystemDependentWindowPeer> xSysDepWin(m_xContainerWindow,uno::UNO_QUERY);
562 if(xSysDepWin.is()) {
563 uno::Sequence<sal_Int8> aProcessIdent(16);
564 rtl_getGlobalProcessId((sal_uInt8*)aProcessIdent.getArray());
565 uno::Any aAny = xSysDepWin->getWindowHandle(aProcessIdent,lang::SystemDependent::SYSTEM_WIN32);
566 sal_Int64 tmp;
567 aAny >>= tmp;
568 HWND aHwnd = (HWND) tmp;
569 m_pIOleIPFrame->SetMenu(
570 m_nMenuShared,m_nOLEMenu,aHwnd);
571 }
572 else
573 m_pIOleIPFrame->SetMenu(
574 m_nMenuShared,m_nOLEMenu,::GetWindow(m_hWndxWinParent,GW_CHILD));
575 return TRUE;
576 }
577
578 BOOL DocumentHolder::InPlaceMenuDestroy()
579 {
580 if( NULL == m_nMenuShared )
581 return TRUE;
582
583 m_pIOleIPFrame->SetMenu(NULL,NULL,NULL);
584
585 OleDestroyMenuDescriptor(m_nOLEMenu),m_nOLEMenu = NULL;
586 return TRUE;
587 }
588
589 void DocumentHolder::OpenIntoWindow()
590 {
591 // not implemented
592 }
593
594 BOOL DocumentHolder::Undo()
595 {
596 // not implemented
597 return false;
598 }
599
600
601 void DocumentHolder::FreeOffice()
602 {
603 uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory));
604 xDesktop->removeTerminateListener(
605 (frame::XTerminateListener*)this );
606 }
607
608 void DocumentHolder::DisconnectFrameDocument( sal_Bool bComplete )
609 {
610 try
611 {
612 uno::Reference< util::XModifyBroadcaster > xModifiable( m_xDocument, uno::UNO_QUERY_THROW );
613 xModifiable->removeModifyListener( (util::XModifyListener*)this );
614 }
615 catch( const uno::Exception& )
616 {}
617
618 try
619 {
620 uno::Reference< util::XCloseBroadcaster > xBroadcaster(
621 m_xDocument, uno::UNO_QUERY_THROW );
622 xBroadcaster->removeCloseListener( (util::XCloseListener*)this );
623 }
624 catch( const uno::Exception& )
625 {}
626
627 try
628 {
629 uno::Reference< util::XCloseBroadcaster > xBroadcaster(
630 m_xFrame, uno::UNO_QUERY_THROW );
631 xBroadcaster->removeCloseListener( (util::XCloseListener*)this );
632 }
633 catch( const uno::Exception& )
634 {}
635
636 if ( bComplete )
637 {
638 m_xFrame.clear();
639 m_pIDispatch = NULL;
640 m_xDocument.clear();
641 }
642 }
643
644 void DocumentHolder::CloseDocument()
645 {
646 DisconnectFrameDocument();
647
648 uno::Reference< util::XCloseable > xCloseable(
649 m_xDocument, uno::UNO_QUERY );
650
651 if ( xCloseable.is() )
652 {
653 try
654 {
655 xCloseable->close( sal_True );
656 }
657 catch( const uno::Exception& )
658 {}
659 }
660
661 m_pIDispatch = NULL;
662 m_xDocument.clear();
663 }
664
665
666 void DocumentHolder::CloseFrame()
667 {
668 try
669 {
670 uno::Reference< util::XCloseBroadcaster > xBroadcaster(
671 m_xFrame, uno::UNO_QUERY_THROW );
672 xBroadcaster->removeCloseListener( (util::XCloseListener*)this );
673 }
674 catch( const uno::Exception& )
675 {}
676
677 uno::Reference<util::XCloseable> xCloseable(
678 m_xFrame,uno::UNO_QUERY);
679 if(xCloseable.is())
680 try {
681 xCloseable->close(sal_True);
682 }
683 catch( const uno::Exception& ) {
684 }
685 else {
686 uno::Reference<lang::XComponent> xComp(m_xFrame, uno::UNO_QUERY);
687 if (xComp.is())
688 xComp->dispose();
689 }
690
691 m_xFrame.clear();
692 }
693
694 void DocumentHolder::SetDocument( const uno::Reference< frame::XModel >& xDoc, sal_Bool bLink )
695 {
696 if ( m_xDocument.is() )
697 CloseDocument();
698
699 m_xDocument = xDoc;
700 m_bLink = bLink;
701
702 uno::Reference< util::XCloseBroadcaster > xBroadcaster(
703 m_xDocument, uno::UNO_QUERY );
704
705 if ( xBroadcaster.is() )
706 xBroadcaster->addCloseListener( (util::XCloseListener*)this );
707
708 if ( m_xDocument.is() && !m_bLink )
709 {
710 // set the document mode to embedded
711 uno::Sequence< beans::PropertyValue > aSeq(1);
712 aSeq[0].Name = "SetEmbedded";
713 aSeq[0].Value <<= sal_True;
714 m_xDocument->attachResource(OUString(),aSeq);
715 }
716 }
717
718 sal_Bool DocumentHolder::ExecuteSuspendCloseFrame()
719 {
720 if ( m_xFrame.is() && m_xFactory.is() )
721 {
722 try
723 {
724 uno::Reference< frame::XController > xController = m_xFrame->getController();
725 if ( xController.is() )
726 {
727 if ( !xController->suspend( sal_True ) )
728 return sal_False;
729
730 FreeOffice();
731 try
732 {
733 uno::Reference<util::XCloseable> xCloseable( m_xFrame, uno::UNO_QUERY );
734 if ( xCloseable.is() )
735 xCloseable->close(sal_True);
736 else
737 {
738 m_xFrame->dispose();
739 }
740 }
741 catch( const util::CloseVetoException& )
742 {
743 // should be called if the frame could not be closed
744 xController->suspend( sal_False );
745 }
746 }
747 }
748 catch( uno::Exception& )
749 {
750 }
751
752 m_xFrame.clear();
753 }
754
755 return sal_True;
756 }
757
758 uno::Reference< frame::XFrame2 > DocumentHolder::DocumentFrame()
759 {
760 if(! m_xFrame.is() )
761 {
762 uno::Reference<frame::XDesktop2> xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory));
763
764 uno::Reference<frame::XFrame> xFrame(xDesktop,uno::UNO_QUERY);
765
766 // the frame will be registered on desktop here, later when the document
767 // is loaded into the frame in ::show() method the terminate listener will be removed
768 // this is so only for outplace activation
769 if( xFrame.is() )
770 m_xFrame.set( xFrame->findFrame( OUString("_blank"), 0 ), uno::UNO_QUERY );
771
772 uno::Reference< util::XCloseBroadcaster > xBroadcaster(
773 m_xFrame, uno::UNO_QUERY );
774
775 if ( xBroadcaster.is() )
776 {
777 xBroadcaster->addCloseListener( (util::XCloseListener*)this );
778 FreeOffice(); // the frame is part of the desktop
779 }
780 }
781
782 if( m_xFrame.is() )
783 {
784 // intercept
785 m_xFrame->registerDispatchProviderInterceptor( CreateNewInterceptor() );
786 }
787
788 return m_xFrame;
789 }
790
791
792 uno::Reference< frame::XDispatchProviderInterceptor > DocumentHolder::CreateNewInterceptor()
793 {
794 ::osl::MutexGuard aGuard( m_aMutex );
795
796 ClearInterceptorInternally();
797
798 uno::Reference< frame::XDispatchProviderInterceptor > xInterceptor( m_pInterceptor = new Interceptor( m_xOleAccess, this, m_bLink ) );
799 m_xInterceptorLocker = xInterceptor;
800 return xInterceptor;
801 }
802
803 void DocumentHolder::ClearInterceptorInternally()
804 {
805 ::osl::MutexGuard aGuard( m_aMutex );
806 uno::Reference< frame::XDispatchProviderInterceptor > xInterceptor( m_xInterceptorLocker );
807 if ( xInterceptor.is() && m_pInterceptor )
808 m_pInterceptor->DisconnectDocHolder();
809
810 m_xInterceptorLocker.clear();
811 m_pInterceptor = 0;
812 }
813
814 void DocumentHolder::ClearInterceptor()
815 {
816 ::osl::MutexGuard aGuard( m_aMutex );
817 m_xInterceptorLocker.clear();
818 m_pInterceptor = 0;
819 }
820
821
822 void DocumentHolder::show()
823 {
824 try
825 {
826 if(m_xFrame.is())
827 {
828 m_xFrame->activate();
829 uno::Reference<awt::XTopWindow> xTopWindow(
830 m_xFrame->getContainerWindow(),uno::UNO_QUERY);
831 if(xTopWindow.is())
832 xTopWindow->toFront();
833 }
834 else if( DocumentFrame().is() )
835 {
836 LoadDocInFrame( sal_False );
837
838 // get rid of second closer if it is there
839 uno::Reference< beans::XPropertySet > xLMProps( m_xFrame->getLayoutManager(), uno::UNO_QUERY );
840 if ( xLMProps.is() )
841 {
842 xLMProps->setPropertyValue("MenuBarCloser",
843 uno::makeAny( uno::Reference< frame::XStatusListener >() ) );
844 }
845
846 if ( !m_bLink )
847 {
848 try
849 {
850 uno::Reference< util::XModifyBroadcaster > xModifiable( m_xDocument, uno::UNO_QUERY_THROW );
851 xModifiable->addModifyListener( (util::XModifyListener*)this );
852 }
853 catch( const uno::Exception& )
854 {}
855 }
856
857 if ( !m_bLink )
858 setTitle(m_aDocumentNamePart);
859 }
860 }
861 catch( const uno::Exception& )
862 {
863 OSL_FAIL( "Can not show the frame!\n" );
864 }
865
866 }
867
868 void DocumentHolder::resizeWin( const SIZEL& rNewSize )
869 {
870 LockedEmbedDocument_Impl aDocLock;
871
872 if ( m_xOleAccess.is() )
873 aDocLock = m_xOleAccess->GetEmbedDocument();
874
875 if ( m_xFrame.is() && aDocLock.GetEmbedDocument() )
876 {
877 uno::Reference< awt::XWindow > xWindow(
878 m_xFrame->getContainerWindow(), uno::UNO_QUERY );
879 uno::Reference< awt::XView > xView( xWindow, uno::UNO_QUERY );
880
881 if ( xWindow.is() && xView.is() )
882 {
883 float fScale = 1;
884 xView->setZoom( fScale, fScale );
885
886 SIZEL aOldSize;
887 GetExtent( &aOldSize );
888
889 if ( aOldSize.cx != rNewSize.cx || aOldSize.cy != rNewSize.cy )
890 {
891 HDC hdc = GetDC( NULL );
892 SetMapMode( hdc, MM_HIMETRIC );
893
894 POINT aOldOffset;
895 aOldOffset.x = aOldSize.cx;
896 aOldOffset.y = aOldSize.cy;
897 BOOL bIsOk = LPtoDP( hdc, &aOldOffset, 1 );
898
899 POINT aNewOffset;
900 aNewOffset.x = rNewSize.cx;
901 aNewOffset.y = rNewSize.cy;
902 bIsOk = LPtoDP( hdc, &aNewOffset, 1 );
903
904 ReleaseDC( NULL, hdc );
905
906 awt::Rectangle aWinRect = xWindow->getPosSize();
907
908 sal_Int32 aWidthDelta = aWinRect.Width - aOldOffset.x;
909 sal_Int32 aHeightDelta = aWinRect.Height - aOldOffset.y;
910
911 if ( aWidthDelta > 0 && aHeightDelta > 0 )
912 xWindow->setPosSize(0,
913 0,
914 aNewOffset.x + aWidthDelta,
915 aNewOffset.y + aHeightDelta,
916 awt::PosSize::SIZE );
917 }
918 }
919 }
920 }
921
922 void DocumentHolder::setTitle(const OUString& aDocumentName)
923 {
924 if(m_xFrame.is())
925 {
926 if(m_aFilterName.getLength() == 0)
927 {
928 OUString aFilterName;
929 uno::Sequence<beans::PropertyValue> aSeq;
930 if(m_xDocument.is())
931 {
932 aSeq =
933 m_xDocument->getArgs();
934 for(sal_Int32 j = 0; j < aSeq.getLength(); ++j)
935 {
936 if(aSeq[j].Name == "FilterName")
937 {
938 aSeq[j].Value >>= aFilterName;
939 break;
940 }
941 }
942 }
943
944 if(aFilterName.getLength())
945 {
946 uno::Reference<container::XNameAccess> xNameAccess(
947 m_xFactory->createInstance("com.sun.star.document.FilterFactory"),
948 uno::UNO_QUERY);
949 try {
950 if(xNameAccess.is() &&
951 (xNameAccess->getByName(aFilterName) >>= aSeq))
952 {
953 for(sal_Int32 j = 0; j < aSeq.getLength(); ++j)
954 if(aSeq[j].Name ==
955 OUString("UIName"))
956 {
957 aSeq[j].Value >>= m_aFilterName;
958 break;
959 }
960 }
961 }
962 catch(const uno::Exception& ) {
963 // nothing better to do here
964 m_aFilterName = aFilterName;
965 }
966 }
967 }
968 // set the title
969 static const sal_Unicode u[] = { ' ','(',0 };
970 static const sal_Unicode c[] = { ')',0 };
971 rtl::OUString aTotalName(m_aFilterName);
972 aTotalName += rtl::OUString(u);
973 aTotalName += aDocumentName;
974 aTotalName += rtl::OUString(c);
975 try {
976 m_xFrame->setTitle( aTotalName );
977 }
978 catch( const uno::Exception& ) {
979 }
980 }
981
982 m_aDocumentNamePart = aDocumentName;
983
984 if(m_pInterceptor)
985 {
986 ::osl::ClearableMutexGuard aGuard( m_aMutex );
987
988 Interceptor* pTmpInter = NULL;
989 uno::Reference< frame::XDispatchProviderInterceptor > xLock( m_xInterceptorLocker );
990 if ( xLock.is() && m_pInterceptor )
991 pTmpInter = m_pInterceptor;
992
993 aGuard.clear();
994
995 if ( pTmpInter )
996 pTmpInter->generateFeatureStateEvent();
997 }
998 }
999
1000
1001 void DocumentHolder::setContainerName(const OUString& aContainerName)
1002 {
1003 m_aContainerName = aContainerName;
1004 }
1005
1006
1007 void DocumentHolder::hide()
1008 {
1009 if(m_xFrame.is()) m_xFrame->deactivate();
1010
1011 //todo: sendadvise
1012 // after hiding the window it is always allowed to InPlaceActivate it
1013 m_bAllowInPlace = true;
1014 }
1015
1016 IDispatch* DocumentHolder::GetIDispatch()
1017 {
1018 if ( !m_pIDispatch && m_xDocument.is() )
1019 {
1020 const OUString aServiceName (
1021 "com.sun.star.bridge.OleBridgeSupplier2" );
1022 uno::Reference< bridge::XBridgeSupplier2 > xSupplier(
1023 m_xFactory->createInstance( aServiceName ), uno::UNO_QUERY );
1024
1025 if ( xSupplier.is() )
1026 {
1027 uno::Sequence< sal_Int8 > aProcId( 16 );
1028 rtl_getGlobalProcessId( (sal_uInt8*)aProcId.getArray() );
1029
1030 try {
1031 uno::Any anyResult = xSupplier->createBridge(
1032 uno::makeAny( m_xDocument ),
1033 aProcId,
1034 bridge::ModelDependent::UNO,
1035 bridge::ModelDependent::OLE );
1036
1037 if ( anyResult.getValueTypeClass() ==
1038 cppu::UnoType<sal_uIntPtr>::get().getTypeClass() )
1039 {
1040 VARIANT* pVariant = *(VARIANT**)anyResult.getValue();
1041 if ( pVariant->vt == VT_DISPATCH )
1042 m_pIDispatch = pVariant->pdispVal;
1043
1044 VariantClear( pVariant );
1045 CoTaskMemFree( pVariant );
1046 }
1047 }
1048 catch ( const uno::Exception& )
1049 {}
1050 }
1051 }
1052
1053 return m_pIDispatch;
1054 }
1055
1056 HRESULT DocumentHolder::GetDocumentBorder( RECT *pRect )
1057 {
1058 if ( pRect && m_xDocument.is() )
1059 {
1060 uno::Sequence< beans::PropertyValue > aArgs = m_xDocument->getArgs();
1061 for ( sal_Int32 nInd = 0; nInd < aArgs.getLength(); nInd++ )
1062 if ( aArgs[nInd].Name == "DocumentBorder" )
1063 {
1064 uno::Sequence< sal_Int32 > aRect;
1065 if ( ( aArgs[nInd].Value >>= aRect ) && aRect.getLength() == 4 )
1066 {
1067 pRect->left = aRect[0];
1068 pRect->top = aRect[1];
1069 pRect->right = aRect[2];
1070 pRect->bottom = aRect[3];
1071
1072 return S_OK;
1073 }
1074
1075 break;
1076 }
1077 }
1078
1079 return E_FAIL;
1080 }
1081
1082 HRESULT DocumentHolder::SetExtent( const SIZEL *pSize )
1083 {
1084 if ( pSize )
1085 {
1086 uno::Reference< embed::XVisualObject > xVisObj( m_xDocument, uno::UNO_QUERY );
1087 if ( xVisObj.is() )
1088 {
1089 try
1090 {
1091 awt::Size aNewSize( pSize->cx, pSize->cy );
1092
1093 sal_Int32 aMapMode = xVisObj->getMapUnit( DVASPECT_CONTENT );
1094
1095 // TODO/LATER: in future UNO API should be used for the conversion, currently there is no
1096 if ( aMapMode == embed::EmbedMapUnits::TWIP )
1097 {
1098 // conversion from ONE_100TH_MM
1099 aNewSize.Width = aNewSize.Width * 144 / 254;
1100 aNewSize.Height = aNewSize.Height * 144 / 254;
1101 }
1102
1103
1104 xVisObj->setVisualAreaSize( DVASPECT_CONTENT, aNewSize );
1105
1106 return S_OK;
1107 }
1108 catch( const uno::Exception& )
1109 {}
1110 }
1111 }
1112
1113 return E_FAIL;
1114 }
1115
1116 HRESULT DocumentHolder::GetExtent( SIZEL *pSize )
1117 {
1118 if ( pSize )
1119 {
1120 uno::Reference< embed::XVisualObject > xVisObj( m_xDocument, uno::UNO_QUERY );
1121 if ( xVisObj.is() )
1122 {
1123 try
1124 {
1125 awt::Size aDocSize = xVisObj->getVisualAreaSize( DVASPECT_CONTENT );
1126
1127 sal_Int32 aMapMode = xVisObj->getMapUnit( DVASPECT_CONTENT );
1128
1129 // TODO/LATER: in future UNO API should be used for the conversion, currently there is no
1130 if ( aMapMode == embed::EmbedMapUnits::TWIP )
1131 {
1132 // conversion to ONE_100TH_MM
1133 aDocSize.Width = aDocSize.Width * 254 / 144;
1134 aDocSize.Height = aDocSize.Height * 254 / 144;
1135 }
1136
1137 pSize->cx = aDocSize.Width;
1138 pSize->cy = aDocSize.Height;
1139
1140 return S_OK;
1141 }
1142 catch( const uno::Exception& )
1143 {}
1144 }
1145 }
1146
1147 return E_FAIL;
1148 }
1149
1150
1151 HRESULT DocumentHolder::SetContRects(LPCRECT aRect)
1152 {
1153 if(m_xContainerWindow.is()) {
1154 RECT wi;
1155 memset(&wi,0,sizeof(wi));
1156 if(m_pIOleIPFrame) {
1157 m_pIOleIPFrame->GetBorder((LPRECT)&wi);
1158 m_xContainerWindow->setPosSize(
1159 0,0,
1160 wi.right - wi.left,
1161 wi.bottom - wi.top,
1162 awt::PosSize::POSSIZE);
1163 }
1164 else
1165 m_xContainerWindow->setPosSize(
1166 0,0,
1167 aRect->right - aRect->left,
1168 aRect->bottom - aRect->top,
1169 awt::PosSize::POSSIZE);
1170 return NOERROR;
1171 }
1172 else {
1173 return ERROR;
1174 }
1175 }
1176
1177
1178 HRESULT DocumentHolder::SetObjectRects(LPCRECT aRect, LPCRECT aClip)
1179 {
1180 ((LPRECT)aRect)->left -= m_aBorder.left;
1181 ((LPRECT)aRect)->right += m_aBorder.right;
1182 ((LPRECT)aRect)->top -= m_aBorder.top;
1183 ((LPRECT)aRect)->bottom += m_aBorder.bottom;
1184 ((LPRECT)aClip)->left -= m_aBorder.left;
1185 ((LPRECT)aClip)->right += m_aBorder.right;
1186 ((LPRECT)aClip)->top -= m_aBorder.top;
1187 ((LPRECT)aClip)->bottom += m_aBorder.bottom;
1188
1189 if(m_pCHatchWin)
1190 m_pCHatchWin->RectsSet((LPRECT)aRect, (LPRECT)aClip);
1191 if(m_xEditWindow.is()) {
1192 m_xEditWindow->setVisible(false);
1193 m_xEditWindow->setPosSize(
1194 m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0,
1195 m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0,
1196 aRect->right - aRect->left,
1197 aRect->bottom - aRect->top,
1198 awt::PosSize::POSSIZE);
1199 m_xEditWindow->setVisible(true);
1200 }
1201 return NOERROR;
1202 }
1203
1204
1205 css::uno::Reference< css::awt::XWindow> SAL_CALL DocumentHolder::getContainerWindow()
1206 throw (
1207 css::uno::RuntimeException
1208 )
1209 {
1210 if(m_xContainerWindow.is())
1211 return m_xContainerWindow;
1212
1213 uno::Reference<awt::XWindow> xWin(0);
1214
1215 uno::Reference<awt::XToolkit2> xToolkit = awt::Toolkit::create( comphelper::getComponentContext(m_xFactory) );
1216
1217 if(m_pIOleIPFrame) {
1218 HWND hWnd;
1219 m_pIOleIPFrame->GetWindow(&hWnd);
1220
1221 uno::Sequence<sal_Int8> aProcessIdent(16);
1222 rtl_getGlobalProcessId((sal_uInt8*)aProcessIdent.getArray());
1223
1224 xWin.set(
1225 xToolkit->createSystemChild(
1226 uno::Any(sal_Int32(hWnd)),
1227 aProcessIdent,
1228 lang::SystemDependent::SYSTEM_WIN32),
1229 uno::UNO_QUERY);
1230
1231 RECT wi;
1232 memset(&wi,0,sizeof(wi));
1233 if(xWin.is() && m_pIOleIPFrame->GetBorder((LPRECT)&wi) == NOERROR) {
1234 xWin->setVisible(true);
1235 xWin->setPosSize(
1236 0,0,
1237 wi.right-wi.left,
1238 wi.bottom - wi.top,
1239 awt::PosSize::POSSIZE);
1240
1241 uno::Reference<awt::XSystemDependentWindowPeer> xSysWin(
1242 xWin,uno::UNO_QUERY);
1243 if(xSysWin.is()) {
1244 uno::Any aAny = xSysWin->getWindowHandle(
1245 aProcessIdent,lang::SystemDependent::SYSTEM_WIN32);
1246 sal_Int64 tmp;
1247 if( aAny >>= tmp )
1248 SetContainerWindowHandle((HWND) tmp);
1249 }
1250 }
1251 }
1252
1253 m_xContainerWindow= xWin;
1254 return xWin;
1255 }
1256
1257
1258 sal_Bool SAL_CALL DocumentHolder::requestDockingAreaSpace( const css::awt::Rectangle& RequestedSpace )
1259 throw(
1260 css::uno::RuntimeException
1261 )
1262 {
1263 if(m_bOnDeactivate)
1264 return sal_True;
1265
1266 BORDERWIDTHS bw;
1267 SetRect((LPRECT)&bw,
1268 RequestedSpace.X,RequestedSpace.Y,
1269 RequestedSpace.Width,RequestedSpace.Height);
1270 if( m_pIOleIPFrame )
1271 return m_pIOleIPFrame->RequestBorderSpace(&bw) == NOERROR ;
1272 else
1273 return sal_Bool(false);
1274 }
1275
1276
1277 void SAL_CALL DocumentHolder::setDockingAreaSpace( const css::awt::Rectangle& BorderSpace )
1278 throw (
1279 css::uno::RuntimeException
1280 )
1281 {
1282 if(m_bOnDeactivate)
1283 return;
1284
1285 BORDERWIDTHS bw;
1286 SetRect((LPRECT)&bw,
1287 BorderSpace.X,BorderSpace.Y,
1288 BorderSpace.Width,BorderSpace.Height);
1289 if( m_pIOleIPFrame ) {
1290 RECT aRect;
1291 GetClientRect(m_hWndxWinCont,&aRect);
1292 HRGN hrgn1 = CreateRectRgn(
1293 0,0,
1294 aRect.right,BorderSpace.Y);
1295 HRGN hrgn2 = CreateRectRgn(aRect.right-BorderSpace.Width,0,aRect.right,aRect.bottom);
1296 CombineRgn(hrgn1,hrgn1,hrgn2,RGN_OR);
1297 DeleteObject(hrgn2);
1298 hrgn2 = CreateRectRgn(0,aRect.bottom-BorderSpace.Height,aRect.right,aRect.bottom);
1299 CombineRgn(hrgn1,hrgn1,hrgn2,RGN_OR);
1300 DeleteObject(hrgn2);
1301 hrgn2 = CreateRectRgn(0,0,BorderSpace.X,aRect.bottom);
1302 CombineRgn(hrgn1,hrgn1,hrgn2,RGN_OR);
1303 DeleteObject(hrgn2);
1304
1305 SetWindowRgn(m_hWndxWinCont,hrgn1,true);
1306 // not:: DeleteObject(hrgn1);
1307 m_pIOleIPFrame->SetBorderSpace(&bw);
1308 }
1309 }
1310
1311
1312 void SAL_CALL DocumentHolder::disposing( const css::lang::EventObject& aSource )
1313 throw( uno::RuntimeException )
1314 {
1315 if ( m_xDocument.is() && m_xDocument == aSource.Source )
1316 {
1317 m_pIDispatch = NULL;
1318 m_xDocument.clear();
1319 }
1320
1321 if( m_xFrame.is() && m_xFrame == aSource.Source )
1322 m_xFrame.clear();
1323 }
1324
1325
1326 void SAL_CALL
1327 DocumentHolder::queryClosing(
1328 const lang::EventObject& aSource,
1329 sal_Bool /*bGetsOwnership*/
1330 )
1331 throw(
1332 util::CloseVetoException
1333 )
1334 {
1335 if (!m_bLink
1336 && ((m_xDocument.is() && m_xDocument == aSource.Source)
1337 || (m_xFrame.is() && m_xFrame == aSource.Source)))
1338 throw util::CloseVetoException();
1339 }
1340
1341
1342 void SAL_CALL
1343 DocumentHolder::notifyClosing(
1344 const lang::EventObject& aSource )
1345 throw( uno::RuntimeException )
1346 {
1347 try
1348 {
1349 uno::Reference< util::XCloseBroadcaster > xEventBroadcaster(
1350 aSource.Source, uno::UNO_QUERY_THROW );
1351 xEventBroadcaster->removeCloseListener( (util::XCloseListener*)this );
1352 }
1353 catch( const uno::Exception& )
1354 {}
1355
1356 if ( m_xDocument.is() && m_xDocument == aSource.Source )
1357 {
1358 // can happen only in case of links
1359 m_pIDispatch = NULL;
1360 m_xDocument.clear();
1361 m_xFrame.clear();
1362
1363 LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument();
1364 if ( aDocLock.GetEmbedDocument() )
1365 aDocLock.GetEmbedDocument()->OLENotifyClosing();
1366 }
1367 else if( m_xFrame.is() && m_xFrame == aSource.Source )
1368 m_xFrame.clear();
1369 }
1370
1371 void SAL_CALL
1372 DocumentHolder::queryTermination(
1373 const lang::EventObject& /*aSource*/
1374 )
1375 throw(
1376 frame::TerminationVetoException
1377 )
1378 {
1379 if ( m_xDocument.is() )
1380 throw frame::TerminationVetoException();
1381 }
1382
1383 void SAL_CALL
1384 DocumentHolder::notifyTermination(
1385 const lang::EventObject& aSource
1386 )
1387 throw( uno::RuntimeException )
1388 {
1389 OSL_ENSURE( !m_xDocument.is(), "Just a disaster..." );
1390 uno::Reference< frame::XDesktop > xDesktop(
1391 aSource.Source, uno::UNO_QUERY );
1392
1393 if ( xDesktop.is() )
1394 xDesktop->removeTerminateListener( (frame::XTerminateListener*)this );
1395 }
1396
1397
1398 void SAL_CALL DocumentHolder::modified( const lang::EventObject& /*aEvent*/ )
1399 throw (uno::RuntimeException)
1400 {
1401 if ( m_xOleAccess.is() )
1402 {
1403 LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument();
1404 if ( aDocLock.GetEmbedDocument() )
1405 aDocLock.GetEmbedDocument()->notify();
1406 }
1407 }
1408
1409 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE