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 #ifndef DBAUI_QUERYTABLEVIEW_HXX 28 #include "QueryTableView.hxx" 29 #endif 30 #ifndef DBAUI_TABLEFIELDINFO_HXX 31 #include "TableFieldInfo.hxx" 32 #endif 33 #ifndef DBAUI_TABLEFIELDDESC_HXX 34 #include "TableFieldDescription.hxx" 35 #endif 36 #ifndef _TOOLS_DEBUG_HXX 37 #include <tools/debug.hxx> 38 #endif 39 #ifndef TOOLS_DIAGNOSE_EX_H 40 #include <tools/diagnose_ex.h> 41 #endif 42 #ifndef _DBA_DBACCESS_HELPID_HRC_ 43 #include "dbaccess_helpid.hrc" 44 #endif 45 #ifndef DBAUI_QUERY_TABLEWINDOW_HXX 46 #include "QTableWindow.hxx" 47 #endif 48 #ifndef DBAUI_QUERYTABLECONNECTION_HXX 49 #include "QTableConnection.hxx" 50 #endif 51 #ifndef DBAUI_QTABLECONNECTIONDATA_HXX 52 #include "QTableConnectionData.hxx" 53 #endif 54 #ifndef DBAUI_QUERYDESIGNVIEW_HXX 55 #include "QueryDesignView.hxx" 56 #endif 57 #ifndef DBAUI_QUERYCONTROLLER_HXX 58 #include "querycontroller.hxx" 59 #endif 60 #ifndef DBAUI_QUERYADDTABCONNUNDOACTION_HXX 61 #include "QueryAddTabConnUndoAction.hxx" 62 #endif 63 #ifndef DBAUI_QUERYTABWINSHOWUNDOACT_HXX 64 #include "QueryTabWinShowUndoAct.hxx" 65 #endif 66 #ifndef DBACCESS_UI_BROWSER_ID_HXX 67 #include "browserids.hxx" 68 #endif 69 #ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_ 70 #include <com/sun/star/sdbcx/XTablesSupplier.hpp> 71 #endif 72 #ifndef _COM_SUN_STAR_SDBC_XCONNECTION_HPP_ 73 #include <com/sun/star/sdbc/XConnection.hpp> 74 #endif 75 #ifndef _COM_SUN_STAR_SDBCX_XKEYSSUPPLIER_HPP_ 76 #include <com/sun/star/sdbcx/XKeysSupplier.hpp> 77 #endif 78 #ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_ 79 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp> 80 #endif 81 #include <com/sun/star/accessibility/AccessibleEventId.hpp> 82 #ifndef DBACCESS_JACCESS_HXX 83 #include "JAccess.hxx" 84 #endif 85 #ifndef _COM_SUN_STAR_SDBCX_KEYTYPE_HPP_ 86 #include <com/sun/star/sdbcx/KeyType.hpp> 87 #endif 88 #ifndef _COM_SUN_STAR_CONTAINER_XINDEXACCESS_HPP_ 89 #include <com/sun/star/container/XIndexAccess.hpp> 90 #endif 91 #ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_ 92 #include <com/sun/star/beans/XPropertySet.hpp> 93 #endif 94 #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC 95 #include "dbustrings.hrc" 96 #endif 97 #ifndef _CONNECTIVITY_DBTOOLS_HXX_ 98 #include <connectivity/dbtools.hxx> 99 #endif 100 #ifndef _COMPHELPER_SEQUENCE_HXX_ 101 #include <comphelper/sequence.hxx> 102 #endif 103 #ifndef DBAUI_QUERYDLG_HXX 104 #include "querydlg.hxx" 105 #endif 106 #ifndef DBAUI_JOINEXCHANGE_HXX 107 #include "JoinExchange.hxx" 108 #endif 109 #ifndef _COMPHELPER_EXTRACT_HXX_ 110 #include <comphelper/extract.hxx> 111 #endif 112 #ifndef DBAUI_QUERYDESIGNVIEW_HXX 113 #include "QueryDesignView.hxx" 114 #endif 115 #ifndef _DBU_QRY_HRC_ 116 #include "dbu_qry.hrc" 117 #endif 118 #ifndef _SV_MSGBOX_HXX 119 #include <vcl/msgbox.hxx> 120 #endif 121 122 using namespace dbaui; 123 using namespace ::com::sun::star::uno; 124 using namespace ::com::sun::star::sdbc; 125 using namespace ::com::sun::star::sdbcx; 126 using namespace ::com::sun::star::beans; 127 using namespace ::com::sun::star::container; 128 using namespace ::com::sun::star::accessibility; 129 130 //------------------------------------------------------------------------------ 131 namespace 132 { 133 // ----------------------------------------------------------------------------- 134 sal_Bool isColumnInKeyType(const Reference<XIndexAccess>& _rxKeys,const ::rtl::OUString& _rColumnName,sal_Int32 _nKeyType) 135 { 136 sal_Bool bReturn = sal_False; 137 if(_rxKeys.is()) 138 { 139 Reference<XColumnsSupplier> xColumnsSupplier; 140 // search the one and only primary key 141 const sal_Int32 nCount = _rxKeys->getCount(); 142 for(sal_Int32 i=0;i< nCount;++i) 143 { 144 Reference<XPropertySet> xProp(_rxKeys->getByIndex(i),UNO_QUERY); 145 if(xProp.is()) 146 { 147 sal_Int32 nKeyType = 0; 148 xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; 149 if(_nKeyType == nKeyType) 150 { 151 xColumnsSupplier.set(xProp,UNO_QUERY); 152 if(xColumnsSupplier.is()) 153 { 154 Reference<XNameAccess> xColumns = xColumnsSupplier->getColumns(); 155 if(xColumns.is() && xColumns->hasByName(_rColumnName)) 156 { 157 bReturn = sal_True; 158 break; 159 } 160 } 161 } 162 } 163 } 164 } 165 return bReturn; 166 } 167 // ----------------------------------------------------------------------------- 168 /** appends a new TabAdd Undo action at controller 169 @param _pView the view which we use 170 @param _pUndoAction the undo action which should be added 171 @param _pConnection the connection for which the undo action should be appended 172 @param _bOwner is the undo action the owner 173 */ 174 // ----------------------------------------------------------------------------- 175 void addUndoAction( OQueryTableView* _pView, 176 OQueryTabConnUndoAction* _pUndoAction, 177 OQueryTableConnection* _pConnection, 178 sal_Bool _bOwner = sal_False) 179 { 180 _pUndoAction->SetOwnership(_bOwner); 181 _pUndoAction->SetConnection(_pConnection); 182 _pView->getDesignView()->getController().addUndoActionAndInvalidate(_pUndoAction); 183 } 184 // ----------------------------------------------------------------------------- 185 /** openJoinDialog opens the join dialog with this connection data 186 @param _pView the view which we use 187 @param _pConnectionData the connection data 188 189 @return true when OK was pressed otherwise false 190 */ 191 sal_Bool openJoinDialog(OQueryTableView* _pView,const TTableConnectionData::value_type& _pConnectionData,sal_Bool _bSelectableTables) 192 { 193 OQueryTableConnectionData* pData = static_cast< OQueryTableConnectionData*>(_pConnectionData.get()); 194 195 DlgQryJoin aDlg(_pView,_pConnectionData,_pView->GetTabWinMap(),_pView->getDesignView()->getController().getConnection(),_bSelectableTables); 196 sal_Bool bOk = aDlg.Execute() == RET_OK; 197 if( bOk ) 198 { 199 pData->SetJoinType(aDlg.GetJoinType()); 200 _pView->getDesignView()->getController().setModified(sal_True); 201 } 202 203 return bOk; 204 } 205 // ----------------------------------------------------------------------------- 206 /** connectionModified adds an undo action for the modified connection and forces an redraw 207 @param _pView the view which we use 208 @param _pConnection the connection which was modified 209 @param _bAddUndo true when an undo action should be appended 210 */ 211 void connectionModified(OQueryTableView* _pView, 212 OTableConnection* _pConnection, 213 sal_Bool _bAddUndo) 214 { 215 OSL_ENSURE(_pConnection,"Invalid connection!"); 216 _pConnection->UpdateLineList(); 217 218 // add an undo action 219 if ( _bAddUndo ) 220 addUndoAction( _pView, 221 new OQueryAddTabConnUndoAction(_pView), 222 static_cast< OQueryTableConnection*>(_pConnection)); 223 // redraw 224 _pConnection->RecalcLines(); 225 // force an invalidation of the bounding rectangle 226 _pConnection->InvalidateConnection(); 227 228 _pView->Invalidate(INVALIDATE_NOCHILDREN); 229 } 230 // ----------------------------------------------------------------------------- 231 void addConnections(OQueryTableView* _pView, 232 const OQueryTableWindow& _rSource, 233 const OQueryTableWindow& _rDest, 234 const Reference<XNameAccess>& _rxSourceForeignKeyColumns) 235 { 236 if ( _rSource.GetData()->isQuery() || _rDest.GetData()->isQuery() ) 237 // nothing to do if one of both denotes a query 238 return; 239 240 // we found a table in our view where we can insert some connections 241 // the key columns have a property called RelatedColumn 242 // OQueryTableConnectionData aufbauen 243 OQueryTableConnectionData* pNewConnData = new OQueryTableConnectionData( _rSource.GetData(), _rDest.GetData() ); 244 TTableConnectionData::value_type aNewConnData(pNewConnData); 245 246 Reference<XIndexAccess> xReferencedKeys( _rDest.GetData()->getKeys()); 247 ::rtl::OUString sRelatedColumn; 248 249 // iterate through all foreignkey columns to create the connections 250 Sequence< ::rtl::OUString> aElements(_rxSourceForeignKeyColumns->getElementNames()); 251 const ::rtl::OUString* pIter = aElements.getConstArray(); 252 const ::rtl::OUString* pEnd = pIter + aElements.getLength(); 253 for(sal_Int32 i=0;pIter != pEnd;++pIter,++i) 254 { 255 Reference<XPropertySet> xColumn; 256 if ( !( _rxSourceForeignKeyColumns->getByName(*pIter) >>= xColumn ) ) 257 { 258 OSL_ENSURE( false, "addConnections: invalid foreign key column!" ); 259 continue; 260 } 261 262 pNewConnData->SetFieldType(JTCS_FROM,TAB_NORMAL_FIELD); 263 264 xColumn->getPropertyValue(PROPERTY_RELATEDCOLUMN) >>= sRelatedColumn; 265 pNewConnData->SetFieldType(JTCS_TO,isColumnInKeyType(xReferencedKeys,sRelatedColumn,KeyType::PRIMARY) ? TAB_PRIMARY_FIELD : TAB_NORMAL_FIELD); 266 267 { 268 Sequence< sal_Int16> aFind(::comphelper::findValue(_rSource.GetOriginalColumns()->getElementNames(),*pIter,sal_True)); 269 if(aFind.getLength()) 270 pNewConnData->SetFieldIndex(JTCS_FROM,aFind[0]+1); 271 else 272 OSL_ENSURE(0,"Column not found!"); 273 } 274 // get the position inside the tabe 275 Reference<XNameAccess> xRefColumns = _rDest.GetOriginalColumns(); 276 if(xRefColumns.is()) 277 { 278 Sequence< sal_Int16> aFind(::comphelper::findValue(xRefColumns->getElementNames(),sRelatedColumn,sal_True)); 279 if(aFind.getLength()) 280 pNewConnData->SetFieldIndex(JTCS_TO,aFind[0]+1); 281 else 282 OSL_ENSURE(0,"Column not found!"); 283 } 284 pNewConnData->AppendConnLine(*pIter,sRelatedColumn); 285 286 // dann die Conn selber dazu 287 OQueryTableConnection aNewConn(_pView, aNewConnData); 288 // der Verweis auf die lokale Variable ist unkritisch, da NotifyQueryTabConn eine neue Kopie anlegt 289 // und mir hinzufuegen (wenn nicht schon existent) 290 _pView->NotifyTabConnection(aNewConn, sal_False); 291 // don't create an Undo-Action for the new connection : the connection is 292 // covered by the Undo-Action for the tabwin, as the "Undo the insert" will 293 // automatically remove all connections adjacent to the win. 294 // (Because of this automatism we would have an ownerhsip ambiguity for 295 // the connection data if we would insert the conn-Undo-Action) 296 // FS - 21.10.99 - 69183 297 } 298 } 299 } 300 //================================================================== 301 // class OQueryTableView 302 //================================================================== 303 DBG_NAME(OQueryTableView) 304 //------------------------------------------------------------------------ 305 OQueryTableView::OQueryTableView( Window* pParent,OQueryDesignView* pView) 306 : OJoinTableView( pParent,pView) 307 { 308 DBG_CTOR(OQueryTableView,NULL); 309 SetHelpId(HID_CTL_QRYDGNTAB); 310 } 311 312 //------------------------------------------------------------------------ 313 OQueryTableView::~OQueryTableView() 314 { 315 DBG_DTOR(OQueryTableView,NULL); 316 } 317 318 //------------------------------------------------------------------------ 319 sal_Int32 OQueryTableView::CountTableAlias(const String& rName, sal_Int32& rMax) 320 { 321 DBG_CHKTHIS(OQueryTableView,NULL); 322 sal_Int32 nRet = 0; 323 324 OTableWindowMapIterator aIter = GetTabWinMap()->find(rName); 325 while(aIter != GetTabWinMap()->end()) 326 { 327 String aNewName; 328 aNewName = rName; 329 aNewName += '_'; 330 aNewName += String::CreateFromInt32(++nRet); 331 332 aIter = GetTabWinMap()->find(aNewName); 333 } 334 335 rMax = nRet; 336 337 return nRet; 338 } 339 //------------------------------------------------------------------------ 340 void OQueryTableView::ReSync() 341 { 342 DBG_CHKTHIS(OQueryTableView,NULL); 343 TTableWindowData* pTabWinDataList = m_pView->getController().getTableWindowData(); 344 DBG_ASSERT((getTableConnections()->size()==0) && (GetTabWinMap()->size()==0), 345 "vor OQueryTableView::ReSync() bitte ClearAll aufrufen !"); 346 347 // ich brauche eine Sammlung aller Fensternamen, deren Anlegen schief geht, damit ich die entsprechenden Connections 348 // gar nicht erst anlege 349 ::std::vector<String> arrInvalidTables; 350 351 TTableWindowData::reverse_iterator aIter = pTabWinDataList->rbegin(); 352 // Fenster kreieren und einfuegen 353 354 for(;aIter != pTabWinDataList->rend();++aIter) 355 { 356 OQueryTableWindowData* pData = static_cast<OQueryTableWindowData*>(aIter->get()); 357 OTableWindow* pTabWin = createWindow(*aIter); 358 359 // ich gehe jetzt NICHT ueber ShowTabWin, da dieses die Daten des Fensters in die Liste des Docs einfuegt, was 360 // schlecht waere, denn genau von dort hole ich sie ja gerade 361 // also Schritt fuer Schritt 362 if (!pTabWin->Init()) 363 { 364 // das Initialisieren ging schief, dass heisst, dieses TabWin steht nicht zur Verfuegung, also muss ich es inklusive 365 // seiner Daten am Dokument aufraeumen 366 pTabWin->clearListBox(); 367 delete pTabWin; 368 arrInvalidTables.push_back(pData->GetAliasName()); 369 370 pTabWinDataList->erase( ::std::remove(pTabWinDataList->begin(),pTabWinDataList->end(),*aIter) ,pTabWinDataList->end()); 371 continue; 372 } 373 374 (*GetTabWinMap())[pData->GetAliasName()] = pTabWin; // am Anfang einfuegen, da ich die DataList ja rueckwaerts durchlaufe 375 // wenn in den Daten keine Position oder Groesse steht -> Default 376 if (!pData->HasPosition() && !pData->HasSize()) 377 SetDefaultTabWinPosSize(pTabWin); 378 379 pTabWin->Show(); 380 } 381 382 // Verbindungen einfuegen 383 TTableConnectionData* pTabConnDataList = m_pView->getController().getTableConnectionData(); 384 TTableConnectionData::reverse_iterator aConIter = pTabConnDataList->rbegin(); 385 386 for(;aConIter != pTabConnDataList->rend();++aConIter) 387 { 388 OQueryTableConnectionData* pTabConnData = static_cast<OQueryTableConnectionData*>(aConIter->get()); 389 390 // gibt es die beiden Tabellen zur Connection ? 391 String strTabExistenceTest = pTabConnData->getReferencingTable()->GetWinName(); 392 sal_Bool bInvalid = ::std::find(arrInvalidTables.begin(),arrInvalidTables.end(),strTabExistenceTest) != arrInvalidTables.end(); 393 strTabExistenceTest = pTabConnData->getReferencedTable()->GetWinName(); 394 bInvalid = bInvalid && ::std::find(arrInvalidTables.begin(),arrInvalidTables.end(),strTabExistenceTest) != arrInvalidTables.end(); 395 396 if (bInvalid) 397 { // nein -> Pech gehabt, die Connection faellt weg 398 pTabConnDataList->erase( ::std::remove(pTabConnDataList->begin(),pTabConnDataList->end(),*aConIter) ,pTabConnDataList->end()); 399 continue; 400 } 401 402 // adds a new connection to join view and notifies our accessible and invaldates the controller 403 addConnection(new OQueryTableConnection(this, *aConIter)); 404 } 405 } 406 407 //------------------------------------------------------------------------ 408 void OQueryTableView::ClearAll() 409 { 410 DBG_CHKTHIS(OQueryTableView,NULL); 411 OJoinTableView::ClearAll(); 412 413 SetUpdateMode(sal_True); 414 m_pView->getController().setModified(sal_True); 415 } 416 417 // ----------------------------------------------------------------------------- 418 OTableWindow* OQueryTableView::createWindow(const TTableWindowData::value_type& _pData) 419 { 420 return new OQueryTableWindow(this,_pData); 421 } 422 423 //------------------------------------------------------------------------------ 424 void OQueryTableView::NotifyTabConnection(const OQueryTableConnection& rNewConn, sal_Bool _bCreateUndoAction) 425 { 426 DBG_CHKTHIS(OQueryTableView,NULL); 427 // erst mal schauen, ob ich diese Connection schon habe 428 OQueryTableConnection* pTabConn = NULL; 429 const ::std::vector<OTableConnection*>* pConnections = getTableConnections(); 430 ::std::vector<OTableConnection*>::const_iterator aEnd = pConnections->end(); 431 ::std::vector<OTableConnection*>::const_iterator aIter = ::std::find( pConnections->begin(), 432 aEnd, 433 static_cast<const OTableConnection*>(&rNewConn) 434 ); 435 if(aIter == aEnd ) 436 { 437 aIter = pConnections->begin(); 438 for(;aIter != aEnd;++aIter) 439 { 440 if(*static_cast<OQueryTableConnection*>(*aIter) == rNewConn) 441 { 442 pTabConn = static_cast<OQueryTableConnection*>(*aIter); 443 break; 444 } 445 } 446 } 447 else 448 pTabConn = static_cast<OQueryTableConnection*>(*aIter); 449 // nein -> einfuegen 450 if (pTabConn == NULL) 451 { 452 // die neuen Daten ... 453 OQueryTableConnectionData* pNewData = static_cast< OQueryTableConnectionData*>(rNewConn.GetData()->NewInstance()); 454 pNewData->CopyFrom(*rNewConn.GetData()); 455 TTableConnectionData::value_type aData(pNewData); 456 OQueryTableConnection* pNewConn = new OQueryTableConnection(this, aData); 457 GetConnection(pNewConn); 458 459 connectionModified(this,pNewConn,_bCreateUndoAction); 460 } 461 } 462 // ----------------------------------------------------------------------------- 463 OTableWindowData* OQueryTableView::CreateImpl(const ::rtl::OUString& _rComposedName 464 ,const ::rtl::OUString& _sTableName 465 ,const ::rtl::OUString& _rWinName) 466 { 467 return new OQueryTableWindowData( _rComposedName, _sTableName,_rWinName ); 468 } 469 //------------------------------------------------------------------------------ 470 void OQueryTableView::AddTabWin(const ::rtl::OUString& _rTableName, const ::rtl::OUString& _rAliasName, sal_Bool bNewTable) 471 { 472 DBG_CHKTHIS(OQueryTableView,NULL); 473 // das ist die aus der Basisklasse geerbte Methode, die fuehre ich auf die an meinem Parent zurueck, die mir eventuell einen 474 // Alias dazu bastelt und das an mein anderes AddTabWin weiterreicht 475 476 // leider ist _rTableName voll qualifiziert, das OQueryDesignView erwartet aber einen String, der 477 // nur aus Schema und Tabelle besteht und keinen Katalog enthaelt. 478 Reference< XConnection> xConnection = m_pView->getController().getConnection(); 479 if(!xConnection.is()) 480 return; 481 try 482 { 483 Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData(); 484 ::rtl::OUString sCatalog, sSchema, sTable; 485 ::dbtools::qualifiedNameComponents(xMetaData, 486 _rTableName, 487 sCatalog, 488 sSchema, 489 sTable, 490 ::dbtools::eInDataManipulation); 491 ::rtl::OUString sRealName(sSchema); 492 if (sRealName.getLength()) 493 sRealName+= ::rtl::OUString('.'); 494 sRealName += sTable; 495 496 AddTabWin(_rTableName, sRealName, _rAliasName, bNewTable); 497 } 498 catch(SQLException&) 499 { 500 OSL_ASSERT(!"qualifiedNameComponents"); 501 } 502 } 503 // ----------------------------------------------------------------------------- 504 // find the table which has a foreign key with this referencedTable name 505 Reference<XPropertySet> getKeyReferencedTo(const Reference<XIndexAccess>& _rxKeys,const ::rtl::OUString& _rReferencedTable) 506 { 507 if(!_rxKeys.is()) 508 return Reference<XPropertySet>(); 509 510 if ( !_rxKeys.is() ) 511 return Reference<XPropertySet>(); 512 // search the one and only primary key 513 const sal_Int32 nCount = _rxKeys->getCount(); 514 for(sal_Int32 i=0;i<nCount ;++i) 515 { 516 Reference<XPropertySet> xKey(_rxKeys->getByIndex(i),UNO_QUERY); 517 if(xKey.is()) 518 { 519 sal_Int32 nKeyType = 0; 520 xKey->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; 521 if(KeyType::FOREIGN == nKeyType) 522 { 523 ::rtl::OUString sReferencedTable; 524 xKey->getPropertyValue(PROPERTY_REFERENCEDTABLE) >>= sReferencedTable; 525 // TODO check case 526 if(sReferencedTable == _rReferencedTable) 527 return xKey; 528 } 529 } 530 } 531 return Reference<XPropertySet>(); 532 } 533 //------------------------------------------------------------------------------ 534 void OQueryTableView::AddTabWin(const ::rtl::OUString& _rComposedName, const ::rtl::OUString& _rTableName, const ::rtl::OUString& strAlias, sal_Bool bNewTable) 535 { 536 DBG_CHKTHIS(OQueryTableView,NULL); 537 DBG_ASSERT(_rTableName.getLength() || strAlias.getLength(), "OQueryTableView::AddTabWin : kein Tabellen- und kein Aliasname !"); 538 // wenn der Tabellenname nicht gesetzt ist, steht das fuer ein Dummy-Fenster, das braucht aber wenigstens einen Alias-Namen 539 540 // neue Datenstruktur erzeugen 541 // first check if this already hav it's data 542 sal_Bool bAppend = bNewTable; 543 TTableWindowData::value_type pNewTabWinData; 544 TTableWindowData* pWindowData = getDesignView()->getController().getTableWindowData(); 545 TTableWindowData::iterator aWinIter = pWindowData->begin(); 546 TTableWindowData::iterator aWinEnd = pWindowData->end(); 547 for(;aWinIter != aWinEnd;++aWinIter) 548 { 549 pNewTabWinData = *aWinIter; 550 if (pNewTabWinData && pNewTabWinData->GetWinName() == strAlias && pNewTabWinData->GetComposedName() == _rComposedName && pNewTabWinData->GetTableName() == _rTableName) 551 break; 552 } 553 if ( !bAppend ) 554 bAppend = ( aWinIter == aWinEnd ); 555 if ( bAppend ) 556 pNewTabWinData = createTableWindowData(_rComposedName, _rTableName, strAlias); 557 // die TabWinData brauche ich nicht in die entsprechende Liste der DocShell eintragen, das macht ShowTabWin 558 559 // neues Fenster erzeugen 560 OQueryTableWindow* pNewTabWin = static_cast<OQueryTableWindow*>(createWindow(pNewTabWinData)); 561 // das Init kann ich hier weglassen, da das in ShowTabWin passiert 562 563 // Neue UndoAction 564 OQueryTabWinShowUndoAct* pUndoAction = new OQueryTabWinShowUndoAct(this); 565 pUndoAction->SetTabWin(pNewTabWin); // Fenster 566 sal_Bool bSuccess = ShowTabWin(pNewTabWin, pUndoAction,bAppend); 567 if(!bSuccess) 568 { 569 // reset table window 570 pUndoAction->SetTabWin(NULL); 571 pUndoAction->SetOwnership(sal_False); 572 573 delete pUndoAction; 574 return; 575 } 576 577 // Relationen zwischen den einzelnen Tabellen anzeigen 578 OTableWindowMap* pTabWins = GetTabWinMap(); 579 if(bNewTable && !pTabWins->empty() && _rTableName.getLength()) 580 { 581 modified(); 582 if ( m_pAccessible ) 583 m_pAccessible->notifyAccessibleEvent( AccessibleEventId::CHILD, 584 Any(), 585 makeAny(pNewTabWin->GetAccessible()) 586 ); 587 588 do { 589 590 if ( pNewTabWin->GetData()->isQuery() ) 591 break; 592 593 try 594 { 595 ////////////////////////////////////////////////////////////////////// 596 // find relations between the table an the tables already inserted 597 Reference< XIndexAccess> xKeyIndex = pNewTabWin->GetData()->getKeys(); 598 if ( !xKeyIndex.is() ) 599 break; 600 601 Reference<XNameAccess> xFKeyColumns; 602 ::rtl::OUString aReferencedTable; 603 Reference<XColumnsSupplier> xColumnsSupplier; 604 605 const sal_Int32 nKeyCount = xKeyIndex->getCount(); 606 for ( sal_Int32 i=0; i<nKeyCount ; ++i ) 607 { 608 Reference< XPropertySet > xProp( xKeyIndex->getByIndex(i), UNO_QUERY_THROW ); 609 xColumnsSupplier.set( xProp, UNO_QUERY_THROW ); 610 xFKeyColumns.set( xColumnsSupplier->getColumns(), UNO_QUERY_THROW ); 611 612 sal_Int32 nKeyType = 0; 613 xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; 614 615 switch ( nKeyType ) 616 { 617 case KeyType::FOREIGN: 618 { // our new table has a foreign key 619 // so look if the referenced table is already in our list 620 xProp->getPropertyValue(PROPERTY_REFERENCEDTABLE) >>= aReferencedTable; 621 OSL_ENSURE(aReferencedTable.getLength(),"Foreign key without referencedTableName"); 622 623 OTableWindowMap::const_iterator aIter = pTabWins->find(aReferencedTable); 624 OTableWindowMap::const_iterator aEnd = pTabWins->end(); 625 if(aIter == aEnd) 626 { 627 for(aIter = pTabWins->begin();aIter != aEnd;++aIter) 628 { 629 OQueryTableWindow* pTabWinTmp = static_cast<OQueryTableWindow*>(aIter->second); 630 OSL_ENSURE( pTabWinTmp,"TableWindow is null!" ); 631 if ( pTabWinTmp != pNewTabWin && pTabWinTmp->GetComposedName() == aReferencedTable ) 632 break; 633 } 634 } 635 if ( aIter != aEnd && pNewTabWin != aIter->second ) 636 addConnections( this, *pNewTabWin, *static_cast<OQueryTableWindow*>(aIter->second), xFKeyColumns ); 637 } 638 break; 639 640 case KeyType::PRIMARY: 641 { 642 // we have a primary key so look in our list if there exsits a key which this is refered to 643 OTableWindowMap::const_iterator aIter = pTabWins->begin(); 644 OTableWindowMap::const_iterator aEnd = pTabWins->end(); 645 for(;aIter != aEnd;++aIter) 646 { 647 OQueryTableWindow* pTabWinTmp = static_cast<OQueryTableWindow*>(aIter->second); 648 if ( pTabWinTmp == pNewTabWin ) 649 continue; 650 651 if ( pTabWinTmp->GetData()->isQuery() ) 652 continue; 653 654 OSL_ENSURE(pTabWinTmp,"TableWindow is null!"); 655 Reference< XPropertySet > xFKKey = getKeyReferencedTo( pTabWinTmp->GetData()->getKeys(), pNewTabWin->GetComposedName() ); 656 if ( !xFKKey.is() ) 657 continue; 658 659 Reference<XColumnsSupplier> xFKColumnsSupplier( xFKKey, UNO_QUERY_THROW ); 660 Reference< XNameAccess > xTColumns( xFKColumnsSupplier->getColumns(), UNO_QUERY_THROW ); 661 addConnections( this, *pTabWinTmp, *pNewTabWin, xTColumns ); 662 } 663 } 664 break; 665 } 666 } 667 } 668 catch( const Exception& ) 669 { 670 DBG_UNHANDLED_EXCEPTION(); 671 } 672 673 } while ( false ); 674 } 675 676 // mein Parent brauche ich, da es vom Loeschen erfahren soll 677 m_pView->getController().addUndoActionAndInvalidate( pUndoAction ); 678 679 if (bSuccess && m_lnkTabWinsChangeHandler.IsSet()) 680 { 681 TabWinsChangeNotification aHint(TabWinsChangeNotification::AT_ADDED_WIN, pNewTabWin->GetAliasName()); 682 m_lnkTabWinsChangeHandler.Call(&aHint); 683 } 684 } 685 // ----------------------------------------------------------------------------- 686 // ----------------------------------------------------------------------------- 687 void OQueryTableView::AddConnection(const OJoinExchangeData& jxdSource, const OJoinExchangeData& jxdDest) 688 { 689 DBG_CHKTHIS(OQueryTableView,NULL); 690 OQueryTableWindow* pSourceWin = static_cast< OQueryTableWindow*>(jxdSource.pListBox->GetTabWin()); 691 OQueryTableWindow* pDestWin = static_cast< OQueryTableWindow*>(jxdDest.pListBox->GetTabWin()); 692 693 String aSourceFieldName, aDestFieldName; 694 aSourceFieldName = jxdSource.pListBox->GetEntryText(jxdSource.pEntry); 695 aDestFieldName = jxdDest.pListBox->GetEntryText(jxdDest.pEntry); 696 697 OTableConnection* pConn = GetTabConn(pSourceWin,pDestWin,true); 698 if ( !pConn ) 699 { 700 // neues Daten-Objekt 701 OQueryTableConnectionData* pNewConnectionData = new OQueryTableConnectionData(pSourceWin->GetData(), pDestWin->GetData()); 702 TTableConnectionData::value_type aNewConnectionData(pNewConnectionData); 703 704 sal_uInt32 nSourceFieldIndex, nDestFieldIndex; 705 ETableFieldType eSourceFieldType, eDestFieldType; 706 707 // Namen/Position/Typ der beiden betroffenen Felder besorgen ... 708 // Source 709 710 nSourceFieldIndex = jxdSource.pListBox->GetModel()->GetAbsPos(jxdSource.pEntry); 711 eSourceFieldType = static_cast< OTableFieldInfo*>(jxdSource.pEntry->GetUserData())->GetKeyType(); 712 713 // Dest 714 715 nDestFieldIndex = jxdDest.pListBox->GetModel()->GetAbsPos(jxdDest.pEntry); 716 eDestFieldType = static_cast< OTableFieldInfo*>(jxdDest.pEntry->GetUserData())->GetKeyType(); 717 718 // ... und setzen 719 720 pNewConnectionData->SetFieldIndex(JTCS_FROM, nSourceFieldIndex); 721 pNewConnectionData->SetFieldIndex(JTCS_TO, nDestFieldIndex); 722 723 pNewConnectionData->SetFieldType(JTCS_FROM, eSourceFieldType); 724 pNewConnectionData->SetFieldType(JTCS_TO, eDestFieldType); 725 726 pNewConnectionData->AppendConnLine( aSourceFieldName,aDestFieldName ); 727 728 OQueryTableConnection aNewConnection(this, aNewConnectionData); 729 NotifyTabConnection(aNewConnection); 730 // wie immer bei NotifyTabConnection ist das Verwenden lokaler Variablen unkritisch, da sowieso eine Kopie erzeugt wird 731 } 732 else 733 { 734 // the connection could point on the other side 735 if(pConn->GetSourceWin() == pDestWin) 736 { 737 String aTmp(aSourceFieldName); 738 aSourceFieldName = aDestFieldName; 739 aDestFieldName = aTmp; 740 } 741 742 pConn->GetData()->AppendConnLine( aSourceFieldName,aDestFieldName ); 743 744 connectionModified(this,pConn,sal_False); 745 } 746 } 747 // ----------------------------------------------------------------------------- 748 void OQueryTableView::ConnDoubleClicked(OTableConnection* pConnection) 749 { 750 DBG_CHKTHIS(OQueryTableView,NULL); 751 if( openJoinDialog(this,pConnection->GetData(),sal_False) ) 752 { 753 connectionModified(this,pConnection,sal_False); 754 SelectConn( pConnection ); 755 } 756 } 757 // ----------------------------------------------------------------------------- 758 void OQueryTableView::createNewConnection() 759 { 760 TTableConnectionData::value_type pData(new OQueryTableConnectionData()); 761 if( openJoinDialog(this,pData,sal_True) ) 762 { 763 OTableWindowMap* pMap = GetTabWinMap(); 764 OQueryTableWindow* pSourceWin = static_cast< OQueryTableWindow*>((*pMap)[pData->getReferencingTable()->GetWinName()]); 765 OQueryTableWindow* pDestWin = static_cast< OQueryTableWindow*>((*pMap)[pData->getReferencedTable()->GetWinName()]); 766 // first we have to look if the this connection already exists 767 OTableConnection* pConn = GetTabConn(pSourceWin,pDestWin,true); 768 sal_Bool bNew = sal_True; 769 if ( pConn ) 770 { 771 pConn->GetData()->CopyFrom( *pData ); 772 bNew = sal_False; 773 } 774 else 775 { 776 // create a new conenction and append it 777 OQueryTableConnection* pQConn = new OQueryTableConnection(this, pData); 778 GetConnection(pQConn); 779 pConn = pQConn; 780 } 781 connectionModified(this,pConn,bNew); 782 if ( !bNew && pConn == GetSelectedConn() ) // our connection was selected before so we have to reselect it 783 SelectConn( pConn ); 784 } 785 } 786 //------------------------------------------------------------------------------ 787 bool OQueryTableView::RemoveConnection( OTableConnection* _pConnection,sal_Bool /*_bDelete*/ ) 788 { 789 DBG_CHKTHIS(OQueryTableView,NULL); 790 791 // we don't want that our connection will be deleted, we put it in the undo manager 792 bool bRet = OJoinTableView::RemoveConnection( _pConnection,sal_False); 793 794 // add undo action 795 addUndoAction( this, 796 new OQueryDelTabConnUndoAction(this), 797 static_cast< OQueryTableConnection*>(_pConnection), 798 sal_True); 799 return bRet; 800 } 801 802 //------------------------------------------------------------------------------ 803 void OQueryTableView::KeyInput( const KeyEvent& rEvt ) 804 { 805 DBG_CHKTHIS(OQueryTableView,NULL); 806 OJoinTableView::KeyInput( rEvt ); 807 } 808 809 //------------------------------------------------------------------------------ 810 OQueryTableWindow* OQueryTableView::FindTable(const String& rAliasName) 811 { 812 DBG_CHKTHIS(OQueryTableView,NULL); 813 DBG_ASSERT(rAliasName.Len(), "OQueryTableView::FindTable : der AliasName sollte nicht leer sein !"); 814 // (nicht dass es schadet, aber es ist sinnlos und weist vielleicht auf Fehler beim Aufrufer hin) 815 OTableWindowMap::const_iterator aIter = GetTabWinMap()->find(rAliasName); 816 if(aIter != GetTabWinMap()->end()) 817 return static_cast<OQueryTableWindow*>(aIter->second); 818 return NULL; 819 } 820 821 //------------------------------------------------------------------------------ 822 sal_Bool OQueryTableView::FindTableFromField(const String& rFieldName, OTableFieldDescRef& rInfo, sal_uInt16& rCnt) 823 { 824 DBG_CHKTHIS(OQueryTableView,NULL); 825 rCnt = 0; 826 OTableWindowMap::const_iterator aIter = GetTabWinMap()->begin(); 827 OTableWindowMap::const_iterator aEnd = GetTabWinMap()->end(); 828 for(;aIter != aEnd;++aIter) 829 { 830 if(static_cast<OQueryTableWindow*>(aIter->second)->ExistsField(rFieldName, rInfo)) 831 ++rCnt; 832 } 833 834 return rCnt == 1; 835 } 836 837 //------------------------------------------------------------------------------ 838 bool OQueryTableView::ContainsTabWin(const OTableWindow& rTabWin) 839 { 840 OTableWindowMap* pTabWins = GetTabWinMap(); 841 DBG_ASSERT(pTabWins != NULL, "OQueryTableView::HideTabWin : habe keine TabWins !"); 842 843 OTableWindowMap::iterator aIter = pTabWins->begin(); 844 OTableWindowMap::iterator aEnd = pTabWins->end(); 845 846 for ( ;aIter != aEnd ; ++aIter ) 847 { 848 if ( aIter->second == &rTabWin ) 849 { 850 return true; 851 } 852 } 853 854 return false; 855 } 856 857 //------------------------------------------------------------------------------ 858 void OQueryTableView::RemoveTabWin(OTableWindow* pTabWin) 859 { 860 DBG_CHKTHIS(OQueryTableView,NULL); 861 DBG_ASSERT(pTabWin != NULL, "OQueryTableView::RemoveTabWin : Fenster sollte ungleich NULL sein !"); 862 863 if(pTabWin && ContainsTabWin(*pTabWin)) // #122589# check if registered before deleting 864 { 865 // mein Parent brauche ich, da es vom Loeschen erfahren soll 866 OQueryDesignView* pParent = static_cast<OQueryDesignView*>(getDesignView()); 867 868 SfxUndoManager& rUndoMgr = m_pView->getController().GetUndoManager(); 869 rUndoMgr.EnterListAction( String( ModuleRes(STR_QUERY_UNDO_TABWINDELETE) ), String() ); 870 871 // Undo-Action anlegen 872 OQueryTabWinDelUndoAct* pUndoAction = new OQueryTabWinDelUndoAct(this); 873 pUndoAction->SetTabWin(static_cast< OQueryTableWindow*>(pTabWin)); 874 875 // und Fenster verstecken 876 HideTabWin(static_cast< OQueryTableWindow*>(pTabWin), pUndoAction); 877 878 // Undo Actions und Loeschen der Felder in SelectionBrowseBox 879 pParent->TableDeleted( static_cast< OQueryTableWindowData*>(pTabWin->GetData().get())->GetAliasName() ); 880 881 m_pView->getController().addUndoActionAndInvalidate( pUndoAction ); 882 rUndoMgr.LeaveListAction(); 883 884 if (m_lnkTabWinsChangeHandler.IsSet()) 885 { 886 TabWinsChangeNotification aHint(TabWinsChangeNotification::AT_REMOVED_WIN, static_cast< OQueryTableWindow*>(pTabWin)->GetAliasName()); 887 m_lnkTabWinsChangeHandler.Call(&aHint); 888 } 889 890 modified(); 891 if ( m_pAccessible ) 892 m_pAccessible->notifyAccessibleEvent( AccessibleEventId::CHILD, 893 makeAny(pTabWin->GetAccessible()), 894 Any() 895 ); 896 } 897 } 898 899 //------------------------------------------------------------------------ 900 void OQueryTableView::EnsureVisible(const OTableWindow* pWin) 901 { 902 DBG_CHKTHIS(OQueryTableView,NULL); 903 904 Invalidate(INVALIDATE_NOCHILDREN); 905 OJoinTableView::EnsureVisible(pWin); 906 } 907 908 //------------------------------------------------------------------------ 909 void OQueryTableView::GetConnection(OQueryTableConnection* pConn) 910 { 911 DBG_CHKTHIS(OQueryTableView,NULL); 912 // bei mir und dem Dokument einfuegen 913 914 addConnection( pConn ); 915 // invalidieren (damit es neu gezeichnet wird) 916 // pConn->Invalidate(); 917 } 918 919 //------------------------------------------------------------------------ 920 void OQueryTableView::DropConnection(OQueryTableConnection* pConn) 921 { 922 DBG_CHKTHIS(OQueryTableView,NULL); 923 // Selektion beachten 924 // bei mir und dem Dokument rausnehmen 925 RemoveConnection( pConn ,sal_False); 926 } 927 928 //------------------------------------------------------------------------ 929 void OQueryTableView::HideTabWin( OQueryTableWindow* pTabWin, OQueryTabWinUndoAct* pUndoAction ) 930 { 931 DBG_CHKTHIS(OQueryTableView,NULL); 932 OTableWindowMap* pTabWins = GetTabWinMap(); 933 DBG_ASSERT(pTabWins != NULL, "OQueryTableView::HideTabWin : habe keine TabWins !"); 934 935 if (pTabWin) 936 { 937 // Fenster 938 // die Position in seinen Daten speichern 939 getDesignView()->SaveTabWinUIConfig(pTabWin); 940 // (ich muss ueber das Parent gehen, da nur das die Position der Scrollbars kennt) 941 // dann aus der Liste der TabWins raus und verstecken 942 OTableWindowMap::iterator aIter = pTabWins->begin(); 943 OTableWindowMap::iterator aEnd = pTabWins->end(); 944 for ( ;aIter != aEnd ; ++aIter ) 945 if ( aIter->second == pTabWin ) 946 { 947 pTabWins->erase( aIter ); 948 break; 949 } 950 951 pTabWin->Hide(); // nicht zerstoeren, steht im Undo!! 952 953 // die Daten zum TabWin muessen auch aus meiner Verantwortung entlassen werden 954 TTableWindowData* pTabWinDataList = m_pView->getController().getTableWindowData(); 955 pTabWinDataList->erase( ::std::remove(pTabWinDataList->begin(),pTabWinDataList->end(),pTabWin->GetData()),pTabWinDataList->end()); 956 // NICHT loeschen, da ja das TabWin selber - das noch lebt - sie auch noch braucht 957 // Entweder geht es irgendwann wieder in meine Verantwortung ueber, (ueber ShowTabWin), dann fuege ich 958 // auch die Daten wieder ein, oder die Undo-Action, die im Augenblick die alleinige Verantwortung fuer das Fenster 959 // und dessen Daten hat, wird zestoert, dann loescht es beides 960 961 if (m_pLastFocusTabWin == pTabWin) 962 m_pLastFocusTabWin = NULL; 963 964 // Verbindungen, die zum Fenster gehoeren, einsammeln und der UndoAction uebergeben 965 sal_Int16 nCnt = 0; 966 const ::std::vector<OTableConnection*>* pTabConList = getTableConnections(); 967 ::std::vector<OTableConnection*>::const_iterator aIter2 = pTabConList->begin(); 968 for(;aIter2 != pTabConList->end();)// the end may change 969 { 970 OQueryTableConnection* pTmpEntry = static_cast<OQueryTableConnection*>(*aIter2); 971 OSL_ENSURE(pTmpEntry,"OQueryTableConnection is null!"); 972 if( pTmpEntry->GetAliasName(JTCS_FROM) == pTabWin->GetAliasName() || 973 pTmpEntry->GetAliasName(JTCS_TO) == pTabWin->GetAliasName() ) 974 { 975 // add to undo list 976 pUndoAction->InsertConnection(pTmpEntry); 977 978 // call base class because we append an undo action 979 // but this time we are in a undo action list 980 OJoinTableView::RemoveConnection(pTmpEntry,sal_False); 981 aIter2 = pTabConList->begin(); 982 ++nCnt; 983 } 984 else 985 ++aIter2; 986 } 987 988 if (nCnt) 989 InvalidateConnections(); 990 991 m_pView->getController().InvalidateFeature(ID_BROWSER_ADDTABLE); 992 993 // der UndoAction sagen, dass das Fenster (inklusive der Connections) jetzt in seinem Besitzt ist 994 pUndoAction->SetOwnership(sal_True); 995 996 // damit habe ich das Doc natuerlich modifiziert 997 m_pView->getController().setModified( sal_True ); 998 m_pView->getController().InvalidateFeature(SID_BROWSER_CLEAR_QUERY); 999 } 1000 } 1001 1002 //------------------------------------------------------------------------ 1003 sal_Bool OQueryTableView::ShowTabWin( OQueryTableWindow* pTabWin, OQueryTabWinUndoAct* pUndoAction,sal_Bool _bAppend ) 1004 { 1005 DBG_CHKTHIS(OQueryTableView,NULL); 1006 1007 sal_Bool bSuccess = sal_False; 1008 1009 if (pTabWin) 1010 { 1011 if (pTabWin->Init()) 1012 { 1013 TTableWindowData::value_type pData = pTabWin->GetData(); 1014 DBG_ASSERT(pData != NULL, "OQueryTableView::ShowTabWin : TabWin hat keine Daten !"); 1015 // Wenn die Daten schon PosSize haben, diese benutzen 1016 if (pData->HasPosition() && pData->HasSize()) 1017 { 1018 Size aSize(CalcZoom(pData->GetSize().Width()),CalcZoom(pData->GetSize().Height())); 1019 pTabWin->SetPosSizePixel(pData->GetPosition(), aSize); 1020 } 1021 else 1022 // ansonsten selber eine Default-Position ermitteln 1023 SetDefaultTabWinPosSize(pTabWin); 1024 1025 // Fenster zeigen und in Liste eintragen 1026 ::rtl::OUString sName = static_cast< OQueryTableWindowData*>(pData.get())->GetAliasName(); 1027 OSL_ENSURE(GetTabWinMap()->find(sName) == GetTabWinMap()->end(),"Alias name already in list!"); 1028 GetTabWinMap()->insert(OTableWindowMap::value_type(sName,pTabWin)); 1029 1030 pTabWin->Show(); 1031 1032 pTabWin->Update(); 1033 // Das Update ist notwendig, damit die Connections an dem Fenster richtig gezeichnet werden. Klingt absurd, 1034 // ich weiss. Aber die Listbox haelt sich intern ein Member, was bei ersten Zeichnen (nachdem die Listbox im Init 1035 // gerade neu gefuellt wurde) initialisiert wird, und genau dieses Member wird irgendwann benoetigt fuer 1036 // GetEntryPos, und dieses wiederum von der Connection, wenn sie ihren Ansatzpunkt am Fenster feststellen will. 1037 1038 // die Connections 1039 ::std::vector<OTableConnection*>* pTableCon = pUndoAction->GetTabConnList(); 1040 ::std::vector<OTableConnection*>::iterator aIter = pTableCon->begin(); 1041 ::std::vector<OTableConnection*>::iterator aEnd = pTableCon->end(); 1042 1043 for(;aIter != aEnd;++aIter) 1044 addConnection(*aIter); // add all connections from the undo action 1045 1046 // each connection should invalidated inside addConnection so we don't need this here any longer 1047 // if ( !pOwnList->empty() ) 1048 // InvalidateConnections(); 1049 pTableCon->clear(); 1050 1051 // und die Daten des Fensters ebenfalls in Liste (des Docs) 1052 if(_bAppend) 1053 m_pView->getController().getTableWindowData()->push_back(pTabWin->GetData()); 1054 1055 m_pView->getController().InvalidateFeature(ID_BROWSER_ADDTABLE); 1056 1057 // und der UndoAction sagen, dass das Fenster jetzt meine ist ... 1058 pUndoAction->SetOwnership(sal_False); 1059 1060 bSuccess = sal_True; 1061 } 1062 else 1063 { 1064 ////////////////////////////////////////////////////////////////// 1065 // Initialisierung fehlgeschlagen 1066 // (z.B. wenn Verbindung zur Datenbank in diesem Augenblick unterbrochen worden ist) 1067 pTabWin->clearListBox(); 1068 delete pTabWin; 1069 } 1070 } 1071 1072 // damit habe ich das Doc natuerlich modifiziert 1073 if(!m_pView->getController().isReadOnly()) 1074 m_pView->getController().setModified( sal_True ); 1075 1076 m_pView->getController().InvalidateFeature(SID_BROWSER_CLEAR_QUERY); 1077 1078 return bSuccess; 1079 } 1080 //------------------------------------------------------------------------ 1081 void OQueryTableView::InsertField(const OTableFieldDescRef& rInfo) 1082 { 1083 DBG_CHKTHIS(OQueryTableView,NULL); 1084 DBG_ASSERT(getDesignView() != NULL, "OQueryTableView::InsertField : habe kein Parent !"); 1085 static_cast<OQueryDesignView*>(getDesignView())->InsertField(rInfo); 1086 } 1087 //------------------------------------------------------------------------------ 1088 sal_Bool OQueryTableView::ExistsAVisitedConn(const OQueryTableWindow* pFrom) const 1089 { 1090 DBG_CHKTHIS(OQueryTableView,NULL); 1091 const ::std::vector<OTableConnection*>* pList = getTableConnections(); 1092 if (pList) 1093 { 1094 ::std::vector<OTableConnection*>::const_iterator aIter = pList->begin(); 1095 ::std::vector<OTableConnection*>::const_iterator aEnd = pList->end(); 1096 for(;aIter != aEnd;++aIter) 1097 { 1098 OQueryTableConnection* pTemp = static_cast<OQueryTableConnection*>(*aIter); 1099 if (pTemp->IsVisited() && 1100 (pFrom == static_cast< OQueryTableWindow*>(pTemp->GetSourceWin()) || pFrom == static_cast< OQueryTableWindow*>(pTemp->GetDestWin()))) 1101 return pTemp != NULL; 1102 } 1103 } 1104 1105 return sal_False; 1106 } 1107 // ----------------------------------------------------------------------------- 1108 void OQueryTableView::onNoColumns_throw() 1109 { 1110 String sError( ModuleRes( STR_STATEMENT_WITHOUT_RESULT_SET ) ); 1111 ::dbtools::throwSQLException( sError, ::dbtools::SQL_GENERAL_ERROR, NULL ); 1112 } 1113 //------------------------------------------------------------------------------ 1114 bool OQueryTableView::supressCrossNaturalJoin(const TTableConnectionData::value_type& _pData) const 1115 { 1116 OQueryTableConnectionData* pQueryData = static_cast<OQueryTableConnectionData*>(_pData.get()); 1117 return pQueryData && (pQueryData->GetJoinType() == CROSS_JOIN); 1118 } 1119 // ----------------------------------------------------------------------------- 1120