xref: /aoo41x/main/dbaccess/source/ui/app/AppControllerDnD.cxx (revision 96de5490)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_dbaccess.hxx"

#ifndef DBAUI_APPCONTROLLER_HXX
#include "AppController.hxx"
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _COMPHELPER_PROPERTY_HXX_
#include <comphelper/property.hxx>
#endif
#ifndef DBACCESS_SHARED_DBUSTRINGS_HRC
#include "dbustrings.hrc"
#endif
#ifndef _COM_SUN_STAR_SDBCX_XDATADESCRIPTORFACTORY_HPP_
#include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XAPPEND_HPP_
#include <com/sun/star/sdbcx/XAppend.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_XSINGLESELECTQUERYCOMPOSER_HPP_
#include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_
#include <com/sun/star/container/XNameContainer.hpp>
#endif
#ifndef _COM_SUN_STAR_UNO_XNAMINGSERVICE_HPP_
#include <com/sun/star/uno/XNamingService.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_XDATASOURCE_HPP_
#include <com/sun/star/sdbc/XDataSource.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XSTORABLE_HPP_
#include <com/sun/star/frame/XStorable.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XCHILD_HPP_
#include <com/sun/star/container/XChild.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XHIERARCHICALNAMECONTAINER_HPP_
#include <com/sun/star/container/XHierarchicalNameContainer.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_
#include <com/sun/star/sdbc/DataType.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_COMMANDTYPE_HPP_
#include <com/sun/star/sdb/CommandType.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_XBOOKMARKSSUPPLIER_HPP_
#include <com/sun/star/sdb/XBookmarksSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_SQLCONTEXT_HPP_
#include <com/sun/star/sdb/SQLContext.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_
#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XVIEWSSUPPLIER_HPP_
#include <com/sun/star/sdbcx/XViewsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_XQUERYDEFINITIONSSUPPLIER_HPP_
#include <com/sun/star/sdb/XQueryDefinitionsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XDROP_HPP_
#include <com/sun/star/sdbcx/XDrop.hpp>
#endif
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef _URLOBJ_HXX
#include <tools/urlobj.hxx>
#endif
#ifndef _UNOTOOLS_UCBHELPER_HXX
#include <unotools/ucbhelper.hxx>
#endif
#ifndef DBAUI_DLGSAVE_HXX
#include "dlgsave.hxx"
#endif
#ifndef _COMPHELPER_TYPES_HXX_
#include <comphelper/types.hxx>
#endif
#ifndef _SV_MSGBOX_HXX
#include <vcl/msgbox.hxx>
#endif
#ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
#include <cppuhelper/typeprovider.hxx>
#endif
#ifndef _CPPUHELPER_EXC_HLP_HXX_
#include <cppuhelper/exc_hlp.hxx>
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
#ifndef _SV_WAITOBJ_HXX
#include <vcl/waitobj.hxx>
#endif
#ifndef _RTL_USTRBUF_HXX_
#include <rtl/ustrbuf.hxx>
#endif
#ifndef DBAUI_APPVIEW_HXX
#include "AppView.hxx"
#endif
#ifndef _SVX_DATACCESSDESCRIPTOR_HXX_
#include <svx/dataaccessdescriptor.hxx>
#endif
#ifndef SVX_DBAOBJECTEX_HXX
#include <svx/dbaobjectex.hxx>
#endif
#ifndef DBACCESS_UI_BROWSER_ID_HXX
#include "browserids.hxx"
#endif
#ifndef _DBAU_REGHELPER_HXX_
#include "dbu_reghelper.hxx"
#endif
#ifndef _DBU_APP_HRC_
#include "dbu_app.hrc"
#endif
#ifndef _SV_MENU_HXX
#include <vcl/menu.hxx>
#endif
#ifndef _COMPHELPER_UNO3_HXX_
#include <comphelper/uno3.hxx>
#endif
#ifndef _SV_SVAPP_HXX //autogen
#include <vcl/svapp.hxx>
#endif
#ifndef _SVLBOXITM_HXX
#include <svtools/svlbitm.hxx>
#endif
#ifndef _DBAUI_LISTVIEWITEMS_HXX_
#include "listviewitems.hxx"
#endif
#ifndef DBAUI_APPDETAILVIEW_HXX
#include "AppDetailView.hxx"
#endif
#ifndef _DBAUI_LINKEDDOCUMENTS_HXX_
#include "linkeddocuments.hxx"
#endif
#ifndef _SV_LSTBOX_HXX
#include <vcl/lstbox.hxx>
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
#ifndef _CONNECTIVITY_DBTOOLS_HXX_
#include <connectivity/dbtools.hxx>
#endif
#ifndef _DBAUI_SQLMESSAGE_HXX_
#include "sqlmessage.hxx"
#endif
#ifndef _STRING_HXX
#include <tools/string.hxx>
#endif
#ifndef DBAUI_DBEXCHANGE_HXX
#include "dbexchange.hxx"
#endif
#ifndef DBAUI_TOOLS_HXX
#include "UITools.hxx"
#endif
#include <algorithm>
#ifndef _SVTREEBOX_HXX
#include <svtools/svtreebx.hxx>
#endif
#ifndef _COM_SUN_STAR_SDB_XREPORTDOCUMENTSSUPPLIER_HPP_
#include <com/sun/star/sdb/XReportDocumentsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_XFORMDOCUMENTSSUPPLIER_HPP_
#include <com/sun/star/sdb/XFormDocumentsSupplier.hpp>
#endif
#ifndef _FILEDLGHELPER_HXX
#include <sfx2/filedlghelper.hxx>
#endif
#ifndef INCLUDED_SVTOOLS_PATHOPTIONS_HXX
#include <unotools/pathoptions.hxx>
#endif
#ifndef _SFX_DOCFILT_HACK_HXX
#include <sfx2/docfilt.hxx>
#endif
#ifndef _SVT_FILEVIEW_HXX
#include <svtools/fileview.hxx>
#endif
#ifndef TOOLS_DIAGNOSE_EX_H
#include <tools/diagnose_ex.h>
#endif
#ifndef DBACCESS_SOURCE_UI_MISC_DEFAULTOBJECTNAMECHECK_HXX
#include "defaultobjectnamecheck.hxx"
#endif
#ifndef _VOS_MUTEX_HXX_
#include <vos/mutex.hxx>
#endif
#include "subcomponentmanager.hxx"

//........................................................................
namespace dbaui
{
//........................................................................
using namespace ::dbtools;
using namespace ::svx;
using namespace ::svtools;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::task;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdbcx;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::ucb;
using namespace ::com::sun::star::util;

// -----------------------------------------------------------------------------
void OApplicationController::deleteTables(const ::std::vector< ::rtl::OUString>& _rList)
{
    SharedConnection xConnection( ensureConnection() );

	Reference<XTablesSupplier> xSup(xConnection,UNO_QUERY);
	OSL_ENSURE(xSup.is(),"OApplicationController::deleteTable: no XTablesSuppier!");
	if ( xSup.is() )
	{
		Reference<XNameAccess> xTables = xSup->getTables();
		Reference<XDrop> xDrop(xTables,UNO_QUERY);
		if ( xDrop.is() )
		{
			bool bConfirm = true;
			::std::vector< ::rtl::OUString>::const_iterator aEnd = _rList.end();
			for (::std::vector< ::rtl::OUString>::const_iterator aIter = _rList.begin(); aIter != aEnd; ++aIter)
			{
				::rtl::OUString sTableName = *aIter;

				sal_Int32 nResult = RET_YES;
				if ( bConfirm )
					nResult = ::dbaui::askForUserAction(getView(),STR_TITLE_CONFIRM_DELETION ,STR_QUERY_DELETE_TABLE,_rList.size() > 1 && (aIter+1) != _rList.end(),sTableName);

                bool bUserConfirmedDelete =
                            ( RET_YES == nResult )
                        ||  ( RET_ALL == nResult );
				if ( bUserConfirmedDelete && m_pSubComponentManager->closeSubFrames( sTableName, E_TABLE ) )
				{
					SQLExceptionInfo aErrorInfo;
					try
					{
						if ( xTables->hasByName(sTableName) )
							xDrop->dropByName(sTableName);
						else
						{// could be a view
							Reference<XViewsSupplier> xViewsSup(xConnection,UNO_QUERY);

							Reference<XNameAccess> xViews;
							if ( xViewsSup.is() )
							{
								xViews = xViewsSup->getViews();
								if ( xViews.is() && xViews->hasByName(sTableName) )
								{
									xDrop.set(xViews,UNO_QUERY);
									if ( xDrop.is() )
										xDrop->dropByName(sTableName);
								}
							}
						}
					}
					catch(SQLContext& e) { aErrorInfo = e; }
					catch(SQLWarning& e) { aErrorInfo = e; }
					catch(SQLException& e) { aErrorInfo = e; }
					catch(WrappedTargetException& e)
					{
						SQLException aSql;
						if(e.TargetException >>= aSql)
							aErrorInfo = aSql;
						else
							OSL_ENSURE(sal_False, "OApplicationController::implDropTable: something strange happended!");
					}
		            catch( const Exception& )
		            {
                        DBG_UNHANDLED_EXCEPTION();
		            }

					if ( aErrorInfo.isValid() )
						showError(aErrorInfo);

					if ( RET_ALL == nResult )
						bConfirm = false;
				}
				else
					break;
			}
		}
		else
		{
			String sMessage(ModuleRes(STR_MISSING_TABLES_XDROP));
			ErrorBox aError(getView(), WB_OK, sMessage);
			aError.Execute();
		}
	}
}
// -----------------------------------------------------------------------------
void OApplicationController::deleteObjects( ElementType _eType, const ::std::vector< ::rtl::OUString>& _rList, bool _bConfirm )
{
    Reference< XNameContainer > xNames( getElements( _eType ), UNO_QUERY );
	Reference< XHierarchicalNameContainer > xHierarchyName( xNames, UNO_QUERY );
	if ( xNames.is() )
	{
		ByteString sDialogPosition;
		svtools::QueryDeleteResult_Impl eResult = _bConfirm ? svtools::QUERYDELETE_YES : svtools::QUERYDELETE_ALL;

        // The list of elements to delete is allowed to contain related elements: A given element may
        // be the ancestor or child of another element from the list.
        // We want to ensure that ancestors get deleted first, so we normalize the list in this respect.
        // #i33353# - 2004-09-27 - fs@openoffice.org
        ::std::set< ::rtl::OUString > aDeleteNames;
            // Note that this implicitly uses ::std::less< ::rtl::OUString > a comparison operation, which
            // results in lexicographical order, which is exactly what we need, because "foo" is *before*
            // any "foo/bar" in this order.
        ::std::copy(
            _rList.begin(), _rList.end(),
            ::std::insert_iterator< ::std::set< ::rtl::OUString > >( aDeleteNames, aDeleteNames.begin() )
        );

        ::std::set< ::rtl::OUString >::size_type nCount = aDeleteNames.size();
        for ( ::std::set< ::rtl::OUString >::size_type nObjectsLeft = nCount; !aDeleteNames.empty(); )
		{
            ::std::set< ::rtl::OUString >::iterator  aThisRound = aDeleteNames.begin();

			if ( eResult != svtools::QUERYDELETE_ALL )
			{
				svtools::QueryDeleteDlg_Impl aDlg( getView(), *aThisRound );

                if ( sDialogPosition.Len() )
					aDlg.SetWindowState( sDialogPosition );

                if ( nObjectsLeft > 1 )
					aDlg.EnableAllButton();

                if ( aDlg.Execute() == RET_OK )
					eResult = aDlg.GetResult();
				else
					return;

				sDialogPosition = aDlg.GetWindowState( );
			}

            bool bSuccess = false;

            bool bUserConfirmedDelete =
                        ( eResult == svtools::QUERYDELETE_ALL )
                    ||  ( eResult == svtools::QUERYDELETE_YES );

            if  (   bUserConfirmedDelete
                &&  (   ( _eType == E_QUERY ) ? m_pSubComponentManager->closeSubFrames( *aThisRound, _eType ) : true )
                )
			{
				try
				{
					if ( xHierarchyName.is() )
						xHierarchyName->removeByHierarchicalName( *aThisRound );
					else
						xNames->removeByName( *aThisRound );

                    bSuccess = true;

                    // now that we removed the element, care for all it's child elements
                    // which may also be a part of the list
                    // #i33353# - 2004-09-27 - fs@openoffice.org
                    OSL_ENSURE( aThisRound->getLength() - 1 >= 0, "OApplicationController::deleteObjects: empty name?" );
					::rtl::OUStringBuffer sSmallestSiblingName( *aThisRound );
                    sSmallestSiblingName.append( (sal_Unicode)( '/' + 1) );

                    ::std::set< ::rtl::OUString >::iterator aUpperChildrenBound = aDeleteNames.lower_bound( sSmallestSiblingName.makeStringAndClear() );
                    for ( ::std::set< ::rtl::OUString >::iterator aObsolete = aThisRound;
                          aObsolete != aUpperChildrenBound;
                        )
                    {
#if OSL_DEBUG_LEVEL > 0
                        ::rtl::OUString sObsoleteName = *aObsolete;
#endif
                        ::std::set< ::rtl::OUString >::iterator aNextObsolete = aObsolete; ++aNextObsolete;
                        aDeleteNames.erase( aObsolete );
                        --nObjectsLeft;
                        aObsolete = aNextObsolete;
                    }
				}
				catch(const SQLException&)
				{
                    showError( SQLExceptionInfo( ::cppu::getCaughtException() ) );
				}
				catch(WrappedTargetException& e)
				{
					SQLException aSql;
					if ( e.TargetException >>= aSql )
						showError( SQLExceptionInfo( e.TargetException ) );
					else
						OSL_ENSURE( sal_False, "OApplicationController::deleteObjects: something strange happended!" );
				}
                catch( const Exception& )
                {
                    DBG_UNHANDLED_EXCEPTION();
                }
			}

            if ( !bSuccess )
            {
                // okay, this object could not be deleted (or the user did not want to delete it),
                // but continue with the rest
                aDeleteNames.erase( aThisRound );
                --nObjectsLeft;
            }
		}
	}
}
// -----------------------------------------------------------------------------
void OApplicationController::deleteEntries()
{
	::vos::OGuard aSolarGuard(Application::GetSolarMutex());
	::osl::MutexGuard aGuard( getMutex() );

	if ( getContainer() )
	{
		::std::vector< ::rtl::OUString> aList;
		getSelectionElementNames(aList);
		ElementType eType = getContainer()->getElementType();
		switch(eType)
		{
		case E_TABLE:
			deleteTables(aList);
			break;
		case E_QUERY:
			deleteObjects( E_QUERY, aList, true );
			break;
		case E_FORM:
			deleteObjects( E_FORM, aList, true );
			break;
		case E_REPORT:
			deleteObjects( E_REPORT, aList, true );
			break;
        case E_NONE:
            break;
		}
	}
}
// -----------------------------------------------------------------------------
const SharedConnection& OApplicationController::ensureConnection( ::dbtools::SQLExceptionInfo* _pErrorInfo )
{
	::vos::OGuard aSolarGuard(Application::GetSolarMutex());
	::osl::MutexGuard aGuard( getMutex() );

    if ( !m_xDataSourceConnection.is() )
    {
		WaitObject aWO(getView());
		String sConnectingContext( ModuleRes( STR_COULDNOTCONNECT_DATASOURCE ) );
		sConnectingContext.SearchAndReplaceAscii("$name$", getStrippedDatabaseName());

		m_xDataSourceConnection.reset( connect( getDatabaseName(), sConnectingContext, _pErrorInfo ) );
        if ( m_xDataSourceConnection.is() )
        {
            SQLExceptionInfo aError;
            try
            {
                m_xMetaData = m_xDataSourceConnection->getMetaData();
            }
            catch( const SQLException& )
            {
                aError = ::cppu::getCaughtException();
            }
            catch( const Exception& )
            {
            	DBG_UNHANDLED_EXCEPTION();
            }
            if ( aError.isValid() )
            {
                if ( _pErrorInfo )
                {
                    *_pErrorInfo = aError;
                }
                else
                {
                    showError( aError );
                }
            }
        }
	}
    return m_xDataSourceConnection;
}
// -----------------------------------------------------------------------------
sal_Bool OApplicationController::isDataSourceReadOnly() const
{
	Reference<XStorable> xStore(m_xModel,UNO_QUERY);
	return !xStore.is() || xStore->isReadonly();
}
// -----------------------------------------------------------------------------
sal_Bool OApplicationController::isConnectionReadOnly() const
{
	sal_Bool bIsConnectionReadOnly = sal_True;
	if ( m_xMetaData.is() )
	{
		try
		{
			bIsConnectionReadOnly = m_xMetaData->isReadOnly();
		}
		catch(const SQLException&)
		{
            DBG_UNHANDLED_EXCEPTION();
		}
	}
	// TODO check configuration
	return bIsConnectionReadOnly;
}
// -----------------------------------------------------------------------------
Reference< XNameAccess > OApplicationController::getElements( ElementType _eType )
{
	Reference< XNameAccess > xElements;
	try
	{
		switch ( _eType )
		{
		case E_REPORT:
		{
			Reference< XReportDocumentsSupplier > xSupp( m_xModel, UNO_QUERY_THROW );
            xElements.set( xSupp->getReportDocuments(), UNO_SET_THROW );
		}
		break;

        case E_FORM:
		{
			Reference< XFormDocumentsSupplier > xSupp( m_xModel, UNO_QUERY_THROW );
            xElements.set( xSupp->getFormDocuments(), UNO_SET_THROW );
		}
		break;

        case E_QUERY:
		{
			xElements.set( getQueryDefintions(), UNO_QUERY_THROW );
		}
		break;

		case E_TABLE:
		{
            if ( m_xDataSourceConnection.is() )
			{
				Reference< XTablesSupplier > xSup( getConnection(), UNO_QUERY_THROW );
				xElements.set( xSup->getTables(), UNO_SET_THROW );
			}
		}
		break;

        default:
            break;
		}
	}
	catch(const Exception&)
	{
        DBG_UNHANDLED_EXCEPTION();
	}

	return xElements;
}
// -----------------------------------------------------------------------------
void OApplicationController::getSelectionElementNames(::std::vector< ::rtl::OUString>& _rNames) const
{
	::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
	::osl::MutexGuard aGuard( getMutex() );

	OSL_ENSURE(getContainer(),"View isn't valid! -> GPF");

	getContainer()->getSelectionElementNames( _rNames );
}

// -----------------------------------------------------------------------------
::std::auto_ptr< OLinkedDocumentsAccess > OApplicationController::getDocumentsAccess( ElementType _eType )
{
    OSL_ENSURE( ( _eType == E_TABLE ) || ( _eType == E_QUERY ) || ( _eType == E_FORM ) || ( _eType == E_REPORT ),
        "OApplicationController::getDocumentsAccess: only forms and reports are supported here!" );

    SharedConnection xConnection( ensureConnection() );
    Reference< XNameAccess > xDocContainer;

    if ( ( _eType == E_FORM ) | ( _eType == E_REPORT ) )
    {
        xDocContainer.set( getElements( _eType ) );
        OSL_ENSURE( xDocContainer.is(), "OApplicationController::getDocumentsAccess: invalid container!" );
    }

    ::std::auto_ptr< OLinkedDocumentsAccess > pDocuments( new OLinkedDocumentsAccess(
        getView(), this, getORB(), xDocContainer, xConnection, getDatabaseName()
    ) );
    return pDocuments;
}
// -----------------------------------------------------------------------------
TransferableHelper* OApplicationController::copyObject()
{
	try
	{
		::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
		::osl::MutexGuard aGuard( getMutex() );

		ElementType eType = getContainer()->getElementType();
		TransferableHelper* pData = NULL;
		switch( eType )
		{
			case E_TABLE:
			case E_QUERY:
			{
                SharedConnection xConnection( ensureConnection() );
				Reference< XDatabaseMetaData> xMetaData;
				if ( xConnection.is() )
					xMetaData = xConnection->getMetaData();

				::rtl::OUString sName = getContainer()->getQualifiedName( NULL );
                if ( sName.getLength() )
                {
				    ::rtl::OUString sDataSource	= getDatabaseName();

				    if ( eType == E_TABLE )
				    {
					    pData = new ODataClipboard(sDataSource, CommandType::TABLE, sName, xConnection, getNumberFormatter(xConnection,getORB()), getORB());
				    }
				    else
				    {
					    pData = new ODataClipboard(sDataSource, CommandType::QUERY, sName, getNumberFormatter(xConnection,getORB()), getORB());
				    }
                }
			}
				break;
			case E_FORM:
			case E_REPORT:
			{
				::std::vector< ::rtl::OUString> aList;
				getSelectionElementNames(aList);
				Reference< XHierarchicalNameAccess > xElements(getElements(eType),UNO_QUERY);
				if ( xElements.is() && !aList.empty() )
				{
					Reference< XContent> xContent(xElements->getByHierarchicalName(*aList.begin()),UNO_QUERY);
					pData = new OComponentTransferable( getDatabaseName(), xContent );
				}
			}
			break;
            default:
                break;
		}

		// the owner ship goes to ODataClipboards
		return pData;
	}
    catch(const SQLException&)
    {
        showError( SQLExceptionInfo( ::cppu::getCaughtException() ) );
    }
	catch( const Exception& )
	{
        DBG_UNHANDLED_EXCEPTION();
	}
	return NULL;
}
// -----------------------------------------------------------------------------
sal_Bool OApplicationController::paste( ElementType _eType,const ::svx::ODataAccessDescriptor& _rPasteData,const String& _sParentFolder ,sal_Bool _bMove)
{
	try
	{
		if ( _eType == E_QUERY )
		{
			sal_Int32 nCommandType = CommandType::TABLE;
			if ( _rPasteData.has(daCommandType) )
				_rPasteData[daCommandType]		>>= nCommandType;

			if ( CommandType::QUERY == nCommandType || CommandType::COMMAND == nCommandType )
			{
				// read all nescessary data

				::rtl::OUString	sCommand;
				sal_Bool bEscapeProcessing = sal_True;

				_rPasteData[daCommand] >>= sCommand;
				if ( _rPasteData.has(daEscapeProcessing) )
					_rPasteData[daEscapeProcessing]	>>= bEscapeProcessing;

				// plausibility check
				sal_Bool bValidDescriptor = sal_False;
                ::rtl::OUString	sDataSourceName = _rPasteData.getDataSource();
				if (CommandType::QUERY == nCommandType)
					bValidDescriptor = sDataSourceName.getLength() && sCommand.getLength();
				else if (CommandType::COMMAND == nCommandType)
					bValidDescriptor = (0 != sCommand.getLength());
				if (!bValidDescriptor)
				{
					DBG_ERROR("OApplicationController::paste: invalid descriptor!");
					return sal_False;
				}

				// the target object name (as we'll suggest it to the user)
                ::rtl::OUString sTargetName;
				try
				{
				    if ( CommandType::QUERY == nCommandType )
                        sTargetName = sCommand;

                    if ( !sTargetName.getLength() )
                    {
                        String sDefaultName = String( ModuleRes( STR_QRY_TITLE ) );
                        sDefaultName = sDefaultName.GetToken( 0, ' ' );

                        Reference< XNameAccess > xQueries( getQueryDefintions(), UNO_QUERY_THROW );
				        sTargetName = ::dbtools::createUniqueName( xQueries, sDefaultName, sal_False );
                    }
				}
				catch(const Exception&)
				{
					DBG_UNHANDLED_EXCEPTION();
				}

                Reference< XPropertySet > xQuery;
				if (CommandType::QUERY == nCommandType)
				{
					// need to extract the statement and the escape processing flag from the query object
					sal_Bool bSuccess = sal_False;
					try
					{
						// the concrete query
						Reference< XQueryDefinitionsSupplier > xSourceQuerySup(
                            getDataSourceByName( sDataSourceName, getView(), getORB(), NULL ),
                            UNO_QUERY_THROW );
                        Reference< XNameAccess > xQueries( xSourceQuerySup->getQueryDefinitions(), UNO_SET_THROW );
						if ( xQueries->hasByName( sCommand ) )
						{
							xQuery.set( xQueries->getByName(sCommand), UNO_QUERY_THROW );
							bSuccess = true;
						}
					}
					catch(SQLException&) { throw; }	// caught and handled by the outer catch
                    catch( const Exception& )
                    {
                        DBG_UNHANDLED_EXCEPTION();
                    }

					if (!bSuccess)
					{
						DBG_ERROR("OApplicationController::paste: could not extract the source query object!");
						// TODO: maybe this is worth an error message to be displayed to the user ....
						return sal_False;
					}
				}


				Reference< XNameContainer > xDestQueries(getQueryDefintions(), UNO_QUERY);
				Reference< XSingleServiceFactory > xQueryFactory(xDestQueries, UNO_QUERY);
				if (!xQueryFactory.is())
				{
					DBG_ERROR("OApplicationController::paste: invalid destination query container!");
					return sal_False;
				}

				// here we have everything needed to create a new query object ...
				// ... ehm, except a new name
                ensureConnection();

                DynamicTableOrQueryNameCheck aNameChecker( getConnection(), CommandType::QUERY );
                ::dbtools::SQLExceptionInfo aDummy;
                bool bNeedAskForName =  ( sCommand.getLength() == 0 )
                                            /* we did not have a source name, so the target name was auto-generated */
                                    ||  ( !aNameChecker.isNameValid( sTargetName, aDummy ) );
                                            /*  name is invalid in the target DB (e.g. because it already
                                                has a /table/ with that name) */
                if ( bNeedAskForName )
                {
				    OSaveAsDlg aAskForName(	getView(),
										    CommandType::QUERY,
                                            getORB(),
										    getConnection(),
										    sTargetName,
                                            aNameChecker,
										    SAD_ADDITIONAL_DESCRIPTION | SAD_TITLE_PASTE_AS);
				    if ( RET_OK != aAskForName.Execute() )
					    // cancelled by the user
					    return sal_False;
				    sTargetName = aAskForName.getName();
                }

				// create a new object
				Reference< XPropertySet > xNewQuery(xQueryFactory->createInstance(), UNO_QUERY);
				DBG_ASSERT(xNewQuery.is(), "OApplicationController::paste: invalid object created by factory!");
				if (xNewQuery.is())
				{
					// initialize
					if ( xQuery.is() )
	                    ::comphelper::copyProperties(xQuery,xNewQuery);
					else
					{
                        xNewQuery->setPropertyValue(PROPERTY_COMMAND,makeAny(sCommand));
                        xNewQuery->setPropertyValue(PROPERTY_ESCAPE_PROCESSING,makeAny(bEscapeProcessing));
                    }
					// insert
					xDestQueries->insertByName( sTargetName, makeAny(xNewQuery) );
                    xNewQuery.set(xDestQueries->getByName( sTargetName),UNO_QUERY);
                    if ( xQuery.is() && xNewQuery.is() )
                    {
                        Reference<XColumnsSupplier> xSrcColSup(xQuery,UNO_QUERY);
                        Reference<XColumnsSupplier> xDstColSup(xNewQuery,UNO_QUERY);
                        if ( xSrcColSup.is() && xDstColSup.is() )
	                    {
		                    Reference<XNameAccess> xSrcNameAccess = xSrcColSup->getColumns();
                            Reference<XNameAccess> xDstNameAccess = xDstColSup->getColumns();
                            Reference<XDataDescriptorFactory> xFac(xDstNameAccess,UNO_QUERY);
                            Reference<XAppend> xAppend(xFac,UNO_QUERY);
		                    if ( xSrcNameAccess.is() && xDstNameAccess.is() && xSrcNameAccess->hasElements() && xAppend.is() )
                            {
                                Reference<XPropertySet> xDstProp(xFac->createDataDescriptor());

                                Sequence< ::rtl::OUString> aSeq = xSrcNameAccess->getElementNames();
			                    const ::rtl::OUString* pIter = aSeq.getConstArray();
			                    const ::rtl::OUString* pEnd	  = pIter + aSeq.getLength();
			                    for( ; pIter != pEnd ; ++pIter)
			                    {
				                    Reference<XPropertySet> xSrcProp(xSrcNameAccess->getByName(*pIter),UNO_QUERY);
                                    ::comphelper::copyProperties(xSrcProp,xDstProp);
                                    xAppend->appendByDescriptor(xDstProp);
                                }
                            }
                        }
					}
				}
			}
			else
				OSL_TRACE("There should be a sequence in it!");
			return sal_True;
		}
		else if ( _rPasteData.has(daComponent) ) // forms or reports
		{
			Reference<XContent> xContent;
			_rPasteData[daComponent] >>= xContent;
			return insertHierachyElement(_eType,_sParentFolder,Reference<XNameAccess>(xContent,UNO_QUERY).is(),xContent,_bMove);
		}
	}
    catch(const SQLException&) { showError( SQLExceptionInfo( ::cppu::getCaughtException() ) ); }
	catch(const Exception& )
	{
        DBG_UNHANDLED_EXCEPTION();
	}
	return sal_False;
}
// -----------------------------------------------------------------------------
Reference<XNameContainer> OApplicationController::getQueryDefintions() const
{
	Reference<XQueryDefinitionsSupplier> xSet(m_xDataSource,UNO_QUERY);
	Reference<XNameContainer> xNames;
	if ( xSet.is() )
	{
		xNames.set(xSet->getQueryDefinitions(),UNO_QUERY);
	}
	return xNames;
}
// -----------------------------------------------------------------------------
void OApplicationController::getSupportedFormats(ElementType _eType,::std::vector<SotFormatStringId>& _rFormatIds) const
{
	switch( _eType )
	{
		case E_TABLE:
			_rFormatIds.push_back(SOT_FORMATSTR_ID_DBACCESS_TABLE);
			_rFormatIds.push_back(SOT_FORMAT_RTF);
			_rFormatIds.push_back(SOT_FORMATSTR_ID_HTML);
			// run through
		case E_QUERY:
			_rFormatIds.push_back(SOT_FORMATSTR_ID_DBACCESS_QUERY);
			break;
        default:
            break;
	}
}
// -----------------------------------------------------------------------------
sal_Bool OApplicationController::isTableFormat()  const
{
	return m_aTableCopyHelper.isTableFormat(getViewClipboard());
}
// -----------------------------------------------------------------------------
IMPL_LINK( OApplicationController, OnAsyncDrop, void*, /*NOTINTERESTEDIN*/ )
{
	m_nAsyncDrop = 0;
	::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
	::osl::MutexGuard aGuard( getMutex() );


	if ( m_aAsyncDrop.nType == E_TABLE )
	{
        SharedConnection xConnection( ensureConnection() );
        if ( xConnection.is() )
		    m_aTableCopyHelper.asyncCopyTagTable( m_aAsyncDrop, getDatabaseName(), xConnection );
	}
	else
	{
		if ( paste(m_aAsyncDrop.nType,m_aAsyncDrop.aDroppedData,m_aAsyncDrop.aUrl,m_aAsyncDrop.nAction == DND_ACTION_MOVE)
			&& m_aAsyncDrop.nAction == DND_ACTION_MOVE )
		{
			Reference<XContent> xContent;
			m_aAsyncDrop.aDroppedData[daComponent] >>= xContent;
			::std::vector< ::rtl::OUString> aList;
			sal_Int32 nIndex = 0;
			::rtl::OUString sName = xContent->getIdentifier()->getContentIdentifier();
			::rtl::OUString sErase = sName.getToken(0,'/',nIndex); // we don't want to have the "private:forms" part
			if ( nIndex != -1 )
			{
				aList.push_back(sName.copy(sErase.getLength() + 1));
				deleteObjects( m_aAsyncDrop.nType, aList, false );
			}
		}
	}

	m_aAsyncDrop.aDroppedData.clear();

	return 0L;
}
//........................................................................
}	// namespace dbaui
//........................................................................