unodatbr.hxx

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 .
 */
 
#pragma once
 
#include <memory>
#include "brwctrlr.hxx"
#include <com/sun/star/frame/XStatusListener.hpp>
#include <com/sun/star/frame/XDispatch.hpp>
#include <com/sun/star/i18n/XCollator.hpp>
#include <com/sun/star/view/XSelectionSupplier.hpp>
#include <com/sun/star/awt/XWindow.hpp>
#include <com/sun/star/document/XScriptInvocationContext.hpp>
#include <com/sun/star/ui/XContextMenuInterception.hpp>
#include <com/sun/star/sdb/application/DatabaseObject.hpp>
#include <com/sun/star/sdb/application/DatabaseObjectContainer.hpp>
#include <com/sun/star/sdb/XDatabaseRegistrationsListener.hpp>
#include <comphelper/interfacecontainer2.hxx>
#include <cppuhelper/implbase5.hxx>
#include "callbacks.hxx"
#include <utility>
#include <vcl/transfer.hxx>
#include <svx/dataaccessdescriptor.hxx>
#include "TableCopyHelper.hxx"
#include "commontypes.hxx"
 
class Splitter;
class ODataClipboard;
 
namespace com::sun::star::container { class XNameContainer; }
 
namespace dbaui
{
    struct DBTreeEditedEntry;
    struct DBTreeListUserData;
    class ImageProvider;
 
    typedef ::cppu::ImplHelper5 <   css::frame::XStatusListener
                                ,   css::view::XSelectionSupplier
                                ,   css::document::XScriptInvocationContext
                                ,   css::ui::XContextMenuInterception
                                ,   css::sdb::XDatabaseRegistrationsListener
                                >   SbaTableQueryBrowser_Base;
    class SbaTableQueryBrowser final
                :public SbaXDataBrowserController
                ,public SbaTableQueryBrowser_Base
                ,public IControlActionListener
                ,public IContextMenuProvider
    {
        css::uno::Reference< css::i18n::XCollator >   m_xCollator;
        css::uno::Reference< css::frame::XFrame >     m_xCurrentFrameParent;
        css::uno::Reference< css::awt::XWindow >      m_xMainToolbar;
 
        struct ExternalFeature
        {
            css::util::URL              aURL;
            css::uno::Reference< css::frame::XDispatch >
                                        xDispatcher;
            bool                        bEnabled;
 
            ExternalFeature() : bEnabled( false ) { }
            ExternalFeature( css::util::URL _aURL ) : aURL(std::move( _aURL )), bEnabled( false ) { }
        };
 
        typedef std::map< sal_uInt16, ExternalFeature >  ExternalFeaturesMap;
        ExternalFeaturesMap     m_aExternalFeatures;
 
        svx::ODataAccessDescriptor    m_aDocumentDataSource;
            // if we're part of a document, this is the state of the DocumentDataSource slot
 
        ::comphelper::OInterfaceContainerHelper2   m_aSelectionListeners;
        ::comphelper::OInterfaceContainerHelper2   m_aContextMenuInterceptors;
 
        OTableCopyHelper::DropDescriptor    m_aAsyncDrop;
        OTableCopyHelper                    m_aTableCopyHelper;
 
        OUString         m_sQueryCommand;    // the command of the query currently loaded (if any)
        //OUString         m_sToBeLoaded;      // contains the element name which should be loaded if any
 
        VclPtr<InterimDBTreeListBox> m_pTreeView; // contains the datasources of the registry
        VclPtr<Splitter>        m_pSplitter;
        std::unique_ptr<weld::TreeIter> m_xCurrentlyDisplayed;
        ImplSVEvent *           m_nAsyncDrop;
 
        bool                m_bQueryEscapeProcessing : 1;   // the escape processing flag of the query currently loaded (if any)
        bool                m_bShowMenu;            // if sal_True the menu should be visible otherwise not
        bool                m_bInSuspend;
        bool                m_bEnableBrowser;
        ::std::optional< bool >
                                m_aDocScriptSupport;    // relevant if and only if we are associated with exactly one DBDoc
 
        virtual OUString getPrivateTitle( ) const override;
    // attribute access
    public:
        SbaTableQueryBrowser(const css::uno::Reference< css::uno::XComponentContext >& _rM);
        virtual ~SbaTableQueryBrowser() override;
 
        enum EntryType
        {
            // don't change the above definitions! There are places (in particular SbaTableQueryBrowser::getCurrentSelection)
            // which rely on the fact that the EntryType values really equal the DatabaseObject(Container) values!
            etDatasource     = css::sdb::application::DatabaseObjectContainer::DATA_SOURCE,
            etQueryContainer = css::sdb::application::DatabaseObjectContainer::QUERIES,
            etTableContainer = css::sdb::application::DatabaseObjectContainer::TABLES,
            etQuery          = css::sdb::application::DatabaseObject::QUERY,
            etTableOrView    = css::sdb::application::DatabaseObject::TABLE,
            etUnknown        = -1
        };
 
        static sal_Int32    getDatabaseObjectType( EntryType _eType );
 
        DECLARE_UNO3_DEFAULTS(SbaTableQueryBrowser,SbaXDataBrowserController)
        // late construction
        virtual bool Construct(vcl::Window* pParent) override;
        // XInterface
        virtual css::uno::Any  SAL_CALL queryInterface(const css::uno::Type& _rType) override;
 
        // XTypeProvider
        virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes(  ) override;
        virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId(  ) override;
 
        // css::beans::XPropertyChangeListener
        virtual void SAL_CALL propertyChange(const css::beans::PropertyChangeEvent& evt) override;
 
        // css::frame::XController
        virtual sal_Bool SAL_CALL suspend(sal_Bool bSuspend) override;
        virtual void SAL_CALL attachFrame(const css::uno::Reference< css::frame::XFrame > & xFrame) override;
 
        // css::lang::XComponent
        virtual void        SAL_CALL disposing() override;
 
        // XStatusListener
        virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent& Event ) override;
 
