dbaccess/source/ui/control/tabletree.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include "tabletree.hxx"
  31 #include "tabletree.hrc"
  32 #include "imageprovider.hxx"
  33 #include "moduledbu.hxx"
  34 #include "dbu_control.hrc"
  35 #include <vcl/menu.hxx>
  36 #include <connectivity/dbtools.hxx>
  37 #include <comphelper/types.hxx>
  38 #include "dbustrings.hrc"
  39 #include <com/sun/star/sdb/application/DatabaseObject.hpp>
  40 #include <com/sun/star/sdb/application/DatabaseObjectContainer.hpp>
  41 #include <com/sun/star/sdbc/XDriverAccess.hpp>
  42 #include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp>
  43 #include <com/sun/star/sdbcx/XViewsSupplier.hpp>
  44 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  45 #include <com/sun/star/sdb/SQLContext.hpp>
  46 #include <com/sun/star/sdbc/XRow.hpp>
  47 #include <com/sun/star/beans/XPropertySet.hpp>
  48 #include "commontypes.hxx"
  49 #include "listviewitems.hxx"
  50 #include <tools/diagnose_ex.h>
  51 #include <osl/diagnose.h>
  52 #include <rtl/ustrbuf.hxx>
  53 #include <connectivity/dbmetadata.hxx>
  54
  55 #include <algorithm>
  56 #include <o3tl/compat_functional.hxx>
  57
  58 //.........................................................................
  59 namespace dbaui
  60 {
  61 //.........................................................................
  62
  63 using namespace ::com::sun::star::uno;
  64 using namespace ::com::sun::star::sdb;
  65 using namespace ::com::sun::star::lang;
  66 using namespace ::com::sun::star::sdbc;
  67 using namespace ::com::sun::star::sdbcx;
  68 using namespace ::com::sun::star::beans;
  69 using namespace ::com::sun::star::container;
  70 using namespace ::com::sun::star::sdb::application;
  71
  72 using namespace ::dbtools;
  73 using namespace ::comphelper;
  74
  75 namespace DatabaseObject = ::com::sun::star::sdb::application::DatabaseObject;
  76 namespace DatabaseObjectContainer = ::com::sun::star::sdb::application::DatabaseObjectContainer;
  77
  78 //========================================================================
  79 //= OTableTreeListBox
  80 //========================================================================
  81 OTableTreeListBox::OTableTreeListBox( Window* pParent, const Reference< XMultiServiceFactory >& _rxORB, WinBits nWinStyle,sal_Bool _bVirtualRoot )
  82     :OMarkableTreeListBox(pParent,_rxORB,nWinStyle)
  83     ,m_pImageProvider( new ImageProvider )
  84     ,m_bVirtualRoot(_bVirtualRoot)
  85     ,m_bNoEmptyFolders( false )
  86 {
  87     implSetDefaultImages();
  88 }
  89 //------------------------------------------------------------------------
  90 OTableTreeListBox::OTableTreeListBox( Window* pParent, const Reference< XMultiServiceFactory >& _rxORB, const ResId& rResId ,sal_Bool _bVirtualRoot)
  91     :OMarkableTreeListBox(pParent,_rxORB,rResId)
  92     ,m_pImageProvider( new ImageProvider )
  93     ,m_bVirtualRoot(_bVirtualRoot)
  94     ,m_bNoEmptyFolders( false )
  95 {
  96     implSetDefaultImages();
  97 }
  98
  99 // -----------------------------------------------------------------------------
 100 OTableTreeListBox::~OTableTreeListBox()
 101 {
 102 }
 103
 104 // -----------------------------------------------------------------------------
 105 void OTableTreeListBox::implSetDefaultImages()
 106 {
 107     ImageProvider aImageProvider;
 108     SetDefaultExpandedEntryBmp(  aImageProvider.getFolderImage( DatabaseObject::TABLE ) );
 109     SetDefaultCollapsedEntryBmp( aImageProvider.getFolderImage( DatabaseObject::TABLE ) );
 110 }
 111
 112 // -----------------------------------------------------------------------------
 113 bool  OTableTreeListBox::isFolderEntry( const SvLBoxEntry* _pEntry ) const
 114 {
 115     sal_Int32 nEntryType = reinterpret_cast< sal_IntPtr >( _pEntry->GetUserData() );
 116     if  (   ( nEntryType == DatabaseObjectContainer::TABLES )
 117         ||  ( nEntryType == DatabaseObjectContainer::CATALOG )
 118         ||  ( nEntryType == DatabaseObjectContainer::SCHEMA )
 119         )
 120         return true;
 121     return false;
 122 }
 123
 124 // -----------------------------------------------------------------------------
 125 void OTableTreeListBox::notifyHiContrastChanged()
 126 {
 127     implSetDefaultImages();
 128
 129     SvLBoxEntry* pEntryLoop = First();
 130     while (pEntryLoop)
 131     {
 132         sal_uInt16 nCount = pEntryLoop->ItemCount();
 133         for (sal_uInt16 i=0;i<nCount;++i)
 134         {
 135             SvLBoxItem* pItem = pEntryLoop->GetItem(i);
 136             if ( pItem && pItem->IsA() == SV_ITEM_ID_LBOXCONTEXTBMP)
 137             {
 138                 SvLBoxContextBmp* pContextBitmapItem = static_cast< SvLBoxContextBmp* >( pItem );
 139
 140                 Image aImage;
 141                 if ( isFolderEntry( pEntryLoop ) )
 142                 {
 143                     aImage = m_pImageProvider->getFolderImage( DatabaseObject::TABLE );
 144                 }
 145                 else
 146                 {
 147                     String sCompleteName( getQualifiedTableName( pEntryLoop ) );
 148                     m_pImageProvider->getImages( sCompleteName, DatabaseObject::TABLE, aImage );
 149                 }
 150
 151                 pContextBitmapItem->SetBitmap1( aImage );
 152                 pContextBitmapItem->SetBitmap2( aImage );
 153                 break;
 154             }
 155         }
 156         pEntryLoop = Next(pEntryLoop);
 157     }
 158 }
 159
 160 //------------------------------------------------------------------------
 161 void OTableTreeListBox::implOnNewConnection( const Reference< XConnection >& _rxConnection )
 162 {
 163     m_xConnection = _rxConnection;
 164     m_pImageProvider.reset( new ImageProvider( m_xConnection  ) );
 165 }
 166
 167 //------------------------------------------------------------------------
 168 void OTableTreeListBox::UpdateTableList( const Reference< XConnection >& _rxConnection ) throw(SQLException)
 169 {
 170     Sequence< ::rtl::OUString > sTables, sViews;
 171
 172     String sCurrentActionError;
 173     try
 174     {
 175         Reference< XTablesSupplier > xTableSupp( _rxConnection, UNO_QUERY_THROW );
 176         sCurrentActionError = String(ModuleRes(STR_NOTABLEINFO));
 177
 178         Reference< XNameAccess > xTables,xViews;
 179
 180         Reference< XViewsSupplier > xViewSupp( _rxConnection, UNO_QUERY );
 181         if ( xViewSupp.is() )
 182         {
 183             xViews = xViewSupp->getViews();
 184             if (xViews.is())
 185                 sViews = xViews->getElementNames();
 186         }
 187
 188         xTables = xTableSupp->getTables();
 189         if (xTables.is())
 190             sTables = xTables->getElementNames();
 191     }
 192     catch(RuntimeException&)
 193     {
 194         OSL_FAIL("OTableTreeListBox::UpdateTableList : caught an RuntimeException!");
 195     }
 196     catch ( const SQLException& )
 197     {
 198         throw;
 199     }
 200     catch(Exception&)
 201     {
 202         // a non-SQLException exception occurred ... simply throw an SQLException
 203         SQLException aInfo;
 204         aInfo.Message = sCurrentActionError;
 205         throw aInfo;
 206     }
 207
 208     UpdateTableList( _rxConnection, sTables, sViews );
 209 }
 210 // -----------------------------------------------------------------------------
 211 namespace
 212 {
 213     struct OViewSetter : public ::std::unary_function< OTableTreeListBox::TNames::value_type, bool>
 214     {
 215         const Sequence< ::rtl::OUString> m_aViews;
 216         ::comphelper::TStringMixEqualFunctor m_aEqualFunctor;
 217
 218         OViewSetter(const Sequence< ::rtl::OUString>& _rViews,sal_Bool _bCase) : m_aViews(_rViews),m_aEqualFunctor(_bCase){}
 219         OTableTreeListBox::TNames::value_type operator() (const ::rtl::OUString& lhs)
 220         {
 221             OTableTreeListBox::TNames::value_type aRet;
 222             aRet.first = lhs;
 223             const ::rtl::OUString* pIter = m_aViews.getConstArray();
 224             const ::rtl::OUString* pEnd = m_aViews.getConstArray() + m_aViews.getLength();
 225             aRet.second = (::std::find_if(pIter,pEnd,::std::bind2nd(m_aEqualFunctor,lhs)) != pEnd);
 226
 227             return aRet;
 228         }
 229     };
 230
 231 }
 232 // -----------------------------------------------------------------------------
 233 void OTableTreeListBox::UpdateTableList(
 234                 const Reference< XConnection >& _rxConnection,
 235                 const Sequence< ::rtl::OUString>& _rTables,
 236                 const Sequence< ::rtl::OUString>& _rViews
 237             )
 238 {
 239     TNames aTables;
 240     aTables.resize(_rTables.getLength());
 241     const ::rtl::OUString* pIter = _rTables.getConstArray();
 242     const ::rtl::OUString* pEnd = _rTables.getConstArray() + _rTables.getLength();
 243     try
 244     {
 245         Reference< XDatabaseMetaData > xMeta( _rxConnection->getMetaData(), UNO_QUERY_THROW );
 246         ::std::transform( pIter, pEnd,
 247             aTables.begin(), OViewSetter( _rViews, xMeta->supportsMixedCaseQuotedIdentifiers() ) );
 248     }
 249     catch(Exception&)
 250     {
 251         DBG_UNHANDLED_EXCEPTION();
 252     }
 253     UpdateTableList( _rxConnection, aTables );
 254 }
 255
 256 //------------------------------------------------------------------------
 257 namespace
 258 {
 259     ::std::vector< ::rtl::OUString > lcl_getMetaDataStrings_throw( const Reference< XResultSet >& _rxMetaDataResult, sal_Int32 _nColumnIndex )
 260     {
 261         ::std::vector< ::rtl::OUString > aStrings;
 262         Reference< XRow > xRow( _rxMetaDataResult, UNO_QUERY_THROW );
 263         while ( _rxMetaDataResult->next() )
 264             aStrings.push_back( xRow->getString( _nColumnIndex ) );
 265         return aStrings;
 266     }
 267
 268     bool lcl_shouldDisplayEmptySchemasAndCatalogs( const Reference< XConnection >& _rxConnection )
 269     {
 270         ::dbtools::DatabaseMetaData aMetaData( _rxConnection );
 271         return aMetaData.displayEmptyTableFolders();
 272     }
 273 }
 274
 275 //------------------------------------------------------------------------
 276 void OTableTreeListBox::UpdateTableList( const Reference< XConnection >& _rxConnection, const TNames& _rTables )
 277 {
 278     implOnNewConnection( _rxConnection );
 279
 280     // throw away all the old stuff
 281     Clear();
 282
 283     try
 284     {
 285         if (haveVirtualRoot())
 286         {
 287             String sRootEntryText;
 288             TNames::const_iterator aViews = ::std::find_if(_rTables.begin(),_rTables.end(),
 289             ::o3tl::compose1(::std::bind2nd(::std::equal_to<sal_Bool>(),sal_False),::o3tl::select2nd<TNames::value_type>()));
 290             TNames::const_iterator aTables = ::std::find_if(_rTables.begin(),_rTables.end(),
 291             ::o3tl::compose1(::std::bind2nd(::std::equal_to<sal_Bool>(),sal_True),::o3tl::select2nd<TNames::value_type>()));
 292
 293             if ( aViews == _rTables.end() )
 294                 sRootEntryText  = String(ModuleRes(STR_ALL_TABLES));
 295             else if ( aTables == _rTables.end() )
 296                 sRootEntryText  = String(ModuleRes(STR_ALL_VIEWS));
 297             else
 298                 sRootEntryText  = String(ModuleRes(STR_ALL_TABLES_AND_VIEWS));
 299             InsertEntry( sRootEntryText, NULL, sal_False, LIST_APPEND, reinterpret_cast< void* >( DatabaseObjectContainer::TABLES ) );
 300         }
 301
 302         if ( _rTables.empty() )
 303             // nothing to do (besides inserting the root entry)
 304             return;
 305
 306         // get the table/view names
 307         TNames::const_iterator aIter = _rTables.begin();
 308         TNames::const_iterator aEnd = _rTables.end();
 309
 310         Reference< XDatabaseMetaData > xMeta( _rxConnection->getMetaData(), UNO_QUERY_THROW );
 311         for ( ; aIter != aEnd; ++aIter )
 312         {
 313             // add the entry
 314             implAddEntry(
 315                 xMeta,
 316                 aIter->first,
 317                 sal_False
 318             );
 319         }
 320
 321         if ( !m_bNoEmptyFolders && lcl_shouldDisplayEmptySchemasAndCatalogs( _rxConnection ) )
 322         {
 323             sal_Bool bSupportsCatalogs = xMeta->supportsCatalogsInDataManipulation();
 324             sal_Bool bSupportsSchemas = xMeta->supportsSchemasInDataManipulation();
 325
 326             if ( bSupportsCatalogs || bSupportsSchemas )
 327             {
 328                 // we display empty catalogs if the DB supports catalogs, and they're noted at the beginning of a
 329                 // composed name. Otherwise, we display empty schematas. (also see the tree structure explained in
 330                 // implAddEntry)
 331                 bool bCatalogs = bSupportsCatalogs && xMeta->isCatalogAtStart();
 332
 333                 ::std::vector< ::rtl::OUString > aFolderNames( lcl_getMetaDataStrings_throw(
 334                     bCatalogs ? xMeta->getCatalogs() : xMeta->getSchemas(), 1 ) );
 335                 sal_Int32 nFolderType = bCatalogs ? DatabaseObjectContainer::CATALOG : DatabaseObjectContainer::SCHEMA;
 336
 337                 SvLBoxEntry* pRootEntry = getAllObjectsEntry();
 338                 for (   ::std::vector< ::rtl::OUString >::const_iterator folder = aFolderNames.begin();
 339                         folder != aFolderNames.end();
 340                         ++folder
 341                     )
 342                 {
 343                     SvLBoxEntry* pFolder = GetEntryPosByName( *folder, pRootEntry );
 344                     if ( !pFolder )
 345                         pFolder = InsertEntry( *folder, pRootEntry, sal_False, LIST_APPEND, reinterpret_cast< void* >( nFolderType ) );
 346                 }
 347             }
 348         }
 349     }
 350     catch ( const Exception& )
 351     {
 352         DBG_UNHANDLED_EXCEPTION();
 353     }
 354 }
 355 //------------------------------------------------------------------------
 356 sal_Bool OTableTreeListBox::isWildcardChecked(SvLBoxEntry* _pEntry) const
 357 {
 358     if (_pEntry)
 359     {
 360         OBoldListboxString* pTextItem = static_cast<OBoldListboxString*>(_pEntry->GetFirstItem(SV_ITEM_ID_BOLDLBSTRING));
 361         if (pTextItem)
 362             return pTextItem->isEmphasized();
 363     }
 364     return sal_False;
 365 }
 366
 367 //------------------------------------------------------------------------
 368 void OTableTreeListBox::checkWildcard(SvLBoxEntry* _pEntry)
 369 {
 370     SetCheckButtonState(_pEntry, SV_BUTTON_CHECKED);
 371     checkedButton_noBroadcast(_pEntry);
 372 }
 373
 374 //------------------------------------------------------------------------
 375 SvLBoxEntry* OTableTreeListBox::getAllObjectsEntry() const
 376 {
 377     return haveVirtualRoot() ? First() : NULL;
 378 }
 379
 380 //------------------------------------------------------------------------
 381 void OTableTreeListBox::checkedButton_noBroadcast(SvLBoxEntry* _pEntry)
 382 {
 383     OMarkableTreeListBox::checkedButton_noBroadcast(_pEntry);
 384
 385     // if an entry has children, it makes a difference if the entry is checked
 386     // because all children are checked or if the user checked it explicitly.
 387     // So we track explicit (un)checking
 388
 389     SvButtonState eState = GetCheckButtonState(_pEntry);
 390     OSL_ENSURE(SV_BUTTON_TRISTATE != eState, "OTableTreeListBox::CheckButtonHdl: user action which lead to TRISTATE?");
 391     implEmphasize(_pEntry, SV_BUTTON_CHECKED == eState);
 392 }
 393
 394 //------------------------------------------------------------------------
 395 void OTableTreeListBox::implEmphasize(SvLBoxEntry* _pEntry, sal_Bool _bChecked, sal_Bool _bUpdateDescendants, sal_Bool _bUpdateAncestors)
 396 {
 397     OSL_ENSURE(_pEntry, "OTableTreeListBox::implEmphasize: invalid entry (NULL)!");
 398
 399     // special emphasizing handling for the "all objects" entry
 400     sal_Bool bAllObjectsEntryAffected = haveVirtualRoot() && (getAllObjectsEntry() == _pEntry);
 401     if  (   GetModel()->HasChildren(_pEntry)              // the entry has children
 402         ||  bAllObjectsEntryAffected                    // or it is the "all objects" entry
 403         )
 404     {
 405         OBoldListboxString* pTextItem = static_cast<OBoldListboxString*>(_pEntry->GetFirstItem(SV_ITEM_ID_BOLDLBSTRING));
 406         if (pTextItem)
 407             pTextItem->emphasize(_bChecked);
 408
 409         if (bAllObjectsEntryAffected)
 410             InvalidateEntry(_pEntry);
 411     }
 412
 413     if (_bUpdateDescendants)
 414     {
 415         // remove the mark for all children of the checked entry
 416         SvLBoxEntry* pChildLoop = FirstChild(_pEntry);
 417         while (pChildLoop)
 418         {
 419             if (GetModel()->HasChildren(pChildLoop))
 420                 implEmphasize(pChildLoop, sal_False, sal_True, sal_False);
 421             pChildLoop = NextSibling(pChildLoop);
 422         }
 423     }
 424
 425     if (_bUpdateAncestors)
 426     {
 427         // remove the mark for all ancestors of the entry
 428         if (GetModel()->HasParent(_pEntry))
 429             implEmphasize(GetParent(_pEntry), sal_False, sal_False, sal_True);
 430     }
 431 }
 432
 433 //------------------------------------------------------------------------
 434 void OTableTreeListBox::InitEntry(SvLBoxEntry* _pEntry, const XubString& _rString, const Image& _rCollapsedBitmap, const Image& _rExpandedBitmap, SvLBoxButtonKind _eButtonKind)
 435 {
 436     OMarkableTreeListBox::InitEntry(_pEntry, _rString, _rCollapsedBitmap, _rExpandedBitmap, _eButtonKind);
 437
 438     // replace the text item with our own one
 439     SvLBoxItem* pTextItem = _pEntry->GetFirstItem(SV_ITEM_ID_LBOXSTRING);
 440     OSL_ENSURE(pTextItem, "OTableTreeListBox::InitEntry: no text item!?");
 441     sal_uInt16 nTextPos = _pEntry->GetPos(pTextItem);
 442     OSL_ENSURE(((sal_uInt16)-1) != nTextPos, "OTableTreeListBox::InitEntry: no text item pos!");
 443
 444     _pEntry->ReplaceItem(new OBoldListboxString(_pEntry, 0, _rString), nTextPos);
 445 }
 446
 447 //------------------------------------------------------------------------
 448 SvLBoxEntry* OTableTreeListBox::implAddEntry(
 449         const Reference< XDatabaseMetaData >& _rxMeta,
 450         const ::rtl::OUString& _rTableName,
 451         sal_Bool _bCheckName
 452     )
 453 {
 454     OSL_PRECOND( _rxMeta.is(), "OTableTreeListBox::implAddEntry: invalid meta data!" );
 455     if ( !_rxMeta.is() )
 456         return NULL;
 457
 458     // split the complete name into it's components
 459     ::rtl::OUString sCatalog, sSchema, sName;
 460     qualifiedNameComponents( _rxMeta, _rTableName, sCatalog, sSchema, sName, ::dbtools::eInDataManipulation );
 461
 462     SvLBoxEntry* pParentEntry = getAllObjectsEntry();
 463
 464     // if the DB uses catalog at the start of identifiers, then our hierarchy is
 465     //   catalog
 466     //   +- schema
 467     //      +- table
 468     // else it is
 469     //   schema
 470     //   +- catalog
 471     //      +- table
 472     sal_Bool bCatalogAtStart = _rxMeta->isCatalogAtStart();
 473     const ::rtl::OUString& rFirstName  = bCatalogAtStart ? sCatalog : sSchema;
 474     const sal_Int32 nFirstFolderType   = bCatalogAtStart ? DatabaseObjectContainer::CATALOG : DatabaseObjectContainer::SCHEMA;
 475     const ::rtl::OUString& rSecondName = bCatalogAtStart ? sSchema : sCatalog;
 476     const sal_Int32 nSecondFolderType  = bCatalogAtStart ? DatabaseObjectContainer::SCHEMA : DatabaseObjectContainer::CATALOG;
 477
 478     if ( !rFirstName.isEmpty() )
 479     {
 480         SvLBoxEntry* pFolder = GetEntryPosByName( rFirstName, pParentEntry );
 481         if ( !pFolder )
 482             pFolder = InsertEntry( rFirstName, pParentEntry, sal_False, LIST_APPEND, reinterpret_cast< void* >( nFirstFolderType ) );
 483         pParentEntry = pFolder;
 484     }
 485
 486     if ( !rSecondName.isEmpty() )
 487     {
 488         SvLBoxEntry* pFolder = GetEntryPosByName( rSecondName, pParentEntry );
 489         if ( !pFolder )
 490             pFolder = InsertEntry( rSecondName, pParentEntry, sal_False, LIST_APPEND, reinterpret_cast< void* >( nSecondFolderType ) );
 491         pParentEntry = pFolder;
 492     }
 493
 494     SvLBoxEntry* pRet = NULL;
 495     if ( !_bCheckName || !GetEntryPosByName( sName, pParentEntry ) )
 496     {
 497         pRet = InsertEntry( sName, pParentEntry, sal_False, LIST_APPEND );
 498
 499         Image aImage;
 500         m_pImageProvider->getImages( _rTableName, DatabaseObject::TABLE, aImage );
 501
 502         SetExpandedEntryBmp( pRet, aImage );
 503         SetCollapsedEntryBmp( pRet, aImage );
 504     }
 505     return pRet;
 506 }
 507
 508 //------------------------------------------------------------------------
 509 NamedDatabaseObject OTableTreeListBox::describeObject( SvLBoxEntry* _pEntry )
 510 {
 511     NamedDatabaseObject aObject;
 512
 513     sal_Int32 nEntryType = reinterpret_cast< sal_IntPtr >( _pEntry->GetUserData() );
 514
 515     if  ( nEntryType == DatabaseObjectContainer::TABLES )
 516     {
 517         aObject.Type = DatabaseObjectContainer::TABLES;
 518     }
 519     else if (   ( nEntryType == DatabaseObjectContainer::CATALOG )
 520             ||  ( nEntryType == DatabaseObjectContainer::SCHEMA )
 521             )
 522     {
 523         SvLBoxEntry* pParent = GetParent( _pEntry );
 524         sal_Int32 nParentEntryType = pParent ? reinterpret_cast< sal_IntPtr >( pParent->GetUserData() ) : -1;
 525
 526         ::rtl::OUStringBuffer buffer;
 527         if  ( nEntryType == DatabaseObjectContainer::CATALOG )
 528         {
 529             if ( nParentEntryType == DatabaseObjectContainer::SCHEMA )
 530             {
 531                 buffer.append( GetEntryText( pParent ) );
 532                 buffer.append( sal_Unicode( '.' ) );
 533             }
 534             buffer.append( GetEntryText( _pEntry ) );
 535         }
 536         else if ( nEntryType == DatabaseObjectContainer::SCHEMA )
 537         {
 538             if ( nParentEntryType == DatabaseObjectContainer::CATALOG )
 539             {
 540                 buffer.append( GetEntryText( pParent ) );
 541                 buffer.append( sal_Unicode( '.' ) );
 542             }
 543             buffer.append( GetEntryText( _pEntry ) );
 544         }
 545     }
 546     else
 547     {
 548         aObject.Type = DatabaseObject::TABLE;
 549         aObject.Name = getQualifiedTableName( _pEntry );
 550     }
 551
 552     return aObject;
 553 }
 554
 555 //------------------------------------------------------------------------
 556 SvLBoxEntry* OTableTreeListBox::addedTable( const ::rtl::OUString& _rName )
 557 {
 558     try
 559     {
 560         Reference< XDatabaseMetaData > xMeta;
 561         if ( impl_getAndAssertMetaData( xMeta ) )
 562             return implAddEntry( xMeta, _rName );
 563     }
 564     catch( const Exception& )
 565     {
 566         DBG_UNHANDLED_EXCEPTION();
 567     }
 568     return NULL;
 569 }
 570
 571 //------------------------------------------------------------------------
 572 bool OTableTreeListBox::impl_getAndAssertMetaData( Reference< XDatabaseMetaData >& _out_rMetaData ) const
 573 {
 574     if ( m_xConnection.is() )
 575         _out_rMetaData = m_xConnection->getMetaData();
 576     OSL_PRECOND( _out_rMetaData.is(), "OTableTreeListBox::impl_getAndAssertMetaData: invalid current connection!" );
 577     return _out_rMetaData.is();
 578 }
 579
 580 //------------------------------------------------------------------------
 581 String OTableTreeListBox::getQualifiedTableName( SvLBoxEntry* _pEntry ) const
 582 {
 583     OSL_PRECOND( !isFolderEntry( _pEntry ), "OTableTreeListBox::getQualifiedTableName: folder entries not allowed here!" );
 584
 585     try
 586     {
 587         Reference< XDatabaseMetaData > xMeta;
 588         if ( !impl_getAndAssertMetaData( xMeta ) )
 589             return String();
 590
 591         ::rtl::OUString sCatalog;
 592         ::rtl::OUString sSchema;
 593         ::rtl::OUString sTable;
 594
 595         SvLBoxEntry* pSchema = GetParent( _pEntry );
 596         if ( pSchema )
 597         {
 598             SvLBoxEntry* pCatalog = GetParent( pSchema );
 599             if  (   pCatalog
 600                 ||  (   xMeta->supportsCatalogsInDataManipulation()
 601                     &&  !xMeta->supportsSchemasInDataManipulation()
 602                     )   // here we support catalog but no schema
 603                 )
 604             {
 605                 if ( pCatalog == NULL )
 606                 {
 607                     pCatalog = pSchema;
 608                     pSchema = NULL;
 609                 }
 610                 sCatalog = GetEntryText( pCatalog );
 611             }
 612             if ( pSchema )
 613                 sSchema = GetEntryText(pSchema);
 614         }
 615         sTable = GetEntryText( _pEntry );
 616
 617         return ::dbtools::composeTableName( xMeta, sCatalog, sSchema, sTable, sal_False, ::dbtools::eInDataManipulation );
 618     }
 619     catch( const Exception& )
 620     {
 621         DBG_UNHANDLED_EXCEPTION();
 622     }
 623     return String();
 624 }
 625
 626 //------------------------------------------------------------------------
 627 SvLBoxEntry* OTableTreeListBox::getEntryByQualifiedName( const ::rtl::OUString& _rName )
 628 {
 629     try
 630     {
 631         Reference< XDatabaseMetaData > xMeta;
 632         if ( !impl_getAndAssertMetaData( xMeta ) )
 633             return NULL;
 634
 635         // split the complete name into it's components
 636         ::rtl::OUString sCatalog, sSchema, sName;
 637         qualifiedNameComponents(xMeta, _rName, sCatalog, sSchema, sName,::dbtools::eInDataManipulation);
 638
 639         SvLBoxEntry* pParent = getAllObjectsEntry();
 640         SvLBoxEntry* pCat = NULL;
 641         SvLBoxEntry* pSchema = NULL;
 642         if ( !sCatalog.isEmpty() )
 643         {
 644             pCat = GetEntryPosByName(sCatalog, pParent);
 645             if ( pCat )
 646                 pParent = pCat;
 647         }
 648
 649         if ( !sSchema.isEmpty() )
 650         {
 651             pSchema = GetEntryPosByName(sSchema, pParent);
 652             if ( pSchema )
 653                 pParent = pSchema;
 654         }
 655
 656         return GetEntryPosByName(sName, pParent);
 657     }
 658     catch( const Exception& )
 659     {
 660         DBG_UNHANDLED_EXCEPTION();
 661     }
 662     return NULL;
 663 }
 664 //------------------------------------------------------------------------
 665 void OTableTreeListBox::removedTable( const ::rtl::OUString& _rName )
 666 {
 667     try
 668     {
 669         SvLBoxEntry* pEntry = getEntryByQualifiedName( _rName );
 670         if ( pEntry )
 671             GetModel()->Remove( pEntry );
 672     }
 673     catch( const Exception& )
 674     {
 675         DBG_UNHANDLED_EXCEPTION();
 676     }
 677 }
 678
 679 //.........................................................................
 680 }   // namespace dbaui
 681 //.........................................................................
 682
 683 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */