dbaccess/source/ui/dlg/tablespage.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "tablespage.hxx"
  21 #include <dsitems.hxx>
  22 #include <datasourceconnector.hxx>
  23 #include <comphelper/types.hxx>
  24 #include <connectivity/dbtools.hxx>
  25 #include <connectivity/dbexception.hxx>
  26 #include <stringlistitem.hxx>
  27 #include <svl/stritem.hxx>
  28 #include <strings.hxx>
  29 #include <com/sun/star/sdbc/SQLException.hpp>
  30 #include <com/sun/star/util/XModifiable.hpp>
  31 #include <sqlmessage.hxx>
  32 #include <UITools.hxx>
  33 #include <osl/diagnose.h>
  34 #include <TablesSingleDlg.hxx>
  35 #include <comphelper/diagnose_ex.hxx>
  36 #include <cppuhelper/exc_hlp.hxx>
  37
  38 namespace dbaui
  39 {
  40
  41     using namespace ::com::sun::star::uno;
  42     using namespace ::com::sun::star::sdbc;
  43     using namespace ::com::sun::star::beans;
  44     using namespace ::com::sun::star::lang;
  45     using namespace ::com::sun::star::util;
  46     using namespace ::dbtools;
  47     using namespace ::comphelper;
  48
  49     // OTableSubscriptionPage
  50     OTableSubscriptionPage::OTableSubscriptionPage(weld::Container* pPage, OTableSubscriptionDialog* pTablesDlg, const SfxItemSet& _rCoreAttrs)
  51         : OGenericAdministrationPage(pPage, pTablesDlg, u"dbaccess/ui/tablesfilterpage.ui"_ustr, u"TablesFilterPage"_ustr, _rCoreAttrs)
  52         , m_bCatalogAtStart(true)
  53         , m_pTablesDlg(pTablesDlg)
  54         , m_xTables(m_xBuilder->weld_widget(u"TablesFilterPage"_ustr))
  55         , m_xTablesList(new OTableTreeListBox(m_xBuilder->weld_tree_view(u"treeview"_ustr), true))
  56     {
  57         m_xTablesList->init();
  58
  59         weld::TreeView& rWidget = m_xTablesList->GetWidget();
  60
  61         rWidget.set_size_request(rWidget.get_approximate_digit_width() * 48,
  62                                  rWidget.get_height_rows(12));
  63
  64         // initialize the TabListBox
  65         rWidget.set_selection_mode(SelectionMode::Multiple);
  66
  67         rWidget.connect_toggled(LINK(this, OTableSubscriptionPage, OnTreeEntryChecked));
  68     }
  69
  70     OTableSubscriptionPage::~OTableSubscriptionPage()
  71     {
  72         // just to make sure that our connection will be removed
  73         try
  74         {
  75             ::comphelper::disposeComponent(m_xCurrentConnection);
  76         }
  77         catch (RuntimeException&) { }
  78     }
  79
  80     void OTableSubscriptionPage::implCheckTables(const Sequence< OUString >& _rTables)
  81     {
  82         // the meta data for the current connection, used for splitting up table names
  83         Reference< XDatabaseMetaData > xMeta;
  84         try
  85         {
  86             if (m_xCurrentConnection.is())
  87                 xMeta = m_xCurrentConnection->getMetaData();
  88         }
  89         catch(SQLException&)
  90         {
  91             OSL_FAIL("OTableSubscriptionPage::implCheckTables : could not retrieve the current connection's meta data!");
  92         }
  93
  94         // uncheck all
  95         CheckAll(false);
  96
  97         // check the ones which are in the list
  98         OUString sCatalog, sSchema, sName;
  99
 100         std::unique_ptr<weld::TreeIter> xRootEntry(m_xTablesList->getAllObjectsEntry());
 101
 102         for (const OUString& rIncludeTable : _rTables)
 103         {
 104             if (xMeta.is())
 105                 qualifiedNameComponents(xMeta, rIncludeTable, sCatalog, sSchema, sName,::dbtools::EComposeRule::InDataManipulation);
 106             else
 107                 sName = rIncludeTable;
 108
 109             bool bAllTables = (1 == sName.getLength()) && ('%' == sName[0]);
 110             bool bAllSchemas = (1 == sSchema.getLength()) && ('%' == sSchema[0]);
 111
 112             // the catalog entry
 113             std::unique_ptr<weld::TreeIter> xCatalog(m_xTablesList->GetEntryPosByName(sCatalog, xRootEntry.get()));
 114             if (!(xCatalog || sCatalog.isEmpty()))
 115                 // the table (resp. its catalog) referred in this filter entry does not exist anymore
 116                 continue;
 117
 118             if (bAllSchemas && xCatalog)
 119             {
 120                 m_xTablesList->checkWildcard(*xCatalog);
 121                 continue;
 122             }
 123
 124             // the schema entry
 125             std::unique_ptr<weld::TreeIter> xSchema = m_xTablesList->GetEntryPosByName(sSchema, (xCatalog ? xCatalog.get() : xRootEntry.get()));
 126             if (!(xSchema || sSchema.isEmpty()))
 127                 // the table (resp. its schema) referred in this filter entry does not exist anymore
 128                 continue;
 129
 130             if (bAllTables && xSchema)
 131             {
 132                 m_xTablesList->checkWildcard(*xSchema);
 133                 continue;
 134             }
 135
 136             std::unique_ptr<weld::TreeIter> xEntry(m_xTablesList->GetEntryPosByName(sName, xSchema ? xSchema.get() : (xCatalog ? xCatalog.get() : xRootEntry.get())));
 137             if (xEntry)
 138                 m_xTablesList->GetWidget().set_toggle(*xEntry, TRISTATE_TRUE);
 139         }
 140         m_xTablesList->CheckButtons();
 141     }
 142
 143     void OTableSubscriptionPage::implCompleteTablesCheck( const css::uno::Sequence< OUString >& _rTableFilter )
 144     {
 145         if (!_rTableFilter.hasElements())
 146         {   // no tables visible
 147             CheckAll(false);
 148         }
 149         else
 150         {
 151             if ((1 == _rTableFilter.getLength()) && _rTableFilter[0] == "%")
 152             {   // all tables visible
 153                 CheckAll();
 154             }
 155             else
 156                 implCheckTables( _rTableFilter );
 157         }
 158     }
 159
 160     void OTableSubscriptionPage::implInitControls(const SfxItemSet& _rSet, bool _bSaveValue)
 161     {
 162         // check whether or not the selection is invalid or readonly (invalid implies readonly, but not vice versa)
 163         bool bValid, bReadonly;
 164         getFlags(_rSet, bValid, bReadonly);
 165
 166         // get the name of the data source we're working for
 167         const SfxStringItem* pNameItem = _rSet.GetItem<SfxStringItem>(DSID_NAME);
 168         OSL_ENSURE(pNameItem, "OTableSubscriptionPage::implInitControls: missing the name attribute!");
 169         OUString sDSName = pNameItem->GetValue();
 170
 171         if (bValid && !sDSName.isEmpty() && !m_xCurrentConnection.is() )
 172         {   // get the current table list from the connection for the current settings
 173
 174             // the PropertyValues for the current dialog settings
 175             Sequence< PropertyValue > aConnectionParams;
 176             OSL_ENSURE(m_pTablesDlg, "OTableSubscriptionPage::implInitControls: need a parent dialog doing the translation!");
 177             if ( m_pTablesDlg )
 178             {
 179                 if (!m_pTablesDlg->getCurrentSettings(aConnectionParams))
 180                 {
 181                     m_xTablesList->GetWidget().clear();
 182                     m_pTablesDlg->endExecution();
 183                     return;
 184                 }
 185             }
 186
 187             // fill the table list with this connection information
 188             SQLExceptionInfo aErrorInfo;
 189
 190             try
 191             {
 192                 weld::WaitObject aWaitCursor(GetFrameWeld());
 193
 194                 Reference<XPropertySet> xProp = m_pTablesDlg->getCurrentDataSource();
 195                 OSL_ENSURE(xProp.is(),"No data source set!");
 196                 if ( xProp.is() )
 197                 {
 198                     Any aTableFilter = xProp->getPropertyValue(PROPERTY_TABLEFILTER);
 199                     Any aTableTypeFilter = xProp->getPropertyValue(PROPERTY_TABLETYPEFILTER);
 200
 201                     Reference<XModifiable> xModi(getDataSourceOrModel(xProp),UNO_QUERY);
 202                     bool bModified = ( xModi.is() && xModi->isModified() );
 203
 204                     Sequence< OUString > aNewTableFilter { u"%"_ustr };
 205                     xProp->setPropertyValue(PROPERTY_TABLEFILTER,Any(aNewTableFilter));
 206
 207                     xProp->setPropertyValue( PROPERTY_TABLETYPEFILTER, Any( Sequence< OUString >() ) );
 208                     Reference< css::lang::XEventListener> xEvt;
 209                     aErrorInfo = ::dbaui::createConnection(xProp, m_xORB, xEvt, m_xCurrentConnection);
 210
 211                     xProp->setPropertyValue(PROPERTY_TABLEFILTER,aTableFilter);
 212                     xProp->setPropertyValue(PROPERTY_TABLETYPEFILTER,aTableTypeFilter);
 213
 214                     if ( xModi.is() && !bModified )
 215                         xModi->setModified(false);
 216
 217                 }
 218
 219                 if ( m_xCurrentConnection.is() )
 220                 {
 221                     m_xTablesList->UpdateTableList( m_xCurrentConnection );
 222                     if (m_pTablesDlg)
 223                         m_pTablesDlg->successfullyConnected();
 224                 }
 225             }
 226             catch (const SQLException&)
 227             {
 228                 aErrorInfo = ::cppu::getCaughtException();
 229             }
 230
 231             if (aErrorInfo.isValid())
 232             {
 233                 // establishing the connection failed. Show an error window and exit.
 234                 OSQLMessageBox aMessageBox(GetFrameWeld(), aErrorInfo);
 235                 aMessageBox.run();
 236                 m_xTables->set_sensitive(false);
 237                 m_xTablesList->GetWidget().clear();
 238
 239                 if ( m_pTablesDlg )
 240                 {
 241                     m_pTablesDlg->clearPassword();
 242                     m_pTablesDlg->endExecution();
 243                 }
 244             }
 245             else
 246             {
 247                 // in addition, we need some infos about the connection used
 248                 m_sCatalogSeparator = ".";    // (default)
 249                 m_bCatalogAtStart = true;   // (default)
 250                 try
 251                 {
 252                     Reference< XDatabaseMetaData > xMeta;
 253                     if (m_xCurrentConnection.is())
 254                         xMeta = m_xCurrentConnection->getMetaData();
 255                     if (xMeta.is() && xMeta->supportsCatalogsInDataManipulation())
 256                     {
 257                         m_sCatalogSeparator = xMeta->getCatalogSeparator();
 258                         m_bCatalogAtStart = xMeta->isCatalogAtStart();
 259                     }
 260                 }
 261                 catch(Exception&)
 262                 {
 263                     DBG_UNHANDLED_EXCEPTION("dbaccess");
 264                 }
 265             }
 266         }
 267
 268         // get the current table filter
 269         const OStringListItem* pTableFilter = _rSet.GetItem<OStringListItem>(DSID_TABLEFILTER);
 270         Sequence< OUString > aTableFilter;
 271         if (pTableFilter)
 272             aTableFilter = pTableFilter->getList();
 273
 274         implCompleteTablesCheck( aTableFilter );
 275
 276         // expand the first entry by default
 277         std::unique_ptr<weld::TreeIter> xExpand = m_xTablesList->getAllObjectsEntry();
 278         while (xExpand)
 279         {
 280             m_xTablesList->GetWidget().expand_row(*xExpand);
 281             if (!m_xTablesList->GetWidget().iter_children(*xExpand))
 282                 break;
 283             std::unique_ptr<weld::TreeIter> xSibling(m_xTablesList->GetWidget().make_iterator(xExpand.get()));
 284             if (m_xTablesList->GetWidget().iter_next_sibling(*xSibling))
 285                 xExpand.reset();
 286         }
 287
 288         // update the toolbox according the current selection and check state
 289         OGenericAdministrationPage::implInitControls(_rSet, _bSaveValue);
 290     }
 291
 292     void OTableSubscriptionPage::CheckAll( bool _bCheck )
 293     {
 294         std::unique_ptr<weld::TreeIter> xEntry(m_xTablesList->GetWidget().make_iterator());
 295         if (m_xTablesList->GetWidget().get_iter_first(*xEntry))
 296         {
 297             do
 298             {
 299                 m_xTablesList->GetWidget().set_toggle(*xEntry, _bCheck ? TRISTATE_TRUE : TRISTATE_FALSE);
 300             }
 301             while (m_xTablesList->GetWidget().iter_next(*xEntry));
 302         }
 303
 304         if (_bCheck)
 305         {
 306             auto xRoot = m_xTablesList->getAllObjectsEntry();
 307             if (xRoot)
 308                 m_xTablesList->checkWildcard(*xRoot);
 309         }
 310     }
 311
 312     DeactivateRC OTableSubscriptionPage::DeactivatePage(SfxItemSet* _pSet)
 313     {
 314         DeactivateRC nResult = OGenericAdministrationPage::DeactivatePage(_pSet);
 315
 316         // dispose the connection, we don't need it anymore, so we're not wasting resources
 317         try
 318         {
 319             ::comphelper::disposeComponent(m_xCurrentConnection);
 320         }
 321         catch (RuntimeException&) { }
 322
 323         return nResult;
 324     }
 325
 326     IMPL_LINK(OTableSubscriptionPage, OnTreeEntryChecked, const weld::TreeView::iter_col&, rRowCol, void)
 327     {
 328         m_xTablesList->checkedButton_noBroadcast(rRowCol.first);
 329         callModifiedHdl();
 330     }
 331
 332     Sequence< OUString > OTableSubscriptionPage::collectDetailedSelection() const
 333     {
 334         Sequence< OUString > aTableFilter;
 335         static constexpr OUString sWildcard = u"%"_ustr;
 336
 337         std::unique_ptr<weld::TreeIter> xAllObjectsEntry(m_xTablesList->getAllObjectsEntry());
 338         if (!xAllObjectsEntry)
 339             return aTableFilter;
 340         std::unique_ptr<weld::TreeIter> xEntry(m_xTablesList->GetWidget().make_iterator(xAllObjectsEntry.get()));
 341         if (!m_xTablesList->GetWidget().iter_next(*xEntry))
 342             xEntry.reset();
 343         while (xEntry)
 344         {
 345             bool bCatalogWildcard = false;
 346             bool bSchemaWildcard =  false;
 347             std::unique_ptr<weld::TreeIter> xSchema;
 348             std::unique_ptr<weld::TreeIter> xCatalog;
 349
 350             if (m_xTablesList->GetWidget().get_toggle(*xEntry) == TRISTATE_TRUE && !m_xTablesList->GetWidget().iter_has_child(*xEntry))
 351             {   // checked and a leaf, which means it's no catalog, no schema, but a real table
 352                 OUStringBuffer sComposedName;
 353                 OUString sCatalog;
 354                 if (m_xTablesList->GetWidget().get_iter_depth(*xEntry))
 355                 {
 356                     xSchema = m_xTablesList->GetWidget().make_iterator(xEntry.get());
 357                     m_xTablesList->GetWidget().iter_parent(*xSchema);
 358                     if (xAllObjectsEntry->equal(*xSchema))
 359                     {
 360                         // do not want to have the root entry
 361                         xSchema.reset();
 362                     }
 363
 364                     if (xSchema)
 365                     {   // it's a real schema entry, not the "all objects" root
 366                         if (m_xTablesList->GetWidget().get_iter_depth(*xSchema))
 367                         {
 368                             xCatalog = m_xTablesList->GetWidget().make_iterator(xSchema.get());
 369                             m_xTablesList->GetWidget().iter_parent(*xCatalog);
 370                             if (xAllObjectsEntry->equal(*xCatalog))
 371                             {
 372                                 // do not want to have the root entry
 373                                 xCatalog.reset();
 374                             }
 375
 376                             if (xCatalog)
 377                             {   // it's a real catalog entry, not the "all objects" root
 378                                 bCatalogWildcard = m_xTablesList->isWildcardChecked(*xCatalog);
 379                                 if (m_bCatalogAtStart)
 380                                 {
 381                                     sComposedName.append(m_xTablesList->GetWidget().get_text(*xCatalog) + m_sCatalogSeparator);
 382                                     if (bCatalogWildcard)
 383                                         sComposedName.append(sWildcard);
 384                                 }
 385                                 else
 386                                 {
 387                                     if (bCatalogWildcard)
 388                                         sCatalog = sWildcard;
 389                                     else
 390                                         sCatalog.clear();
 391                                     sCatalog += m_sCatalogSeparator + m_xTablesList->GetWidget().get_text(*xCatalog) ;
 392                                 }
 393                             }
 394                         }
 395                         bSchemaWildcard = m_xTablesList->isWildcardChecked(*xSchema);
 396                         sComposedName.append(m_xTablesList->GetWidget().get_text(*xSchema) + ".");
 397                     }
 398
 399                     if (bSchemaWildcard)
 400                         sComposedName.append(sWildcard);
 401                 }
 402                 if (!bSchemaWildcard && !bCatalogWildcard)
 403                     sComposedName.append(m_xTablesList->GetWidget().get_text(*xEntry));
 404
 405                 if (!m_bCatalogAtStart && !bCatalogWildcard)
 406                     sComposedName.append(sCatalog);
 407
 408                 // need some space
 409                 sal_Int32 nOldLen = aTableFilter.getLength();
 410                 aTableFilter.realloc(nOldLen + 1);
 411                 // add the new name
 412                 aTableFilter.getArray()[nOldLen] = sComposedName.makeStringAndClear();
 413             }
 414
 415             if (bCatalogWildcard)
 416                 xEntry = implNextSibling(xCatalog.get());
 417             else if (bSchemaWildcard)
 418                 xEntry = implNextSibling(xSchema.get());
 419             else
 420             {
 421                 if (!m_xTablesList->GetWidget().iter_next(*xEntry))
 422                     xEntry.reset();
 423             }
 424         }
 425
 426         return aTableFilter;
 427     }
 428
 429     std::unique_ptr<weld::TreeIter> OTableSubscriptionPage::implNextSibling(const weld::TreeIter* pEntry) const
 430     {
 431         std::unique_ptr<weld::TreeIter> xReturn;
 432         if (pEntry)
 433         {
 434             xReturn = m_xTablesList->GetWidget().make_iterator(pEntry);
 435             if (!m_xTablesList->GetWidget().iter_next_sibling(*xReturn))
 436             {
 437                 std::unique_ptr<weld::TreeIter> xParent = m_xTablesList->GetWidget().make_iterator(pEntry);
 438                 if (m_xTablesList->GetWidget().iter_parent(*xParent))
 439                     xReturn = implNextSibling(xParent.get());
 440                 else
 441                     xReturn.reset();
 442             }
 443         }
 444         return xReturn;
 445     }
 446
 447     bool OTableSubscriptionPage::FillItemSet( SfxItemSet* _rCoreAttrs )
 448     {
 449         bool bValid, bReadonly;
 450         getFlags(*_rCoreAttrs, bValid, bReadonly);
 451
 452         if (!bValid || bReadonly)
 453             // don't store anything if the data we're working with is invalid or readonly
 454             return true;
 455
 456         // create the output string which contains all the table names
 457         if ( m_xCurrentConnection.is() )
 458         {   // collect the table filter data only if we have a connection - else no tables are displayed at all
 459             Sequence< OUString > aTableFilter;
 460             auto xRoot = m_xTablesList->getAllObjectsEntry();
 461             if (xRoot && m_xTablesList->isWildcardChecked(*xRoot))
 462             {
 463                 aTableFilter = { u"%"_ustr };
 464             }
 465             else
 466             {
 467                 aTableFilter = collectDetailedSelection();
 468             }
 469             _rCoreAttrs->Put( OStringListItem(DSID_TABLEFILTER, aTableFilter) );
 470         }
 471
 472         return true;
 473     }
 474
 475     void OTableSubscriptionPage::fillControls(std::vector< std::unique_ptr<ISaveValueWrapper> >& /*_rControlList*/)
 476     {
 477     }
 478
 479     void OTableSubscriptionPage::fillWindows(std::vector< std::unique_ptr<ISaveValueWrapper> >& _rControlList)
 480     {
 481         _rControlList.emplace_back(new ODisableWidgetWrapper<weld::Widget>(m_xTables.get()));
 482     }
 483 }   // namespace dbaui
 484
 485 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */