LibreOffice Module embeddedobj (master) 1
docholder.cxx
Go to the documentation of this file.
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
20#include <com/sun/star/embed/Aspects.hpp>
21#include <com/sun/star/frame/TaskCreator.hpp>
22#include <com/sun/star/frame/XTitle.hpp>
23#include <com/sun/star/frame/TerminationVetoException.hpp>
24#include <com/sun/star/frame/XComponentLoader.hpp>
25#include <com/sun/star/frame/XSynchronousFrameLoader.hpp>
26#include <com/sun/star/lang/XSingleServiceFactory.hpp>
27#include <com/sun/star/lang/XSingleComponentFactory.hpp>
28#include <com/sun/star/util/CloseVetoException.hpp>
29#include <com/sun/star/util/XCloseBroadcaster.hpp>
30#include <com/sun/star/util/XCloseable.hpp>
31#include <com/sun/star/lang/XServiceInfo.hpp>
32#include <com/sun/star/beans/XPropertySet.hpp>
33#include <com/sun/star/beans/NamedValue.hpp>
34#include <com/sun/star/frame/XModel.hpp>
35#include <com/sun/star/frame/Desktop.hpp>
36#include <com/sun/star/frame/XFramesSupplier.hpp>
37#include <com/sun/star/frame/XControllerBorder.hpp>
38#include <com/sun/star/util/XModifyBroadcaster.hpp>
39#include <com/sun/star/frame/XDispatchProviderInterception.hpp>
40#include <com/sun/star/awt/Toolkit.hpp>
41#include <com/sun/star/awt/XTopWindow.hpp>
42#include <com/sun/star/awt/PosSize.hpp>
43#include <com/sun/star/awt/WindowAttribute.hpp>
44#include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
45#include <com/sun/star/embed/XHatchWindow.hpp>
46#include <com/sun/star/embed/HatchWindowFactory.hpp>
47#include <com/sun/star/frame/XLayoutManager.hpp>
48#include <com/sun/star/frame/XMenuBarMergingAcceptor.hpp>
49#include <com/sun/star/frame/ModuleManager.hpp>
50#include <com/sun/star/ui/XDockingAreaAcceptor.hpp>
51#include <com/sun/star/ui/XUIElementSettings.hpp>
52#include <com/sun/star/ui/XUIConfigurationManager.hpp>
53#include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
54#include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
55#include <com/sun/star/embed/StateChangeInProgressException.hpp>
56
57#include <com/sun/star/embed/EmbedMisc.hpp>
58#include <com/sun/star/embed/EmbedStates.hpp>
59#include <osl/diagnose.h>
60#include <utility>
61#include <vcl/svapp.hxx>
62#include <unotools/resmgr.hxx>
63#include <sfx2/strings.hrc>
64
65#include <comphelper/processfactory.hxx>
66#include <comphelper/namedvaluecollection.hxx>
67
68#include <docholder.hxx>
69#include <commonembobj.hxx>
70#include <intercept.hxx>
71
72#define HATCH_BORDER_WIDTH (((m_pEmbedObj->getStatus(embed::Aspects::MSOLE_CONTENT)&embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE) && \
73 m_pEmbedObj->getCurrentState()!=embed::EmbedStates::UI_ACTIVE) ? 0 : 4 )
74
75using namespace ::com::sun::star;
76
77namespace {
78
79class IntCounterGuard
80{
81 sal_Int32& m_rFlag;
82public:
83 explicit IntCounterGuard(sal_Int32& rFlag)
84 : m_rFlag(rFlag)
85 {
86 ++m_rFlag;
87 }
88
89 ~IntCounterGuard()
90 {
91 if (m_rFlag)
92 --m_rFlag;
93 }
94};
95
96}
97
98static void InsertMenu_Impl( const uno::Reference< container::XIndexContainer >& xTargetMenu,
99 sal_Int32 nTargetIndex,
100 const uno::Reference< container::XIndexAccess >& xSourceMenu,
101 sal_Int32 nSourceIndex,
102 const OUString& aContModuleName,
103 const uno::Reference< frame::XDispatchProvider >& xSourceDisp )
104{
105 sal_Int32 nInd = 0;
106 OUString aModuleIdentPropName( "ModuleIdentifier" );
107 OUString aDispProvPropName( "DispatchProvider" );
108 bool bModuleNameSet = false;
109 bool bDispProvSet = false;
110
111 uno::Sequence< beans::PropertyValue > aSourceProps;
112 xSourceMenu->getByIndex( nSourceIndex ) >>= aSourceProps;
113 uno::Sequence< beans::PropertyValue > aTargetProps( aSourceProps.getLength() );
114 auto aTargetPropsRange = asNonConstRange(aTargetProps);
115 for ( nInd = 0; nInd < aSourceProps.getLength(); nInd++ )
116 {
117 aTargetPropsRange[nInd].Name = aSourceProps[nInd].Name;
118 if ( !aContModuleName.isEmpty() && aTargetProps[nInd].Name == aModuleIdentPropName )
119 {
120 aTargetPropsRange[nInd].Value <<= aContModuleName;
121 bModuleNameSet = true;
122 }
123 else if ( aTargetProps[nInd].Name == aDispProvPropName )
124 {
125 aTargetPropsRange[nInd].Value <<= xSourceDisp;
126 bDispProvSet = true;
127 }
128 else
129 aTargetPropsRange[nInd].Value = aSourceProps[nInd].Value;
130 }
131
132 if ( !bModuleNameSet && !aContModuleName.isEmpty() )
133 {
134 aTargetProps.realloc( ++nInd );
135 auto pTargetProps = aTargetProps.getArray();
136 pTargetProps[nInd-1].Name = aModuleIdentPropName;
137 pTargetProps[nInd-1].Value <<= aContModuleName;
138 }
139
140 if ( !bDispProvSet && xSourceDisp.is() )
141 {
142 aTargetProps.realloc( ++nInd );
143 auto pTargetProps = aTargetProps.getArray();
144 pTargetProps[nInd-1].Name = aDispProvPropName;
145 pTargetProps[nInd-1].Value <<= xSourceDisp;
146 }
147
148 xTargetMenu->insertByIndex( nTargetIndex, uno::Any( aTargetProps ) );
149}
150
151
152DocumentHolder::DocumentHolder( uno::Reference< uno::XComponentContext > xContext,
153 OCommonEmbeddedObject* pEmbObj )
154: m_pEmbedObj( pEmbObj ),
155 m_xContext(std::move( xContext )),
156 m_bReadOnly( false ),
157 m_bWaitForClose( false ),
158 m_bAllowClosing( false ),
159 m_bDesktopTerminated( false ),
160 m_nNoBorderResizeReact( 0 ),
161 m_nNoResizeReact( 0 )
162{
163 uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create( m_xContext );
164 osl_atomic_increment(&m_refCount);
165 try
166 {
167 xDesktop->addTerminateListener( this );
168 }
169 catch ( const uno::Exception& )
170 {
171 }
172 osl_atomic_decrement(&m_refCount);
173
174 m_aOutplaceFrameProps = { uno::Any(beans::NamedValue{ "TopWindow", uno::Any(true) }),
175 uno::Any(beans::NamedValue{ "MakeVisible", uno::Any(false) }),
176 //TODO/LATER: should use parent document frame
177 uno::Any(beans::NamedValue{ "ParentFrame", uno::Any(xDesktop) }) };
178}
179
180
181DocumentHolder::~DocumentHolder()
182{
183 osl_atomic_increment(&m_refCount); // to allow deregistration as a listener
184
185 if( m_xFrame.is() )
186 CloseFrame();
187
188 if ( m_xComponent.is() )
189 {
190 try {
191 CloseDocument( true, false );
192 } catch( const uno::Exception& ) {}
193 }
194
195 if ( m_xInterceptor.is() )
196 {
197 m_xInterceptor->DisconnectDocHolder();
198 m_xInterceptor.clear();
199 }
200
201 if ( !m_bDesktopTerminated )
202 FreeOffice();
203}
204
205
206void DocumentHolder::CloseFrame()
207{
208 uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xFrame, uno::UNO_QUERY );
209 if ( xCloseBroadcaster.is() )
210 xCloseBroadcaster->removeCloseListener( static_cast<util::XCloseListener*>(this) );
211
212 uno::Reference<util::XCloseable> xCloseable(
213 m_xFrame,uno::UNO_QUERY );
214 if( xCloseable.is() )
215 try {
216 xCloseable->close( true );
217 }
218 catch( const uno::Exception& ) {
219 }
220 else {
221 if( m_xFrame.is() )
222 m_xFrame->dispose();
223 }
224
225 if ( m_xHatchWindow.is() )
226 m_xHatchWindow->dispose();
227
228 m_xHatchWindow.clear();
229 m_xOwnWindow.clear();
230 m_xFrame.clear();
231}
232
233
234void DocumentHolder::FreeOffice()
235{
236 try {
237 uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create( m_xContext );
238 xDesktop->removeTerminateListener( this );
239 } catch (const css::uno::DeploymentException&) {
240 // if this happens, the desktop is already gone
241 }
242
243 // the following code is commented out since for now there is still no completely correct way to detect
244 // whether the office can be terminated, so it is better to have unnecessary process running than
245 // to lose any data
246
247// uno::Reference< frame::XFramesSupplier > xFramesSupplier( xDesktop, uno::UNO_QUERY );
248// if ( xFramesSupplier.is() )
249// {
250// uno::Reference< frame::XFrames > xFrames = xFramesSupplier->getFrames();
251// if ( xFrames.is() && !xFrames->hasElements() )
252// {
253// try
254// {
255// xDesktop->terminate();
256// }
257// catch( uno::Exception & )
258// {}
259// }
260// }
261}
262
263
264void DocumentHolder::CloseDocument( bool bDeliverOwnership, bool bWaitForClose )
265{
266 if ( m_xComponent.is() )
267 {
268 uno::Reference< document::XEventBroadcaster > xEventBroadcaster( m_xComponent, uno::UNO_QUERY );
269 if ( xEventBroadcaster.is() )
270 xEventBroadcaster->removeEventListener( static_cast<document::XEventListener*>(this) );
271 else
272 {
273 // the object does not support document::XEventBroadcaster interface
274 // use the workaround, register for modified events
275 uno::Reference< util::XModifyBroadcaster > xModifyBroadcaster( m_xComponent, uno::UNO_QUERY );
276 if ( xModifyBroadcaster.is() )
277 xModifyBroadcaster->removeModifyListener( static_cast<util::XModifyListener*>(this) );
278 }
279
280 m_bAllowClosing = true;
281 m_bWaitForClose = bWaitForClose;
282 m_xComponent->close( bDeliverOwnership );
283 }
284
285 m_xComponent = nullptr;
286}
287
288
289void DocumentHolder::PlaceFrame( const awt::Rectangle& aNewRect )
290{
291 OSL_ENSURE( m_xFrame.is() && m_xOwnWindow.is(),
292 "The object does not have windows required for inplace mode!" );
293
294 //TODO: may need mutex locking???
295 if ( !(m_xFrame.is() && m_xOwnWindow.is()) )
296 return;
297
298 // the frame can be replaced only in inplace mode
299 frame::BorderWidths aOldWidths;
300 IntCounterGuard aGuard( m_nNoBorderResizeReact );
301
302 do
303 {
304 aOldWidths = m_aBorderWidths;
305
306 awt::Rectangle aHatchRect = AddBorderToArea( aNewRect );
307
308 ResizeWindows_Impl( aHatchRect );
309
310 } while ( aOldWidths.Left != m_aBorderWidths.Left
311 || aOldWidths.Top != m_aBorderWidths.Top
312 || aOldWidths.Right != m_aBorderWidths.Right
313 || aOldWidths.Bottom != m_aBorderWidths.Bottom );
314
315 m_aObjRect = aNewRect;
316}
317
318
319void DocumentHolder::ResizeWindows_Impl( const awt::Rectangle& aHatchRect )
320{
321 OSL_ENSURE( m_xFrame.is() && m_xOwnWindow.is() /*&& m_xHatchWindow.is()*/,
322 "The object does not have windows required for inplace mode!" );
323 if ( m_xHatchWindow.is() )
324 {
325 m_xOwnWindow->setPosSize( HATCH_BORDER_WIDTH,
326 HATCH_BORDER_WIDTH,
327 aHatchRect.Width - 2*HATCH_BORDER_WIDTH,
328 aHatchRect.Height - 2*HATCH_BORDER_WIDTH,
329 awt::PosSize::POSSIZE );
330
331
332 m_xHatchWindow->setPosSize( aHatchRect.X,
333 aHatchRect.Y,
334 aHatchRect.Width,
335 aHatchRect.Height,
336 awt::PosSize::POSSIZE );
337 }
338 else
339 m_xOwnWindow->setPosSize( aHatchRect.X + HATCH_BORDER_WIDTH,
340 aHatchRect.Y + HATCH_BORDER_WIDTH,
341 aHatchRect.Width - 2*HATCH_BORDER_WIDTH,
342 aHatchRect.Height - 2*HATCH_BORDER_WIDTH,
343 awt::PosSize::POSSIZE );
344}
345
346
347bool DocumentHolder::SetFrameLMVisibility( const uno::Reference< frame::XFrame >& xFrame, bool bVisible )
348{
349 bool bResult = false;
350
351 try
352 {
353 uno::Reference< css::frame::XLayoutManager > xLayoutManager;
354 uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY_THROW );
355 xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager;
356 if ( xLayoutManager.is() )
357 {
358 xLayoutManager->setVisible( bVisible );
359
360 // MBA: locking is done only on the container LM, because it is not about hiding windows, it's about
361 // giving up control over the component window (and stopping to listen for resize events of the container window)
362 if ( bVisible )
363 xLayoutManager->unlock();
364 else
365 xLayoutManager->lock();
366
367 bResult = true;
368 }
369 }
370 catch( const uno::Exception& )
371 {}
372
373 return bResult;
374}
375
376
377bool DocumentHolder::ShowInplace( const uno::Reference< awt::XWindowPeer >& xParent,
378 const awt::Rectangle& aRectangleToShow,
379 const uno::Reference< frame::XDispatchProvider >& xContDisp )
380{
381 OSL_ENSURE( !m_xFrame.is(), "A frame exists already!" );
382
383 if ( !m_xFrame.is() )
384 {
385 uno::Reference < frame::XModel > xModel( GetComponent(), uno::UNO_QUERY );
386 awt::Rectangle aHatchRectangle = AddBorderToArea( aRectangleToShow );
387
388 awt::Rectangle aOwnRectangle( HATCH_BORDER_WIDTH,
389 HATCH_BORDER_WIDTH,
390 aHatchRectangle.Width - 2*HATCH_BORDER_WIDTH,
391 aHatchRectangle.Height - 2*HATCH_BORDER_WIDTH );
392 uno::Reference< awt::XWindow > xHWindow;
393 uno::Reference< awt::XWindowPeer > xMyParent( xParent );
394
395 if ( xModel.is() )
396 {
397
398 uno::Reference< embed::XHatchWindowFactory > xHatchFactory =
399 embed::HatchWindowFactory::create(m_xContext);
400
401 uno::Reference< embed::XHatchWindow > xHatchWindow =
402 xHatchFactory->createHatchWindowInstance( xParent,
403 aHatchRectangle,
404 awt::Size( HATCH_BORDER_WIDTH, HATCH_BORDER_WIDTH ) );
405
406 uno::Reference< awt::XWindowPeer > xHatchWinPeer( xHatchWindow, uno::UNO_QUERY );
407 xHWindow.set( xHatchWinPeer, uno::UNO_QUERY_THROW );
408
409 xHatchWindow->setController( uno::Reference< embed::XHatchWindowController >(
410 static_cast< embed::XHatchWindowController* >( this ) ) );
411
412 xMyParent = xHatchWinPeer;
413 }
414 else
415 {
416 aOwnRectangle.X += aHatchRectangle.X;
417 aOwnRectangle.Y += aHatchRectangle.Y;
418 }
419
420 awt::WindowDescriptor aOwnWinDescriptor( awt::WindowClass_TOP,
421 "dockingwindow",
422 xMyParent,
423 0,
424 awt::Rectangle(),//aOwnRectangle,
425 awt::WindowAttribute::SHOW | awt::VclWindowPeerAttribute::CLIPCHILDREN );
426
427 uno::Reference< awt::XToolkit2 > xToolkit = awt::Toolkit::create(m_xContext);
428
429 uno::Reference< awt::XWindowPeer > xNewWinPeer = xToolkit->createWindow( aOwnWinDescriptor );
430 uno::Reference< awt::XWindow > xOwnWindow( xNewWinPeer, uno::UNO_QUERY_THROW );
431 uno::Reference< frame::XFrame > xContFrame( xContDisp, uno::UNO_QUERY );
432
433 // create a frame based on the specified window
434 uno::Reference< lang::XSingleServiceFactory > xFrameFact = frame::TaskCreator::create(m_xContext);
435
436 uno::Sequence< uno::Any > aArgs( xContFrame.is() ? 2 : 1 );
437 auto pArgs = aArgs.getArray();
438 beans::NamedValue aArg;
439
440 aArg.Name = "ContainerWindow";
441 aArg.Value <<= xOwnWindow;
442 pArgs[0] <<= aArg;
443
444 if ( xContFrame.is() )
445 {
446 aArg.Name = "ParentFrame";
447 aArg.Value <<= xContFrame;
448 pArgs[1] <<= aArg;
449 }
450
451 // the call will create, initialize the frame, and register it in the parent
452 m_xFrame.set( xFrameFact->createInstanceWithArguments( aArgs ), uno::UNO_QUERY_THROW );
453
454 m_xHatchWindow = xHWindow;
455 m_xOwnWindow = xOwnWindow;
456
457 if ( !SetFrameLMVisibility( m_xFrame, false ) )
458 {
459 OSL_FAIL( "Can't deactivate LayoutManager!" );
460 // TODO/LATER: error handling?
461 }
462
463 // m_bIsInplace = sal_True; TODO: ?
464
465 uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xFrame, uno::UNO_QUERY );
466 if ( xCloseBroadcaster.is() )
467 xCloseBroadcaster->addCloseListener( static_cast<util::XCloseListener*>(this) );
468
469 // TODO: some listeners to the frame and the window ( resize for example )
470 }
471
472 if ( !m_xComponent )
473 return false;
474
475 if ( !LoadDocToFrame( true ) )
476 {
477 CloseFrame();
478 return false;
479 }
480
481 uno::Reference< frame::XControllerBorder > xControllerBorder( m_xFrame->getController(), uno::UNO_QUERY );
482 if ( xControllerBorder.is() )
483 {
484 m_aBorderWidths = xControllerBorder->getBorder();
485 xControllerBorder->addBorderResizeListener( static_cast<frame::XBorderResizeListener*>(this) );
486 }
487
488 PlaceFrame( aRectangleToShow );
489
490 if ( m_xHatchWindow.is() )
491 m_xHatchWindow->setVisible( true );
492
493 return true;
494}
495
496
497uno::Reference< container::XIndexAccess > DocumentHolder::RetrieveOwnMenu_Impl()
498{
499 uno::Reference< container::XIndexAccess > xResult;
500
501 uno::Reference< css::ui::XUIConfigurationManagerSupplier > xUIConfSupplier(
502 m_xComponent,
503 uno::UNO_QUERY );
504 uno::Reference< css::ui::XUIConfigurationManager > xUIConfigManager;
505 if( xUIConfSupplier.is())
506 {
507 xUIConfigManager.set(
508 xUIConfSupplier->getUIConfigurationManager(),
509 uno::UNO_SET_THROW );
510 }
511
512 try
513 {
514 if( xUIConfigManager.is())
515 {
516 xResult = xUIConfigManager->getSettings(
517 "private:resource/menubar/menubar",
518 false );
519 }
520 }
521 catch( const uno::Exception& )
522 {}
523
524 if ( !xResult.is() )
525 {
526 // no internal document configuration, use the one from the module
527 uno::Reference< frame::XModuleManager2 > xModuleMan = frame::ModuleManager::create(m_xContext);
528 OUString aModuleIdent =
529 xModuleMan->identify( uno::Reference< uno::XInterface >( m_xComponent, uno::UNO_QUERY ) );
530
531 if ( !aModuleIdent.isEmpty() )
532 {
533 uno::Reference< ui::XModuleUIConfigurationManagerSupplier > xModConfSupplier =
534 ui::theModuleUIConfigurationManagerSupplier::get(m_xContext);
535 uno::Reference< css::ui::XUIConfigurationManager > xModUIConfMan(
536 xModConfSupplier->getUIConfigurationManager( aModuleIdent ),
537 uno::UNO_SET_THROW );
538 xResult = xModUIConfMan->getSettings(
539 "private:resource/menubar/menubar",
540 false );
541 }
542 }
543
544 if ( !xResult.is() )
545 throw uno::RuntimeException();
546
547 return xResult;
548}
549
550
551void DocumentHolder::FindConnectPoints(
552 const uno::Reference< container::XIndexAccess >& xMenu,
553 sal_Int32 nConnectPoints[2] )
554{
555 nConnectPoints[0] = -1;
556 nConnectPoints[1] = -1;
557 for ( sal_Int32 nInd = 0; nInd < xMenu->getCount(); nInd++ )
558 {
559 uno::Sequence< beans::PropertyValue > aProps;
560 xMenu->getByIndex( nInd ) >>= aProps;
561 OUString aCommand;
562 for ( beans::PropertyValue const & prop : std::as_const(aProps) )
563 if ( prop.Name == "CommandURL" )
564 {
565 prop.Value >>= aCommand;
566 break;
567 }
568
569 if ( aCommand.isEmpty() )
570 throw uno::RuntimeException();
571
572 if ( aCommand == ".uno:PickList" )
573 nConnectPoints[0] = nInd;
574 else if ( aCommand == ".uno:WindowList" )
575 nConnectPoints[1] = nInd;
576 }
577}
578
579
580uno::Reference< container::XIndexAccess > DocumentHolder::MergeMenusForInplace(
581 const uno::Reference< container::XIndexAccess >& xContMenu,
582 const uno::Reference< frame::XDispatchProvider >& xContDisp,
583 const OUString& aContModuleName,
584 const uno::Reference< container::XIndexAccess >& xOwnMenu,
585 const uno::Reference< frame::XDispatchProvider >& xOwnDisp )
586{
587 // TODO/LATER: use dispatch providers on merge
588
589 sal_Int32 nContPoints[2];
590 sal_Int32 nOwnPoints[2];
591
592 uno::Reference< lang::XSingleComponentFactory > xIndAccessFact( xContMenu, uno::UNO_QUERY_THROW );
593
594 uno::Reference< container::XIndexContainer > xMergedMenu(
595 xIndAccessFact->createInstanceWithContext(
596 comphelper::getProcessComponentContext() ),
597 uno::UNO_QUERY_THROW );
598
599 FindConnectPoints( xContMenu, nContPoints );
600 FindConnectPoints( xOwnMenu, nOwnPoints );
601
602 for ( sal_Int32 nInd = 0; nInd < xOwnMenu->getCount(); nInd++ )
603 {
604 if ( nOwnPoints[0] == nInd )
605 {
606 if ( nContPoints[0] >= 0 && nContPoints[0] < xContMenu->getCount() )
607 {
608 InsertMenu_Impl( xMergedMenu, nInd, xContMenu, nContPoints[0], aContModuleName, xContDisp );
609 }
610 }
611 else if ( nOwnPoints[1] == nInd )
612 {
613 if ( nContPoints[1] >= 0 && nContPoints[1] < xContMenu->getCount() )
614 {
615 InsertMenu_Impl( xMergedMenu, nInd, xContMenu, nContPoints[1], aContModuleName, xContDisp );
616 }
617 }
618 else
619 InsertMenu_Impl( xMergedMenu, nInd, xOwnMenu, nInd, OUString(), xOwnDisp );
620 }
621
622 return uno::Reference< container::XIndexAccess >( xMergedMenu, uno::UNO_QUERY_THROW );
623}
624
625
626bool DocumentHolder::MergeMenus_Impl( const uno::Reference< css::frame::XLayoutManager >& xOwnLM,
627 const uno::Reference< css::frame::XLayoutManager >& xContLM,
628 const uno::Reference< frame::XDispatchProvider >& xContDisp,
629 const OUString& aContModuleName )
630{
631 bool bMenuMerged = false;
632 try
633 {
634 uno::Reference< css::ui::XUIElementSettings > xUISettings(
635 xContLM->getElement( "private:resource/menubar/menubar" ),
636 uno::UNO_QUERY_THROW );
637 uno::Reference< container::XIndexAccess > xContMenu = xUISettings->getSettings( true );
638 if ( !xContMenu.is() )
639 throw uno::RuntimeException();
640
641 uno::Reference< container::XIndexAccess > xOwnMenu = RetrieveOwnMenu_Impl();
642 uno::Reference< frame::XDispatchProvider > xOwnDisp( m_xFrame, uno::UNO_QUERY_THROW );
643
644 uno::Reference< container::XIndexAccess > xMergedMenu = MergeMenusForInplace( xContMenu, xContDisp, aContModuleName, xOwnMenu, xOwnDisp );
645 uno::Reference< css::frame::XMenuBarMergingAcceptor > xMerge( xOwnLM,
646 uno::UNO_QUERY_THROW );
647 bMenuMerged = xMerge->setMergedMenuBar( xMergedMenu );
648 }
649 catch( const uno::Exception& )
650 {}
651
652 return bMenuMerged;
653}
654
655bool DocumentHolder::ShowUI( const uno::Reference< css::frame::XLayoutManager >& xContainerLM,
656 const uno::Reference< frame::XDispatchProvider >& xContainerDP,
657 const OUString& aContModuleName )
658{
659 bool bResult = false;
660 if ( xContainerLM.is() )
661 {
662 // the LM of the embedded frame and its current DockingAreaAcceptor
663 uno::Reference< css::frame::XLayoutManager > xOwnLM;
664 uno::Reference< css::ui::XDockingAreaAcceptor > xDocAreaAcc;
665
666 try
667 {
668 uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY_THROW );
669 xPropSet->getPropertyValue("LayoutManager") >>= xOwnLM;
670 xDocAreaAcc = xContainerLM->getDockingAreaAcceptor();
671 }
672 catch( const uno::Exception& ){}
673
674 if ( xOwnLM.is() && xDocAreaAcc.is() )
675 {
676 // make sure that lock state of LM is correct even if an exception is thrown in between
677 bool bUnlockContainerLM = false;
678 bool bLockOwnLM = false;
679 try
680 {
681 // take over the control over the containers window
682 // as long as the LM is invisible and locked an empty tool space will be used on resizing
683 xOwnLM->setDockingAreaAcceptor( xDocAreaAcc );
684
685 // try to merge menus; don't do anything else if it fails
686 if ( MergeMenus_Impl( xOwnLM, xContainerLM, xContainerDP, aContModuleName ) )
687 {
688 // make sure that the container LM does not control the size of the containers window anymore
689 // this must be done after merging menus as we won't get the container menu otherwise
690 xContainerLM->setDockingAreaAcceptor( uno::Reference < ui::XDockingAreaAcceptor >() );
691
692 uno::Reference< lang::XServiceInfo> xServiceInfo(m_xComponent, uno::UNO_QUERY);
693 if (!xServiceInfo.is() || !xServiceInfo->supportsService("com.sun.star.chart2.ChartDocument"))
694 {
695 // prevent further changes at this LM
696 xContainerLM->setVisible(false);
697 xContainerLM->lock();
698 bUnlockContainerLM = true;
699 }
700
701 // by unlocking the LM each layout change will now resize the containers window; pending layouts will be processed now
702 xOwnLM->setVisible( true );
703
704 uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
705 if ( xSupp.is() )
706 xSupp->setActiveFrame( m_xFrame );
707
708 xOwnLM->unlock();
709 bLockOwnLM = true;
710 bResult = true;
711
712 // TODO/LATER: The following action should be done only if the window is not hidden
713 // otherwise the activation must fail, unfortunately currently it is not possible
714 // to detect whether the window is hidden using UNO API
715 m_xOwnWindow->setFocus();
716 }
717 }
718 catch( const uno::Exception& )
719 {
720 // activation failed; reestablish old state
721 try
722 {
723 uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
724 if ( xSupp.is() )
725 xSupp->setActiveFrame( nullptr );
726
727 // remove control about containers window from own LM
728 if (bLockOwnLM)
729 xOwnLM->lock();
730 xOwnLM->setVisible( false );
731 xOwnLM->setDockingAreaAcceptor( uno::Reference< css::ui::XDockingAreaAcceptor >() );
732
733 // unmerge menu
734 uno::Reference< css::frame::XMenuBarMergingAcceptor > xMerge( xOwnLM, uno::UNO_QUERY_THROW );
735 xMerge->removeMergedMenuBar();
736 }
737 catch( const uno::Exception& ) {}
738
739 try
740 {
741 // reestablish control of containers window
742 xContainerLM->setDockingAreaAcceptor( xDocAreaAcc );
743 xContainerLM->setVisible( true );
744 if (bUnlockContainerLM)
745 xContainerLM->unlock();
746 }
747 catch( const uno::Exception& ) {}
748 }
749 }
750 }
751
752 return bResult;
753}
754
755
756bool DocumentHolder::HideUI( const uno::Reference< css::frame::XLayoutManager >& xContainerLM )
757{
758 bool bResult = false;
759
760 if ( xContainerLM.is() )
761 {
762 uno::Reference< css::frame::XLayoutManager > xOwnLM;
763
764 try {
765 uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY_THROW );
766 xPropSet->getPropertyValue("LayoutManager") >>= xOwnLM;
767 } catch( const uno::Exception& )
768 {}
769
770 if ( xOwnLM.is() )
771 {
772 try {
773 uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
774 if ( xSupp.is() )
775 xSupp->setActiveFrame( nullptr );
776
777 uno::Reference< css::ui::XDockingAreaAcceptor > xDocAreaAcc = xOwnLM->getDockingAreaAcceptor();
778
779 xOwnLM->setDockingAreaAcceptor( uno::Reference < ui::XDockingAreaAcceptor >() );
780 xOwnLM->lock();
781 xOwnLM->setVisible( false );
782
783 uno::Reference< css::frame::XMenuBarMergingAcceptor > xMerge( xOwnLM, uno::UNO_QUERY_THROW );
784 xMerge->removeMergedMenuBar();
785
786 xContainerLM->setDockingAreaAcceptor( xDocAreaAcc );
787 uno::Reference< lang::XServiceInfo> xServiceInfo(m_xComponent, uno::UNO_QUERY);
788 if (!xServiceInfo.is() || !xServiceInfo->supportsService("com.sun.star.chart2.ChartDocument"))
789 {
790 xContainerLM->setVisible(true);
791 xContainerLM->unlock();
792 }
793
794 xContainerLM->doLayout();
795 bResult = true;
796 }
797 catch( const uno::Exception& )
798 {
799 SetFrameLMVisibility( m_xFrame, true );
800 }
801 }
802 }
803
804 return bResult;
805}
806
807
808uno::Reference< frame::XFrame > const & DocumentHolder::GetDocFrame()
809{
810 // the frame for outplace activation
811 if ( !m_xFrame.is() )
812 {
813 uno::Reference< lang::XSingleServiceFactory > xFrameFact = frame::TaskCreator::create(m_xContext);
814
815 m_xFrame.set(xFrameFact->createInstanceWithArguments( m_aOutplaceFrameProps ), uno::UNO_QUERY_THROW);
816
817 uno::Reference< frame::XDispatchProviderInterception > xInterception( m_xFrame, uno::UNO_QUERY );
818 if ( xInterception.is() )
819 {
820 if ( m_xInterceptor.is() )
821 {
822 m_xInterceptor->DisconnectDocHolder();
823 m_xInterceptor.clear();
824 }
825
826 m_xInterceptor = new Interceptor( this );
827
828 xInterception->registerDispatchProviderInterceptor( m_xInterceptor );
829
830 // register interceptor from outside
831 if ( m_xOutplaceInterceptor.is() )
832 xInterception->registerDispatchProviderInterceptor( m_xOutplaceInterceptor );
833 }
834
835 uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xFrame, uno::UNO_QUERY );
836 if ( xCloseBroadcaster.is() )
837 xCloseBroadcaster->addCloseListener( static_cast<util::XCloseListener*>(this) );
838 }
839
840 if ( m_xComponent.is() )
841 {
842 uno::Reference< css::frame::XLayoutManager > xOwnLM;
843 try {
844 uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY_THROW );
845 xPropSet->getPropertyValue("LayoutManager") >>= xOwnLM;
846 } catch( const uno::Exception& )
847 {}
848
849 if ( xOwnLM.is() )
850 xOwnLM->lock();
851
852 // TODO/LATER: get it for the real aspect
853 awt::Size aSize;
854 LoadDocToFrame(false);
855
856 if ( xOwnLM.is() )
857 {
858 xOwnLM->unlock();
859 xOwnLM->lock();
860 }
861
862 GetExtent(embed::Aspects::MSOLE_CONTENT, &aSize);
863 SetExtent(embed::Aspects::MSOLE_CONTENT, aSize);
864
865 if ( xOwnLM.is() )
866 xOwnLM->unlock();
867 }
868
869 try
870 {
871 uno::Reference< awt::XWindow > xHWindow = m_xFrame->getContainerWindow();
872
873 if( xHWindow.is() )
874 {
875 sal_Int32 nDisplay = Application::GetDisplayBuiltInScreen();
876
877 tools::Rectangle aWorkRect = Application::GetScreenPosSizePixel( nDisplay );
878 awt::Rectangle aWindowRect = xHWindow->getPosSize();
879
880 if (( aWindowRect.Width < aWorkRect.GetWidth()) && ( aWindowRect.Height < aWorkRect.GetHeight() ))
881 {
882 int OffsetX = ( aWorkRect.GetWidth() - aWindowRect.Width ) / 2 + aWorkRect.Left();
883 int OffsetY = ( aWorkRect.GetHeight() - aWindowRect.Height ) /2 + aWorkRect.Top();
884 xHWindow->setPosSize( OffsetX, OffsetY, aWindowRect.Width, aWindowRect.Height, awt::PosSize::POS );
885 }
886 else
887 {
888 xHWindow->setPosSize( aWorkRect.Left(), aWorkRect.Top(), aWorkRect.GetWidth(), aWorkRect.GetHeight(), awt::PosSize::POSSIZE );
889 }
890
891 xHWindow->setVisible( true );
892 }
893 }
894 catch ( const uno::Exception& )
895 {
896 }
897
898 return m_xFrame;
899}
900
901
902void DocumentHolder::SetComponent( const uno::Reference< util::XCloseable >& xDoc, bool bReadOnly )
903{
904 if ( m_xComponent.is() )
905 {
906 // May be should be improved
907 try {
908 CloseDocument( true, false );
909 } catch( const uno::Exception& )
910 {}
911 }
912
913 m_xComponent = xDoc;
914
915 m_bReadOnly = bReadOnly;
916 m_bAllowClosing = false;
917
918 if ( m_xComponent.is() )
919 m_xComponent->addCloseListener( static_cast<util::XCloseListener*>(this) );
920
921 uno::Reference< document::XEventBroadcaster > xEventBroadcaster( m_xComponent, uno::UNO_QUERY );
922 if ( xEventBroadcaster.is() )
923 xEventBroadcaster->addEventListener( static_cast<document::XEventListener*>(this) );
924 else
925 {
926 // the object does not support document::XEventBroadcaster interface
927 // use the workaround, register for modified events
928 uno::Reference< util::XModifyBroadcaster > xModifyBroadcaster( m_xComponent, uno::UNO_QUERY );
929 if ( xModifyBroadcaster.is() )
930 xModifyBroadcaster->addModifyListener( static_cast<util::XModifyListener*>(this) );
931 }
932
933 if ( m_xFrame.is() )
934 LoadDocToFrame(false);
935}
936
937
938bool DocumentHolder::LoadDocToFrame( bool bInPlace )
939{
940 if ( !m_xFrame || !m_xComponent )
941 return true;
942
943 uno::Reference < frame::XModel > xDoc( m_xComponent, uno::UNO_QUERY );
944 if ( xDoc.is() )
945 {
946 // load new document into the frame
947 uno::Reference< frame::XComponentLoader > xComponentLoader( m_xFrame, uno::UNO_QUERY_THROW );
948
949 ::comphelper::NamedValueCollection aArgs;
950 aArgs.put( "Model", m_xComponent );
951 aArgs.put( "ReadOnly", m_bReadOnly );
952
953 // set document title to show in the title bar
954 css::uno::Reference< css::frame::XTitle > xModelTitle( xDoc, css::uno::UNO_QUERY );
955 if( xModelTitle.is() && m_pEmbedObj && !m_pEmbedObj->getContainerName().isEmpty() )
956 {
957 std::locale aResLoc = Translate::Create("sfx");
958 OUString sEmbedded = Translate::get(STR_EMBEDDED_TITLE, aResLoc);
959 xModelTitle->setTitle( m_pEmbedObj->getContainerName() + sEmbedded );
960 m_aContainerName = m_pEmbedObj->getContainerName();
961 // TODO: get real m_aDocumentNamePart
962 m_aDocumentNamePart = sEmbedded;
963 }
964
965 if ( bInPlace )
966 aArgs.put( "PluginMode", sal_Int16(1) );
967 OUString sUrl;
968 uno::Reference< lang::XServiceInfo> xServiceInfo(xDoc,uno::UNO_QUERY);
969 if ( xServiceInfo.is()
970 && xServiceInfo->supportsService("com.sun.star.report.ReportDefinition") )
971 {
972 sUrl = ".component:DB/ReportDesign";
973 }
974 else if( xServiceInfo.is()
975 && xServiceInfo->supportsService("com.sun.star.chart2.ChartDocument"))
976 sUrl = "private:factory/schart";
977 else
978 sUrl = "private:object";
979
980 xComponentLoader->loadComponentFromURL( sUrl,
981 "_self",
982 0,
983 aArgs.getPropertyValues() );
984
985 return true;
986 }
987 else
988 {
989 uno::Reference < frame::XSynchronousFrameLoader > xLoader( m_xComponent, uno::UNO_QUERY );
990 if ( xLoader.is() )
991 return xLoader->load( uno::Sequence < beans::PropertyValue >(), m_xFrame );
992 else
993 return false;
994 }
995
996 return true;
997}
998
999
1000void DocumentHolder::Show()
1001{
1002 if( m_xFrame.is() )
1003 {
1004 m_xFrame->activate();
1005 uno::Reference<awt::XTopWindow> xTopWindow( m_xFrame->getContainerWindow(), uno::UNO_QUERY );
1006 if( xTopWindow.is() )
1007 xTopWindow->toFront();
1008 }
1009 else
1010 GetDocFrame();
1011}
1012
1013
1014bool DocumentHolder::SetExtent( sal_Int64 nAspect, const awt::Size& aSize )
1015{
1016 uno::Reference< embed::XVisualObject > xDocVis( m_xComponent, uno::UNO_QUERY );
1017 if ( xDocVis.is() )
1018 {
1019 try
1020 {
1021 xDocVis->setVisualAreaSize( nAspect, aSize );
1022 return true;
1023 }
1024 catch( const uno::Exception& )
1025 {
1026 // TODO: Error handling
1027 }
1028 }
1029
1030 return false;
1031}
1032
1033
1034bool DocumentHolder::GetExtent( sal_Int64 nAspect, awt::Size *pSize )
1035{
1036 uno::Reference< embed::XVisualObject > xDocVis( m_xComponent, uno::UNO_QUERY );
1037 if ( pSize && xDocVis.is() )
1038 {
1039 try
1040 {
1041 *pSize = xDocVis->getVisualAreaSize( nAspect );
1042 return true;
1043 }
1044 catch( const uno::Exception& )
1045 {
1046 // TODO: Error handling
1047 }
1048 }
1049
1050 return false;
1051}
1052
1053
1054sal_Int32 DocumentHolder::GetMapUnit( sal_Int64 nAspect )
1055{
1056 uno::Reference< embed::XVisualObject > xDocVis( m_xComponent, uno::UNO_QUERY );
1057 if ( xDocVis.is() )
1058 {
1059 try
1060 {
1061 return xDocVis->getMapUnit( nAspect );
1062 }
1063 catch( const uno::Exception& )
1064 {
1065 // TODO: Error handling
1066 }
1067 }
1068
1069 return 0;
1070}
1071
1072
1073awt::Rectangle DocumentHolder::CalculateBorderedArea( const awt::Rectangle& aRect )
1074{
1075 return awt::Rectangle( aRect.X + m_aBorderWidths.Left + HATCH_BORDER_WIDTH,
1076 aRect.Y + m_aBorderWidths.Top + HATCH_BORDER_WIDTH,
1077 aRect.Width - m_aBorderWidths.Left - m_aBorderWidths.Right - 2*HATCH_BORDER_WIDTH,
1078 aRect.Height - m_aBorderWidths.Top - m_aBorderWidths.Bottom - 2*HATCH_BORDER_WIDTH );
1079}
1080
1081
1082awt::Rectangle DocumentHolder::AddBorderToArea( const awt::Rectangle& aRect )
1083{
1084 return awt::Rectangle( aRect.X - m_aBorderWidths.Left - HATCH_BORDER_WIDTH,
1085 aRect.Y - m_aBorderWidths.Top - HATCH_BORDER_WIDTH,
1086 aRect.Width + m_aBorderWidths.Left + m_aBorderWidths.Right + 2*HATCH_BORDER_WIDTH,
1087 aRect.Height + m_aBorderWidths.Top + m_aBorderWidths.Bottom + 2*HATCH_BORDER_WIDTH );
1088}
1089
1090
1091void SAL_CALL DocumentHolder::disposing( const css::lang::EventObject& aSource )
1092{
1093 if ( m_xComponent.is() && m_xComponent == aSource.Source )
1094 {
1095 m_xComponent = nullptr;
1096 if ( m_bWaitForClose )
1097 {
1098 m_bWaitForClose = false;
1099 FreeOffice();
1100 }
1101 }
1102
1103 if( m_xFrame.is() && m_xFrame == aSource.Source )
1104 {
1105 m_xHatchWindow.clear();
1106 m_xOwnWindow.clear();
1107 m_xFrame.clear();
1108 }
1109}
1110
1111
1112void SAL_CALL DocumentHolder::queryClosing( const lang::EventObject& aSource, sal_Bool /*bGetsOwnership*/ )
1113{
1114 if ( m_xComponent.is() && m_xComponent == aSource.Source && !m_bAllowClosing )
1115 throw util::CloseVetoException("To close an embedded document, close the document holder (document definition), not the document itself.", static_cast< ::cppu::OWeakObject*>(this));
1116}
1117
1118
1119void SAL_CALL DocumentHolder::notifyClosing( const lang::EventObject& aSource )
1120{
1121 if ( m_xComponent.is() && m_xComponent == aSource.Source )
1122 {
1123 m_xComponent = nullptr;
1124 if ( m_bWaitForClose )
1125 {
1126 m_bWaitForClose = false;
1127 FreeOffice();
1128 }
1129 }
1130
1131 if( m_xFrame.is() && m_xFrame == aSource.Source )
1132 {
1133 m_xHatchWindow.clear();
1134 m_xOwnWindow.clear();
1135 m_xFrame.clear();
1136 }
1137}
1138
1139
1140void SAL_CALL DocumentHolder::queryTermination( const lang::EventObject& )
1141{
1142 if ( m_bWaitForClose )
1143 throw frame::TerminationVetoException();
1144}
1145
1146
1147void SAL_CALL DocumentHolder::notifyTermination( const lang::EventObject& aSource )
1148{
1149 OSL_ENSURE( !m_xComponent.is(), "Just a disaster..." );
1150
1151 uno::Reference< frame::XDesktop > xDesktop( aSource.Source, uno::UNO_QUERY );
1152 m_bDesktopTerminated = true;
1153 if ( xDesktop.is() )
1154 xDesktop->removeTerminateListener( static_cast<frame::XTerminateListener*>(this) );
1155}
1156
1157
1158void SAL_CALL DocumentHolder::modified( const lang::EventObject& aEvent )
1159{
1160 // if the component does not support document::XEventBroadcaster
1161 // the modify notifications are used as workaround, but only for running state
1162 if( aEvent.Source == m_xComponent && m_pEmbedObj && m_pEmbedObj->getCurrentState() == embed::EmbedStates::RUNNING )
1163 m_pEmbedObj->PostEvent_Impl( "OnVisAreaChanged" );
1164}
1165
1166
1167void SAL_CALL DocumentHolder::notifyEvent( const document::EventObject& Event )
1168{
1169 if( m_pEmbedObj && Event.Source == m_xComponent )
1170 {
1171 // for now the ignored events are not forwarded, but sent by the object itself
1172 if ( !Event.EventName.startsWith( "OnSave" )
1173 && !Event.EventName.startsWith( "OnSaveDone" )
1174 && !Event.EventName.startsWith( "OnSaveAs" )
1175 && !Event.EventName.startsWith( "OnSaveAsDone" )
1176 && !( Event.EventName.startsWith( "OnVisAreaChanged" ) && m_nNoResizeReact ) )
1177 m_pEmbedObj->PostEvent_Impl( Event.EventName );
1178 }
1179}
1180
1181
1182void SAL_CALL DocumentHolder::borderWidthsChanged( const uno::Reference< uno::XInterface >& aObject,
1183 const frame::BorderWidths& aNewSize )
1184{
1185 // TODO: may require mutex introduction ???
1186 if ( m_pEmbedObj && m_xFrame.is() && aObject == m_xFrame->getController() )
1187 {
1188 if ( m_aBorderWidths.Left != aNewSize.Left
1189 || m_aBorderWidths.Right != aNewSize.Right
1190 || m_aBorderWidths.Top != aNewSize.Top
1191 || m_aBorderWidths.Bottom != aNewSize.Bottom )
1192 {
1193 m_aBorderWidths = aNewSize;
1194 if ( !m_nNoBorderResizeReact )
1195 PlaceFrame( m_aObjRect );
1196 }
1197 }
1198}
1199
1200
1201void SAL_CALL DocumentHolder::requestPositioning( const awt::Rectangle& aRect )
1202{
1203 // TODO: may require mutex introduction ???
1204 if ( m_pEmbedObj )
1205 {
1206 // borders should not be counted
1207 awt::Rectangle aObjRect = CalculateBorderedArea( aRect );
1208 IntCounterGuard aGuard( m_nNoResizeReact );
1209 m_pEmbedObj->requestPositioning( aObjRect );
1210 }
1211}
1212
1213
1214awt::Rectangle SAL_CALL DocumentHolder::calcAdjustedRectangle( const awt::Rectangle& aRect )
1215{
1216 // Solar mutex should be locked already since this is a call from HatchWindow with focus
1217 awt::Rectangle aResult( aRect );
1218
1219 if ( m_xFrame.is() )
1220 {
1221 // borders should not be counted
1222 uno::Reference< frame::XControllerBorder > xControllerBorder( m_xFrame->getController(), uno::UNO_QUERY );
1223 if ( xControllerBorder.is() )
1224 {
1225 awt::Rectangle aObjRect = CalculateBorderedArea( aRect );
1226 aObjRect = xControllerBorder->queryBorderedArea( aObjRect );
1227 aResult = AddBorderToArea( aObjRect );
1228 }
1229 }
1230
1231 awt::Rectangle aMinRectangle = AddBorderToArea( awt::Rectangle() );
1232 if ( aResult.Width < aMinRectangle.Width + 2 )
1233 aResult.Width = aMinRectangle.Width + 2;
1234 if ( aResult.Height < aMinRectangle.Height + 2 )
1235 aResult.Height = aMinRectangle.Height + 2;
1236
1237 return aResult;
1238}
1239
1240void SAL_CALL DocumentHolder::activated( )
1241{
1242 if ( !(m_pEmbedObj->getStatus(embed::Aspects::MSOLE_CONTENT)&embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE) )
1243 return;
1244
1245 if ( m_pEmbedObj->getCurrentState() != embed::EmbedStates::UI_ACTIVE &&
1246 !(m_pEmbedObj->getStatus(embed::Aspects::MSOLE_CONTENT)&embed::EmbedMisc::MS_EMBED_NOUIACTIVATE) )
1247 {
1248 try
1249 {
1250 m_pEmbedObj->changeState( embed::EmbedStates::UI_ACTIVE );
1251 }
1252 catch ( const css::embed::StateChangeInProgressException& )
1253 {
1254 // must catch this exception because focus is grabbed while UI activation in doVerb()
1255 }
1256 catch ( const css::uno::Exception& )
1257 {
1258 // no outgoing exceptions specified here
1259 }
1260 }
1261 else
1262 {
1263 uno::Reference< frame::XFramesSupplier > xSupp = m_xFrame->getCreator();
1264 if ( xSupp.is() )
1265 xSupp->setActiveFrame( m_xFrame );
1266 }
1267}
1268
1269void DocumentHolder::ResizeHatchWindow()
1270{
1271 awt::Rectangle aHatchRect = AddBorderToArea( m_aObjRect );
1272 ResizeWindows_Impl( aHatchRect );
1273 uno::Reference< embed::XHatchWindow > xHatchWindow( m_xHatchWindow, uno::UNO_QUERY );
1274 xHatchWindow->setHatchBorderSize( awt::Size( HATCH_BORDER_WIDTH, HATCH_BORDER_WIDTH ) );
1275}
1276
1277void SAL_CALL DocumentHolder::deactivated( )
1278{
1279 // deactivation is too unspecific to be useful; usually we only trigger code from activation
1280 // so UIDeactivation is actively triggered by the container
1281}
1282
1283/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
m_xContext
Reference< XComponentContext > m_xContext
aEvent
AnyEventRef aEvent
Application::GetDisplayBuiltInScreen
static unsigned int GetDisplayBuiltInScreen()
Application::GetScreenPosSizePixel
static tools::Rectangle GetScreenPosSizePixel(unsigned int nScreen)
DocumentHolder::disposing
virtual void SAL_CALL disposing(const css::lang::EventObject &aSource) override
Definition: docholder.cxx:1091
DocumentHolder::notifyTermination
virtual void SAL_CALL notifyTermination(const css::lang::EventObject &aSource) override
DocumentHolder::queryTermination
virtual void SAL_CALL queryTermination(const css::lang::EventObject &aSource) override
DocumentHolder::~DocumentHolder
~DocumentHolder() override
Definition: docholder.cxx:181
DocumentHolder::queryClosing
virtual void SAL_CALL queryClosing(const css::lang::EventObject &aSource, sal_Bool bGetsOwnership) override
DocumentHolder::GetExtent
HRESULT GetExtent(SIZEL *pSize)
DocumentHolder::modified
virtual void SAL_CALL modified(const css::lang::EventObject &aEvent) override
DocumentHolder::m_aContainerName
OUString m_aContainerName
Definition: docholder.hxx:70
DocumentHolder::notifyClosing
virtual void SAL_CALL notifyClosing(const css::lang::EventObject &aSource) override
DocumentHolder::CloseFrame
void CloseFrame()
Definition: docholder.cxx:206
DocumentHolder::FreeOffice
void FreeOffice()
Definition: docholder.cxx:234
DocumentHolder::SetExtent
HRESULT SetExtent(const SIZEL *pSize)
DocumentHolder::CloseDocument
void CloseDocument()
DocumentHolder::m_aDocumentNamePart
OUString m_aDocumentNamePart
Definition: docholder.hxx:71
DocumentHolder::m_xFrame
css::uno::Reference< css::frame::XFrame2 > m_xFrame
DocumentHolder::DocumentHolder
DocumentHolder(const css::uno::Reference< css::lang::XMultiServiceFactory > &xFactory, const ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl > &xOleAccess)
OCommonEmbeddedObject
Represents an OLE object that has native data and we loaded that data into a document model successfu...
Definition: commonembobj.hxx:92
OCommonEmbeddedObject::PostEvent_Impl
void PostEvent_Impl(const OUString &aEventName)
Definition: miscobj.cxx:313
OCommonEmbeddedObject::changeState
virtual void SAL_CALL changeState(sal_Int32 nNewState) override
Definition: embedobj.cxx:476
OCommonEmbeddedObject::getContainerName
OUString const & getContainerName() const
Definition: commonembobj.hxx:281
OCommonEmbeddedObject::requestPositioning
void requestPositioning(const css::awt::Rectangle &aRect)
Definition: miscobj.cxx:289
OCommonEmbeddedObject::getStatus
virtual sal_Int64 SAL_CALL getStatus(sal_Int64 nAspect) override
Definition: embedobj.cxx:684
OCommonEmbeddedObject::getCurrentState
virtual sal_Int32 SAL_CALL getCurrentState() override
Definition: embedobj.cxx:553
comphelper::NamedValueCollection::put
bool put(const OUString &_rValueName, const VALUE_TYPE &_rValue)
comphelper::NamedValueCollection::getPropertyValues
css::uno::Sequence< css::beans::PropertyValue > getPropertyValues() const
tools::Rectangle::GetWidth
constexpr tools::Long GetWidth() const
tools::Rectangle::Top
constexpr tools::Long Top() const
tools::Rectangle::GetHeight
constexpr tools::Long GetHeight() const
tools::Rectangle::Left
constexpr tools::Long Left() const
HATCH_BORDER_WIDTH
#define HATCH_BORDER_WIDTH
Definition: docholder.cxx:72
InsertMenu_Impl
static void InsertMenu_Impl(const uno::Reference< container::XIndexContainer > &xTargetMenu, sal_Int32 nTargetIndex, const uno::Reference< container::XIndexAccess > &xSourceMenu, sal_Int32 nSourceIndex, const OUString &aContModuleName, const uno::Reference< frame::XDispatchProvider > &xSourceDisp)
Definition: docholder.cxx:98
m_rFlag
bool & m_rFlag
bReadOnly
bool bReadOnly
m_bReadOnly
bool m_bReadOnly
Translate::Create
std::locale Create(std::string_view aPrefixName, const LanguageTag &rLocale)
Translate::get
OUString get(TranslateId sContextAndId, const std::locale &loc)
comphelper::getProcessComponentContext
Reference< XComponentContext > getProcessComponentContext()
xModel
Reference< XModel > xModel
aCommand
OUString aCommand
Name
OUString Name
sal_Bool
unsigned char sal_Bool
Generated on Sun Jul 30 2023 04:38:36 for LibreOffice Module embeddedobj (master) by doxygen 1.9.3