dbaccess/source/ui/app/AppControllerGen.cxx

   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 "AppController.hxx"
  21 #include "AppDetailView.hxx"
  22 #include "AppView.hxx"
  23 #include "dbaccess_slotid.hrc"
  24 #include "dbu_app.hrc"
  25 #include "dbustrings.hrc"
  26 #include "defaultobjectnamecheck.hxx"
  27 #include "dlgsave.hxx"
  28 #include "UITools.hxx"
  29 #include "subcomponentmanager.hxx"
  30
  31 #include <com/sun/star/container/XChild.hpp>
  32 #include <com/sun/star/container/XContainer.hpp>
  33 #include <com/sun/star/container/XHierarchicalNameContainer.hpp>
  34 #include <com/sun/star/container/XNameAccess.hpp>
  35 #include <com/sun/star/container/XNameContainer.hpp>
  36 #include <com/sun/star/lang/XEventListener.hpp>
  37 #include <com/sun/star/sdb/CommandType.hpp>
  38 #include <com/sun/star/sdb/SQLContext.hpp>
  39 #include <com/sun/star/sdb/XQueriesSupplier.hpp>
  40 #include <com/sun/star/sdbcx/XRename.hpp>
  41 #include <com/sun/star/sdb/ErrorCondition.hpp>
  42 #include <com/sun/star/sdb/application/DatabaseObject.hpp>
  43 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  44 #include <com/sun/star/sdbcx/XViewsSupplier.hpp>
  45 #include <com/sun/star/ucb/Command.hpp>
  46 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  47 #include <com/sun/star/ucb/XCommandProcessor.hpp>
  48 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  49 #include <com/sun/star/uno/XNamingService.hpp>
  50 #include <com/sun/star/util/XRefreshable.hpp>
  51
  52 #include <cppuhelper/exc_hlp.hxx>
  53 #include <comphelper/processfactory.hxx>
  54 #include <connectivity/dbexception.hxx>
  55 #include <connectivity/dbtools.hxx>
  56 #include <connectivity/sqlerror.hxx>
  57 #include <sfx2/mailmodelapi.hxx>
  58 #include <svx/dbaexchange.hxx>
  59 #include <toolkit/helper/vclunohelper.hxx>
  60 #include <tools/diagnose_ex.h>
  61 #include <osl/diagnose.h>
  62 #include <unotools/bootstrap.hxx>
  63 #include <vcl/layout.hxx>
  64 #include <vcl/mnemonic.hxx>
  65 #include <vcl/svapp.hxx>
  66 #include <vcl/waitobj.hxx>
  67 #include <osl/mutex.hxx>
  68
  69 namespace dbaui
  70 {
  71 using namespace ::dbtools;
  72 using namespace ::connectivity;
  73 using namespace ::svx;
  74 using namespace ::com::sun::star;
  75 using namespace ::com::sun::star::uno;
  76 using namespace ::com::sun::star::awt;
  77 using namespace ::com::sun::star::util;
  78 using namespace ::com::sun::star::frame;
  79 using namespace ::com::sun::star::lang;
  80 using namespace ::com::sun::star::ui::dialogs;
  81 using namespace ::com::sun::star::sdb;
  82 using namespace ::com::sun::star::sdbc;
  83 using namespace ::com::sun::star::sdbcx;
  84 using namespace ::com::sun::star::beans;
  85 using namespace ::com::sun::star::container;
  86 using namespace ::com::sun::star::ucb;
  87
  88 using ::com::sun::star::ui::XContextMenuInterceptor;
  89
  90 namespace DatabaseObject = ::com::sun::star::sdb::application::DatabaseObject;
  91 namespace ErrorCondition = ::com::sun::star::sdb::ErrorCondition;
  92
  93 void OApplicationController::convertToView(const OUString& _sName)
  94 {
  95     try
  96     {
  97         SharedConnection xConnection( getConnection() );
  98         Reference< XQueriesSupplier > xSup( xConnection, UNO_QUERY_THROW );
  99         Reference< XNameAccess > xQueries( xSup->getQueries(), UNO_QUERY_THROW );
 100         Reference< XPropertySet > xSourceObject( xQueries->getByName( _sName ), UNO_QUERY_THROW );
 101
 102         Reference< XTablesSupplier > xTablesSup( xConnection, UNO_QUERY_THROW );
 103         Reference< XNameAccess > xTables( xTablesSup->getTables(), UNO_QUERY_THROW );
 104
 105         Reference< XDatabaseMetaData  > xMeta = xConnection->getMetaData();
 106
 107         OUString aName = OUString(ModuleRes(STR_TBL_TITLE));
 108         aName = aName.getToken(0,' ');
 109         OUString aDefaultName = ::dbaui::createDefaultName(xMeta,xTables,aName);
 110
 111         DynamicTableOrQueryNameCheck aNameChecker( xConnection, CommandType::TABLE );
 112         ScopedVclPtrInstance< OSaveAsDlg > aDlg( getView(), CommandType::TABLE, getORB(), xConnection, aDefaultName, aNameChecker );
 113         if ( aDlg->Execute() == RET_OK )
 114         {
 115             OUString sName = aDlg->getName();
 116             OUString sCatalog = aDlg->getCatalog();
 117             OUString sSchema  = aDlg->getSchema();
 118             OUString sNewName(
 119                 ::dbtools::composeTableName( xMeta, sCatalog, sSchema, sName, false, ::dbtools::EComposeRule::InTableDefinitions ) );
 120             Reference<XPropertySet> xView = ::dbaui::createView(sNewName,xConnection,xSourceObject);
 121             if ( !xView.is() )
 122                 throw SQLException(OUString(ModuleRes(STR_NO_TABLE_FORMAT_INSIDE)),*this,OUString( "S1000" ) ,0,Any());
 123             getContainer()->elementAdded(E_TABLE,sNewName,makeAny(xView));
 124         }
 125     }
 126     catch(const SQLException& )
 127     {
 128         showError( SQLExceptionInfo( ::cppu::getCaughtException() ) );
 129     }
 130     catch( const Exception& )
 131     {
 132         DBG_UNHANDLED_EXCEPTION();
 133     }
 134 }
 135
 136 void OApplicationController::pasteFormat(SotClipboardFormatId _nFormatId)
 137 {
 138     if ( _nFormatId != SotClipboardFormatId::NONE )
 139     {
 140         try
 141         {
 142             const TransferableDataHelper& rClipboard = getViewClipboard();
 143             ElementType eType = getContainer()->getElementType();
 144             if ( eType == E_TABLE )
 145             {
 146                 m_aTableCopyHelper.pasteTable( _nFormatId, rClipboard, getDatabaseName(), ensureConnection() );
 147             }
 148             else
 149                 paste( eType, ODataAccessObjectTransferable::extractObjectDescriptor( rClipboard ) );
 150
 151         }
 152         catch( const Exception& )
 153         {
 154             DBG_UNHANDLED_EXCEPTION();
 155         }
 156     }
 157 }
 158
 159 void OApplicationController::openDialog( const OUString& _sServiceName )
 160 {
 161     try
 162     {
 163         SolarMutexGuard aSolarGuard;
 164         ::osl::MutexGuard aGuard( getMutex() );
 165         WaitObject aWO(getView());
 166
 167         Sequence< Any > aArgs(3);
 168         sal_Int32 nArgPos = 0;
 169
 170         Reference< css::awt::XWindow> xWindow = getTopMostContainerWindow();
 171         if ( !xWindow.is() )
 172         {
 173             OSL_ENSURE( getContainer(), "OApplicationController::Construct: have no view!" );
 174             if ( getContainer() )
 175                 xWindow = VCLUnoHelper::GetInterface(getView()->Window::GetParent());
 176         }
 177         // the parent window
 178         aArgs[nArgPos++] <<= PropertyValue( OUString("ParentWindow"),
 179                                     0,
 180                                     makeAny(xWindow),
 181                                     PropertyState_DIRECT_VALUE);
 182
 183         // the initial selection
 184         OUString sInitialSelection;
 185         if ( getContainer() )
 186             sInitialSelection = getDatabaseName();
 187         if ( !sInitialSelection.isEmpty() )
 188         {
 189             aArgs[ nArgPos++ ] <<= PropertyValue(
 190                 OUString( "InitialSelection" ), 0,
 191                 makeAny( sInitialSelection ), PropertyState_DIRECT_VALUE );
 192         }
 193
 194         SharedConnection xConnection( getConnection() );
 195         if ( xConnection.is() )
 196         {
 197             aArgs[ nArgPos++ ] <<= PropertyValue(
 198                 PROPERTY_ACTIVE_CONNECTION, 0,
 199                 makeAny( xConnection ), PropertyState_DIRECT_VALUE );
 200         }
 201         aArgs.realloc( nArgPos );
 202
 203         // create the dialog
 204         Reference< XExecutableDialog > xAdminDialog;
 205         xAdminDialog.set(
 206             getORB()->getServiceManager()->createInstanceWithArgumentsAndContext(_sServiceName, aArgs, getORB()),
 207             UNO_QUERY);
 208
 209         // execute it
 210         if (xAdminDialog.is())
 211             xAdminDialog->execute();
 212     }
 213     catch( const Exception& )
 214     {
 215         DBG_UNHANDLED_EXCEPTION();
 216     }
 217 }
 218
 219 void OApplicationController::refreshTables()
 220 {
 221     if ( getContainer() && getContainer()->getDetailView() )
 222     {
 223         WaitObject aWO(getView());
 224         OSL_ENSURE(getContainer()->getElementType() == E_TABLE,"Only allowed when the tables container is selected!");
 225         try
 226         {
 227             Reference<XRefreshable> xRefresh(getElements(E_TABLE),UNO_QUERY);
 228             if ( xRefresh.is() )
 229                 xRefresh->refresh();
 230         }
 231         catch(const Exception&)
 232         {
 233             OSL_FAIL("Could not refresh tables!");
 234         }
 235
 236         getContainer()->getDetailView()->clearPages(false);
 237         getContainer()->getDetailView()->createTablesPage( ensureConnection() );
 238     }
 239 }
 240
 241 void SAL_CALL OApplicationController::propertyChange( const PropertyChangeEvent& evt ) throw (RuntimeException, std::exception)
 242 {
 243     SolarMutexGuard aSolarGuard;
 244     ::osl::MutexGuard aGuard( getMutex() );
 245     if ( evt.PropertyName == PROPERTY_USER )
 246     {
 247         m_bNeedToReconnect = true;
 248         InvalidateFeature(SID_DB_APP_STATUS_USERNAME);
 249     }
 250     else if ( evt.PropertyName == PROPERTY_URL )
 251     {
 252         m_bNeedToReconnect = true;
 253         InvalidateFeature(SID_DB_APP_STATUS_DBNAME);
 254         InvalidateFeature(SID_DB_APP_STATUS_TYPE);
 255         InvalidateFeature(SID_DB_APP_STATUS_HOSTNAME);
 256     }
 257     else if ( PROPERTY_NAME == evt.PropertyName )
 258     {
 259         const ElementType eType = getContainer()->getElementType();
 260         if ( eType == E_FORM || eType == E_REPORT )
 261         {
 262             OUString sOldName,sNewName;
 263             evt.OldValue >>= sOldName;
 264             evt.NewValue >>= sNewName;
 265
 266             // if the old name is empty, then this is a newly inserted content. We're notified of it via the
 267             // elementInserted method, so there's no need to handle it here.
 268
 269             if ( !sOldName.isEmpty() )
 270             {
 271                 Reference<XChild> xChild(evt.Source,UNO_QUERY);
 272                 if ( xChild.is() )
 273                 {
 274                     Reference<XContent> xContent(xChild->getParent(),UNO_QUERY);
 275                     if ( xContent.is() )
 276                         sOldName = xContent->getIdentifier()->getContentIdentifier() + "/" + sOldName;
 277                 }
 278
 279                 getContainer()->elementReplaced( eType , sOldName, sNewName );
 280             }
 281         }
 282     }
 283
 284     EventObject aEvt;
 285     aEvt.Source = m_xModel;
 286     modified(aEvt);
 287 }
 288
 289 Reference< XDataSource > SAL_CALL OApplicationController::getDataSource() throw (RuntimeException, std::exception)
 290 {
 291     ::osl::MutexGuard aGuard( getMutex() );
 292     Reference< XDataSource > xDataSource( m_xDataSource, UNO_QUERY );
 293     return xDataSource;
 294 }
 295
 296 Reference< XWindow > SAL_CALL OApplicationController::getApplicationMainWindow() throw (RuntimeException, std::exception)
 297 {
 298     ::osl::MutexGuard aGuard( getMutex() );
 299     Reference< XFrame > xFrame( getFrame(), UNO_QUERY_THROW );
 300     Reference< XWindow > xWindow( xFrame->getContainerWindow(), UNO_QUERY_THROW );
 301     return xWindow;
 302 }
 303
 304 Sequence< Reference< XComponent > > SAL_CALL OApplicationController::getSubComponents() throw (RuntimeException, std::exception)
 305 {
 306     ::osl::MutexGuard aGuard( getMutex() );
 307     return m_pSubComponentManager->getSubComponents();
 308 }
 309
 310 Reference< XConnection > SAL_CALL OApplicationController::getActiveConnection() throw (RuntimeException, std::exception)
 311 {
 312     ::osl::MutexGuard aGuard( getMutex() );
 313     return m_xDataSourceConnection.getTyped();
 314 }
 315
 316 sal_Bool SAL_CALL OApplicationController::isConnected(  ) throw (RuntimeException, std::exception)
 317 {
 318     ::osl::MutexGuard aGuard( getMutex() );
 319     return m_xDataSourceConnection.is();
 320 }
 321
 322 void SAL_CALL OApplicationController::connect(  ) throw (SQLException, RuntimeException, std::exception)
 323 {
 324     SQLExceptionInfo aError;
 325     SharedConnection xConnection = ensureConnection( &aError );
 326     if ( !xConnection.is() )
 327     {
 328         if ( aError.isValid() )
 329             aError.doThrow();
 330
 331         // no particular error, but nonetheless could not connect -> throw a generic exception
 332         OUString sConnectingContext( ModuleRes( STR_COULDNOTCONNECT_DATASOURCE ) );
 333         ::dbtools::throwGenericSQLException( sConnectingContext.replaceFirst( "$name$", getStrippedDatabaseName() ), *this );
 334     }
 335 }
 336
 337 beans::Pair< ::sal_Int32, OUString > SAL_CALL OApplicationController::identifySubComponent( const Reference< XComponent >& i_rSubComponent ) throw (IllegalArgumentException, RuntimeException, std::exception)
 338 {
 339     ::osl::MutexGuard aGuard( getMutex() );
 340
 341     sal_Int32 nType = -1;
 342     OUString sName;
 343
 344     if ( !m_pSubComponentManager->lookupSubComponent( i_rSubComponent, sName, nType ) )
 345         throw IllegalArgumentException( OUString(), *this, 1 );
 346
 347     if ( nType == SID_DB_APP_DSRELDESIGN )
 348         // this is somewhat hacky ... we're expected to return a DatabaseObject value. However, there is no such
 349         // value for the relation design. /me thinks we should change the API definition here ...
 350         nType = -1;
 351
 352     return beans::Pair< ::sal_Int32, OUString >( nType, sName );
 353 }
 354
 355 sal_Bool SAL_CALL OApplicationController::closeSubComponents(  ) throw (RuntimeException, std::exception)
 356 {
 357     SolarMutexGuard aSolarGuard;
 358     ::osl::MutexGuard aGuard( getMutex() );
 359     return m_pSubComponentManager->closeSubComponents();
 360 }
 361
 362 namespace
 363 {
 364     ElementType lcl_objectType2ElementType( const sal_Int32 _nObjectType )
 365     {
 366         ElementType eType( E_NONE );
 367         switch ( _nObjectType )
 368         {
 369         case DatabaseObject::TABLE:  eType = E_TABLE;   break;
 370         case DatabaseObject::QUERY:  eType = E_QUERY;   break;
 371         case DatabaseObject::FORM:   eType = E_FORM;    break;
 372         case DatabaseObject::REPORT: eType = E_REPORT;  break;
 373         default:
 374             OSL_FAIL( "lcl_objectType2ElementType: unsupported object type!" );
 375                 // this should have been caught earlier
 376         }
 377         return eType;
 378     }
 379 }
 380
 381 void OApplicationController::impl_validateObjectTypeAndName_throw( const sal_Int32 _nObjectType, const ::boost::optional< OUString >& i_rObjectName )
 382 {
 383     // ensure we're connected
 384     if ( !isConnected() )
 385     {
 386         SQLError aError( getORB() );
 387         aError.raiseException( ErrorCondition::DB_NOT_CONNECTED, *this );
 388     }
 389
 390     // ensure a proper object type
 391     if  (   ( _nObjectType != DatabaseObject::TABLE )
 392         &&  ( _nObjectType != DatabaseObject::QUERY )
 393         &&  ( _nObjectType != DatabaseObject::FORM )
 394         &&  ( _nObjectType != DatabaseObject::REPORT )
 395         )
 396         throw IllegalArgumentException( OUString(), *this, 1 );
 397
 398     if ( !i_rObjectName )
 399         return;
 400
 401     // ensure an existing object
 402     Reference< XNameAccess > xContainer( getElements( lcl_objectType2ElementType( _nObjectType ) ) );
 403     if ( !xContainer.is() )
 404         // all possible reasons for this (e.g. not being connected currently) should
 405         // have been handled before
 406         throw RuntimeException( OUString(), *this );
 407
 408     bool bExistentObject = false;
 409     switch ( _nObjectType )
 410     {
 411     case DatabaseObject::TABLE:
 412     case DatabaseObject::QUERY:
 413         bExistentObject = xContainer->hasByName( *i_rObjectName );
 414         break;
 415     case DatabaseObject::FORM:
 416     case DatabaseObject::REPORT:
 417     {
 418         Reference< XHierarchicalNameAccess > xHierarchy( xContainer, UNO_QUERY_THROW );
 419         bExistentObject = xHierarchy->hasByHierarchicalName( *i_rObjectName );
 420     }
 421     break;
 422     }
 423
 424     if ( !bExistentObject )
 425         throw NoSuchElementException( *i_rObjectName, *this );
 426 }
 427
 428 Reference< XComponent > SAL_CALL OApplicationController::loadComponent( ::sal_Int32 ObjectType,
 429     const OUString& ObjectName, sal_Bool ForEditing ) throw (IllegalArgumentException, NoSuchElementException, SQLException, RuntimeException, std::exception)
 430 {
 431     return loadComponentWithArguments( ObjectType, ObjectName, ForEditing, Sequence< PropertyValue >() );
 432 }
 433
 434 Reference< XComponent > SAL_CALL OApplicationController::loadComponentWithArguments( ::sal_Int32 ObjectType,
 435     const OUString& ObjectName, sal_Bool ForEditing, const Sequence< PropertyValue >& Arguments ) throw (IllegalArgumentException, NoSuchElementException, SQLException, RuntimeException, std::exception)
 436 {
 437     SolarMutexGuard aSolarGuard;
 438     ::osl::MutexGuard aGuard( getMutex() );
 439
 440     impl_validateObjectTypeAndName_throw( ObjectType, ObjectName );
 441
 442     Reference< XComponent > xComponent( openElementWithArguments(
 443         ObjectName,
 444         lcl_objectType2ElementType( ObjectType ),
 445         ForEditing ? E_OPEN_DESIGN : E_OPEN_NORMAL,
 446         ForEditing ? SID_DB_APP_EDIT : SID_DB_APP_OPEN,
 447         ::comphelper::NamedValueCollection( Arguments )
 448     ) );
 449
 450     return xComponent;
 451 }
 452
 453 Reference< XComponent > SAL_CALL OApplicationController::createComponent( ::sal_Int32 i_nObjectType, Reference< XComponent >& o_DocumentDefinition  ) throw (IllegalArgumentException, SQLException, RuntimeException, std::exception)
 454 {
 455     return createComponentWithArguments( i_nObjectType, Sequence< PropertyValue >(), o_DocumentDefinition );
 456 }
 457
 458 Reference< XComponent > SAL_CALL OApplicationController::createComponentWithArguments( ::sal_Int32 i_nObjectType, const Sequence< PropertyValue >& i_rArguments, Reference< XComponent >& o_DocumentDefinition ) throw (IllegalArgumentException, NoSuchElementException, SQLException, RuntimeException, std::exception)
 459 {
 460     SolarMutexGuard aSolarGuard;
 461     ::osl::MutexGuard aGuard( getMutex() );
 462
 463     impl_validateObjectTypeAndName_throw( i_nObjectType, ::boost::optional< OUString >() );
 464
 465     Reference< XComponent > xComponent( newElement(
 466         lcl_objectType2ElementType( i_nObjectType ),
 467         ::comphelper::NamedValueCollection( i_rArguments ),
 468         o_DocumentDefinition
 469     ) );
 470
 471     return xComponent;
 472 }
 473
 474 void SAL_CALL OApplicationController::registerContextMenuInterceptor( const Reference< XContextMenuInterceptor >& Interceptor ) throw (RuntimeException, std::exception)
 475 {
 476     if ( Interceptor.is() )
 477         m_aContextMenuInterceptors.addInterface( Interceptor );
 478 }
 479
 480 void SAL_CALL OApplicationController::releaseContextMenuInterceptor( const Reference< XContextMenuInterceptor >& Interceptor ) throw (RuntimeException, std::exception)
 481 {
 482     m_aContextMenuInterceptors.removeInterface( Interceptor );
 483 }
 484
 485 void OApplicationController::previewChanged( sal_Int32 _nMode )
 486 {
 487     SolarMutexGuard aSolarGuard;
 488     ::osl::MutexGuard aGuard( getMutex() );
 489
 490     if ( m_xDataSource.is() && !isDataSourceReadOnly() )
 491     {
 492         try
 493         {
 494             ::comphelper::NamedValueCollection aLayoutInfo( m_xDataSource->getPropertyValue( PROPERTY_LAYOUTINFORMATION ) );
 495             sal_Int32 nOldMode = aLayoutInfo.getOrDefault( "Preview", _nMode );
 496             if ( nOldMode != _nMode )
 497             {
 498                 aLayoutInfo.put( "Preview", _nMode );
 499                 m_xDataSource->setPropertyValue( PROPERTY_LAYOUTINFORMATION, makeAny( aLayoutInfo.getPropertyValues() ) );
 500             }
 501         }
 502         catch ( const Exception& )
 503         {
 504             DBG_UNHANDLED_EXCEPTION();
 505         }
 506     }
 507     InvalidateFeature(SID_DB_APP_DISABLE_PREVIEW);
 508     InvalidateFeature(SID_DB_APP_VIEW_DOCINFO_PREVIEW);
 509     InvalidateFeature(SID_DB_APP_VIEW_DOC_PREVIEW);
 510 }
 511
 512 void OApplicationController::askToReconnect()
 513 {
 514     if ( m_bNeedToReconnect )
 515     {
 516         m_bNeedToReconnect = false;
 517         bool bClear = true;
 518         if ( !m_pSubComponentManager->empty() )
 519         {
 520             ScopedVclPtrInstance< MessageDialog > aQry(getView(), ModuleRes(STR_QUERY_CLOSEDOCUMENTS), VclMessageType::Question, VCL_BUTTONS_YES_NO);
 521             switch (aQry->Execute())
 522             {
 523                 case RET_YES:
 524                     closeSubComponents();
 525                     break;
 526                 default:
 527                     bClear = false;
 528                     break;
 529             }
 530         }
 531         if ( bClear )
 532         {
 533             ElementType eType = getContainer()->getElementType();
 534             disconnect();
 535             getContainer()->getDetailView()->clearPages(false);
 536             getContainer()->selectContainer(E_NONE); // invalidate the old selection
 537             m_eCurrentType = E_NONE;
 538             getContainer()->selectContainer(eType); // reselect the current one again
 539         }
 540     }
 541 }
 542
 543 OUString OApplicationController::getDatabaseName() const
 544 {
 545     OUString sDatabaseName;
 546     try
 547     {
 548         if ( m_xDataSource.is() )
 549         {
 550             OSL_VERIFY( m_xDataSource->getPropertyValue( PROPERTY_NAME ) >>= sDatabaseName );
 551         }
 552     }
 553     catch ( const Exception& )
 554     {
 555         DBG_UNHANDLED_EXCEPTION();
 556     }
 557     return sDatabaseName;
 558 }
 559
 560 OUString OApplicationController::getStrippedDatabaseName() const
 561 {
 562     OUString sDatabaseName;
 563     return ::dbaui::getStrippedDatabaseName( m_xDataSource, sDatabaseName );
 564 }
 565
 566 void OApplicationController::onDocumentOpened( const OUString& _rName, const sal_Int32 _nType,
 567         const ElementOpenMode _eMode, const Reference< XComponent >& _xDocument, const Reference< XComponent >& _rxDefinition )
 568 {
 569     if ( !_xDocument.is() )
 570         return;
 571
 572     try
 573     {
 574         OSL_ENSURE( _xDocument.is(), "OApplicationController::onDocumentOpened: is there any *valid* scenario where this fails?" );
 575         m_pSubComponentManager->onSubComponentOpened( _rName, _nType, _eMode, _xDocument.is() ? _xDocument : _rxDefinition );
 576
 577         if ( _rxDefinition.is() )
 578         {
 579             Reference< XPropertySet > xProp( _rxDefinition, UNO_QUERY_THROW );
 580             Reference< XPropertySetInfo > xPSI( xProp->getPropertySetInfo(), UNO_SET_THROW );
 581             xProp->addPropertyChangeListener( PROPERTY_NAME, static_cast< XPropertyChangeListener* >( this ) );
 582         }
 583     }
 584     catch( const Exception& )
 585     {
 586         DBG_UNHANDLED_EXCEPTION();
 587     }
 588 }
 589
 590 bool OApplicationController::insertHierachyElement(ElementType _eType, const OUString& _sParentFolder, bool _bCollection, const Reference<XContent>& _xContent, bool _bMove)
 591 {
 592     Reference<XHierarchicalNameContainer> xNames(getElements(_eType), UNO_QUERY);
 593     return dbaui::insertHierachyElement(getView()
 594                            ,getORB()
 595                            ,xNames
 596                            ,_sParentFolder
 597                            ,_eType == E_FORM
 598                            ,_bCollection
 599                            ,_xContent
 600                            ,_bMove);
 601 }
 602
 603 bool OApplicationController::isRenameDeleteAllowed(ElementType _eType, bool _bDelete) const
 604 {
 605     ElementType eType = getContainer()->getElementType();
 606     bool bEnabled = !isDataSourceReadOnly() && eType == _eType;
 607     if ( bEnabled )
 608     {
 609
 610         if ( E_TABLE == eType )
 611             bEnabled = !isConnectionReadOnly() && getContainer()->isALeafSelected();
 612
 613         bool bCompareRes = false;
 614         if ( _bDelete )
 615             bCompareRes = getContainer()->getSelectionCount() > 0;
 616         else
 617         {
 618             bCompareRes = getContainer()->getSelectionCount() == 1;
 619             if ( bEnabled && bCompareRes && E_TABLE == eType )
 620             {
 621                 ::std::vector< OUString> aList;
 622                 getSelectionElementNames(aList);
 623
 624                 try
 625                 {
 626                     Reference< XNameAccess > xContainer = const_cast<OApplicationController*>(this)->getElements(eType);
 627                     bEnabled = (xContainer.is() && xContainer->hasByName(*aList.begin()));
 628                     if ( bEnabled )
 629                         bEnabled = Reference<XRename>(xContainer->getByName(*aList.begin()),UNO_QUERY).is();
 630                 }
 631                 catch(Exception&)
 632                 {
 633                     bEnabled = false;
 634                 }
 635             }
 636         }
 637
 638         bEnabled = bEnabled && bCompareRes;
 639     }
 640     return bEnabled;
 641 }
 642
 643 void OApplicationController::onLoadedMenu(const Reference< css::frame::XLayoutManager >& _xLayoutManager)
 644 {
 645
 646     if ( _xLayoutManager.is() )
 647     {
 648         static const char s_sStatusbar[] = "private:resource/statusbar/statusbar";
 649         _xLayoutManager->createElement( s_sStatusbar );
 650         _xLayoutManager->requestElement( s_sStatusbar );
 651
 652         if ( getContainer() )
 653         {
 654             // we need to share the "mnemonic space":
 655             MnemonicGenerator aMnemonicGenerator;
 656             // - the menu already has mnemonics
 657             SystemWindow* pSystemWindow = getContainer()->GetSystemWindow();
 658             MenuBar* pMenu = pSystemWindow ? pSystemWindow->GetMenuBar() : nullptr;
 659             if ( pMenu )
 660             {
 661                 sal_uInt16 nMenuItems = pMenu->GetItemCount();
 662                 for ( sal_uInt16 i = 0; i < nMenuItems; ++i )
 663                     aMnemonicGenerator.RegisterMnemonic( pMenu->GetItemText( pMenu->GetItemId( i ) ) );
 664             }
 665             // - the icons should use automatic ones
 666             getContainer()->createIconAutoMnemonics( aMnemonicGenerator );
 667             // - as well as the entries in the task pane
 668             getContainer()->setTaskExternalMnemonics( aMnemonicGenerator );
 669         }
 670
 671         Execute( SID_DB_APP_VIEW_FORMS, Sequence< PropertyValue >() );
 672         InvalidateAll();
 673     }
 674 }
 675
 676 void OApplicationController::doAction(sal_uInt16 _nId, const ElementOpenMode _eOpenMode)
 677 {
 678     ::std::vector< OUString> aList;
 679     getSelectionElementNames(aList);
 680     ElementType eType = getContainer()->getElementType();
 681     ::comphelper::NamedValueCollection aArguments;
 682     ElementOpenMode eOpenMode = _eOpenMode;
 683     if ( eType == E_REPORT && E_OPEN_FOR_MAIL == _eOpenMode )
 684     {
 685         aArguments.put("Hidden",true);
 686         eOpenMode = E_OPEN_NORMAL;
 687     }
 688
 689     ::std::vector< ::std::pair< OUString ,Reference< XModel > > > aComponents;
 690     ::std::vector< OUString>::const_iterator aEnd = aList.end();
 691     for (::std::vector< OUString>::const_iterator aIter = aList.begin(); aIter != aEnd; ++aIter)
 692     {
 693         if ( SID_DB_APP_CONVERTTOVIEW == _nId )
 694             convertToView(*aIter);
 695         else
 696         {
 697             Reference< XModel > xModel( openElementWithArguments( *aIter, eType, eOpenMode, _nId,aArguments ), UNO_QUERY );
 698             aComponents.push_back( ::std::pair< OUString, Reference< XModel > >( *aIter, xModel ) );
 699         }
 700     }
 701
 702     // special handling for mail, if more than one document is selected attach them all
 703     if ( _eOpenMode == E_OPEN_FOR_MAIL )
 704     {
 705
 706         ::std::vector< ::std::pair< OUString ,Reference< XModel > > >::const_iterator componentIter = aComponents.begin();
 707         ::std::vector< ::std::pair< OUString ,Reference< XModel > > >::const_iterator componentEnd = aComponents.end();
 708         OUString aDocTypeString;
 709         SfxMailModel aSendMail;
 710         SfxMailModel::SendMailResult eResult = SfxMailModel::SEND_MAIL_OK;
 711         for (; componentIter != componentEnd && SfxMailModel::SEND_MAIL_OK == eResult; ++componentIter)
 712         {
 713             try
 714             {
 715                 Reference< XModel > xModel(componentIter->second,UNO_QUERY);
 716
 717                 // Send document as e-Mail using stored/default type
 718                 eResult = aSendMail.AttachDocument(aDocTypeString,xModel,componentIter->first);
 719                 ::comphelper::disposeComponent(xModel);
 720             }
 721             catch(const Exception&)
 722             {
 723                 DBG_UNHANDLED_EXCEPTION();
 724             }
 725         }
 726         if ( !aSendMail.IsEmpty() )
 727             aSendMail.Send( getFrame() );
 728     }
 729 }
 730
 731 ElementType OApplicationController::getElementType(const Reference< XContainer >& _xContainer)
 732 {
 733     ElementType eRet = E_NONE;
 734     Reference<XServiceInfo> xServiceInfo(_xContainer,UNO_QUERY);
 735     if ( xServiceInfo.is() )
 736     {
 737         if ( xServiceInfo->supportsService(SERVICE_SDBCX_TABLES) )
 738             eRet = E_TABLE;
 739         else if ( xServiceInfo->supportsService(SERVICE_NAME_FORM_COLLECTION) )
 740             eRet = E_FORM;
 741         else if ( xServiceInfo->supportsService(SERVICE_NAME_REPORT_COLLECTION) )
 742             eRet = E_REPORT;
 743         else
 744             eRet = E_QUERY;
 745     }
 746     return eRet;
 747 }
 748
 749 }   // namespace dbaui
 750
 751 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */