LCOV - code coverage report
Current view: top level - framework/source/dispatch - closedispatcher.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 138 216 63.9 %
Date: 2014-11-03 Functions: 14 19 73.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <dispatch/closedispatcher.hxx>
      21             : #include <pattern/frame.hxx>
      22             : #include <framework/framelistanalyzer.hxx>
      23             : #include <services.h>
      24             : #include <general.h>
      25             : 
      26             : #include <com/sun/star/frame/Desktop.hpp>
      27             : #include <com/sun/star/frame/XController.hpp>
      28             : #include <com/sun/star/frame/CommandGroup.hpp>
      29             : #include <com/sun/star/frame/StartModule.hpp>
      30             : #include <com/sun/star/lang/DisposedException.hpp>
      31             : #include <com/sun/star/awt/XTopWindow.hpp>
      32             : #include <com/sun/star/document/XActionLockable.hpp>
      33             : #include <com/sun/star/beans/XFastPropertySet.hpp>
      34             : #include <toolkit/helper/vclunohelper.hxx>
      35             : 
      36             : #include <vcl/window.hxx>
      37             : #include <vcl/svapp.hxx>
      38             : #include <vcl/syswin.hxx>
      39             : #include <osl/mutex.hxx>
      40             : #include <unotools/moduleoptions.hxx>
      41             : #include <comphelper/processfactory.hxx>
      42             : 
      43             : using namespace com::sun::star;
      44             : 
      45             : namespace framework{
      46             : 
      47             : #ifdef fpf
      48             :     #error "Who uses \"fpf\" as define. It will overwrite my namespace alias ..."
      49             : #endif
      50             : namespace fpf = ::framework::pattern::frame;
      51             : 
      52             : const char URL_CLOSEDOC[] = ".uno:CloseDoc";
      53             : const char URL_CLOSEWIN[] = ".uno:CloseWin";
      54             : const char URL_CLOSEFRAME[] = ".uno:CloseFrame";
      55             : 
      56           4 : CloseDispatcher::CloseDispatcher(const css::uno::Reference< css::uno::XComponentContext >& rxContext ,
      57             :                                  const css::uno::Reference< css::frame::XFrame >&          xFrame ,
      58             :                                  const OUString&                                           sTarget)
      59             :     : m_xContext         (rxContext                                       )
      60             :     , m_aAsyncCallback(
      61           4 :         new vcl::EventPoster(LINK(this, CloseDispatcher, impl_asyncCallback)))
      62             :     , m_eOperation(E_CLOSE_DOC)
      63             :     , m_lStatusListener(m_mutex)
      64           8 :     , m_pSysWindow(NULL)
      65             : {
      66           4 :     uno::Reference<frame::XFrame> xTarget = static_impl_searchRightTargetFrame(xFrame, sTarget);
      67           4 :     m_xCloseFrame = xTarget;
      68             : 
      69             :     // Try to retrieve the system window instance of the closing frame.
      70           8 :     uno::Reference<awt::XWindow> xWindow = xTarget->getContainerWindow();
      71           4 :     if (xWindow.is())
      72             :     {
      73           4 :         vcl::Window* pWindow = VCLUnoHelper::GetWindow(xWindow);
      74           4 :         if (pWindow->IsSystemWindow())
      75           4 :             m_pSysWindow = dynamic_cast<SystemWindow*>(pWindow);
      76           4 :     }
      77           4 : }
      78             : 
      79          12 : CloseDispatcher::~CloseDispatcher()
      80             : {
      81           4 :     SolarMutexGuard g;
      82           4 :     m_aAsyncCallback.reset();
      83           8 : }
      84             : 
      85           4 : void SAL_CALL CloseDispatcher::dispatch(const css::util::URL&                                  aURL      ,
      86             :                                         const css::uno::Sequence< css::beans::PropertyValue >& lArguments)
      87             :     throw(css::uno::RuntimeException, std::exception)
      88             : {
      89           4 :     dispatchWithNotification(aURL, lArguments, css::uno::Reference< css::frame::XDispatchResultListener >());
      90           4 : }
      91             : 
      92           0 : css::uno::Sequence< sal_Int16 > SAL_CALL CloseDispatcher::getSupportedCommandGroups()
      93             :     throw(css::uno::RuntimeException, std::exception)
      94             : {
      95           0 :     css::uno::Sequence< sal_Int16 > lGroups(2);
      96           0 :     lGroups[0] = css::frame::CommandGroup::VIEW;
      97           0 :     lGroups[1] = css::frame::CommandGroup::DOCUMENT;
      98           0 :     return lGroups;
      99             : }
     100             : 
     101           0 : css::uno::Sequence< css::frame::DispatchInformation > SAL_CALL CloseDispatcher::getConfigurableDispatchInformation(sal_Int16 nCommandGroup)
     102             :     throw(css::uno::RuntimeException, std::exception)
     103             : {
     104           0 :     if (nCommandGroup == css::frame::CommandGroup::VIEW)
     105             :     {
     106             :         /* Attention: Dont add .uno:CloseFrame here. Because its not really
     107             :                       a configurable feature ... and further it does not have
     108             :                       a valid UIName entry inside the GenericCommands.xcu ... */
     109           0 :         css::uno::Sequence< css::frame::DispatchInformation > lViewInfos(1);
     110           0 :         lViewInfos[0].Command = OUString(URL_CLOSEWIN);
     111           0 :         lViewInfos[0].GroupId = css::frame::CommandGroup::VIEW;
     112           0 :         return lViewInfos;
     113             :     }
     114           0 :     else if (nCommandGroup == css::frame::CommandGroup::DOCUMENT)
     115             :     {
     116           0 :         css::uno::Sequence< css::frame::DispatchInformation > lDocInfos(1);
     117           0 :         lDocInfos[0].Command = OUString(URL_CLOSEDOC);
     118           0 :         lDocInfos[0].GroupId = css::frame::CommandGroup::DOCUMENT;
     119           0 :         return lDocInfos;
     120             :     }
     121             : 
     122           0 :     return css::uno::Sequence< css::frame::DispatchInformation >();
     123             : }
     124             : 
     125           0 : void SAL_CALL CloseDispatcher::addStatusListener(const css::uno::Reference< css::frame::XStatusListener >& /*xListener*/,
     126             :                                                  const css::util::URL&                                     /*aURL*/     )
     127             :     throw(css::uno::RuntimeException, std::exception)
     128             : {
     129           0 : }
     130             : 
     131           0 : void SAL_CALL CloseDispatcher::removeStatusListener(const css::uno::Reference< css::frame::XStatusListener >& /*xListener*/,
     132             :                                                     const css::util::URL&                                     /*aURL*/     )
     133             :     throw(css::uno::RuntimeException, std::exception)
     134             : {
     135           0 : }
     136             : 
     137           4 : void SAL_CALL CloseDispatcher::dispatchWithNotification(const css::util::URL&                                             aURL      ,
     138             :                                                         const css::uno::Sequence< css::beans::PropertyValue >&            lArguments,
     139             :                                                         const css::uno::Reference< css::frame::XDispatchResultListener >& xListener )
     140             :     throw(css::uno::RuntimeException, std::exception)
     141             : {
     142             :     // SAFE -> ----------------------------------
     143           4 :     SolarMutexClearableGuard aWriteLock;
     144             : 
     145             :     // This reference indicates, that we was already called before and
     146             :     // our asynchronous process was not finished yet.
     147             :     // We have to reject double calls. Otherwhise we risk,
     148             :     // that we try to close an already closed resource ...
     149             :     // And its no problem to do nothing then. The UI user will try it again, if
     150             :     // non of these jobs was successfully.
     151           4 :     if (m_xSelfHold.is())
     152             :     {
     153           0 :         aWriteLock.clear();
     154             :         // <- SAFE ------------------------------
     155             : 
     156             :         implts_notifyResultListener(
     157             :             xListener,
     158             :             css::frame::DispatchResultState::DONTKNOW,
     159           0 :             css::uno::Any());
     160           0 :         return;
     161             :     }
     162             : 
     163             :     // First we have to check, if this dispatcher is used right. Means if valid URLs are used.
     164             :     // If not - we have to break this operation. But an optional listener must be informed.
     165             :     // BTW: We save the information about the requested operation. Because
     166             :     // we need it later.
     167           4 :     if ( aURL.Complete == URL_CLOSEDOC )
     168           2 :         m_eOperation = E_CLOSE_DOC;
     169           2 :     else if ( aURL.Complete == URL_CLOSEWIN )
     170           2 :         m_eOperation = E_CLOSE_WIN;
     171           0 :     else if ( aURL.Complete == URL_CLOSEFRAME )
     172           0 :         m_eOperation = E_CLOSE_FRAME;
     173             :     else
     174             :     {
     175           0 :         aWriteLock.clear();
     176             :         // <- SAFE ------------------------------
     177             : 
     178             :         implts_notifyResultListener(
     179             :             xListener,
     180             :             css::frame::DispatchResultState::FAILURE,
     181           0 :             css::uno::Any());
     182           0 :         return;
     183             :     }
     184             : 
     185           4 :     if (m_pSysWindow && m_pSysWindow->GetCloseHdl().IsSet())
     186             :     {
     187             :         // The closing frame has its own close handler.  Call it instead.
     188           0 :         m_pSysWindow->GetCloseHdl().Call(m_pSysWindow);
     189           0 :         return;
     190             :     }
     191             : 
     192             :     // OK - URLs are the right ones.
     193             :     // But we can't execute synchronously :-)
     194             :     // May we are called from a generic key-input handler,
     195             :     // which isn't aware that this call kill its own environment ...
     196             :     // Do it asynchronous everytimes!
     197             : 
     198             :     // But dont forget to hold usself alive.
     199             :     // We are called back from an environment, which doesn't know an uno reference.
     200             :     // They call us back by using our c++ interface.
     201             : 
     202           4 :     m_xResultListener = xListener;
     203           4 :     m_xSelfHold       = css::uno::Reference< css::uno::XInterface >(static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY);
     204             : 
     205           4 :     aWriteLock.clear();
     206             :     // <- SAFE ----------------------------------
     207             : 
     208           4 :     bool bIsSynchron = false;
     209           4 :     for (sal_Int32 nArgs=0; nArgs<lArguments.getLength(); nArgs++ )
     210             :     {
     211           0 :         if ( lArguments[nArgs].Name == "SynchronMode" )
     212             :         {
     213           0 :             lArguments[nArgs].Value >>= bIsSynchron;
     214           0 :             break;
     215             :         }
     216             :     }
     217             : 
     218           4 :     if ( bIsSynchron )
     219           0 :         impl_asyncCallback(0);
     220             :     else
     221             :     {
     222           4 :         SolarMutexGuard g;
     223           4 :         m_aAsyncCallback->Post(0);
     224           4 :     }
     225             : }
     226             : 
     227             : /**
     228             :     @short      asynchronous callback
     229             :     @descr      We start all actions inside this object asnychronoue.
     230             :                 (see comments there).
     231             :                 Now we do the following:
     232             :                 - close all views to the same document, if needed and possible
     233             :                 - make the current frame empty
     234             :                   ! This step is necessary to handle errors during closing the
     235             :                     document inside the frame. May the document shows a dialog and
     236             :                     the user ignore it. Then the state of the office can be changed
     237             :                     during we try to close frame and document.
     238             :                 - check the environment (menas count open frames - exlcuding our
     239             :                   current one)
     240             :                 - decide then, if we must close this frame only, establish the backing mode
     241             :                   or shutdown the whole application.
     242             : */
     243           8 : IMPL_LINK_NOARG(CloseDispatcher, impl_asyncCallback)
     244             : {
     245             :     try
     246             :     {
     247             : 
     248             :     // Allow calling of XController->suspend() everytimes.
     249             :     // Dispatch is an UI functionality. We implement such dispatch object here.
     250             :     // And further XController->suspend() was designed to bring an UI ...
     251           4 :     bool bAllowSuspend        = true;
     252           4 :     bool bControllerSuspended = false;
     253             : 
     254             :     bool bCloseAllViewsToo;
     255             :     EOperation                                                  eOperation;
     256           4 :     css::uno::Reference< css::uno::XComponentContext >          xContext;
     257           8 :     css::uno::Reference< css::frame::XFrame >                   xCloseFrame;
     258           8 :     css::uno::Reference< css::frame::XDispatchResultListener >  xListener;
     259             :     {
     260           4 :         SolarMutexGuard g;
     261             : 
     262             :         // Closing of all views, related to the same document, is allowed
     263             :         // only if the dispatched URL was ".uno:CloseDoc"!
     264           4 :         bCloseAllViewsToo = (m_eOperation == E_CLOSE_DOC);
     265             : 
     266           4 :         eOperation  = m_eOperation;
     267           4 :         xContext    = m_xContext;
     268           4 :         xCloseFrame.set(m_xCloseFrame.get(), css::uno::UNO_QUERY);
     269           4 :         xListener   = m_xResultListener;
     270             :     }
     271             : 
     272             :     // frame already dead ?!
     273             :     // Nothing to do !
     274           4 :     if (! xCloseFrame.is())
     275           0 :         return 0;
     276             : 
     277           4 :     bool bCloseFrame           = false;
     278           4 :     bool bEstablishBackingMode = false;
     279           4 :     bool bTerminateApp         = false;
     280             : 
     281             :     // Analyze the environment a first time.
     282             :     // If we found some special cases, we can
     283             :     // make some decisions erliar!
     284           8 :     css::uno::Reference< css::frame::XFramesSupplier > xDesktop( css::frame::Desktop::create(xContext), css::uno::UNO_QUERY_THROW);
     285           8 :     FrameListAnalyzer aCheck1(xDesktop, xCloseFrame, FrameListAnalyzer::E_HELP | FrameListAnalyzer::E_BACKINGCOMPONENT);
     286             : 
     287             :     // a) If the curent frame (where the close dispatch was requested for) does not have
     288             :     //    any parent frame ... it will close this frame only. Such frame isn't part of the
     289             :     //    global desktop tree ... and such frames are used as "implementation details" only.
     290             :     //    E.g. the live previews of our wizards doing such things. And then the owner of the frame
     291             :     //    is responsible for closing the application or accepting closing of the application
     292             :     //    by others.
     293           4 :     if ( ! xCloseFrame->getCreator().is())
     294           0 :         bCloseFrame = true;
     295             : 
     296             :     // b) The help window can't disagree with any request.
     297             :     //    Because it doesn't implement a controller - it uses a window only.
     298             :     //    Further t can't be the last open frame - if we do all other things
     299             :     //    right inside this CloseDispatcher implementation.
     300             :     //    => close it!
     301           4 :     else if (aCheck1.m_bReferenceIsHelp)
     302           0 :         bCloseFrame = true;
     303             : 
     304             :     // c) If we are already in "backing mode", we have to terminate
     305             :     //    the application, if this special frame is closed.
     306             :     //    It doesn't matter, how many other frames (can be the help or hidden frames only)
     307             :     //    are open then.
     308             :     //    => terminate the application!
     309           4 :     else if (aCheck1.m_bReferenceIsBacking)
     310           0 :         bTerminateApp = true;
     311             : 
     312             :     // d) Otherwhise we have to: close all views to the same document, close the
     313             :     //    document inside our own frame and decide then again, what has to be done!
     314             :     else
     315             :     {
     316           4 :         if (implts_prepareFrameForClosing(m_xCloseFrame, bAllowSuspend, bCloseAllViewsToo, bControllerSuspended))
     317             :         {
     318             :             // OK; this frame is empty now.
     319             :             // Check the environment again to decide, what is the next step.
     320           4 :             FrameListAnalyzer aCheck2(xDesktop, xCloseFrame, FrameListAnalyzer::E_ALL);
     321             : 
     322             :             // c1) there is as minimum 1 frame open, which is visible and contains a document
     323             :             //     different from our one. And its not the help!
     324             :             //     => close our frame only - nothing else.
     325           4 :             if (aCheck2.m_lOtherVisibleFrames.getLength()>0)
     326           2 :                 bCloseFrame = true;
     327             :             else
     328             : 
     329             :             // c2) if we close the current view ... but not all other views
     330             :             //     to the same document, we must close the current frame only!
     331             :             //     Because implts_closeView() suspended this view only - does not
     332             :             //     close the frame.
     333           2 :             if (
     334           4 :                 (!bCloseAllViewsToo                    ) &&
     335           2 :                 (aCheck2.m_lModelFrames.getLength() > 0)
     336             :                )
     337           0 :                 bCloseFrame = true;
     338             : 
     339             :             else
     340             :             // c3) there is no other (visible) frame open ...
     341             :             //     The help module will be ignored everytimes!
     342             :             //     But we have to decide if we must terminate the
     343             :             //     application or establish the backing mode now.
     344             :             //     And that depends from the dispatched URL ...
     345             :             {
     346           2 :                 if (eOperation == E_CLOSE_FRAME)
     347           0 :                     bTerminateApp = true;
     348           2 :                 else if( SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::E_SSTARTMODULE) )
     349           2 :                     bEstablishBackingMode = true;
     350             :                 else
     351           0 :                     bTerminateApp = true;
     352           4 :             }
     353             :         }
     354             :     }
     355             : 
     356             :     // Do it now ...
     357           4 :     bool bSuccess = false;
     358           4 :     if (bCloseFrame)
     359           2 :         bSuccess = implts_closeFrame();
     360           2 :     else if (bEstablishBackingMode)
     361             :     #if defined MACOSX
     362             :     {
     363             :         // on mac close down, quickstarter keeps the process alive
     364             :         // however if someone has shut down the quickstarter
     365             :         // behave as any other platform
     366             : 
     367             :         bool bQuickstarterRunning = false;
     368             :         // get quickstart service
     369             :         try
     370             :         {
     371             :             css::uno::Reference< css::beans::XFastPropertySet > xSet( xContext->getServiceManager()->createInstanceWithContext(IMPLEMENTATIONNAME_QUICKLAUNCHER, xContext), css::uno::UNO_QUERY_THROW );
     372             :             if( xSet.is() )
     373             :             {
     374             :                 css::uno::Any aVal( xSet->getFastPropertyValue( 0 ) );
     375             :                 sal_Bool bState = sal_False;
     376             :                 if( aVal >>= bState )
     377             :                     bQuickstarterRunning = bState;
     378             :             }
     379             :         }
     380             :         catch( const css::uno::Exception& )
     381             :         {
     382             :         }
     383             :         bSuccess = bQuickstarterRunning ? implts_terminateApplication() : implts_establishBackingMode();
     384             :     }
     385             :     #else
     386           2 :         bSuccess = implts_establishBackingMode();
     387             :     #endif
     388           0 :     else if (bTerminateApp)
     389           0 :         bSuccess = implts_terminateApplication();
     390             : 
     391           4 :     if (
     392           4 :         ( ! bSuccess             ) &&
     393             :         (   bControllerSuspended )
     394             :        )
     395             :     {
     396           0 :         css::uno::Reference< css::frame::XController > xController = xCloseFrame->getController();
     397           0 :         if (xController.is())
     398           0 :             xController->suspend(sal_False);
     399             :     }
     400             : 
     401             :     // inform listener
     402           4 :     sal_Int16 nState = css::frame::DispatchResultState::FAILURE;
     403           4 :     if (bSuccess)
     404           4 :         nState = css::frame::DispatchResultState::SUCCESS;
     405           4 :     implts_notifyResultListener(xListener, nState, css::uno::Any());
     406             : 
     407           8 :     SolarMutexGuard g;
     408             :     // This method was called asynchronous from our main thread by using a pointer.
     409             :     // We reached this method only, by using a reference to ourself :-)
     410             :     // Further this member is used to detect still running and not yet finished
     411             :     // ansynchronous operations. So its time now to release this reference.
     412             :     // But hold it temp alive. Otherwise we die before we can finish this method really :-))
     413           8 :     css::uno::Reference< css::uno::XInterface > xTempHold = m_xSelfHold;
     414           4 :     m_xSelfHold.clear();
     415           8 :     m_xResultListener.clear();
     416             :     }
     417           0 :     catch(const css::lang::DisposedException&)
     418             :     {
     419             :     }
     420             : 
     421           4 :     return 0;
     422             : }
     423             : 
     424           4 : bool CloseDispatcher::implts_prepareFrameForClosing(const css::uno::Reference< css::frame::XFrame >& xFrame                ,
     425             :                                                           bool                                   bAllowSuspend         ,
     426             :                                                           bool                                   bCloseAllOtherViewsToo,
     427             :                                                           bool&                                  bControllerSuspended  )
     428             : {
     429             :     // Frame already dead ... so this view is closed ... is closed ... is ... .-)
     430           4 :     if (! xFrame.is())
     431           0 :         return true;
     432             : 
     433             :     // Close all views to the same document ... if forced to do so.
     434             :     // But dont touch our own frame here!
     435             :     // We must do so ... because the may be following controller->suspend()
     436             :     // will show the "save/discard/cancel" dialog for the last view only!
     437           4 :     if (bCloseAllOtherViewsToo)
     438             :     {
     439           2 :         css::uno::Reference< css::uno::XComponentContext > xContext;
     440             :         {
     441           2 :             SolarMutexGuard g;
     442           2 :             xContext = m_xContext;
     443             :         }
     444             : 
     445           4 :         css::uno::Reference< css::frame::XFramesSupplier > xDesktop( css::frame::Desktop::create( xContext ), css::uno::UNO_QUERY_THROW);
     446           4 :         FrameListAnalyzer aCheck(xDesktop, xFrame, FrameListAnalyzer::E_ALL);
     447             : 
     448           2 :         sal_Int32 c = aCheck.m_lModelFrames.getLength();
     449           2 :         sal_Int32 i = 0;
     450           2 :         for (i=0; i<c; ++i)
     451             :         {
     452           0 :             if (!fpf::closeIt(aCheck.m_lModelFrames[i], false))
     453           0 :                 return false;
     454           2 :         }
     455             :     }
     456             : 
     457             :     // If allowed - inform user about modified documents or
     458             :     // still running jobs (e.g. printing).
     459           4 :     if (bAllowSuspend)
     460             :     {
     461           4 :         css::uno::Reference< css::frame::XController > xController = xFrame->getController();
     462           4 :         if (xController.is()) // some views dont uses a controller .-( (e.g. the help window)
     463             :         {
     464           4 :             bControllerSuspended = xController->suspend(sal_True);
     465           4 :             if (! bControllerSuspended)
     466           0 :                 return false;
     467           4 :         }
     468             :     }
     469             : 
     470             :     // dont remove the component really by e.g. calling setComponent(null, null).
     471             :     // It's enough to suspend the controller.
     472             :     // If we close the frame later this controller doesn't show the same dialog again.
     473           4 :     return true;
     474             : }
     475             : 
     476           2 : bool CloseDispatcher::implts_closeFrame()
     477             : {
     478           2 :     css::uno::Reference< css::frame::XFrame > xFrame;
     479             :     {
     480           2 :         SolarMutexGuard g;
     481           2 :         xFrame.set(m_xCloseFrame.get(), css::uno::UNO_QUERY);
     482             :     }
     483             : 
     484             :     // frame already dead ? => so it's closed ... it's closed ...
     485           2 :     if ( ! xFrame.is() )
     486           0 :         return true;
     487             : 
     488             :     // dont deliver owner ship; our "UI user" will try it again if it failed.
     489             :     // OK - he will get an empty frame then. But normally an empty frame
     490             :     // should be closeable always :-)
     491           2 :     if (!fpf::closeIt(xFrame, false))
     492           0 :         return false;
     493             : 
     494             :     {
     495           2 :         SolarMutexGuard g;
     496           2 :         m_xCloseFrame = css::uno::WeakReference< css::frame::XFrame >();
     497             :     }
     498             : 
     499           2 :     return true;
     500             : }
     501             : 
     502           2 : bool CloseDispatcher::implts_establishBackingMode()
     503             : {
     504           2 :     css::uno::Reference< css::uno::XComponentContext > xContext;
     505           4 :     css::uno::Reference< css::frame::XFrame >          xFrame;
     506             :     {
     507           2 :         SolarMutexGuard g;
     508           2 :         xContext  = m_xContext;
     509           2 :         xFrame.set(m_xCloseFrame.get(), css::uno::UNO_QUERY);
     510             :     }
     511             : 
     512           2 :     if (!xFrame.is())
     513           0 :         return false;
     514             : 
     515           4 :     css::uno::Reference < css::document::XActionLockable > xLock( xFrame, css::uno::UNO_QUERY );
     516           2 :     if ( xLock.is() && xLock->isActionLocked() )
     517           0 :         return false;
     518             : 
     519           4 :     css::uno::Reference< css::awt::XWindow > xContainerWindow = xFrame->getContainerWindow();
     520             : 
     521             :     css::uno::Reference< css::frame::XController > xStartModule = css::frame::StartModule::createWithParentWindow(
     522           4 :                         xContext, xContainerWindow);
     523             : 
     524             :     // Attention: You MUST(!) call setComponent() before you call attachFrame().
     525           4 :     css::uno::Reference< css::awt::XWindow > xBackingWin(xStartModule, css::uno::UNO_QUERY);
     526           2 :     xFrame->setComponent(xBackingWin, xStartModule);
     527           2 :     xStartModule->attachFrame(xFrame);
     528           2 :     xContainerWindow->setVisible(sal_True);
     529             : 
     530           4 :     return true;
     531             : }
     532             : 
     533           0 : bool CloseDispatcher::implts_terminateApplication()
     534             : {
     535           0 :     css::uno::Reference< css::uno::XComponentContext > xContext;
     536             :     {
     537           0 :         SolarMutexGuard g;
     538           0 :         xContext = m_xContext;
     539             :     }
     540             : 
     541           0 :     css::uno::Reference< css::frame::XDesktop2 > xDesktop = css::frame::Desktop::create( xContext );
     542             : 
     543           0 :     return xDesktop->terminate();
     544             : }
     545             : 
     546           4 : void CloseDispatcher::implts_notifyResultListener(const css::uno::Reference< css::frame::XDispatchResultListener >& xListener,
     547             :                                                         sal_Int16                                                   nState   ,
     548             :                                                   const css::uno::Any&                                              aResult  )
     549             : {
     550           4 :     if (!xListener.is())
     551           8 :         return;
     552             : 
     553             :     css::frame::DispatchResultEvent aEvent(
     554             :         css::uno::Reference< css::uno::XInterface >(static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY),
     555             :         nState,
     556           0 :         aResult);
     557             : 
     558           0 :     xListener->dispatchFinished(aEvent);
     559             : }
     560             : 
     561           4 : css::uno::Reference< css::frame::XFrame > CloseDispatcher::static_impl_searchRightTargetFrame(const css::uno::Reference< css::frame::XFrame >& xFrame ,
     562             :                                                                                               const OUString&                           sTarget)
     563             : {
     564           4 :     if (sTarget.equalsIgnoreAsciiCase("_self"))
     565           0 :         return xFrame;
     566             : 
     567             :     OSL_ENSURE(sTarget.isEmpty(), "CloseDispatch used for unexpected target. Magic things will happen now .-)");
     568             : 
     569           4 :     css::uno::Reference< css::frame::XFrame > xTarget = xFrame;
     570             :     while(true)
     571             :     {
     572             :         // a) top frames wil be closed
     573           4 :         if (xTarget->isTop())
     574           8 :             return xTarget;
     575             : 
     576             :         // b) even child frame containing top level windows (e.g. query designer of database) will be closed
     577           0 :         css::uno::Reference< css::awt::XWindow >    xWindow        = xTarget->getContainerWindow();
     578           0 :         css::uno::Reference< css::awt::XTopWindow > xTopWindowCheck(xWindow, css::uno::UNO_QUERY);
     579           0 :         if (xTopWindowCheck.is())
     580             :         {
     581             :             // b1) Note: Toolkit interface XTopWindow sometimes is used by real VCL-child-windows also .-)
     582             :             //     Be sure that these window is really a "top system window".
     583             :             //     Attention ! Checking Window->GetParent() isn't the right approach here.
     584             :             //     Because sometimes VCL create "implicit border windows" as parents even we created
     585             :             //     a simple XWindow using the toolkit only .-(
     586           0 :             SolarMutexGuard aSolarLock;
     587           0 :             vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
     588           0 :             if (
     589           0 :                 (pWindow                  ) &&
     590           0 :                 (pWindow->IsSystemWindow())
     591             :                )
     592           0 :                 return xTarget;
     593             :         }
     594             : 
     595             :         // c) try to find better results on parent frame
     596             :         //    If no parent frame exists (because this frame is used outside the desktop tree)
     597             :         //    the given frame must be used directly.
     598           0 :         css::uno::Reference< css::frame::XFrame > xParent(xTarget->getCreator(), css::uno::UNO_QUERY);
     599           0 :         if ( ! xParent.is())
     600           0 :             return xTarget;
     601             : 
     602             :         // c1) check parent frame inside next loop ...
     603           0 :         xTarget = xParent;
     604           4 :     }
     605             : }
     606             : 
     607         951 : } // namespace framework
     608             : 
     609             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10