        // XEventListener
        virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
 
        // XSelectionSupplier
        virtual sal_Bool SAL_CALL select( const css::uno::Any& aSelection ) override;
        virtual css::uno::Any SAL_CALL getSelection(  ) override;
        virtual void SAL_CALL addSelectionChangeListener( const css::uno::Reference< css::view::XSelectionChangeListener >& xListener ) override;
        virtual void SAL_CALL removeSelectionChangeListener( const css::uno::Reference< css::view::XSelectionChangeListener >& xListener ) override;
 
        // XServiceInfo
        virtual OUString SAL_CALL getImplementationName() override;
        virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
 
        // XContainerListener
        virtual void SAL_CALL elementInserted( const css::container::ContainerEvent& Event ) override;
        virtual void SAL_CALL elementRemoved( const css::container::ContainerEvent& Event ) override;
        virtual void SAL_CALL elementReplaced( const css::container::ContainerEvent& Event ) override;
        // css::frame::XFrameActionListener
        virtual void SAL_CALL frameAction(const css::frame::FrameActionEvent& aEvent) override;
 
        // XScriptInvocationContext
        virtual css::uno::Reference< css::document::XEmbeddedScripts > SAL_CALL getScriptContainer() override;
 
        // XContextMenuInterception
        virtual void SAL_CALL registerContextMenuInterceptor( const css::uno::Reference< css::ui::XContextMenuInterceptor >& Interceptor ) override;
        virtual void SAL_CALL releaseContextMenuInterceptor( const css::uno::Reference< css::ui::XContextMenuInterceptor >& Interceptor ) override;
 
        // XDatabaseRegistrationsListener
        virtual void SAL_CALL registeredDatabaseLocation( const css::sdb::DatabaseRegistrationEvent& Event ) override;
        virtual void SAL_CALL revokedDatabaseLocation( const css::sdb::DatabaseRegistrationEvent& Event ) override;
        virtual void SAL_CALL changedDatabaseLocation( const css::sdb::DatabaseRegistrationEvent& Event ) override;
 
    private:
        // SbaXDataBrowserController overridable
        virtual bool     InitializeForm( const css::uno::Reference< css::beans::XPropertySet >& i_formProperties ) override;
 
        void             InitializeGridModel(const css::uno::Reference< css::form::XFormComponent > & xGrid);
 
        virtual bool     preReloadForm() override;
        virtual void     postReloadForm() override;
 
        virtual void addModelListeners(const css::uno::Reference< css::awt::XControlModel > & _xGridControlModel) override;
        virtual void removeModelListeners(const css::uno::Reference< css::awt::XControlModel > & _xGridControlModel) override;
 
        virtual void AddColumnListener(const css::uno::Reference< css::beans::XPropertySet > & xCol) override;
        virtual void RemoveColumnListener(const css::uno::Reference< css::beans::XPropertySet > & xCol) override;
 
        virtual void LoadFinished(bool _bWasSynch) override;
 
        virtual void criticalFail() override;
 
        virtual void            describeSupportedFeatures() override;
        virtual FeatureState    GetState(sal_uInt16 nId) const override;
        virtual void            Execute(sal_uInt16 nId, const css::uno::Sequence< css::beans::PropertyValue>& aArgs) override;
 
        // IControlActionListener overridables
        virtual bool        requestQuickHelp(const void* pUserData, OUString& rText) const override;
        virtual bool        requestDrag(const weld::TreeIter& rEntry) override;
        virtual sal_Int8    queryDrop( const AcceptDropEvent& _rEvt, const DataFlavorExVector& _rFlavors ) override;
        virtual sal_Int8    executeDrop( const ExecuteDropEvent& _rEvt ) override;
 
        // IContextMenuProvider
        virtual OUString          getContextMenuResourceName() const override;
        virtual IController&      getCommandController() override;
        virtual ::comphelper::OInterfaceContainerHelper2*
                                  getContextMenuInterceptors() override;
        virtual css::uno::Any     getCurrentSelection(weld::TreeView& rControl) const override;
        virtual vcl::Window* getMenuParent() const override;
        virtual void adjustMenuPosition(const weld::TreeView& rControl, ::Point& rPos) const override;
 
        virtual void impl_initialize() override;
 
        // SbaGridListener overridables
        virtual void RowChanged() override;
        virtual void ColumnChanged() override;
        virtual void SelectionChanged() override;
 
        // methods for showing/hiding the explorer part
        bool        haveExplorer() const;
        void        hideExplorer();
        void        showExplorer();
        void        toggleExplorer() { if (haveExplorer()) hideExplorer(); else showExplorer(); }
 
        // methods for handling the 'selection' (painting them bold) of SvLBoxEntries
        // returns <TRUE/> if the entry is selected (which means it's part of the selected path)
        bool isSelected(const weld::TreeIter& rEntry) const;
        // select the entry (and only the entry, not the whole path)
        void        select(const weld::TreeIter* pEntry, bool bSelect);
        // select the path of the entry (which must be an entry without children)
        void        selectPath(const weld::TreeIter* pEntry, bool bSelect = true);
 
        virtual void loadMenu(const css::uno::Reference< css::frame::XFrame >& _xFrame) override;
 
        // check the state of the external slot given, update any UI elements if necessary
        void implCheckExternalSlot( sal_uInt16 _nId );
 
        // connect to the external dispatchers (if any)
        void connectExternalDispatches();
 
        bool getExternalSlotState( sal_uInt16 _nId ) const;
 
        void implAddDatasource(const OUString& _rDbName, OUString& _rDbImage,
                OUString& _rQueryName, OUString& _rQueryImage,
                OUString& _rTableName, OUString& _rTableImage,
                const SharedConnection& _rxConnection
            );
 
        void    implAddDatasource( const OUString& _rDataSourceName, const SharedConnection& _rxConnection );
 
        void        impl_cleanupDataSourceEntry( std::u16string_view _rDataSourceName );
 
        void clearTreeModel();
 
        void unloadAndCleanup( bool _bDisposeConnection = true );
 
        // disposes the connection associated with the given entry (which must represent a data source)
        void        disposeConnection(const weld::TreeIter* xpDSEntry);
 
        void        impl_releaseConnection( SharedConnection& _rxConnection );
 
        void        closeConnection(const weld::TreeIter& rEntry, bool bDisposeConnection = true);
 
        void        populateTree(const css::uno::Reference< css::container::XNameAccess>& xNameAccess, const weld::TreeIter& rParent, EntryType eEntryType);
        void        initializeTreeModel();
 
        std::unique_ptr<weld::TreeIter> getEntryFromContainer(const css::uno::Reference<css::container::XNameAccess>& rxNameAccess);
 
        // return true when there is connection available
        bool ensureConnection(const weld::TreeIter* pDSEntry, void * pDSData, SharedConnection& rConnection);
        bool ensureConnection(const weld::TreeIter* pAnyEntry, SharedConnection& rConnection);
 
        bool getExistentConnectionFor(const weld::TreeIter* pDSEntry, SharedConnection& rConnection);
        std::unique_ptr<ImageProvider> getImageProviderFor(const weld::TreeIter* pAnyEntry);
 
        void    implAdministrate(const weld::TreeIter& rApplyTo);
 
        bool implCopyObject(ODataClipboard& rExchange, const weld::TreeIter& rApplyTo, sal_Int32 nCommandType);
 
        EntryType getEntryType(const weld::TreeIter& rEntry) const;
        EntryType getChildType(const weld::TreeIter& rEntry) const;
        static bool    isObject( EntryType _eType ) { return ( etTableOrView== _eType ) || ( etQuery == _eType ); }
        static bool    isContainer( EntryType _eType ) { return (etTableContainer == _eType) || (etQueryContainer == _eType); }
        bool isContainer(const weld::TreeIter& rEntry) const { return isContainer(getEntryType(rEntry)); }
 
        // ensure that the xObject for the given entry is set on the user data
        bool          ensureEntryObject(const weld::TreeIter& rEntry);
 
        // get the display text of the entry given
        OUString      GetEntryText(const weld::TreeIter& rEntry) const;
 
        // is called when a table or a query was selected
        DECL_LINK( OnSelectionChange, LinkParamNone*, void );
        DECL_LINK( OnExpandEntry, const weld::TreeIter&, bool );
 
        DECL_LINK( OnCopyEntry, LinkParamNone*, void );
 
        int OnTreeEntryCompare(const weld::TreeIter& rLHS, const weld::TreeIter& rRHS);
 
        DECL_LINK( OnAsyncDrop, void*, void );
 
        void implRemoveStatusListeners();
 
        bool implSelect(const svx::ODataAccessDescriptor& _rDescriptor, bool _bSelectDirect = false);
        bool implSelect(const weld::TreeIter* pEntry);
 
        bool implSelect(
            const OUString& _rDataSourceName,
            const OUString& _rCommand,
            const sal_Int32 _nCommandType,
            const bool _bEscapeProcessing,
            const SharedConnection& _rxConnection,
            bool _bSelectDirect
        );
 
        std::unique_ptr<weld::TreeIter> implGetConnectionEntry(const weld::TreeIter& rEntry) const;
        std::unique_ptr<weld::TreeIter> implAppendEntry(
            const weld::TreeIter* pParent,
            const OUString& rName,
            const DBTreeListUserData* pUserData);
 
        bool implLoadAnything(const OUString& _rDataSourceName, const OUString& _rCommand,
            const sal_Int32 _nCommandType, const bool _bEscapeProcessing, const SharedConnection& _rxConnection );
 
        std::unique_ptr<weld::TreeIter> getObjectEntry(const svx::ODataAccessDescriptor& rDescriptor,
            std::unique_ptr<weld::TreeIter>* ppDataSourceEntry, std::unique_ptr<weld::TreeIter>* ppContainerEntry
        );
        std::unique_ptr<weld::TreeIter> getObjectEntry(
            const OUString& rDataSource, const OUString& rCommand, sal_Int32 nCommandType,
            std::unique_ptr<weld::TreeIter>* ppDataSourceEntry, std::unique_ptr<weld::TreeIter>* ppContainerEntry,
            bool _bExpandAncestors = true,
            const SharedConnection& rxConnection = SharedConnection()
        );
 
        void checkDocumentDataSource();
 
        static void extractDescriptorProps(const svx::ODataAccessDescriptor& _rDescriptor,
            OUString& _rDataSource, OUString& _rCommand, sal_Int32& _rCommandType, bool& _rEscapeProcessing);
 
        void transferChangedControlProperty(const OUString& _rProperty, const css::uno::Any& _rNewValue);
 
        // checks whether the given tree entry denotes a data source
        bool impl_isDataSourceEntry(const weld::TreeIter* pEntry) const;
 
        OUString  getDataSourceAccessor(const weld::TreeIter& rDataSourceEntry) const;
 
        bool implGetQuerySignature( OUString& _rCommand, bool& _bEscapeProcessing );
 
        bool isEntryCopyAllowed(const weld::TreeIter& rEntry) const;
 
        void copyEntry(const weld::TreeIter& rEntry);
 
        // remove all grid columns and dispose them
        static void clearGridColumns(const css::uno::Reference< css::container::XNameContainer >& _xColContainer);
 
        bool isCurrentlyDisplayedChanged(std::u16string_view rName, const weld::TreeIter& rContainer);
 
        void initializePreviewMode();
 
        void    impl_sanitizeRowSetClauses_nothrow();
    };
 
}   // namespace dbaui
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */