backingcomp.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include "backingwindow.hxx"
 
#include <com/sun/star/frame/XDispatchProvider.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/awt/KeyEvent.hpp>
#include <com/sun/star/frame/XLayoutManager.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/awt/XWindow.hpp>
#include <com/sun/star/awt/XKeyListener.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/frame/XFrame.hpp>
#include <com/sun/star/frame/XDispatch.hpp>
#include <com/sun/star/lang/XEventListener.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/lang/XTypeProvider.hpp>
 
#include <cppuhelper/supportsservice.hxx>
#include <cppuhelper/queryinterface.hxx>
#include <cppuhelper/typeprovider.hxx>
#include <cppuhelper/weak.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <vcl/wrkwin.hxx>
#include <vcl/svapp.hxx>
#include <vcl/syswin.hxx>
 
#include <sfx2/notebookbar/SfxNotebookBar.hxx>
 
namespace {
 
class BackingComp : public  css::lang::XTypeProvider
                  , public  css::lang::XServiceInfo
                  , public  css::lang::XInitialization
                  , public  css::frame::XController  // => XComponent
                  , public  css::awt::XKeyListener // => XEventListener
                  , public css::frame::XDispatchProvider
                  , public css::frame::XDispatch
                  , public  ::cppu::OWeakObject
{
private:
    css::uno::Reference< css::awt::XWindow > m_xWindow;
 
    css::uno::Reference< css::frame::XFrame > m_xFrame;
 
    Size m_aInitialWindowMinSize;
 
public:
 
    explicit BackingComp();
 
    // XInterface
    virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
    virtual void          SAL_CALL acquire       (                             ) noexcept override;
    virtual void          SAL_CALL release       (                             ) noexcept override;
 
    // XTypeProvide
    virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes           () override;
    virtual css::uno::Sequence< sal_Int8 >       SAL_CALL getImplementationId() override;
 
    // XServiceInfo
    virtual OUString                       SAL_CALL getImplementationName   (                                     ) override;
    virtual sal_Bool                              SAL_CALL supportsService         ( const OUString& sServiceName ) override;
    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(                                     ) override;
 
    // XInitialization
    virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& lArgs ) override;
 
    // XController
    virtual void SAL_CALL attachFrame( const css::uno::Reference< css::frame::XFrame >& xFrame ) override;
    virtual sal_Bool SAL_CALL attachModel( const css::uno::Reference< css::frame::XModel >& xModel ) override;
    virtual sal_Bool SAL_CALL suspend( sal_Bool bSuspend ) override;
    virtual css::uno::Any SAL_CALL getViewData() override;
    virtual void SAL_CALL restoreViewData( const css::uno::Any& aData ) override;
    virtual css::uno::Reference< css::frame::XModel > SAL_CALL getModel() override;
    virtual css::uno::Reference< css::frame::XFrame > SAL_CALL getFrame() override;
 
    // XKeyListener
    virtual void SAL_CALL keyPressed ( const css::awt::KeyEvent& aEvent ) override;
    virtual void SAL_CALL keyReleased( const css::awt::KeyEvent& aEvent ) override;
 
    // XEventListener
    virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override;
 
    // XComponent
    virtual void SAL_CALL dispose            (                                                                   ) override;
    virtual void SAL_CALL addEventListener   ( const css::uno::Reference< css::lang::XEventListener >& xListener ) override;
    virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener ) override;
 
    // XDispatchProvider
    virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL queryDispatch( const css::util::URL& aURL, const OUString& sTargetFrameName , sal_Int32 nSearchFlags ) override;
    virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& lDescriptions    ) override;
 
    // XDispatch
    virtual void SAL_CALL dispatch( const css::util::URL& aURL, const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override;
    virtual void SAL_CALL addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener, const css::util::URL& aURL ) override;
    virtual void SAL_CALL removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener, const css::util::URL& aURL ) override;
};
 
BackingComp::BackingComp()
{
}
 
css::uno::Any SAL_CALL BackingComp::queryInterface( /*IN*/ const css::uno::Type& aType )
{
    // first look for own supported interfaces
    css::uno::Any aResult = ::cppu::queryInterface(
                aType,
                static_cast< css::lang::XTypeProvider* >(this),
                static_cast< css::lang::XServiceInfo* >(this),
                static_cast< css::lang::XInitialization* >(this),
                static_cast< css::frame::XController* >(this),
                static_cast< css::lang::XComponent* >(this),
                static_cast< css::lang::XEventListener* >(this),
                static_cast< css::awt::XKeyListener* >(static_cast< css::lang::XEventListener* >(this)),
                static_cast< css::frame::XDispatchProvider* >(this),
                static_cast< css::frame::XDispatch* >(this) );
 
    // then look for supported window interfaces
    // Note: They exist only, if this instance was initialized
    // with a valid window reference. It's aggregation on demand ...
    if (!aResult.hasValue())
    {
        /* SAFE { */
        SolarMutexGuard aGuard;
        if (m_xWindow.is())
            aResult = m_xWindow->queryInterface(aType);
        /* } SAFE */
    }
 
    // look for XWeak and XInterface
    if (!aResult.hasValue())
        aResult = OWeakObject::queryInterface(aType);
 
    return aResult;
}
 
 
void SAL_CALL BackingComp::acquire()
    noexcept
{
    OWeakObject::acquire();
}
 
 
void SAL_CALL BackingComp::release()
    noexcept
{
    OWeakObject::release();
}
 
 
css::uno::Sequence< css::uno::Type > SAL_CALL BackingComp::getTypes()
{
    static cppu::OTypeCollection aTypeCollection = [this]() {
        SolarMutexGuard aGuard;
        css::uno::Reference<css::lang::XTypeProvider> xProvider(m_xWindow, css::uno::UNO_QUERY);
 
        css::uno::Sequence<css::uno::Type> lWindowTypes;
        if (xProvider.is())
            lWindowTypes = xProvider->getTypes();
 
        return cppu::OTypeCollection(
            cppu::UnoType<css::lang::XInitialization>::get(),
            cppu::UnoType<css::lang::XTypeProvider>::get(),
            cppu::UnoType<css::lang::XServiceInfo>::get(),
            cppu::UnoType<css::frame::XController>::get(),
            cppu::UnoType<css::lang::XComponent>::get(),
            cppu::UnoType<css::frame::XDispatchProvider>::get(),
            cppu::UnoType<css::frame::XDispatch>::get(), lWindowTypes);
    }();
 
    return aTypeCollection.getTypes();
}
 
 
css::uno::Sequence< sal_Int8 > SAL_CALL BackingComp::getImplementationId()
{
    return css::uno::Sequence<sal_Int8>();
}
 
OUString SAL_CALL BackingComp::getImplementationName()
{
    return "com.sun.star.comp.sfx2.BackingComp";
}
 
sal_Bool SAL_CALL BackingComp::supportsService( /*IN*/ const OUString& sServiceName )
{
    return cppu::supportsService(this, sServiceName);
}
 
