1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_dbui.hxx" 26 27 #ifndef DBAUI_APPCONTROLLER_HXX 28 #include "AppController.hxx" 29 #endif 30 #ifndef _COMPHELPER_SEQUENCE_HXX_ 31 #include <comphelper/sequence.hxx> 32 #endif 33 #ifndef _COMPHELPER_PROPERTY_HXX_ 34 #include <comphelper/property.hxx> 35 #endif 36 #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC 37 #include "dbustrings.hrc" 38 #endif 39 #ifndef _COM_SUN_STAR_SDBCX_XDATADESCRIPTORFACTORY_HPP_ 40 #include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp> 41 #endif 42 #ifndef _COM_SUN_STAR_SDBCX_XAPPEND_HPP_ 43 #include <com/sun/star/sdbcx/XAppend.hpp> 44 #endif 45 #ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_ 46 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> 47 #endif 48 #ifndef _COM_SUN_STAR_SDB_XSINGLESELECTQUERYCOMPOSER_HPP_ 49 #include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp> 50 #endif 51 #ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_ 52 #include <com/sun/star/container/XNameContainer.hpp> 53 #endif 54 #ifndef _COM_SUN_STAR_UNO_XNAMINGSERVICE_HPP_ 55 #include <com/sun/star/uno/XNamingService.hpp> 56 #endif 57 #ifndef _COM_SUN_STAR_SDBC_XDATASOURCE_HPP_ 58 #include <com/sun/star/sdbc/XDataSource.hpp> 59 #endif 60 #ifndef _COM_SUN_STAR_FRAME_XSTORABLE_HPP_ 61 #include <com/sun/star/frame/XStorable.hpp> 62 #endif 63 #ifndef _COM_SUN_STAR_CONTAINER_XCHILD_HPP_ 64 #include <com/sun/star/container/XChild.hpp> 65 #endif 66 #ifndef _COM_SUN_STAR_CONTAINER_XHIERARCHICALNAMECONTAINER_HPP_ 67 #include <com/sun/star/container/XHierarchicalNameContainer.hpp> 68 #endif 69 #ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_ 70 #include <com/sun/star/sdbc/DataType.hpp> 71 #endif 72 #ifndef _COM_SUN_STAR_SDB_COMMANDTYPE_HPP_ 73 #include <com/sun/star/sdb/CommandType.hpp> 74 #endif 75 #ifndef _COM_SUN_STAR_SDB_XBOOKMARKSSUPPLIER_HPP_ 76 #include <com/sun/star/sdb/XBookmarksSupplier.hpp> 77 #endif 78 #ifndef _COM_SUN_STAR_SDB_SQLCONTEXT_HPP_ 79 #include <com/sun/star/sdb/SQLContext.hpp> 80 #endif 81 #ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_ 82 #include <com/sun/star/sdbcx/XTablesSupplier.hpp> 83 #endif 84 #ifndef _COM_SUN_STAR_SDBCX_XVIEWSSUPPLIER_HPP_ 85 #include <com/sun/star/sdbcx/XViewsSupplier.hpp> 86 #endif 87 #ifndef _COM_SUN_STAR_SDB_XQUERYDEFINITIONSSUPPLIER_HPP_ 88 #include <com/sun/star/sdb/XQueryDefinitionsSupplier.hpp> 89 #endif 90 #ifndef _COM_SUN_STAR_SDBCX_XDROP_HPP_ 91 #include <com/sun/star/sdbcx/XDrop.hpp> 92 #endif 93 #ifndef _TOOLS_DEBUG_HXX 94 #include <tools/debug.hxx> 95 #endif 96 #ifndef _URLOBJ_HXX 97 #include <tools/urlobj.hxx> 98 #endif 99 #ifndef _UNOTOOLS_UCBHELPER_HXX 100 #include <unotools/ucbhelper.hxx> 101 #endif 102 #ifndef DBAUI_DLGSAVE_HXX 103 #include "dlgsave.hxx" 104 #endif 105 #ifndef _COMPHELPER_TYPES_HXX_ 106 #include <comphelper/types.hxx> 107 #endif 108 #ifndef _SV_MSGBOX_HXX 109 #include <vcl/msgbox.hxx> 110 #endif 111 #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_ 112 #include <cppuhelper/typeprovider.hxx> 113 #endif 114 #ifndef _CPPUHELPER_EXC_HLP_HXX_ 115 #include <cppuhelper/exc_hlp.hxx> 116 #endif 117 #ifndef _DBHELPER_DBEXCEPTION_HXX_ 118 #include <connectivity/dbexception.hxx> 119 #endif 120 #ifndef _SV_WAITOBJ_HXX 121 #include <vcl/waitobj.hxx> 122 #endif 123 #ifndef _RTL_USTRBUF_HXX_ 124 #include <rtl/ustrbuf.hxx> 125 #endif 126 #ifndef DBAUI_APPVIEW_HXX 127 #include "AppView.hxx" 128 #endif 129 #ifndef _SVX_DATACCESSDESCRIPTOR_HXX_ 130 #include <svx/dataaccessdescriptor.hxx> 131 #endif 132 #ifndef SVX_DBAOBJECTEX_HXX 133 #include <svx/dbaobjectex.hxx> 134 #endif 135 #ifndef DBACCESS_UI_BROWSER_ID_HXX 136 #include "browserids.hxx" 137 #endif 138 #ifndef _DBAU_REGHELPER_HXX_ 139 #include "dbu_reghelper.hxx" 140 #endif 141 #ifndef _DBU_APP_HRC_ 142 #include "dbu_app.hrc" 143 #endif 144 #ifndef _SV_MENU_HXX 145 #include <vcl/menu.hxx> 146 #endif 147 #ifndef _COMPHELPER_UNO3_HXX_ 148 #include <comphelper/uno3.hxx> 149 #endif 150 #ifndef _SV_SVAPP_HXX //autogen 151 #include <vcl/svapp.hxx> 152 #endif 153 #ifndef _SVLBOXITM_HXX 154 #include <svtools/svlbitm.hxx> 155 #endif 156 #ifndef _DBAUI_LISTVIEWITEMS_HXX_ 157 #include "listviewitems.hxx" 158 #endif 159 #ifndef DBAUI_APPDETAILVIEW_HXX 160 #include "AppDetailView.hxx" 161 #endif 162 #ifndef _DBAUI_LINKEDDOCUMENTS_HXX_ 163 #include "linkeddocuments.hxx" 164 #endif 165 #ifndef _SV_LSTBOX_HXX 166 #include <vcl/lstbox.hxx> 167 #endif 168 #ifndef _DBHELPER_DBEXCEPTION_HXX_ 169 #include <connectivity/dbexception.hxx> 170 #endif 171 #ifndef _CONNECTIVITY_DBTOOLS_HXX_ 172 #include <connectivity/dbtools.hxx> 173 #endif 174 #ifndef _DBAUI_SQLMESSAGE_HXX_ 175 #include "sqlmessage.hxx" 176 #endif 177 #ifndef _STRING_HXX 178 #include <tools/string.hxx> 179 #endif 180 #ifndef DBAUI_DBEXCHANGE_HXX 181 #include "dbexchange.hxx" 182 #endif 183 #ifndef DBAUI_TOOLS_HXX 184 #include "UITools.hxx" 185 #endif 186 #include <algorithm> 187 #include <iterator> 188 #ifndef _SVTREEBOX_HXX 189 #include <svtools/svtreebx.hxx> 190 #endif 191 #ifndef _COM_SUN_STAR_SDB_XREPORTDOCUMENTSSUPPLIER_HPP_ 192 #include <com/sun/star/sdb/XReportDocumentsSupplier.hpp> 193 #endif 194 #ifndef _COM_SUN_STAR_SDB_XFORMDOCUMENTSSUPPLIER_HPP_ 195 #include <com/sun/star/sdb/XFormDocumentsSupplier.hpp> 196 #endif 197 #ifndef _FILEDLGHELPER_HXX 198 #include <sfx2/filedlghelper.hxx> 199 #endif 200 #ifndef INCLUDED_SVTOOLS_PATHOPTIONS_HXX 201 #include <unotools/pathoptions.hxx> 202 #endif 203 #ifndef _SFX_DOCFILT_HACK_HXX 204 #include <sfx2/docfilt.hxx> 205 #endif 206 #ifndef _SVT_FILEVIEW_HXX 207 #include <svtools/fileview.hxx> 208 #endif 209 #ifndef TOOLS_DIAGNOSE_EX_H 210 #include <tools/diagnose_ex.h> 211 #endif 212 #ifndef DBACCESS_SOURCE_UI_MISC_DEFAULTOBJECTNAMECHECK_HXX 213 #include "defaultobjectnamecheck.hxx" 214 #endif 215 #ifndef _VOS_MUTEX_HXX_ 216 #include <vos/mutex.hxx> 217 #endif 218 #include "subcomponentmanager.hxx" 219 220 //........................................................................ 221 namespace dbaui 222 { 223 //........................................................................ 224 using namespace ::dbtools; 225 using namespace ::svx; 226 using namespace ::svtools; 227 using namespace ::com::sun::star::uno; 228 using namespace ::com::sun::star::task; 229 using namespace ::com::sun::star::beans; 230 using namespace ::com::sun::star::lang; 231 using namespace ::com::sun::star::container; 232 using namespace ::com::sun::star::sdb; 233 using namespace ::com::sun::star::sdbc; 234 using namespace ::com::sun::star::sdbcx; 235 using namespace ::com::sun::star::frame; 236 using namespace ::com::sun::star::ucb; 237 using namespace ::com::sun::star::util; 238 239 // ----------------------------------------------------------------------------- 240 void OApplicationController::deleteTables(const ::std::vector< ::rtl::OUString>& _rList) 241 { 242 SharedConnection xConnection( ensureConnection() ); 243 244 Reference<XTablesSupplier> xSup(xConnection,UNO_QUERY); 245 OSL_ENSURE(xSup.is(),"OApplicationController::deleteTable: no XTablesSuppier!"); 246 if ( xSup.is() ) 247 { 248 Reference<XNameAccess> xTables = xSup->getTables(); 249 Reference<XDrop> xDrop(xTables,UNO_QUERY); 250 if ( xDrop.is() ) 251 { 252 bool bConfirm = true; 253 ::std::vector< ::rtl::OUString>::const_iterator aEnd = _rList.end(); 254 for (::std::vector< ::rtl::OUString>::const_iterator aIter = _rList.begin(); aIter != aEnd; ++aIter) 255 { 256 ::rtl::OUString sTableName = *aIter; 257 258 sal_Int32 nResult = RET_YES; 259 if ( bConfirm ) 260 nResult = ::dbaui::askForUserAction(getView(),STR_TITLE_CONFIRM_DELETION ,STR_QUERY_DELETE_TABLE,_rList.size() > 1 && (aIter+1) != _rList.end(),sTableName); 261 262 bool bUserConfirmedDelete = 263 ( RET_YES == nResult ) 264 || ( RET_ALL == nResult ); 265 if ( bUserConfirmedDelete && m_pSubComponentManager->closeSubFrames( sTableName, E_TABLE ) ) 266 { 267 SQLExceptionInfo aErrorInfo; 268 try 269 { 270 if ( xTables->hasByName(sTableName) ) 271 xDrop->dropByName(sTableName); 272 else 273 {// could be a view 274 Reference<XViewsSupplier> xViewsSup(xConnection,UNO_QUERY); 275 276 Reference<XNameAccess> xViews; 277 if ( xViewsSup.is() ) 278 { 279 xViews = xViewsSup->getViews(); 280 if ( xViews.is() && xViews->hasByName(sTableName) ) 281 { 282 xDrop.set(xViews,UNO_QUERY); 283 if ( xDrop.is() ) 284 xDrop->dropByName(sTableName); 285 } 286 } 287 } 288 } 289 catch(SQLContext& e) { aErrorInfo = e; } 290 catch(SQLWarning& e) { aErrorInfo = e; } 291 catch(SQLException& e) { aErrorInfo = e; } 292 catch(WrappedTargetException& e) 293 { 294 SQLException aSql; 295 if(e.TargetException >>= aSql) 296 aErrorInfo = aSql; 297 else 298 OSL_ENSURE(sal_False, "OApplicationController::implDropTable: something strange happened!"); 299 } 300 catch( const Exception& ) 301 { 302 DBG_UNHANDLED_EXCEPTION(); 303 } 304 305 if ( aErrorInfo.isValid() ) 306 showError(aErrorInfo); 307 308 if ( RET_ALL == nResult ) 309 bConfirm = false; 310 } 311 else 312 break; 313 } 314 } 315 else 316 { 317 String sMessage(ModuleRes(STR_MISSING_TABLES_XDROP)); 318 ErrorBox aError(getView(), WB_OK, sMessage); 319 aError.Execute(); 320 } 321 } 322 } 323 // ----------------------------------------------------------------------------- 324 void OApplicationController::deleteObjects( ElementType _eType, const ::std::vector< ::rtl::OUString>& _rList, bool _bConfirm ) 325 { 326 Reference< XNameContainer > xNames( getElements( _eType ), UNO_QUERY ); 327 Reference< XHierarchicalNameContainer > xHierarchyName( xNames, UNO_QUERY ); 328 if ( xNames.is() ) 329 { 330 ByteString sDialogPosition; 331 svtools::QueryDeleteResult_Impl eResult = _bConfirm ? svtools::QUERYDELETE_YES : svtools::QUERYDELETE_ALL; 332 333 // The list of elements to delete is allowed to contain related elements: A given element may 334 // be the ancestor or child of another element from the list. 335 // We want to ensure that ancestors get deleted first, so we normalize the list in this respect. 336 // #i33353# - 2004-09-27 - fs@openoffice.org 337 ::std::set< ::rtl::OUString > aDeleteNames; 338 // Note that this implicitly uses ::std::less< ::rtl::OUString > a comparison operation, which 339 // results in lexicographical order, which is exactly what we need, because "foo" is *before* 340 // any "foo/bar" in this order. 341 ::std::copy( 342 _rList.begin(), _rList.end(), 343 ::std::insert_iterator< ::std::set< ::rtl::OUString > >( aDeleteNames, aDeleteNames.begin() ) 344 ); 345 346 ::std::set< ::rtl::OUString >::size_type nCount = aDeleteNames.size(); 347 for ( ::std::set< ::rtl::OUString >::size_type nObjectsLeft = nCount; !aDeleteNames.empty(); ) 348 { 349 ::std::set< ::rtl::OUString >::iterator aThisRound = aDeleteNames.begin(); 350 351 if ( eResult != svtools::QUERYDELETE_ALL ) 352 { 353 svtools::QueryDeleteDlg_Impl aDlg( getView(), *aThisRound ); 354 355 if ( sDialogPosition.Len() ) 356 aDlg.SetWindowState( sDialogPosition ); 357 358 if ( nObjectsLeft > 1 ) 359 aDlg.EnableAllButton(); 360 361 if ( aDlg.Execute() == RET_OK ) 362 eResult = aDlg.GetResult(); 363 else 364 return; 365 366 sDialogPosition = aDlg.GetWindowState( ); 367 } 368 369 bool bSuccess = false; 370 371 bool bUserConfirmedDelete = 372 ( eResult == svtools::QUERYDELETE_ALL ) 373 || ( eResult == svtools::QUERYDELETE_YES ); 374 375 if ( bUserConfirmedDelete 376 && ( ( _eType == E_QUERY ) ? m_pSubComponentManager->closeSubFrames( *aThisRound, _eType ) : true ) 377 ) 378 { 379 try 380 { 381 if ( xHierarchyName.is() ) 382 xHierarchyName->removeByHierarchicalName( *aThisRound ); 383 else 384 xNames->removeByName( *aThisRound ); 385 386 bSuccess = true; 387 388 // now that we removed the element, care for all it's child elements 389 // which may also be a part of the list 390 // #i33353# - 2004-09-27 - fs@openoffice.org 391 OSL_ENSURE( aThisRound->getLength() - 1 >= 0, "OApplicationController::deleteObjects: empty name?" ); 392 ::rtl::OUStringBuffer sSmallestSiblingName( *aThisRound ); 393 sSmallestSiblingName.append( (sal_Unicode)( '/' + 1) ); 394 395 ::std::set< ::rtl::OUString >::iterator aUpperChildrenBound = aDeleteNames.lower_bound( sSmallestSiblingName.makeStringAndClear() ); 396 for ( ::std::set< ::rtl::OUString >::iterator aObsolete = aThisRound; 397 aObsolete != aUpperChildrenBound; 398 ) 399 { 400 #if OSL_DEBUG_LEVEL > 0 401 ::rtl::OUString sObsoleteName = *aObsolete; 402 #endif 403 ::std::set< ::rtl::OUString >::iterator aNextObsolete = aObsolete; ++aNextObsolete; 404 aDeleteNames.erase( aObsolete ); 405 --nObjectsLeft; 406 aObsolete = aNextObsolete; 407 } 408 } 409 catch(const SQLException&) 410 { 411 showError( SQLExceptionInfo( ::cppu::getCaughtException() ) ); 412 } 413 catch(WrappedTargetException& e) 414 { 415 SQLException aSql; 416 if ( e.TargetException >>= aSql ) 417 showError( SQLExceptionInfo( e.TargetException ) ); 418 else 419 OSL_ENSURE( sal_False, "OApplicationController::deleteObjects: something strange happened!" ); 420 } 421 catch( const Exception& ) 422 { 423 DBG_UNHANDLED_EXCEPTION(); 424 } 425 } 426 427 if ( !bSuccess ) 428 { 429 // okay, this object could not be deleted (or the user did not want to delete it), 430 // but continue with the rest 431 aDeleteNames.erase( aThisRound ); 432 --nObjectsLeft; 433 } 434 } 435 } 436 } 437 // ----------------------------------------------------------------------------- 438 void OApplicationController::deleteEntries() 439 { 440 ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); 441 ::osl::MutexGuard aGuard( getMutex() ); 442 443 if ( getContainer() ) 444 { 445 ::std::vector< ::rtl::OUString> aList; 446 getSelectionElementNames(aList); 447 ElementType eType = getContainer()->getElementType(); 448 switch(eType) 449 { 450 case E_TABLE: 451 deleteTables(aList); 452 break; 453 case E_QUERY: 454 deleteObjects( E_QUERY, aList, true ); 455 break; 456 case E_FORM: 457 deleteObjects( E_FORM, aList, true ); 458 break; 459 case E_REPORT: 460 deleteObjects( E_REPORT, aList, true ); 461 break; 462 case E_NONE: 463 break; 464 } 465 } 466 } 467 // ----------------------------------------------------------------------------- 468 const SharedConnection& OApplicationController::ensureConnection( ::dbtools::SQLExceptionInfo* _pErrorInfo ) 469 { 470 ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); 471 ::osl::MutexGuard aGuard( getMutex() ); 472 473 if ( !m_xDataSourceConnection.is() ) 474 { 475 WaitObject aWO(getView()); 476 String sConnectingContext( ModuleRes( STR_COULDNOTCONNECT_DATASOURCE ) ); 477 sConnectingContext.SearchAndReplaceAscii("$name$", getStrippedDatabaseName()); 478 479 m_xDataSourceConnection.reset( connect( getDatabaseName(), sConnectingContext, _pErrorInfo ) ); 480 if ( m_xDataSourceConnection.is() ) 481 { 482 SQLExceptionInfo aError; 483 try 484 { 485 m_xMetaData = m_xDataSourceConnection->getMetaData(); 486 } 487 catch( const SQLException& ) 488 { 489 aError = ::cppu::getCaughtException(); 490 } 491 catch( const Exception& ) 492 { 493 DBG_UNHANDLED_EXCEPTION(); 494 } 495 if ( aError.isValid() ) 496 { 497 if ( _pErrorInfo ) 498 { 499 *_pErrorInfo = aError; 500 } 501 else 502 { 503 showError( aError ); 504 } 505 } 506 } 507 } 508 return m_xDataSourceConnection; 509 } 510 // ----------------------------------------------------------------------------- 511 sal_Bool OApplicationController::isDataSourceReadOnly() const 512 { 513 Reference<XStorable> xStore(m_xModel,UNO_QUERY); 514 return !xStore.is() || xStore->isReadonly(); 515 } 516 // ----------------------------------------------------------------------------- 517 sal_Bool OApplicationController::isConnectionReadOnly() const 518 { 519 sal_Bool bIsConnectionReadOnly = sal_True; 520 if ( m_xMetaData.is() ) 521 { 522 try 523 { 524 bIsConnectionReadOnly = m_xMetaData->isReadOnly(); 525 } 526 catch(const SQLException&) 527 { 528 DBG_UNHANDLED_EXCEPTION(); 529 } 530 } 531 // TODO check configuration 532 return bIsConnectionReadOnly; 533 } 534 // ----------------------------------------------------------------------------- 535 Reference< XNameAccess > OApplicationController::getElements( ElementType _eType ) 536 { 537 Reference< XNameAccess > xElements; 538 try 539 { 540 switch ( _eType ) 541 { 542 case E_REPORT: 543 { 544 Reference< XReportDocumentsSupplier > xSupp( m_xModel, UNO_QUERY_THROW ); 545 xElements.set( xSupp->getReportDocuments(), UNO_SET_THROW ); 546 } 547 break; 548 549 case E_FORM: 550 { 551 Reference< XFormDocumentsSupplier > xSupp( m_xModel, UNO_QUERY_THROW ); 552 xElements.set( xSupp->getFormDocuments(), UNO_SET_THROW ); 553 } 554 break; 555 556 case E_QUERY: 557 { 558 xElements.set( getQueryDefintions(), UNO_QUERY_THROW ); 559 } 560 break; 561 562 case E_TABLE: 563 { 564 if ( m_xDataSourceConnection.is() ) 565 { 566 Reference< XTablesSupplier > xSup( getConnection(), UNO_QUERY_THROW ); 567 xElements.set( xSup->getTables(), UNO_SET_THROW ); 568 } 569 } 570 break; 571 572 default: 573 break; 574 } 575 } 576 catch(const Exception&) 577 { 578 DBG_UNHANDLED_EXCEPTION(); 579 } 580 581 return xElements; 582 } 583 // ----------------------------------------------------------------------------- 584 void OApplicationController::getSelectionElementNames(::std::vector< ::rtl::OUString>& _rNames) const 585 { 586 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 587 ::osl::MutexGuard aGuard( getMutex() ); 588 589 OSL_ENSURE(getContainer(),"View isn't valid! -> GPF"); 590 591 getContainer()->getSelectionElementNames( _rNames ); 592 } 593 594 // ----------------------------------------------------------------------------- 595 ::std::auto_ptr< OLinkedDocumentsAccess > OApplicationController::getDocumentsAccess( ElementType _eType ) 596 { 597 OSL_ENSURE( ( _eType == E_TABLE ) || ( _eType == E_QUERY ) || ( _eType == E_FORM ) || ( _eType == E_REPORT ), 598 "OApplicationController::getDocumentsAccess: only forms and reports are supported here!" ); 599 600 SharedConnection xConnection( ensureConnection() ); 601 Reference< XNameAccess > xDocContainer; 602 603 if ( ( _eType == E_FORM ) | ( _eType == E_REPORT ) ) 604 { 605 xDocContainer.set( getElements( _eType ) ); 606 OSL_ENSURE( xDocContainer.is(), "OApplicationController::getDocumentsAccess: invalid container!" ); 607 } 608 609 ::std::auto_ptr< OLinkedDocumentsAccess > pDocuments( new OLinkedDocumentsAccess( 610 getView(), this, getORB(), xDocContainer, xConnection, getDatabaseName() 611 ) ); 612 return pDocuments; 613 } 614 // ----------------------------------------------------------------------------- 615 TransferableHelper* OApplicationController::copyObject() 616 { 617 try 618 { 619 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 620 ::osl::MutexGuard aGuard( getMutex() ); 621 622 ElementType eType = getContainer()->getElementType(); 623 TransferableHelper* pData = NULL; 624 switch( eType ) 625 { 626 case E_TABLE: 627 case E_QUERY: 628 { 629 SharedConnection xConnection( ensureConnection() ); 630 Reference< XDatabaseMetaData> xMetaData; 631 if ( xConnection.is() ) 632 xMetaData = xConnection->getMetaData(); 633 634 ::rtl::OUString sName = getContainer()->getQualifiedName( NULL ); 635 if ( sName.getLength() ) 636 { 637 ::rtl::OUString sDataSource = getDatabaseName(); 638 639 if ( eType == E_TABLE ) 640 { 641 pData = new ODataClipboard(sDataSource, CommandType::TABLE, sName, xConnection, getNumberFormatter(xConnection,getORB()), getORB()); 642 } 643 else 644 { 645 pData = new ODataClipboard(sDataSource, CommandType::QUERY, sName, getNumberFormatter(xConnection,getORB()), getORB()); 646 } 647 } 648 } 649 break; 650 case E_FORM: 651 case E_REPORT: 652 { 653 ::std::vector< ::rtl::OUString> aList; 654 getSelectionElementNames(aList); 655 Reference< XHierarchicalNameAccess > xElements(getElements(eType),UNO_QUERY); 656 if ( xElements.is() && !aList.empty() ) 657 { 658 Reference< XContent> xContent(xElements->getByHierarchicalName(*aList.begin()),UNO_QUERY); 659 pData = new OComponentTransferable( getDatabaseName(), xContent ); 660 } 661 } 662 break; 663 default: 664 break; 665 } 666 667 // the owner ship goes to ODataClipboards 668 return pData; 669 } 670 catch(const SQLException&) 671 { 672 showError( SQLExceptionInfo( ::cppu::getCaughtException() ) ); 673 } 674 catch( const Exception& ) 675 { 676 DBG_UNHANDLED_EXCEPTION(); 677 } 678 return NULL; 679 } 680 // ----------------------------------------------------------------------------- 681 sal_Bool OApplicationController::paste( ElementType _eType,const ::svx::ODataAccessDescriptor& _rPasteData,const String& _sParentFolder ,sal_Bool _bMove) 682 { 683 try 684 { 685 if ( _eType == E_QUERY ) 686 { 687 sal_Int32 nCommandType = CommandType::TABLE; 688 if ( _rPasteData.has(daCommandType) ) 689 _rPasteData[daCommandType] >>= nCommandType; 690 691 if ( CommandType::QUERY == nCommandType || CommandType::COMMAND == nCommandType ) 692 { 693 // read all necessary data 694 695 ::rtl::OUString sCommand; 696 sal_Bool bEscapeProcessing = sal_True; 697 698 _rPasteData[daCommand] >>= sCommand; 699 if ( _rPasteData.has(daEscapeProcessing) ) 700 _rPasteData[daEscapeProcessing] >>= bEscapeProcessing; 701 702 // plausibility check 703 sal_Bool bValidDescriptor = sal_False; 704 ::rtl::OUString sDataSourceName = _rPasteData.getDataSource(); 705 if (CommandType::QUERY == nCommandType) 706 bValidDescriptor = sDataSourceName.getLength() && sCommand.getLength(); 707 else if (CommandType::COMMAND == nCommandType) 708 bValidDescriptor = (0 != sCommand.getLength()); 709 if (!bValidDescriptor) 710 { 711 DBG_ERROR("OApplicationController::paste: invalid descriptor!"); 712 return sal_False; 713 } 714 715 // the target object name (as we'll suggest it to the user) 716 ::rtl::OUString sTargetName; 717 try 718 { 719 if ( CommandType::QUERY == nCommandType ) 720 sTargetName = sCommand; 721 722 if ( !sTargetName.getLength() ) 723 { 724 String sDefaultName = String( ModuleRes( STR_QRY_TITLE ) ); 725 sDefaultName = sDefaultName.GetToken( 0, ' ' ); 726 727 Reference< XNameAccess > xQueries( getQueryDefintions(), UNO_QUERY_THROW ); 728 sTargetName = ::dbtools::createUniqueName( xQueries, sDefaultName, sal_False ); 729 } 730 } 731 catch(const Exception&) 732 { 733 DBG_UNHANDLED_EXCEPTION(); 734 } 735 736 Reference< XPropertySet > xQuery; 737 if (CommandType::QUERY == nCommandType) 738 { 739 // need to extract the statement and the escape processing flag from the query object 740 sal_Bool bSuccess = sal_False; 741 try 742 { 743 // the concrete query 744 Reference< XQueryDefinitionsSupplier > xSourceQuerySup( 745 getDataSourceByName( sDataSourceName, getView(), getORB(), NULL ), 746 UNO_QUERY_THROW ); 747 Reference< XNameAccess > xQueries( xSourceQuerySup->getQueryDefinitions(), UNO_SET_THROW ); 748 if ( xQueries->hasByName( sCommand ) ) 749 { 750 xQuery.set( xQueries->getByName(sCommand), UNO_QUERY_THROW ); 751 bSuccess = true; 752 } 753 } 754 catch(SQLException&) { throw; } // caught and handled by the outer catch 755 catch( const Exception& ) 756 { 757 DBG_UNHANDLED_EXCEPTION(); 758 } 759 760 if (!bSuccess) 761 { 762 DBG_ERROR("OApplicationController::paste: could not extract the source query object!"); 763 // TODO: maybe this is worth an error message to be displayed to the user .... 764 return sal_False; 765 } 766 } 767 768 769 Reference< XNameContainer > xDestQueries(getQueryDefintions(), UNO_QUERY); 770 Reference< XSingleServiceFactory > xQueryFactory(xDestQueries, UNO_QUERY); 771 if (!xQueryFactory.is()) 772 { 773 DBG_ERROR("OApplicationController::paste: invalid destination query container!"); 774 return sal_False; 775 } 776 777 // here we have everything needed to create a new query object ... 778 // ... ehm, except a new name 779 ensureConnection(); 780 781 DynamicTableOrQueryNameCheck aNameChecker( getConnection(), CommandType::QUERY ); 782 ::dbtools::SQLExceptionInfo aDummy; 783 bool bNeedAskForName = ( sCommand.getLength() == 0 ) 784 /* we did not have a source name, so the target name was auto-generated */ 785 || ( !aNameChecker.isNameValid( sTargetName, aDummy ) ); 786 /* name is invalid in the target DB (e.g. because it already 787 has a /table/ with that name) */ 788 if ( bNeedAskForName ) 789 { 790 OSaveAsDlg aAskForName( getView(), 791 CommandType::QUERY, 792 getORB(), 793 getConnection(), 794 sTargetName, 795 aNameChecker, 796 SAD_ADDITIONAL_DESCRIPTION | SAD_TITLE_PASTE_AS); 797 if ( RET_OK != aAskForName.Execute() ) 798 // cancelled by the user 799 return sal_False; 800 sTargetName = aAskForName.getName(); 801 } 802 803 // create a new object 804 Reference< XPropertySet > xNewQuery(xQueryFactory->createInstance(), UNO_QUERY); 805 DBG_ASSERT(xNewQuery.is(), "OApplicationController::paste: invalid object created by factory!"); 806 if (xNewQuery.is()) 807 { 808 // initialize 809 if ( xQuery.is() ) 810 ::comphelper::copyProperties(xQuery,xNewQuery); 811 else 812 { 813 xNewQuery->setPropertyValue(PROPERTY_COMMAND,makeAny(sCommand)); 814 xNewQuery->setPropertyValue(PROPERTY_ESCAPE_PROCESSING,makeAny(bEscapeProcessing)); 815 } 816 // insert 817 xDestQueries->insertByName( sTargetName, makeAny(xNewQuery) ); 818 xNewQuery.set(xDestQueries->getByName( sTargetName),UNO_QUERY); 819 if ( xQuery.is() && xNewQuery.is() ) 820 { 821 Reference<XColumnsSupplier> xSrcColSup(xQuery,UNO_QUERY); 822 Reference<XColumnsSupplier> xDstColSup(xNewQuery,UNO_QUERY); 823 if ( xSrcColSup.is() && xDstColSup.is() ) 824 { 825 Reference<XNameAccess> xSrcNameAccess = xSrcColSup->getColumns(); 826 Reference<XNameAccess> xDstNameAccess = xDstColSup->getColumns(); 827 Reference<XDataDescriptorFactory> xFac(xDstNameAccess,UNO_QUERY); 828 Reference<XAppend> xAppend(xFac,UNO_QUERY); 829 if ( xSrcNameAccess.is() && xDstNameAccess.is() && xSrcNameAccess->hasElements() && xAppend.is() ) 830 { 831 Reference<XPropertySet> xDstProp(xFac->createDataDescriptor()); 832 833 Sequence< ::rtl::OUString> aSeq = xSrcNameAccess->getElementNames(); 834 const ::rtl::OUString* pIter = aSeq.getConstArray(); 835 const ::rtl::OUString* pEnd = pIter + aSeq.getLength(); 836 for( ; pIter != pEnd ; ++pIter) 837 { 838 Reference<XPropertySet> xSrcProp(xSrcNameAccess->getByName(*pIter),UNO_QUERY); 839 ::comphelper::copyProperties(xSrcProp,xDstProp); 840 xAppend->appendByDescriptor(xDstProp); 841 } 842 } 843 } 844 } 845 } 846 } 847 else 848 OSL_TRACE("There should be a sequence in it!"); 849 return sal_True; 850 } 851 else if ( _rPasteData.has(daComponent) ) // forms or reports 852 { 853 Reference<XContent> xContent; 854 _rPasteData[daComponent] >>= xContent; 855 return insertHierachyElement(_eType,_sParentFolder,Reference<XNameAccess>(xContent,UNO_QUERY).is(),xContent,_bMove); 856 } 857 } 858 catch(const SQLException&) { showError( SQLExceptionInfo( ::cppu::getCaughtException() ) ); } 859 catch(const Exception& ) 860 { 861 DBG_UNHANDLED_EXCEPTION(); 862 } 863 return sal_False; 864 } 865 // ----------------------------------------------------------------------------- 866 Reference<XNameContainer> OApplicationController::getQueryDefintions() const 867 { 868 Reference<XQueryDefinitionsSupplier> xSet(m_xDataSource,UNO_QUERY); 869 Reference<XNameContainer> xNames; 870 if ( xSet.is() ) 871 { 872 xNames.set(xSet->getQueryDefinitions(),UNO_QUERY); 873 } 874 return xNames; 875 } 876 // ----------------------------------------------------------------------------- 877 void OApplicationController::getSupportedFormats(ElementType _eType,::std::vector<SotFormatStringId>& _rFormatIds) const 878 { 879 switch( _eType ) 880 { 881 case E_TABLE: 882 _rFormatIds.push_back(SOT_FORMATSTR_ID_DBACCESS_TABLE); 883 _rFormatIds.push_back(SOT_FORMAT_RTF); 884 _rFormatIds.push_back(SOT_FORMATSTR_ID_HTML); 885 // run through 886 case E_QUERY: 887 _rFormatIds.push_back(SOT_FORMATSTR_ID_DBACCESS_QUERY); 888 break; 889 default: 890 break; 891 } 892 } 893 // ----------------------------------------------------------------------------- 894 sal_Bool OApplicationController::isTableFormat() const 895 { 896 return m_aTableCopyHelper.isTableFormat(getViewClipboard()); 897 } 898 // ----------------------------------------------------------------------------- 899 IMPL_LINK( OApplicationController, OnAsyncDrop, void*, /*NOTINTERESTEDIN*/ ) 900 { 901 m_nAsyncDrop = 0; 902 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 903 ::osl::MutexGuard aGuard( getMutex() ); 904 905 906 if ( m_aAsyncDrop.nType == E_TABLE ) 907 { 908 SharedConnection xConnection( ensureConnection() ); 909 if ( xConnection.is() ) 910 m_aTableCopyHelper.asyncCopyTagTable( m_aAsyncDrop, getDatabaseName(), xConnection ); 911 } 912 else 913 { 914 if ( paste(m_aAsyncDrop.nType,m_aAsyncDrop.aDroppedData,m_aAsyncDrop.aUrl,m_aAsyncDrop.nAction == DND_ACTION_MOVE) 915 && m_aAsyncDrop.nAction == DND_ACTION_MOVE ) 916 { 917 Reference<XContent> xContent; 918 m_aAsyncDrop.aDroppedData[daComponent] >>= xContent; 919 ::std::vector< ::rtl::OUString> aList; 920 sal_Int32 nIndex = 0; 921 ::rtl::OUString sName = xContent->getIdentifier()->getContentIdentifier(); 922 ::rtl::OUString sErase = sName.getToken(0,'/',nIndex); // we don't want to have the "private:forms" part 923 if ( nIndex != -1 ) 924 { 925 aList.push_back(sName.copy(sErase.getLength() + 1)); 926 deleteObjects( m_aAsyncDrop.nType, aList, false ); 927 } 928 } 929 } 930 931 m_aAsyncDrop.aDroppedData.clear(); 932 933 return 0L; 934 } 935 //........................................................................ 936 } // namespace dbaui 937 //........................................................................ 938