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_dbaccess.hxx" 26 27 #include "adtabdlg.hxx" 28 #include "browserids.hxx" 29 #include "dbu_qry.hrc" 30 #include "dbu_reghelper.hxx" 31 #include "dbustrings.hrc" 32 #include "defaultobjectnamecheck.hxx" 33 #include "dlgsave.hxx" 34 #include "localresaccess.hxx" 35 #include "QTableWindow.hxx" 36 #include "QTableWindowData.hxx" 37 #include "querycontainerwindow.hxx" 38 #include "querycontroller.hxx" 39 #include "QueryDesignView.hxx" 40 #include "QueryTableView.hxx" 41 #include "QueryTextView.hxx" 42 #include "queryview.hxx" 43 #include "QueryViewSwitch.hxx" 44 #include "sqlmessage.hxx" 45 #include "TableConnectionData.hxx" 46 #include "TableFieldDescription.hxx" 47 #include "UITools.hxx" 48 49 /** === begin UNO includes === **/ 50 #include <com/sun/star/beans/PropertyAttribute.hpp> 51 #include <com/sun/star/container/XChild.hpp> 52 #include <com/sun/star/container/XNameContainer.hpp> 53 #include <com/sun/star/frame/FrameSearchFlag.hpp> 54 #include <com/sun/star/frame/XLoadEventListener.hpp> 55 #include <com/sun/star/io/XActiveDataSink.hpp> 56 #include <com/sun/star/io/XActiveDataSource.hpp> 57 #include <com/sun/star/sdb/CommandType.hpp> 58 #include <com/sun/star/sdb/SQLContext.hpp> 59 #include <com/sun/star/sdb/XQueriesSupplier.hpp> 60 #include <com/sun/star/sdb/XQueryDefinitionsSupplier.hpp> 61 #include <com/sun/star/sdb/XSQLQueryComposerFactory.hpp> 62 #include <com/sun/star/sdbc/SQLWarning.hpp> 63 #include <com/sun/star/sdbc/XRow.hpp> 64 #include <com/sun/star/sdbcx/XAppend.hpp> 65 #include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp> 66 #include <com/sun/star/sdbcx/XDrop.hpp> 67 #include <com/sun/star/sdbcx/XTablesSupplier.hpp> 68 #include <com/sun/star/sdbcx/XViewsSupplier.hpp> 69 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> 70 #include <com/sun/star/util/XCloseable.hpp> 71 #include <com/sun/star/util/VetoException.hpp> 72 #include <com/sun/star/frame/XUntitledNumbers.hpp> 73 /** === end UNO includes === **/ 74 75 #include <comphelper/basicio.hxx> 76 #include <comphelper/extract.hxx> 77 #include <comphelper/property.hxx> 78 #include <comphelper/seqstream.hxx> 79 #include <comphelper/streamsection.hxx> 80 #include <comphelper/types.hxx> 81 #include <connectivity/dbexception.hxx> 82 #include <connectivity/dbtools.hxx> 83 #include <cppuhelper/exc_hlp.hxx> 84 #include <sfx2/sfxsids.hrc> 85 #include <svtools/localresaccess.hxx> 86 #include <toolkit/helper/vclunohelper.hxx> 87 #include <tools/diagnose_ex.h> 88 #include <vcl/msgbox.hxx> 89 #include <vcl/svapp.hxx> 90 #include <vos/mutex.hxx> 91 92 extern "C" void SAL_CALL createRegistryInfo_OQueryControl() 93 { 94 static ::dbaui::OMultiInstanceAutoRegistration< ::dbaui::OQueryController > aAutoRegistration; 95 } 96 namespace dbaui 97 { 98 using namespace ::com::sun::star::uno; 99 using namespace ::com::sun::star::beans; 100 using namespace ::com::sun::star::frame; 101 using namespace ::com::sun::star::util; 102 using namespace ::com::sun::star::lang; 103 104 class OViewController : public OQueryController 105 { 106 //------------------------------------------------------------------------------ 107 virtual ::rtl::OUString SAL_CALL getImplementationName() throw( RuntimeException ) 108 { 109 return getImplementationName_Static(); 110 } 111 //------------------------------------------------------------------------- 112 virtual Sequence< ::rtl::OUString> SAL_CALL getSupportedServiceNames() throw(RuntimeException) 113 { 114 return getSupportedServiceNames_Static(); 115 } 116 public: 117 OViewController(const Reference< XMultiServiceFactory >& _rM) : OQueryController(_rM){} 118 119 // need by registration 120 static ::rtl::OUString getImplementationName_Static() throw( RuntimeException ) 121 { 122 return ::rtl::OUString::createFromAscii("org.openoffice.comp.dbu.OViewDesign"); 123 } 124 static Sequence< ::rtl::OUString > getSupportedServiceNames_Static(void) throw( RuntimeException ) 125 { 126 Sequence< ::rtl::OUString> aSupported(1); 127 aSupported.getArray()[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdb.ViewDesign"); 128 return aSupported; 129 } 130 static Reference< XInterface > SAL_CALL Create(const Reference< XMultiServiceFactory >& _rM) 131 { 132 return *(new OViewController(_rM)); 133 } 134 }; 135 } 136 extern "C" void SAL_CALL createRegistryInfo_OViewControl() 137 { 138 static ::dbaui::OMultiInstanceAutoRegistration< ::dbaui::OViewController > aAutoRegistration; 139 } 140 141 namespace dbaui 142 { 143 using namespace ::connectivity; 144 #if OSL_DEBUG_LEVEL > 1 145 namespace 146 { 147 // ----------------------------------------------------------------------------- 148 void insertParseTree(SvTreeListBox* _pBox,::connectivity::OSQLParseNode* _pNode,SvLBoxEntry* _pParent = NULL) 149 { 150 ::rtl::OUString rString; 151 if (!_pNode->isToken()) 152 { 153 // Regelnamen als rule: ... 154 rString = ::rtl::OUString::createFromAscii("RULE_ID: "); 155 rString += ::rtl::OUString::valueOf( (sal_Int32)_pNode->getRuleID()); 156 rString+= ::rtl::OUString::createFromAscii("("); 157 rString += OSQLParser::RuleIDToStr(_pNode->getRuleID()); 158 rString+= ::rtl::OUString::createFromAscii(")"); 159 160 161 _pParent = _pBox->InsertEntry(rString,_pParent); 162 163 // einmal auswerten wieviel Subtrees dieser Knoten besitzt 164 sal_uInt32 nStop = _pNode->count(); 165 // hol dir den ersten Subtree 166 for(sal_uInt32 i=0;i<nStop;++i) 167 insertParseTree(_pBox,_pNode->getChild(i),_pParent); 168 } 169 else 170 { 171 // ein Token gefunden 172 // tabs fuer das Einruecken entsprechend nLevel 173 174 switch (_pNode->getNodeType()) 175 { 176 177 case SQL_NODE_KEYWORD: 178 { 179 rString+= ::rtl::OUString::createFromAscii("SQL_KEYWORD:"); 180 ::rtl::OString sT = OSQLParser::TokenIDToStr(_pNode->getTokenID()); 181 rString += ::rtl::OStringToOUString( sT, RTL_TEXTENCODING_UTF8); 182 break;} 183 184 case SQL_NODE_COMPARISON: 185 {rString+= ::rtl::OUString::createFromAscii("SQL_COMPARISON:"); 186 rString += _pNode->getTokenValue(); // haenge Nodevalue an 187 // und beginne neu Zeile 188 break;} 189 190 case SQL_NODE_NAME: 191 {rString+= ::rtl::OUString::createFromAscii("SQL_NAME:"); 192 rString+= ::rtl::OUString::createFromAscii("\""); 193 rString += _pNode->getTokenValue(); 194 rString+= ::rtl::OUString::createFromAscii("\""); 195 196 break;} 197 198 case SQL_NODE_STRING: 199 {rString += ::rtl::OUString::createFromAscii("SQL_STRING:'"); 200 rString += _pNode->getTokenValue(); 201 break;} 202 203 case SQL_NODE_INTNUM: 204 {rString += ::rtl::OUString::createFromAscii("SQL_INTNUM:"); 205 rString += _pNode->getTokenValue(); 206 break;} 207 208 case SQL_NODE_APPROXNUM: 209 {rString += ::rtl::OUString::createFromAscii("SQL_APPROXNUM:"); 210 rString += _pNode->getTokenValue(); 211 break;} 212 213 case SQL_NODE_PUNCTUATION: 214 {rString += ::rtl::OUString::createFromAscii("SQL_PUNCTUATION:"); 215 rString += _pNode->getTokenValue(); // haenge Nodevalue an 216 break;} 217 218 case SQL_NODE_AMMSC: 219 {rString += ::rtl::OUString::createFromAscii("SQL_AMMSC:"); 220 rString += _pNode->getTokenValue(); // haenge Nodevalue an 221 222 break;} 223 224 default: 225 OSL_ASSERT("OSQLParser::ShowParseTree: unzulaessiger NodeType"); 226 rString += _pNode->getTokenValue(); 227 } 228 _pBox->InsertEntry(rString,_pParent); 229 } 230 } 231 } 232 #endif // OSL_DEBUG_LEVEL 233 234 namespace 235 { 236 // ----------------------------------------------------------------------------- 237 String lcl_getObjectResourceString( sal_uInt16 _nResId, sal_Int32 _nCommandType ) 238 { 239 String sMessageText = String( ModuleRes( _nResId ) ); 240 String sObjectType; 241 { 242 LocalResourceAccess aLocalRes( RSC_QUERY_OBJECT_TYPE, RSC_RESOURCE ); 243 sObjectType = String( ModuleRes( (sal_uInt16)( _nCommandType + 1 ) ) ); 244 } 245 sMessageText.SearchAndReplace( String::CreateFromAscii( "$object$" ), sObjectType ); 246 return sMessageText; 247 } 248 } 249 250 using namespace ::com::sun::star::uno; 251 using namespace ::com::sun::star::io; 252 using namespace ::com::sun::star::beans; 253 using namespace ::com::sun::star::frame; 254 using namespace ::com::sun::star::util; 255 using namespace ::com::sun::star::lang; 256 using namespace ::com::sun::star::container; 257 using namespace ::com::sun::star::sdbcx; 258 using namespace ::com::sun::star::sdbc; 259 using namespace ::com::sun::star::sdb; 260 using namespace ::com::sun::star::ui::dialogs; 261 using namespace ::com::sun::star::awt; 262 using namespace ::dbtools; 263 264 using namespace ::comphelper; 265 266 namespace 267 { 268 void ensureToolbars( OQueryController& _rController, sal_Bool _bDesign ) 269 { 270 Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager = _rController.getLayoutManager( _rController.getFrame() ); 271 if ( xLayoutManager.is() ) 272 { 273 xLayoutManager->lock(); 274 static ::rtl::OUString s_sDesignToolbar(RTL_CONSTASCII_USTRINGPARAM("private:resource/toolbar/designobjectbar")); 275 static ::rtl::OUString s_sSqlToolbar(RTL_CONSTASCII_USTRINGPARAM("private:resource/toolbar/sqlobjectbar")); 276 if ( _bDesign ) 277 { 278 xLayoutManager->destroyElement( s_sSqlToolbar ); 279 xLayoutManager->createElement( s_sDesignToolbar ); 280 } 281 else 282 { 283 xLayoutManager->destroyElement( s_sDesignToolbar ); 284 xLayoutManager->createElement( s_sSqlToolbar ); 285 } 286 xLayoutManager->unlock(); 287 xLayoutManager->doLayout(); 288 } 289 } 290 } 291 292 //------------------------------------------------------------------------------ 293 ::rtl::OUString SAL_CALL OQueryController::getImplementationName() throw( RuntimeException ) 294 { 295 return getImplementationName_Static(); 296 } 297 298 //------------------------------------------------------------------------------ 299 ::rtl::OUString OQueryController::getImplementationName_Static() throw( RuntimeException ) 300 { 301 return ::rtl::OUString::createFromAscii("org.openoffice.comp.dbu.OQueryDesign"); 302 } 303 //------------------------------------------------------------------------------ 304 Sequence< ::rtl::OUString> OQueryController::getSupportedServiceNames_Static(void) throw( RuntimeException ) 305 { 306 Sequence< ::rtl::OUString> aSupported(1); 307 aSupported.getArray()[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdb.QueryDesign"); 308 return aSupported; 309 } 310 //------------------------------------------------------------------------- 311 Sequence< ::rtl::OUString> SAL_CALL OQueryController::getSupportedServiceNames() throw(RuntimeException) 312 { 313 return getSupportedServiceNames_Static(); 314 } 315 // ------------------------------------------------------------------------- 316 Reference< XInterface > SAL_CALL OQueryController::Create(const Reference<XMultiServiceFactory >& _rxFactory) 317 { 318 return *(new OQueryController(_rxFactory)); 319 } 320 DBG_NAME(OQueryController); 321 // ----------------------------------------------------------------------------- 322 OQueryController::OQueryController(const Reference< XMultiServiceFactory >& _rM) 323 :OJoinController(_rM) 324 ,OQueryController_PBase( getBroadcastHelper() ) 325 ,m_pParseContext( new svxform::OSystemParseContext ) 326 ,m_aSqlParser( _rM, m_pParseContext ) 327 ,m_pSqlIterator(NULL) 328 ,m_nVisibleRows(0x400) 329 ,m_nSplitPos(-1) 330 ,m_nCommandType( CommandType::QUERY ) 331 ,m_bGraphicalDesign(sal_False) 332 ,m_bDistinct(sal_False) 333 ,m_bViewAlias(sal_False) 334 ,m_bViewTable(sal_False) 335 ,m_bViewFunction(sal_False) 336 ,m_bEscapeProcessing(sal_True) 337 { 338 DBG_CTOR(OQueryController,NULL); 339 InvalidateAll(); 340 341 registerProperty( PROPERTY_ACTIVECOMMAND, PROPERTY_ID_ACTIVECOMMAND, PropertyAttribute::READONLY | PropertyAttribute::BOUND, 342 &m_sStatement, ::getCppuType( &m_sStatement ) ); 343 registerProperty( PROPERTY_ESCAPE_PROCESSING, PROPERTY_ID_ESCAPE_PROCESSING, PropertyAttribute::READONLY | PropertyAttribute::BOUND, 344 &m_bEscapeProcessing, ::getCppuType( &m_bEscapeProcessing ) ); 345 } 346 347 // ----------------------------------------------------------------------------- 348 OQueryController::~OQueryController() 349 { 350 DBG_DTOR(OQueryController,NULL); 351 if ( !getBroadcastHelper().bDisposed && !getBroadcastHelper().bInDispose ) 352 { 353 OSL_ENSURE(0,"Please check who doesn't dispose this component!"); 354 // increment ref count to prevent double call of Dtor 355 osl_incrementInterlockedCount( &m_refCount ); 356 dispose(); 357 } 358 } 359 360 IMPLEMENT_FORWARD_XINTERFACE2( OQueryController, OJoinController, OQueryController_PBase ) 361 IMPLEMENT_FORWARD_XTYPEPROVIDER2( OQueryController, OJoinController, OQueryController_PBase ) 362 363 //------------------------------------------------------------------------- 364 Reference< XPropertySetInfo > SAL_CALL OQueryController::getPropertySetInfo() throw(RuntimeException) 365 { 366 Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 367 return xInfo; 368 } 369 370 //------------------------------------------------------------------------- 371 sal_Bool SAL_CALL OQueryController::convertFastPropertyValue( Any& o_rConvertedValue, Any& o_rOldValue, sal_Int32 i_nHandle, const Any& i_rValue ) throw (IllegalArgumentException) 372 { 373 return OPropertyContainer::convertFastPropertyValue( o_rConvertedValue, o_rOldValue, i_nHandle, i_rValue ); 374 } 375 376 //------------------------------------------------------------------------- 377 void SAL_CALL OQueryController::setFastPropertyValue_NoBroadcast( sal_Int32 i_nHandle, const Any& i_rValue ) throw ( Exception ) 378 { 379 OPropertyContainer::setFastPropertyValue_NoBroadcast( i_nHandle, i_rValue ); 380 } 381 382 //------------------------------------------------------------------------- 383 void SAL_CALL OQueryController::getFastPropertyValue( Any& o_rValue, sal_Int32 i_nHandle ) const 384 { 385 switch ( i_nHandle ) 386 { 387 case PROPERTY_ID_CURRENT_QUERY_DESIGN: 388 { 389 ::comphelper::NamedValueCollection aCurrentDesign; 390 aCurrentDesign.put( "GraphicalDesign", isGraphicalDesign() ); 391 aCurrentDesign.put( (::rtl::OUString)PROPERTY_ESCAPE_PROCESSING, m_bEscapeProcessing ); 392 393 if ( isGraphicalDesign() ) 394 { 395 getContainer()->SaveUIConfig(); 396 saveViewSettings( aCurrentDesign, true ); 397 aCurrentDesign.put( "Statement", m_sStatement ); 398 } 399 else 400 { 401 aCurrentDesign.put( "Statement", getContainer()->getStatement() ); 402 } 403 404 o_rValue <<= aCurrentDesign.getPropertyValues(); 405 } 406 break; 407 408 default: 409 OPropertyContainer::getFastPropertyValue( o_rValue, i_nHandle ); 410 break; 411 } 412 } 413 414 //------------------------------------------------------------------------- 415 ::cppu::IPropertyArrayHelper& OQueryController::getInfoHelper() 416 { 417 return *const_cast< OQueryController* >( this )->getArrayHelper(); 418 } 419 420 //-------------------------------------------------------------------- 421 ::cppu::IPropertyArrayHelper* OQueryController::createArrayHelper( ) const 422 { 423 Sequence< Property > aProps; 424 describeProperties( aProps ); 425 426 // one additional property: 427 const sal_Int32 nLength = aProps.getLength(); 428 aProps.realloc( nLength + 1 ); 429 aProps[ nLength ] = Property( 430 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CurrentQueryDesign" ) ), 431 PROPERTY_ID_CURRENT_QUERY_DESIGN, 432 ::cppu::UnoType< Sequence< PropertyValue > >::get(), 433 PropertyAttribute::READONLY 434 ); 435 436 ::std::sort( 437 aProps.getArray(), 438 aProps.getArray() + aProps.getLength(), 439 ::comphelper::PropertyCompareByName() 440 ); 441 442 return new ::cppu::OPropertyArrayHelper(aProps); 443 } 444 445 // ----------------------------------------------------------------------------- 446 void OQueryController::deleteIterator() 447 { 448 if(m_pSqlIterator) 449 { 450 delete m_pSqlIterator->getParseTree(); 451 m_pSqlIterator->dispose(); 452 delete m_pSqlIterator; 453 m_pSqlIterator = NULL; 454 } 455 } 456 // ----------------------------------------------------------------------------- 457 void OQueryController::disposing() 458 { 459 OQueryController_PBase::disposing(); 460 461 deleteIterator(); 462 463 delete m_pParseContext; 464 465 clearFields(); 466 OTableFields().swap(m_vUnUsedFieldsDesc); 467 468 ::comphelper::disposeComponent(m_xComposer); 469 OJoinController::disposing(); 470 OQueryController_PBase::disposing(); 471 } 472 // ----------------------------------------------------------------------------- 473 void OQueryController::clearFields() 474 { 475 OTableFields().swap(m_vTableFieldDesc); 476 } 477 // ----------------------------------------------------------------------------- 478 FeatureState OQueryController::GetState(sal_uInt16 _nId) const 479 { 480 FeatureState aReturn; 481 aReturn.bEnabled = sal_True; 482 // (disabled automatically) 483 484 switch (_nId) 485 { 486 case ID_BROWSER_EDITDOC: 487 if ( editingCommand() ) 488 aReturn.bEnabled = sal_False; 489 else if ( editingView() && !m_xAlterView.is() ) 490 aReturn.bEnabled = sal_False; 491 else 492 aReturn = OJoinController::GetState( _nId ); 493 break; 494 495 case ID_BROWSER_ESACPEPROCESSING: 496 aReturn.bChecked = !m_bEscapeProcessing; 497 aReturn.bEnabled = ( m_pSqlIterator != NULL ) && !m_bGraphicalDesign; 498 break; 499 case SID_RELATION_ADD_RELATION: 500 aReturn.bEnabled = isEditable() && m_bGraphicalDesign && m_vTableData.size() > 1; 501 break; 502 case ID_BROWSER_SAVEASDOC: 503 aReturn.bEnabled = !editingCommand() && !editingView() && (!m_bGraphicalDesign || !(m_vTableFieldDesc.empty() || m_vTableData.empty())); 504 break; 505 case ID_BROWSER_SAVEDOC: 506 aReturn.bEnabled = impl_isModified() && (!m_bGraphicalDesign || !(m_vTableFieldDesc.empty() || m_vTableData.empty())); 507 break; 508 case SID_PRINTDOCDIRECT: 509 break; 510 case ID_BROWSER_CUT: 511 aReturn.bEnabled = isEditable() && getContainer() && getContainer()->isCutAllowed(); 512 break; 513 case ID_BROWSER_COPY: 514 aReturn.bEnabled = getContainer() && getContainer()->isCopyAllowed(); 515 break; 516 case ID_BROWSER_PASTE: 517 aReturn.bEnabled = isEditable() && getContainer() && getContainer()->isPasteAllowed(); 518 break; 519 case ID_BROWSER_SQL: 520 aReturn.bEnabled = m_bEscapeProcessing && m_pSqlIterator; 521 aReturn.bChecked = m_bGraphicalDesign; 522 break; 523 case SID_BROWSER_CLEAR_QUERY: 524 aReturn.bEnabled = isEditable() && (m_sStatement.getLength() || !m_vTableData.empty()); 525 break; 526 case SID_QUERY_VIEW_FUNCTIONS: 527 case SID_QUERY_VIEW_TABLES: 528 case SID_QUERY_VIEW_ALIASES: 529 aReturn.bChecked = getContainer() && getContainer()->isSlotEnabled(_nId); 530 aReturn.bEnabled = m_bGraphicalDesign; 531 break; 532 case SID_QUERY_DISTINCT_VALUES: 533 aReturn.bEnabled = m_bGraphicalDesign && isEditable(); 534 aReturn.bChecked = m_bDistinct; 535 break; 536 case ID_BROWSER_QUERY_EXECUTE: 537 aReturn.bEnabled = sal_True; 538 break; 539 case SID_DB_QUERY_PREVIEW: 540 aReturn.bEnabled = sal_True; 541 aReturn.bChecked = getContainer() && getContainer()->getPreviewFrame().is(); 542 break; 543 #if OSL_DEBUG_LEVEL > 1 544 case ID_EDIT_QUERY_SQL: 545 break; 546 case ID_EDIT_QUERY_DESIGN: 547 break; 548 #endif 549 case ID_BROWSER_ADDTABLE: 550 if ( !m_bGraphicalDesign ) 551 { 552 aReturn.bEnabled = sal_False; 553 break; 554 } 555 // run through 556 default: 557 aReturn = OJoinController::GetState(_nId); 558 break; 559 } 560 return aReturn; 561 } 562 // ----------------------------------------------------------------------------- 563 void OQueryController::Execute(sal_uInt16 _nId, const Sequence< PropertyValue >& aArgs) 564 { 565 switch(_nId) 566 { 567 case ID_BROWSER_ESACPEPROCESSING: 568 setEscapeProcessing_fireEvent( !m_bEscapeProcessing ); 569 if ( !editingView() ) 570 setModified(sal_True); 571 InvalidateFeature(ID_BROWSER_SQL); 572 break; 573 case ID_BROWSER_SAVEASDOC: 574 case ID_BROWSER_SAVEDOC: 575 doSaveAsDoc(ID_BROWSER_SAVEASDOC == _nId); 576 break; 577 case SID_RELATION_ADD_RELATION: 578 { 579 OJoinDesignView* pView = getJoinView(); 580 if( pView ) 581 static_cast<OQueryTableView*>(pView->getTableView())->createNewConnection(); 582 } 583 break; 584 case SID_PRINTDOCDIRECT: 585 break; 586 case ID_BROWSER_CUT: 587 getContainer()->cut(); 588 break; 589 case ID_BROWSER_COPY: 590 getContainer()->copy(); 591 break; 592 case ID_BROWSER_PASTE: 593 getContainer()->paste(); 594 break; 595 case ID_BROWSER_SQL: 596 { 597 if ( !getContainer()->checkStatement() ) 598 break; 599 SQLExceptionInfo aError; 600 try 601 { 602 ::rtl::OUString aErrorMsg; 603 setStatement_fireEvent( getContainer()->getStatement() ); 604 if(!m_sStatement.getLength() && m_pSqlIterator) 605 { 606 // change the view of the data 607 delete m_pSqlIterator->getParseTree(); 608 m_pSqlIterator->setParseTree(NULL); 609 m_bGraphicalDesign = !m_bGraphicalDesign; 610 impl_setViewMode( &aError ); 611 } 612 else 613 { 614 ::connectivity::OSQLParseNode* pNode = m_aSqlParser.parseTree(aErrorMsg,m_sStatement,m_bGraphicalDesign); 615 if ( pNode ) 616 { 617 delete m_pSqlIterator->getParseTree(); 618 m_pSqlIterator->setParseTree(pNode); 619 m_pSqlIterator->traverseAll(); 620 621 if ( m_pSqlIterator->hasErrors() ) 622 { 623 aError = m_pSqlIterator->getErrors(); 624 } 625 else 626 { 627 const OSQLTables& xTabs = m_pSqlIterator->getTables(); 628 if ( m_pSqlIterator->getStatementType() != SQL_STATEMENT_SELECT || xTabs.begin() == xTabs.end() ) 629 { 630 aError = SQLException( 631 String( ModuleRes( STR_QRY_NOSELECT ) ), 632 NULL, 633 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "S1000" ) ), 634 1000, 635 Any() 636 ); 637 } 638 else 639 { 640 // change the view of the data 641 m_bGraphicalDesign = !m_bGraphicalDesign; 642 ::rtl::OUString sNewStatement; 643 pNode->parseNodeToStr( sNewStatement, getConnection() ); 644 setStatement_fireEvent( sNewStatement ); 645 getContainer()->SaveUIConfig(); 646 m_vTableConnectionData.clear(); 647 impl_setViewMode( &aError ); 648 } 649 } 650 } 651 else 652 { 653 aError = SQLException( 654 String( ModuleRes( STR_QRY_SYNTAX ) ), 655 NULL, 656 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "S1000" ) ), 657 1000, 658 Any() 659 ); 660 } 661 } 662 } 663 catch(const SQLException& e) 664 { 665 aError = ::cppu::getCaughtException(); 666 } 667 catch(const Exception&) 668 { 669 DBG_UNHANDLED_EXCEPTION(); 670 } 671 672 if ( aError.isValid() ) 673 showError( aError ); 674 675 if(m_bGraphicalDesign) 676 { 677 InvalidateFeature(ID_BROWSER_ADDTABLE); 678 InvalidateFeature(SID_RELATION_ADD_RELATION); 679 } 680 } 681 break; 682 case SID_BROWSER_CLEAR_QUERY: 683 { 684 GetUndoManager().EnterListAction( String( ModuleRes(STR_QUERY_UNDO_TABWINDELETE) ), String() ); 685 getContainer()->clear(); 686 GetUndoManager().LeaveListAction(); 687 688 setStatement_fireEvent( ::rtl::OUString() ); 689 if(m_bGraphicalDesign) 690 InvalidateFeature(ID_BROWSER_ADDTABLE); 691 } 692 // InvalidateFeature(ID_BROWSER_QUERY_EXECUTE); 693 break; 694 case SID_QUERY_VIEW_FUNCTIONS: 695 case SID_QUERY_VIEW_TABLES: 696 case SID_QUERY_VIEW_ALIASES: 697 getContainer()->setSlotEnabled(_nId,!getContainer()->isSlotEnabled(_nId)); 698 setModified(sal_True); 699 break; 700 case SID_QUERY_DISTINCT_VALUES: 701 m_bDistinct = !m_bDistinct; 702 setModified(sal_True); 703 break; 704 case ID_BROWSER_QUERY_EXECUTE: 705 if ( getContainer()->checkStatement() ) 706 executeQuery(); 707 break; 708 case SID_DB_QUERY_PREVIEW: 709 try 710 { 711 Reference< ::com::sun::star::util::XCloseable > xCloseFrame( getContainer()->getPreviewFrame(), UNO_QUERY ); 712 if ( xCloseFrame.is() ) 713 { 714 try 715 { 716 xCloseFrame->close( sal_True ); 717 } 718 catch( const Exception& ) 719 { 720 OSL_ENSURE( sal_False, "OQueryController::Execute(SID_DB_QUERY_PREVIEW): *nobody* is expected to veto closing the preview frame!" ); 721 } 722 } 723 else 724 Execute(ID_BROWSER_QUERY_EXECUTE,Sequence< PropertyValue >()); 725 } 726 catch(Exception&) 727 { 728 } 729 break; 730 case ID_QUERY_ZOOM_IN: 731 { 732 // m_aZoom *= Fraction(1,10); 733 // static_cast<OQueryViewSwitch*>(getView())->zoomTableView(m_aZoom); 734 } 735 break; 736 case ID_QUERY_ZOOM_OUT: 737 { 738 // if(m_aZoom != Fraction(1,1)) 739 // m_aZoom /= Fraction(1,10); 740 // static_cast<OQueryViewSwitch*>(getView())->zoomTableView(m_aZoom); 741 } 742 break; 743 #if OSL_DEBUG_LEVEL > 1 744 case ID_EDIT_QUERY_DESIGN: 745 case ID_EDIT_QUERY_SQL: 746 { 747 ::rtl::OUString aErrorMsg; 748 setStatement_fireEvent( getContainer()->getStatement() ); 749 ::connectivity::OSQLParseNode* pNode = m_aSqlParser.parseTree( aErrorMsg, m_sStatement, m_bGraphicalDesign ); 750 if ( pNode ) 751 { 752 Window* pView = getView(); 753 ModalDialog* pWindow = new ModalDialog( pView, WB_STDMODAL | WB_SIZEMOVE | WB_CENTER ); 754 pWindow->SetSizePixel( ::Size( pView->GetSizePixel().Width() / 2, pView->GetSizePixel().Height() / 2 ) ); 755 SvTreeListBox* pTreeBox = new SvTreeListBox( pWindow, WB_BORDER | WB_HASLINES | WB_HASBUTTONS | WB_HASBUTTONSATROOT | WB_HASLINESATROOT | WB_VSCROLL ); 756 pTreeBox->SetPosSizePixel( ::Point( 6, 6 ), ::Size( pWindow->GetSizePixel().Width() - 12, pWindow->GetSizePixel().Height() - 12 )); 757 pTreeBox->SetNodeDefaultImages(); 758 759 if ( _nId == ID_EDIT_QUERY_DESIGN ) 760 { 761 ::connectivity::OSQLParseNode* pTemp = pNode ? pNode->getChild(3)->getChild(1) : NULL; 762 // no where clause found 763 if ( pTemp && !pTemp->isLeaf() ) 764 { 765 ::connectivity::OSQLParseNode * pCondition = pTemp->getChild(1); 766 if ( pCondition ) // no where clause 767 { 768 ::connectivity::OSQLParseNode::negateSearchCondition(pCondition); 769 ::connectivity::OSQLParseNode *pNodeTmp = pTemp->getChild(1); 770 771 ::connectivity::OSQLParseNode::disjunctiveNormalForm(pNodeTmp); 772 pNodeTmp = pTemp->getChild(1); 773 ::connectivity::OSQLParseNode::absorptions(pNodeTmp); 774 pNodeTmp = pTemp->getChild(1); 775 OSQLParseNode::compress(pNodeTmp); 776 pNodeTmp = pTemp->getChild(1); 777 } // if ( pCondition ) // no where clause 778 ::rtl::OUString sTemp; 779 pNode->parseNodeToStr(sTemp,getConnection()); 780 getContainer()->setStatement(sTemp); 781 782 } 783 } 784 785 insertParseTree(pTreeBox,pNode); 786 787 pTreeBox->Show(); 788 pWindow->Execute(); 789 790 delete pTreeBox; 791 delete pWindow; 792 delete pNode; 793 } 794 break; 795 } 796 #endif 797 default: 798 OJoinController::Execute(_nId,aArgs); 799 return; // else we would invalidate twice 800 } 801 InvalidateFeature(_nId); 802 } 803 804 // ----------------------------------------------------------------------------- 805 void OQueryController::impl_showAutoSQLViewError( const ::com::sun::star::uno::Any& _rErrorDetails ) 806 { 807 SQLContext aErrorContext; 808 aErrorContext.Message = lcl_getObjectResourceString( STR_ERROR_PARSING_STATEMENT, m_nCommandType ); 809 aErrorContext.Context = *this; 810 aErrorContext.Details = lcl_getObjectResourceString( STR_INFO_OPENING_IN_SQL_VIEW, m_nCommandType ); 811 aErrorContext.NextException = _rErrorDetails; 812 showError( aErrorContext ); 813 } 814 815 // ----------------------------------------------------------------------------- 816 bool OQueryController::impl_setViewMode( ::dbtools::SQLExceptionInfo* _pErrorInfo ) 817 { 818 OSL_PRECOND( getContainer(), "OQueryController::impl_setViewMode: illegal call!" ); 819 820 bool wasModified = isModified(); 821 822 SQLExceptionInfo aError; 823 bool bSuccess = getContainer()->switchView( &aError ); 824 if ( !bSuccess ) 825 { 826 m_bGraphicalDesign = !m_bGraphicalDesign; 827 // restore old state 828 getContainer()->switchView( NULL ); 829 // don't pass &aError here, this would overwrite the error which the first switchView call 830 // returned in this location. 831 if ( _pErrorInfo ) 832 *_pErrorInfo = aError; 833 else 834 showError( aError ); 835 } 836 else 837 { 838 ensureToolbars( *this, m_bGraphicalDesign ); 839 } 840 841 setModified( wasModified ); 842 return bSuccess; 843 } 844 845 // ----------------------------------------------------------------------------- 846 void OQueryController::impl_initialize() 847 { 848 OJoinController::impl_initialize(); 849 850 const NamedValueCollection& rArguments( getInitParams() ); 851 852 ::rtl::OUString sCommand; 853 m_nCommandType = CommandType::QUERY; 854 855 // ����������������������������������������������������������������������������������������������������������������� 856 // � reading parameters 857 // ����������������������������������������������������������������������������������������������������������������� 858 // legacy parameters first (later overwritten by regular parameters) 859 ::rtl::OUString sIndependentSQLCommand; 860 if ( rArguments.get_ensureType( "IndependentSQLCommand", sIndependentSQLCommand ) ) 861 { 862 OSL_ENSURE( false, "OQueryController::impl_initialize: IndependentSQLCommand is regognized for compatibility only!" ); 863 sCommand = sIndependentSQLCommand; 864 m_nCommandType = CommandType::COMMAND; 865 } 866 867 ::rtl::OUString sCurrentQuery; 868 if ( rArguments.get_ensureType( "CurrentQuery", sCurrentQuery ) ) 869 { 870 OSL_ENSURE( false, "OQueryController::impl_initialize: CurrentQuery is regognized for compatibility only!" ); 871 sCommand = sCurrentQuery; 872 m_nCommandType = CommandType::QUERY; 873 } 874 875 sal_Bool bCreateView( sal_False ); 876 if ( rArguments.get_ensureType( "CreateView", bCreateView ) && bCreateView ) 877 { 878 OSL_ENSURE( false, "OQueryController::impl_initialize: CurrentQuery is regognized for compatibility only!" ); 879 m_nCommandType = CommandType::TABLE; 880 } 881 882 // non-legacy parameters which overwrite the legacy parameters 883 rArguments.get_ensureType( (::rtl::OUString)PROPERTY_COMMAND, sCommand ); 884 rArguments.get_ensureType( (::rtl::OUString)PROPERTY_COMMAND_TYPE, m_nCommandType ); 885 886 // translate Command/Type into proper members 887 // TODO/Later: all this (including those members) should be hidden behind some abstact interface, 888 // which is implemented for all the three commands 889 switch ( m_nCommandType ) 890 { 891 case CommandType::QUERY: 892 m_sName = sCommand; 893 break; 894 case CommandType::TABLE: 895 m_sName = sCommand; 896 break; 897 case CommandType::COMMAND: 898 setStatement_fireEvent( sCommand ); 899 m_sName = ::rtl::OUString(); 900 break; 901 default: 902 OSL_ENSURE( false, "OQueryController::impl_initialize: logic error in code!" ); 903 throw RuntimeException(); 904 } 905 906 // more legacy parameters 907 sal_Bool bGraphicalDesign( sal_True ); 908 if ( rArguments.get_ensureType( (::rtl::OUString)PROPERTY_QUERYDESIGNVIEW, bGraphicalDesign ) ) 909 { 910 OSL_ENSURE( false, "OQueryController::impl_initialize: QueryDesignView is regognized for compatibility only!" ); 911 m_bGraphicalDesign = bGraphicalDesign; 912 } 913 914 // more non-legacy 915 rArguments.get_ensureType( (::rtl::OUString)PROPERTY_GRAPHICAL_DESIGN, m_bGraphicalDesign ); 916 917 bool bEscapeProcessing( sal_True ); 918 if ( rArguments.get_ensureType( (::rtl::OUString)PROPERTY_ESCAPE_PROCESSING, bEscapeProcessing ) ) 919 { 920 setEscapeProcessing_fireEvent( bEscapeProcessing ); 921 922 OSL_ENSURE( m_bEscapeProcessing || !m_bGraphicalDesign, "OQueryController::impl_initialize: can't do the graphical design without escape processing!" ); 923 if ( !m_bEscapeProcessing ) 924 m_bGraphicalDesign = false; 925 } 926 927 // ................................................................................................................. 928 // . initial design 929 bool bForceInitialDesign = false; 930 Sequence< PropertyValue > aCurrentQueryDesignProps; 931 aCurrentQueryDesignProps = rArguments.getOrDefault( "CurrentQueryDesign", aCurrentQueryDesignProps ); 932 933 if ( aCurrentQueryDesignProps.getLength() ) 934 { 935 ::comphelper::NamedValueCollection aCurrentQueryDesign( aCurrentQueryDesignProps ); 936 if ( aCurrentQueryDesign.has( (::rtl::OUString)PROPERTY_GRAPHICAL_DESIGN ) ) 937 { 938 aCurrentQueryDesign.get_ensureType( (::rtl::OUString)PROPERTY_GRAPHICAL_DESIGN, m_bGraphicalDesign ); 939 } 940 if ( aCurrentQueryDesign.has( (::rtl::OUString)PROPERTY_ESCAPE_PROCESSING ) ) 941 { 942 aCurrentQueryDesign.get_ensureType( (::rtl::OUString)PROPERTY_ESCAPE_PROCESSING, m_bEscapeProcessing ); 943 } 944 if ( aCurrentQueryDesign.has( "Statement" ) ) 945 { 946 ::rtl::OUString sStatement; 947 aCurrentQueryDesign.get_ensureType( "Statement", sStatement ); 948 aCurrentQueryDesign.remove( "Statement" ); 949 setStatement_fireEvent( sStatement ); 950 } 951 952 loadViewSettings( aCurrentQueryDesign ); 953 954 bForceInitialDesign = true; 955 } 956 957 // ����������������������������������������������������������������������������������������������������������������� 958 if ( !ensureConnected( sal_False ) ) 959 { // we have no connection so what else should we do 960 m_bGraphicalDesign = sal_False; 961 if ( editingView() ) 962 { 963 connectionLostMessage(); 964 throw SQLException(); 965 } 966 } 967 968 // check the view capabilities 969 if ( isConnected() && editingView() ) 970 { 971 Reference< XViewsSupplier > xViewsSup( getConnection(), UNO_QUERY ); 972 Reference< XNameAccess > xViews; 973 if ( xViewsSup.is() ) 974 xViews = xViewsSup->getViews(); 975 976 if ( !xViews.is() ) 977 { // we can't create views so we ask if the user wants to create a query instead 978 m_nCommandType = CommandType::QUERY; 979 sal_Bool bClose = sal_False; 980 { 981 String aTitle( ModuleRes( STR_QUERYDESIGN_NO_VIEW_SUPPORT ) ); 982 String aMessage( ModuleRes( STR_QUERYDESIGN_NO_VIEW_ASK ) ); 983 ODataView* pWindow = getView(); 984 OSQLMessageBox aDlg( pWindow, aTitle, aMessage, WB_YES_NO | WB_DEF_YES, OSQLMessageBox::Query ); 985 bClose = aDlg.Execute() == RET_NO; 986 } 987 if ( bClose ) 988 throw VetoException(); 989 } 990 991 // now if we are to edit an existing view, check whether this is possible 992 if ( m_sName.getLength() ) 993 { 994 Any aView( xViews->getByName( m_sName ) ); 995 // will throw if there is no such view 996 if ( !( aView >>= m_xAlterView ) ) 997 { 998 throw IllegalArgumentException( 999 ::rtl::OUString( String( ModuleRes( STR_NO_ALTER_VIEW_SUPPORT ) ) ), 1000 *this, 1001 1 1002 ); 1003 } 1004 } 1005 } 1006 1007 OSL_ENSURE(getDataSource().is(),"OQueryController::impl_initialize: need a datasource!"); 1008 1009 try 1010 { 1011 getContainer()->initialize(); 1012 impl_reset( bForceInitialDesign ); 1013 1014 SQLExceptionInfo aError; 1015 const bool bAttemptedGraphicalDesign = m_bGraphicalDesign; 1016 1017 if ( bForceInitialDesign ) 1018 { 1019 getContainer()->forceInitialView(); 1020 } 1021 else 1022 { 1023 impl_setViewMode( &aError ); 1024 } 1025 1026 if ( aError.isValid() && bAttemptedGraphicalDesign && !m_bGraphicalDesign ) 1027 { 1028 // we tried initializing the graphical view, this failed, and we were automatically switched to SQL 1029 // view => tell this to the user 1030 if ( !editingView() ) 1031 { 1032 impl_showAutoSQLViewError( aError.get() ); 1033 } 1034 } 1035 1036 ClearUndoManager(); 1037 1038 if ( ( m_bGraphicalDesign ) 1039 && ( ( !m_sName.getLength() && !editingCommand() ) 1040 || ( !m_sStatement.getLength() && editingCommand() ) 1041 ) 1042 ) 1043 { 1044 Application::PostUserEvent( LINK( this, OQueryController, OnExecuteAddTable ) ); 1045 } 1046 1047 setModified(sal_False); 1048 } 1049 catch(SQLException& e) 1050 { 1051 DBG_UNHANDLED_EXCEPTION(); 1052 // we caught an exception so we switch to text only mode 1053 { 1054 m_bGraphicalDesign = sal_False; 1055 getContainer()->initialize(); 1056 ODataView* pWindow = getView(); 1057 OSQLMessageBox(pWindow,e).Execute(); 1058 } 1059 throw; 1060 } 1061 } 1062 1063 // ----------------------------------------------------------------------------- 1064 void OQueryController::onLoadedMenu(const Reference< ::com::sun::star::frame::XLayoutManager >& /*_xLayoutManager*/) 1065 { 1066 ensureToolbars( *this, m_bGraphicalDesign ); 1067 } 1068 1069 // ----------------------------------------------------------------------------- 1070 ::rtl::OUString OQueryController::getPrivateTitle( ) const 1071 { 1072 ::rtl::OUString sName = m_sName; 1073 if ( !sName.getLength() ) 1074 { 1075 if ( !editingCommand() ) 1076 { 1077 ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); 1078 ::osl::MutexGuard aGuard( getMutex() ); 1079 String aDefaultName = String( ModuleRes( editingView() ? STR_VIEW_TITLE : STR_QRY_TITLE ) ); 1080 sName = aDefaultName.GetToken(0,' '); 1081 sName += ::rtl::OUString::valueOf(getCurrentStartNumber()); 1082 } 1083 } 1084 return sName; 1085 } 1086 // ----------------------------------------------------------------------------- 1087 void OQueryController::setQueryComposer() 1088 { 1089 if(isConnected()) 1090 { 1091 Reference< XSQLQueryComposerFactory > xFactory(getConnection(), UNO_QUERY); 1092 OSL_ENSURE(xFactory.is(),"Connection doesn't support a querycomposer"); 1093 if ( xFactory.is() && getContainer() ) 1094 { 1095 try 1096 { 1097 m_xComposer = xFactory->createQueryComposer(); 1098 getContainer()->setStatement(m_sStatement); 1099 } 1100 catch (Exception&) 1101 { 1102 m_xComposer = NULL; 1103 } 1104 OSL_ENSURE(m_xComposer.is(),"No querycomposer available!"); 1105 Reference<XTablesSupplier> xTablesSup(getConnection(), UNO_QUERY); 1106 deleteIterator(); 1107 m_pSqlIterator = new ::connectivity::OSQLParseTreeIterator( getConnection(), xTablesSup->getTables(), m_aSqlParser, NULL ); 1108 } 1109 } 1110 } 1111 // ----------------------------------------------------------------------------- 1112 sal_Bool OQueryController::Construct(Window* pParent) 1113 { 1114 // TODO: we have to check if we should create the text- or the design- view 1115 1116 setView( * new OQueryContainerWindow( pParent, *this, getORB() ) ); 1117 1118 return OJoinController::Construct(pParent); 1119 } 1120 1121 // ----------------------------------------------------------------------------- 1122 OJoinDesignView* OQueryController::getJoinView() 1123 { 1124 return getContainer()->getDesignView(); 1125 } 1126 // ----------------------------------------------------------------------------- 1127 void OQueryController::describeSupportedFeatures() 1128 { 1129 OJoinController::describeSupportedFeatures(); 1130 implDescribeSupportedFeature( ".uno:SaveAs", ID_BROWSER_SAVEASDOC, CommandGroup::DOCUMENT ); 1131 implDescribeSupportedFeature( ".uno:SbaNativeSql", ID_BROWSER_ESACPEPROCESSING,CommandGroup::FORMAT ); 1132 implDescribeSupportedFeature( ".uno:DBViewFunctions", SID_QUERY_VIEW_FUNCTIONS, CommandGroup::VIEW ); 1133 implDescribeSupportedFeature( ".uno:DBViewTableNames", SID_QUERY_VIEW_TABLES, CommandGroup::VIEW ); 1134 implDescribeSupportedFeature( ".uno:DBViewAliases", SID_QUERY_VIEW_ALIASES, CommandGroup::VIEW ); 1135 implDescribeSupportedFeature( ".uno:DBDistinctValues", SID_QUERY_DISTINCT_VALUES, CommandGroup::FORMAT ); 1136 implDescribeSupportedFeature( ".uno:DBChangeDesignMode",ID_BROWSER_SQL, CommandGroup::VIEW ); 1137 implDescribeSupportedFeature( ".uno:DBClearQuery", SID_BROWSER_CLEAR_QUERY, CommandGroup::EDIT ); 1138 implDescribeSupportedFeature( ".uno:SbaExecuteSql", ID_BROWSER_QUERY_EXECUTE, CommandGroup::VIEW ); 1139 implDescribeSupportedFeature( ".uno:DBAddRelation", SID_RELATION_ADD_RELATION, CommandGroup::EDIT ); 1140 implDescribeSupportedFeature( ".uno:DBQueryPreview", SID_DB_QUERY_PREVIEW, CommandGroup::VIEW ); 1141 1142 #if OSL_DEBUG_LEVEL > 1 1143 implDescribeSupportedFeature( ".uno:DBShowParseTree", ID_EDIT_QUERY_SQL ); 1144 implDescribeSupportedFeature( ".uno:DBMakeDisjunct", ID_EDIT_QUERY_DESIGN ); 1145 #endif 1146 } 1147 // ----------------------------------------------------------------------------- 1148 void OQueryController::impl_onModifyChanged() 1149 { 1150 OJoinController::impl_onModifyChanged(); 1151 InvalidateFeature(SID_BROWSER_CLEAR_QUERY); 1152 InvalidateFeature(ID_BROWSER_SAVEASDOC); 1153 InvalidateFeature(ID_BROWSER_QUERY_EXECUTE); 1154 } 1155 // ----------------------------------------------------------------------------- 1156 void SAL_CALL OQueryController::disposing( const EventObject& Source ) throw(RuntimeException) 1157 { 1158 ::vos::OGuard aGuard(Application::GetSolarMutex()); 1159 1160 if ( getContainer() && Source.Source.is() ) 1161 { 1162 if ( Source.Source == m_aCurrentFrame.getFrame() ) 1163 { // our frame is beeing disposed -> close the preview window (if we have one) 1164 Reference< XFrame > xPreviewFrame( getContainer()->getPreviewFrame() ); 1165 ::comphelper::disposeComponent( xPreviewFrame ); 1166 } 1167 else if ( Source.Source == getContainer()->getPreviewFrame() ) 1168 { 1169 getContainer()->disposingPreview(); 1170 } 1171 } 1172 1173 OJoinController::disposing(Source); 1174 } 1175 // ----------------------------------------------------------------------------- 1176 void OQueryController::reconnect(sal_Bool _bUI) 1177 { 1178 deleteIterator(); 1179 ::comphelper::disposeComponent(m_xComposer); 1180 1181 OJoinController::reconnect( _bUI ); 1182 1183 if (isConnected()) 1184 { 1185 setQueryComposer(); 1186 } 1187 else 1188 { 1189 if(m_bGraphicalDesign) 1190 { 1191 m_bGraphicalDesign = sal_False; 1192 // don't call Execute(SQL) because this changes the sql statement 1193 impl_setViewMode( NULL ); 1194 } 1195 InvalidateAll(); 1196 } 1197 } 1198 1199 // ----------------------------------------------------------------------------- 1200 void OQueryController::saveViewSettings( ::comphelper::NamedValueCollection& o_rViewSettings, const bool i_includingCriteria ) const 1201 { 1202 saveTableWindows( o_rViewSettings ); 1203 1204 OTableFields::const_iterator field = m_vTableFieldDesc.begin(); 1205 OTableFields::const_iterator fieldEnd = m_vTableFieldDesc.end(); 1206 1207 ::comphelper::NamedValueCollection aAllFieldsData; 1208 ::comphelper::NamedValueCollection aFieldData; 1209 for ( sal_Int32 i = 1; field != fieldEnd; ++field, ++i ) 1210 { 1211 if ( !(*field)->IsEmpty() ) 1212 { 1213 aFieldData.clear(); 1214 (*field)->Save( aFieldData, i_includingCriteria ); 1215 1216 const ::rtl::OUString sFieldSettingName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Field" ) ) + ::rtl::OUString::valueOf( i ); 1217 aAllFieldsData.put( sFieldSettingName, aFieldData.getPropertyValues() ); 1218 } 1219 } 1220 1221 o_rViewSettings.put( "Fields", aAllFieldsData.getPropertyValues() ); 1222 o_rViewSettings.put( "SplitterPosition", m_nSplitPos ); 1223 o_rViewSettings.put( "VisibleRows", m_nVisibleRows ); 1224 } 1225 // ----------------------------------------------------------------------------- 1226 void OQueryController::loadViewSettings( const ::comphelper::NamedValueCollection& o_rViewSettings ) 1227 { 1228 loadTableWindows( o_rViewSettings ); 1229 1230 m_nSplitPos = o_rViewSettings.getOrDefault( "SplitterPosition", m_nSplitPos ); 1231 m_nVisibleRows = o_rViewSettings.getOrDefault( "VisibleRows", m_nVisibleRows ); 1232 m_aFieldInformation = o_rViewSettings.getOrDefault( "Fields", m_aFieldInformation ); 1233 } 1234 // ----------------------------------------------------------------------------- 1235 sal_Int32 OQueryController::getColWidth(sal_uInt16 _nColPos) const 1236 { 1237 if ( _nColPos < m_aFieldInformation.getLength() ) 1238 { 1239 ::std::auto_ptr<OTableFieldDesc> pField( new OTableFieldDesc()); 1240 pField->Load( m_aFieldInformation[ _nColPos ], false ); 1241 return pField->GetColWidth(); 1242 } 1243 return 0; 1244 } 1245 // ----------------------------------------------------------------------------- 1246 Reference<XNameAccess> OQueryController::getObjectContainer() const 1247 { 1248 Reference< XNameAccess > xElements; 1249 if ( editingView() ) 1250 { 1251 Reference< XViewsSupplier > xViewsSupp( getConnection(), UNO_QUERY ); 1252 if ( xViewsSupp.is() ) 1253 xElements = xViewsSupp->getViews(); 1254 } 1255 else 1256 { 1257 Reference< XQueriesSupplier > xQueriesSupp( getConnection(), UNO_QUERY ); 1258 if ( xQueriesSupp.is() ) 1259 xElements = xQueriesSupp->getQueries(); 1260 else 1261 { 1262 Reference< XQueryDefinitionsSupplier > xQueryDefsSupp( getDataSource(), UNO_QUERY ); 1263 if ( xQueryDefsSupp.is() ) 1264 xElements = xQueryDefsSupp->getQueryDefinitions(); 1265 } 1266 } 1267 1268 OSL_ENSURE( xElements.is(), "OQueryController::getObjectContainer: unable to obtain the container!" ); 1269 return xElements; 1270 } 1271 1272 // ----------------------------------------------------------------------------- 1273 void OQueryController::executeQuery() 1274 { 1275 // we don't need to check the connection here because we already check the composer 1276 // which can't live without his connection 1277 ::rtl::OUString sTranslatedStmt = translateStatement( false ); 1278 1279 ::rtl::OUString sDataSourceName = getDataSourceName(); 1280 if ( sDataSourceName.getLength() && sTranslatedStmt.getLength() ) 1281 { 1282 try 1283 { 1284 getContainer()->showPreview( getFrame() ); 1285 InvalidateFeature(SID_DB_QUERY_PREVIEW); 1286 1287 URL aWantToDispatch; 1288 aWantToDispatch.Complete = ::rtl::OUString::createFromAscii(".component:DB/DataSourceBrowser"); 1289 1290 ::rtl::OUString sFrameName( FRAME_NAME_QUERY_PREVIEW ); 1291 sal_Int32 nSearchFlags = FrameSearchFlag::CHILDREN; 1292 1293 Reference< XDispatch> xDisp; 1294 Reference< XDispatchProvider> xProv( getFrame()->findFrame( sFrameName, nSearchFlags ), UNO_QUERY ); 1295 if(!xProv.is()) 1296 { 1297 xProv.set( getFrame(), UNO_QUERY ); 1298 if (xProv.is()) 1299 xDisp = xProv->queryDispatch(aWantToDispatch, sFrameName, nSearchFlags); 1300 } 1301 else 1302 { 1303 xDisp = xProv->queryDispatch(aWantToDispatch, sFrameName, FrameSearchFlag::SELF); 1304 } 1305 if (xDisp.is()) 1306 { 1307 Sequence< PropertyValue> aProps(9); 1308 aProps[0].Name = PROPERTY_DATASOURCENAME; 1309 aProps[0].Value <<= sDataSourceName; 1310 1311 aProps[1].Name = PROPERTY_COMMAND_TYPE; 1312 aProps[1].Value <<= CommandType::COMMAND; 1313 1314 aProps[2].Name = PROPERTY_COMMAND; 1315 aProps[2].Value <<= sTranslatedStmt; 1316 1317 aProps[3].Name = PROPERTY_ENABLE_BROWSER; 1318 aProps[3].Value = ::cppu::bool2any(sal_False); 1319 1320 aProps[4].Name = PROPERTY_ACTIVE_CONNECTION; 1321 aProps[4].Value <<= getConnection(); 1322 1323 aProps[5].Name = PROPERTY_UPDATE_CATALOGNAME; 1324 aProps[5].Value <<= m_sUpdateCatalogName; 1325 1326 aProps[6].Name = PROPERTY_UPDATE_SCHEMANAME; 1327 aProps[6].Value <<= m_sUpdateSchemaName; 1328 1329 aProps[7].Name = PROPERTY_UPDATE_TABLENAME; 1330 aProps[7].Value <<= m_sUpdateTableName; 1331 1332 aProps[8].Name = PROPERTY_ESCAPE_PROCESSING; 1333 aProps[8].Value = ::cppu::bool2any(m_bEscapeProcessing); 1334 1335 xDisp->dispatch(aWantToDispatch, aProps); 1336 // check the state of the beamer 1337 // be notified when the beamer frame is closed 1338 Reference< XComponent > xComponent( getFrame()->findFrame( sFrameName, nSearchFlags ), UNO_QUERY ); 1339 if (xComponent.is()) 1340 { 1341 OSL_ENSURE(Reference< XFrame >(xComponent, UNO_QUERY).get() == getContainer()->getPreviewFrame().get(), 1342 "OQueryController::executeQuery: oops ... which window do I have here?"); 1343 Reference< XEventListener> xEvtL((::cppu::OWeakObject*)this,UNO_QUERY); 1344 xComponent->addEventListener(xEvtL); 1345 } 1346 } 1347 else 1348 { 1349 OSL_ENSURE(0,"Couldn't create a beamer window!"); 1350 } 1351 } 1352 catch(const Exception&) 1353 { 1354 OSL_ENSURE(0,"Couldn't create a beamer window!"); 1355 } 1356 } 1357 } 1358 // ----------------------------------------------------------------------------- 1359 sal_Bool OQueryController::askForNewName(const Reference<XNameAccess>& _xElements,sal_Bool _bSaveAs) 1360 { 1361 OSL_ENSURE( !editingCommand(), "OQueryController::askForNewName: not to be called when designing an independent statement!" ); 1362 if ( editingCommand() ) 1363 return sal_False; 1364 1365 OSL_PRECOND( _xElements.is(), "OQueryController::askForNewName: invalid container!" ); 1366 if ( !_xElements.is() ) 1367 return sal_False; 1368 1369 sal_Bool bRet = sal_True; 1370 sal_Bool bNew = _bSaveAs || !_xElements->hasByName( m_sName ); 1371 if(bNew) 1372 { 1373 String aDefaultName; 1374 if ( ( _bSaveAs && !bNew ) || ( bNew && m_sName.getLength() ) ) 1375 aDefaultName = String( m_sName ); 1376 else 1377 { 1378 String sName = String( ModuleRes( editingView() ? STR_VIEW_TITLE : STR_QRY_TITLE ) ); 1379 aDefaultName = sName.GetToken(0,' '); 1380 //aDefaultName = getPrivateTitle( ); 1381 aDefaultName = ::dbtools::createUniqueName(_xElements,aDefaultName); 1382 } 1383 1384 DynamicTableOrQueryNameCheck aNameChecker( getConnection(), CommandType::QUERY ); 1385 OSaveAsDlg aDlg( 1386 getView(), 1387 m_nCommandType, 1388 getORB(), 1389 getConnection(), 1390 aDefaultName, 1391 aNameChecker, 1392 SAD_DEFAULT ); 1393 1394 bRet = ( aDlg.Execute() == RET_OK ); 1395 if ( bRet ) 1396 { 1397 m_sName = aDlg.getName(); 1398 if ( editingView() ) 1399 { 1400 m_sUpdateCatalogName = aDlg.getCatalog(); 1401 m_sUpdateSchemaName = aDlg.getSchema(); 1402 } 1403 } 1404 } 1405 return bRet; 1406 } 1407 // ----------------------------------------------------------------------------- 1408 bool OQueryController::doSaveAsDoc(sal_Bool _bSaveAs) 1409 { 1410 OSL_ENSURE(isEditable(),"Slot ID_BROWSER_SAVEDOC should not be enabled!"); 1411 if ( !editingCommand() && !haveDataSource() ) 1412 { 1413 String aMessage(ModuleRes(STR_DATASOURCE_DELETED)); 1414 OSQLWarningBox( getView(), aMessage ).Execute(); 1415 return false; 1416 } 1417 1418 Reference< XNameAccess > xElements = getObjectContainer(); 1419 if ( !xElements.is() ) 1420 return false; 1421 1422 if ( !getContainer()->checkStatement() ) 1423 return false; 1424 1425 ::rtl::OUString sTranslatedStmt = translateStatement(); 1426 if ( editingCommand() ) 1427 { 1428 setModified( sal_False ); 1429 // this is all we need to do here. translateStatement implicitly set our m_sStatement, and 1430 // notified it, and that's all 1431 return true; 1432 } 1433 1434 if ( !sTranslatedStmt.getLength() ) 1435 return false; 1436 1437 // first we need a name for our query so ask the user 1438 // did we get a name 1439 ::rtl::OUString sOriginalName( m_sName ); 1440 if ( !askForNewName( xElements, _bSaveAs ) || !m_sName.getLength() ) 1441 return false; 1442 1443 SQLExceptionInfo aInfo; 1444 bool bSuccess = false; 1445 bool bNew = false; 1446 try 1447 { 1448 bNew = ( _bSaveAs ) 1449 || ( !xElements->hasByName( m_sName ) ); 1450 1451 Reference<XPropertySet> xQuery; 1452 if ( bNew ) // just to make sure the query already exists 1453 { 1454 // drop the query, in case it already exists 1455 if ( xElements->hasByName( m_sName ) ) 1456 { 1457 Reference< XDrop > xNameCont( xElements, UNO_QUERY ); 1458 if ( xNameCont.is() ) 1459 xNameCont->dropByName( m_sName ); 1460 else 1461 { 1462 Reference< XNameContainer > xCont( xElements, UNO_QUERY ); 1463 if ( xCont.is() ) 1464 xCont->removeByName( m_sName ); 1465 } 1466 } 1467 1468 // create a new (empty, uninitialized) query resp. view 1469 Reference< XDataDescriptorFactory > xFact( xElements, UNO_QUERY ); 1470 if ( xFact.is() ) 1471 { 1472 xQuery = xFact->createDataDescriptor(); 1473 // to set the name is only allowed when the query is new 1474 xQuery->setPropertyValue( PROPERTY_NAME, makeAny( m_sName ) ); 1475 } 1476 else 1477 { 1478 Reference< XSingleServiceFactory > xSingleFac( xElements, UNO_QUERY ); 1479 if ( xSingleFac.is() ) 1480 xQuery = xQuery.query( xSingleFac->createInstance() ); 1481 } 1482 } 1483 else 1484 { 1485 xElements->getByName( m_sName ) >>= xQuery; 1486 } 1487 if ( !xQuery.is() ) 1488 throw RuntimeException(); 1489 1490 // the new commands 1491 if ( editingView() && !bNew ) 1492 { 1493 OSL_ENSURE( xQuery == m_xAlterView, "OQueryController::doSaveAsDoc: already have another alterable view ...!?" ); 1494 m_xAlterView.set( xQuery, UNO_QUERY_THROW ); 1495 m_xAlterView->alterCommand( sTranslatedStmt ); 1496 } 1497 else 1498 { // we're creating a query, or a *new* view 1499 xQuery->setPropertyValue( PROPERTY_COMMAND, makeAny( sTranslatedStmt ) ); 1500 1501 if ( editingView() ) 1502 { 1503 xQuery->setPropertyValue( PROPERTY_CATALOGNAME, makeAny( m_sUpdateCatalogName ) ); 1504 xQuery->setPropertyValue( PROPERTY_SCHEMANAME, makeAny( m_sUpdateSchemaName ) ); 1505 } 1506 1507 if ( editingQuery() ) 1508 { 1509 xQuery->setPropertyValue( PROPERTY_UPDATE_TABLENAME, makeAny( m_sUpdateTableName ) ); 1510 xQuery->setPropertyValue( PROPERTY_ESCAPE_PROCESSING,::cppu::bool2any( m_bEscapeProcessing ) ); 1511 1512 xQuery->setPropertyValue( PROPERTY_LAYOUTINFORMATION, getViewData() ); 1513 } 1514 } 1515 1516 if ( bNew ) 1517 { 1518 Reference< XAppend > xAppend( xElements, UNO_QUERY ); 1519 if ( xAppend.is() ) 1520 { 1521 xAppend->appendByDescriptor( xQuery ); 1522 } 1523 else 1524 { 1525 Reference< XNameContainer > xCont( xElements, UNO_QUERY ); 1526 if ( xCont.is() ) 1527 xCont->insertByName( m_sName, makeAny( xQuery ) ); 1528 } 1529 1530 if ( editingView() ) 1531 { 1532 Reference< XPropertySet > xViewProps; 1533 if ( xElements->hasByName( m_sName ) ) 1534 xViewProps.set( xElements->getByName( m_sName ), UNO_QUERY ); 1535 1536 if ( !xViewProps.is() ) // correct name and try again 1537 m_sName = ::dbtools::composeTableName( getMetaData(), xQuery, ::dbtools::eInDataManipulation, false, false, false ); 1538 1539 OSL_ENSURE( xElements->hasByName( m_sName ), "OQueryController::doSaveAsDoc: newly creaed view does not exist!" ); 1540 1541 if ( xElements->hasByName( m_sName ) ) 1542 m_xAlterView.set( xElements->getByName( m_sName ), UNO_QUERY ); 1543 1544 // now check if our datasource has set a tablefilter and if so, append the new table name to it 1545 ::dbaui::appendToFilter( getConnection(), m_sName, getORB(), getView() ); 1546 } // if ( editingView() ) 1547 Reference< XTitleChangeListener> xEventListener(impl_getTitleHelper_throw(),UNO_QUERY); 1548 if ( xEventListener.is() ) 1549 { 1550 TitleChangedEvent aEvent; 1551 xEventListener->titleChanged(aEvent); 1552 } 1553 releaseNumberForComponent(); 1554 } 1555 1556 setModified( sal_False ); 1557 bSuccess = true; 1558 1559 } 1560 catch( const SQLException& ) 1561 { 1562 if ( !bNew ) 1563 m_sName = sOriginalName; 1564 aInfo = SQLExceptionInfo( ::cppu::getCaughtException() ); 1565 } 1566 catch(Exception&) 1567 { 1568 if ( !bNew ) 1569 m_sName = sOriginalName; 1570 DBG_UNHANDLED_EXCEPTION(); 1571 } 1572 1573 showError( aInfo ); 1574 1575 // update the title of our window 1576 //updateTitle(); 1577 1578 // if we successfully saved a view we were creating, then close the designer 1579 if ( bSuccess && editingView() && !m_xAlterView.is() ) 1580 { 1581 closeTask(); 1582 } 1583 1584 if ( bSuccess && editingView() ) 1585 InvalidateFeature( ID_BROWSER_EDITDOC ); 1586 1587 return bSuccess; 1588 } 1589 // ----------------------------------------------------------------------------- 1590 ::rtl::OUString OQueryController::translateStatement( bool _bFireStatementChange ) 1591 { 1592 // now set the properties 1593 setStatement_fireEvent( getContainer()->getStatement(), _bFireStatementChange ); 1594 ::rtl::OUString sTranslatedStmt; 1595 if(m_sStatement.getLength() && m_xComposer.is() && m_bEscapeProcessing) 1596 { 1597 try 1598 { 1599 ::rtl::OUString aErrorMsg; 1600 1601 ::connectivity::OSQLParseNode* pNode = m_aSqlParser.parseTree( aErrorMsg, m_sStatement, m_bGraphicalDesign ); 1602 if(pNode) 1603 { 1604 pNode->parseNodeToStr( sTranslatedStmt, getConnection() ); 1605 delete pNode; 1606 } 1607 1608 m_xComposer->setQuery(sTranslatedStmt); 1609 sTranslatedStmt = m_xComposer->getComposedQuery(); 1610 } 1611 catch(SQLException& e) 1612 { 1613 ::dbtools::SQLExceptionInfo aInfo(e); 1614 showError(aInfo); 1615 // an error occured so we clear the statement 1616 sTranslatedStmt = ::rtl::OUString(); 1617 } 1618 } 1619 else if(!m_sStatement.getLength()) 1620 { 1621 ModuleRes aModuleRes(STR_QRY_NOSELECT); 1622 String sTmpStr(aModuleRes); 1623 ::rtl::OUString sError(sTmpStr); 1624 showError(SQLException(sError,NULL,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000") ),1000,Any())); 1625 } 1626 else 1627 sTranslatedStmt = m_sStatement; 1628 1629 return sTranslatedStmt; 1630 } 1631 // ----------------------------------------------------------------------------- 1632 short OQueryController::saveModified() 1633 { 1634 vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 1635 ::osl::MutexGuard aGuard( getMutex() ); 1636 short nRet = RET_YES; 1637 if ( !isConnected() || !isModified() ) 1638 return nRet; 1639 1640 if ( !m_bGraphicalDesign 1641 || ( !m_vTableFieldDesc.empty() 1642 && !m_vTableData.empty() 1643 ) 1644 ) 1645 { 1646 String sMessageText( lcl_getObjectResourceString( STR_QUERY_SAVEMODIFIED, m_nCommandType ) ); 1647 QueryBox aQry( getView(), WB_YES_NO_CANCEL | WB_DEF_YES, sMessageText ); 1648 1649 nRet = aQry.Execute(); 1650 if ( ( nRet == RET_YES ) 1651 && !doSaveAsDoc( sal_False ) 1652 ) 1653 { 1654 nRet = RET_CANCEL; 1655 } 1656 } 1657 return nRet; 1658 } 1659 // ----------------------------------------------------------------------------- 1660 void OQueryController::impl_reset( const bool i_bForceCurrentControllerSettings ) 1661 { 1662 bool bValid = false; 1663 1664 Sequence< PropertyValue > aLayoutInformation; 1665 // get command from the query if a query name was supplied 1666 if ( !i_bForceCurrentControllerSettings && !editingCommand() ) 1667 { 1668 if ( m_sName.getLength() ) 1669 { 1670 Reference< XNameAccess > xQueries = getObjectContainer(); 1671 if ( xQueries.is() ) 1672 { 1673 Reference< XPropertySet > xProp; 1674 if( xQueries->hasByName( m_sName ) && ( xQueries->getByName( m_sName ) >>= xProp ) && xProp.is() ) 1675 { 1676 ::rtl::OUString sNewStatement; 1677 xProp->getPropertyValue( PROPERTY_COMMAND ) >>= sNewStatement; 1678 setStatement_fireEvent( sNewStatement ); 1679 1680 sal_Bool bNewEscapeProcessing( sal_True ); 1681 if ( editingQuery() ) 1682 { 1683 xProp->getPropertyValue( PROPERTY_ESCAPE_PROCESSING ) >>= bNewEscapeProcessing; 1684 setEscapeProcessing_fireEvent( bNewEscapeProcessing ); 1685 } 1686 1687 m_bGraphicalDesign = m_bGraphicalDesign && m_bEscapeProcessing; 1688 bValid = true; 1689 1690 try 1691 { 1692 if ( editingQuery() ) 1693 xProp->getPropertyValue( PROPERTY_LAYOUTINFORMATION ) >>= aLayoutInformation; 1694 } 1695 catch( const Exception& ) 1696 { 1697 OSL_ENSURE( sal_False, "OQueryController::impl_reset: could not retrieve the layout information from the query!" ); 1698 } 1699 } 1700 } 1701 } 1702 } 1703 else 1704 { 1705 bValid = true; 1706 // assume that we got all necessary information during initialization 1707 } 1708 1709 if ( bValid ) 1710 { 1711 // load the layoutInformation 1712 if ( aLayoutInformation.getLength() ) 1713 { 1714 try 1715 { 1716 loadViewSettings( aLayoutInformation ); 1717 } 1718 catch( const Exception& ) 1719 { 1720 DBG_UNHANDLED_EXCEPTION(); 1721 } 1722 } 1723 1724 if ( m_sStatement.getLength() ) 1725 { 1726 setQueryComposer(); 1727 1728 bool bError( false ); 1729 1730 if ( !m_pSqlIterator ) 1731 { 1732 bError = true; 1733 } 1734 else if ( m_bEscapeProcessing ) 1735 { 1736 ::rtl::OUString aErrorMsg; 1737 ::std::auto_ptr< ::connectivity::OSQLParseNode > pNode( 1738 m_aSqlParser.parseTree( aErrorMsg, m_sStatement, m_bGraphicalDesign ) ); 1739 1740 if ( pNode.get() ) 1741 { 1742 delete m_pSqlIterator->getParseTree(); 1743 m_pSqlIterator->setParseTree( pNode.release() ); 1744 m_pSqlIterator->traverseAll(); 1745 if ( m_pSqlIterator->hasErrors() ) 1746 { 1747 if ( !i_bForceCurrentControllerSettings && m_bGraphicalDesign && !editingView() ) 1748 { 1749 impl_showAutoSQLViewError( makeAny( m_pSqlIterator->getErrors() ) ); 1750 } 1751 bError = true; 1752 } 1753 } 1754 else 1755 { 1756 if ( !i_bForceCurrentControllerSettings && !editingView() ) 1757 { 1758 String aTitle(ModuleRes(STR_SVT_SQL_SYNTAX_ERROR)); 1759 OSQLMessageBox aDlg(getView(),aTitle,aErrorMsg); 1760 aDlg.Execute(); 1761 } 1762 bError = true; 1763 } 1764 } 1765 1766 if ( bError ) 1767 { 1768 m_bGraphicalDesign = sal_False; 1769 if ( editingView() ) 1770 // if we're editing a view whose statement could not be parsed, default to "no escape processing" 1771 setEscapeProcessing_fireEvent( sal_False ); 1772 } 1773 } 1774 } 1775 1776 if(!m_pSqlIterator) 1777 setQueryComposer(); 1778 OSL_ENSURE(m_pSqlIterator,"No SQLIterator set!"); 1779 1780 getContainer()->setNoneVisbleRow(m_nVisibleRows); 1781 } 1782 1783 // ----------------------------------------------------------------------------- 1784 void OQueryController::reset() 1785 { 1786 impl_reset(); 1787 getContainer()->reset( NULL ); 1788 ClearUndoManager(); 1789 } 1790 1791 // ----------------------------------------------------------------------------- 1792 void OQueryController::setStatement_fireEvent( const ::rtl::OUString& _rNewStatement, bool _bFireStatementChange ) 1793 { 1794 Any aOldValue = makeAny( m_sStatement ); 1795 m_sStatement = _rNewStatement; 1796 Any aNewValue = makeAny( m_sStatement ); 1797 1798 sal_Int32 nHandle = PROPERTY_ID_ACTIVECOMMAND; 1799 if ( _bFireStatementChange ) 1800 fire( &nHandle, &aNewValue, &aOldValue, 1, sal_False ); 1801 } 1802 1803 // ----------------------------------------------------------------------------- 1804 void OQueryController::setEscapeProcessing_fireEvent( const sal_Bool _bEscapeProcessing ) 1805 { 1806 if ( _bEscapeProcessing == m_bEscapeProcessing ) 1807 return; 1808 1809 Any aOldValue = makeAny( m_bEscapeProcessing ); 1810 m_bEscapeProcessing = _bEscapeProcessing; 1811 Any aNewValue = makeAny( m_bEscapeProcessing ); 1812 1813 sal_Int32 nHandle = PROPERTY_ID_ESCAPE_PROCESSING; 1814 fire( &nHandle, &aNewValue, &aOldValue, 1, sal_False ); 1815 } 1816 1817 // ----------------------------------------------------------------------------- 1818 IMPL_LINK( OQueryController, OnExecuteAddTable, void*, /*pNotInterestedIn*/ ) 1819 { 1820 Execute( ID_BROWSER_ADDTABLE,Sequence<PropertyValue>() ); 1821 return 0L; 1822 } 1823 1824 // ----------------------------------------------------------------------------- 1825 bool OQueryController::allowViews() const 1826 { 1827 return true; 1828 } 1829 1830 // ----------------------------------------------------------------------------- 1831 bool OQueryController::allowQueries() const 1832 { 1833 DBG_ASSERT( getSdbMetaData().isConnected(), "OQueryController::allowQueries: illegal call!" ); 1834 if ( !getSdbMetaData().supportsSubqueriesInFrom() ) 1835 return false; 1836 1837 const NamedValueCollection& rArguments( getInitParams() ); 1838 sal_Int32 nCommandType = rArguments.getOrDefault( (::rtl::OUString)PROPERTY_COMMAND_TYPE, (sal_Int32)CommandType::QUERY ); 1839 sal_Bool bCreatingView = ( nCommandType == CommandType::TABLE ); 1840 return !bCreatingView; 1841 } 1842 1843 // ----------------------------------------------------------------------------- 1844 Any SAL_CALL OQueryController::getViewData() throw( RuntimeException ) 1845 { 1846 ::osl::MutexGuard aGuard( getMutex() ); 1847 1848 getContainer()->SaveUIConfig(); 1849 1850 ::comphelper::NamedValueCollection aViewSettings; 1851 saveViewSettings( aViewSettings, false ); 1852 1853 return makeAny( aViewSettings.getPropertyValues() ); 1854 } 1855 // ----------------------------------------------------------------------------- 1856 void SAL_CALL OQueryController::restoreViewData(const Any& /*Data*/) throw( RuntimeException ) 1857 { 1858 // TODO 1859 } 1860 1861 // ----------------------------------------------------------------------------- 1862 } // namespace dbaui 1863 // ----------------------------------------------------------------------------- 1864 1865