css::uno::Sequence< OUString > SAL_CALL BackingComp::getSupportedServiceNames()
{
    return { "com.sun.star.frame.StartModule", "com.sun.star.frame.ProtocolHandler" };
}
 
 
void SAL_CALL BackingComp::attachFrame( /*IN*/ const css::uno::Reference< css::frame::XFrame >& xFrame )
{
    /* SAFE */
    SolarMutexGuard aGuard;
 
    // check some required states
    if (m_xFrame.is())
        throw css::uno::RuntimeException(
                "already attached",
                getXWeak());
 
    if (!xFrame.is())
        throw css::uno::RuntimeException(
                "invalid frame reference",
                getXWeak());
 
    if (!m_xWindow.is())
        return; // disposed
 
    // safe the frame reference
    m_xFrame = xFrame;
 
    // initialize the component and its parent window
    css::uno::Reference< css::awt::XWindow > xParentWindow = xFrame->getContainerWindow();
    VclPtr< WorkWindow > pParent = static_cast<WorkWindow*>(VCLUnoHelper::GetWindow(xParentWindow));
    VclPtr< vcl::Window > pWindow = VCLUnoHelper::GetWindow(m_xWindow);
 
    // disable full screen mode of the frame!
    if (pParent && pParent->IsFullScreenMode())
    {
        pParent->ShowFullScreenMode(false);
        pParent->SetMenuBarMode(MenuBarMode::Normal);
    }
 
    // create the menu bar for the backing component
    css::uno::Reference< css::beans::XPropertySet > xPropSet(m_xFrame, css::uno::UNO_QUERY_THROW);
    css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
    xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager;
    if (xLayoutManager.is())
    {
        xLayoutManager->lock();
        xLayoutManager->createElement("private:resource/menubar/menubar");
        xLayoutManager->unlock();
    }
 
    if (pWindow)
    {
        // set help ID for our canvas
        pWindow->SetHelpId("FWK_HID_BACKINGWINDOW");
    }
 
    // inform BackingWindow about frame
    BackingWindow* pBack = dynamic_cast<BackingWindow*>(pWindow.get());
    if( pBack )
        pBack->setOwningFrame( m_xFrame );
 
    // Set a minimum size for Start Center
    if( !pParent || !pBack )
        return;
 
    tools::Long nMenuHeight = 0;
    vcl::Window* pMenu = pParent->GetWindow(GetWindowType::Next);
    if( pMenu )
        nMenuHeight = pMenu->GetSizePixel().Height();
 
    m_aInitialWindowMinSize = pParent->GetMinOutputSizePixel();
    if (!m_aInitialWindowMinSize.Width())
        m_aInitialWindowMinSize.AdjustWidth(1);
    if (!m_aInitialWindowMinSize.Height())
        m_aInitialWindowMinSize.AdjustHeight(1);
 
    pParent->SetMinOutputSizePixel(
        Size(
            pBack->get_width_request(),
            pBack->get_height_request() + nMenuHeight));
 
    /* } SAFE */
}
 
 
sal_Bool SAL_CALL BackingComp::attachModel( /*IN*/ const css::uno::Reference< css::frame::XModel >& )
{
    return false;
}
 
 
css::uno::Reference< css::frame::XModel > SAL_CALL BackingComp::getModel()
{
    return css::uno::Reference< css::frame::XModel >();
}
 
 
css::uno::Any SAL_CALL BackingComp::getViewData()
{
    return css::uno::Any();
}
 
 
void SAL_CALL BackingComp::restoreViewData( /*IN*/ const css::uno::Any& )
{
}
 
 
css::uno::Reference< css::frame::XFrame > SAL_CALL BackingComp::getFrame()
{
    /* SAFE { */
    SolarMutexGuard aGuard;
    return m_xFrame;
    /* } SAFE */
}
 
 
sal_Bool SAL_CALL BackingComp::suspend( /*IN*/ sal_Bool )
{
    /* FIXME ... implemented by using default :-( */
    return true;
}
 
 
void SAL_CALL BackingComp::disposing( /*IN*/ const css::lang::EventObject& aEvent )
{
    // Attention: don't free m_pAccExec here! see comments inside dtor and
    // keyPressed() for further details.
 
    /* SAFE { */
    SolarMutexGuard aGuard;
 
    if (!aEvent.Source.is() || aEvent.Source!=m_xWindow || !m_xWindow.is())
        throw css::uno::RuntimeException(
                "unexpected source or called twice",
                getXWeak());
 
    m_xWindow.clear();
 
    /* } SAFE */
}
 
 
void SAL_CALL BackingComp::dispose()
{
    /* SAFE { */
    SolarMutexGuard aGuard;
 
    if (m_xFrame.is())
    {
        css::uno::Reference< css::awt::XWindow > xParentWindow = m_xFrame->getContainerWindow();
        VclPtr< WorkWindow > pParent = static_cast<WorkWindow*>(VCLUnoHelper::GetWindow(xParentWindow));
        if (pParent)
        {
            pParent->SetMinOutputSizePixel(m_aInitialWindowMinSize);
            // hide NotebookBar
            sfx2::SfxNotebookBar::CloseMethod(static_cast<SystemWindow*>(pParent));
        }
    }
 
    // stop listening at the window
    if (m_xWindow.is())
    {
        m_xWindow->removeEventListener(this);
        m_xWindow->removeKeyListener(this);
        m_xWindow.clear();
    }
 
    // forget all other used references
    m_xFrame.clear();
 
    /* } SAFE */
}
 
 
void SAL_CALL BackingComp::addEventListener( /*IN*/ const css::uno::Reference< css::lang::XEventListener >& )
{
    throw css::uno::RuntimeException(
            "not supported",
            getXWeak());
}
 
 
void SAL_CALL BackingComp::removeEventListener( /*IN*/ const css::uno::Reference< css::lang::XEventListener >& )
{
}
 
 
void SAL_CALL BackingComp::initialize( /*IN*/ const css::uno::Sequence< css::uno::Any >& lArgs )
{
    /* SAFE { */
    SolarMutexGuard aGuard;
 
    if (m_xWindow.is())
        throw css::uno::Exception(
                "already initialized",
                getXWeak());
 
    css::uno::Reference< css::awt::XWindow > xParentWindow;
    if (
        (lArgs.getLength()!=1         ) ||
        (!(lArgs[0] >>= xParentWindow)) ||
        (!xParentWindow.is()          )
       )
    {
        throw css::uno::Exception(
                "wrong or corrupt argument list",
                getXWeak());
    }
 
    // create the component window
    VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(xParentWindow);
    VclPtr<vcl::Window> pWindow = VclPtr<BackingWindow>::Create(pParent);
    m_xWindow = VCLUnoHelper::GetInterface(pWindow);
 
    if (!m_xWindow.is())
        throw css::uno::RuntimeException(
                "couldn't create component window",
                getXWeak());
 
    // start listening for window disposing
    // It's set at our owner frame as component window later too. So it will may be disposed there ...
    m_xWindow->addEventListener(static_cast< css::lang::XEventListener* >(this));
 
    m_xWindow->setVisible(true);
 
    /* } SAFE */
}
 
 
void SAL_CALL BackingComp::keyPressed( /*IN*/ const css::awt::KeyEvent&  )
{
}
 
 
void SAL_CALL BackingComp::keyReleased( /*IN*/ const css::awt::KeyEvent& )
{
    /* Attention
        Please use keyPressed() instead of this method. Otherwise it would be possible, that
        - a key input may be first switch to the backing mode
        - and this component register itself as key listener too
        - and it's first event will be a keyReleased() for the already well known event, which switched to the backing mode!
        So it will be handled twice! document => backing mode => exit app...
     */
}
 
// XDispatchProvider
css::uno::Reference< css::frame::XDispatch > SAL_CALL BackingComp::queryDispatch( const css::util::URL& aURL, const OUString& /*sTargetFrameName*/, sal_Int32 /*nSearchFlags*/ )
{
    css::uno::Reference< css::frame::XDispatch > xDispatch;
    if ( aURL.Protocol == "vnd.org.libreoffice.recentdocs:" )
        xDispatch = this;
 
    return xDispatch;
}
 
css::uno::Sequence < css::uno::Reference< css::frame::XDispatch > > SAL_CALL BackingComp::queryDispatches( const css::uno::Sequence < css::frame::DispatchDescriptor >& seqDescripts )
{
    sal_Int32 nCount = seqDescripts.getLength();
    css::uno::Sequence < css::uno::Reference < XDispatch > > lDispatcher( nCount );
 
    std::transform(seqDescripts.begin(), seqDescripts.end(), lDispatcher.getArray(),
        [this](const css::frame::DispatchDescriptor& rDesc) -> css::uno::Reference<XDispatch> {
            return queryDispatch(rDesc.FeatureURL, rDesc.FrameName, rDesc.SearchFlags); });
 
    return lDispatcher;
}
 
// XDispatch
void SAL_CALL BackingComp::dispatch( const css::util::URL& aURL, const css::uno::Sequence < css::beans::PropertyValue >& /*lArgs*/ )
{
    // vnd.org.libreoffice.recentdocs:ClearRecentFileList  - clear recent files
    if ( aURL.Path != "ClearRecentFileList" )
        return;
 
    VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(m_xWindow);
    BackingWindow* pBack = dynamic_cast<BackingWindow*>(pWindow.get());
    if( !pBack )
        return;
 
    pBack->clearRecentFileList();
 
    // Recalculate minimum width
    css::uno::Reference< css::awt::XWindow > xParentWindow = m_xFrame->getContainerWindow();
    VclPtr< WorkWindow > pParent = static_cast<WorkWindow*>(VCLUnoHelper::GetWindow(xParentWindow));
    if( pParent )
    {
        pParent->SetMinOutputSizePixel( Size(
                pBack->get_width_request(),
                pParent->GetMinOutputSizePixel().Height()) );
    }
}
 
void SAL_CALL BackingComp::addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& /*xControl*/, const css::util::URL& /*aURL*/ )
{
}
 
void SAL_CALL BackingComp::removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& /*xControl*/, const css::util::URL& /*aURL*/ )
{
}
 
}
 
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
com_sun_star_comp_sfx2_BackingComp_get_implementation(
    css::uno::XComponentContext *,
    css::uno::Sequence<css::uno::Any> const &)
{
    return cppu::acquire(new BackingComp);
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */