extensions/source/dbpilots/controlwizard.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 "controlwizard.hxx"
  21 #include <tools/debug.hxx>
  22 #include <com/sun/star/container/XNameAccess.hpp>
  23 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  24 #include <com/sun/star/sdb/DatabaseContext.hpp>
  25 #include <com/sun/star/sdb/XQueriesSupplier.hpp>
  26 #include <com/sun/star/sdbc/XPreparedStatement.hpp>
  27 #include <com/sun/star/container/XChild.hpp>
  28 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  29 #include <com/sun/star/frame/XModel.hpp>
  30 #include <com/sun/star/sheet/XSpreadsheetView.hpp>
  31 #include <com/sun/star/drawing/XDrawView.hpp>
  32 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
  33 #include <com/sun/star/sdb/CommandType.hpp>
  34 #include <com/sun/star/sdbc/SQLWarning.hpp>
  35 #include <com/sun/star/sdb/SQLContext.hpp>
  36 #include <com/sun/star/task/InteractionHandler.hpp>
  37 #include <comphelper/types.hxx>
  38 #include <connectivity/dbtools.hxx>
  39 #include <comphelper/interaction.hxx>
  40 #include <vcl/stdtext.hxx>
  41 #include <connectivity/conncleanup.hxx>
  42 #include <com/sun/star/sdbc/DataType.hpp>
  43 #include <tools/urlobj.hxx>
  44 #include <vcl/layout.hxx>
  45 #include <osl/diagnose.h>
  46
  47 #define WINDOW_SIZE_X   240
  48 #define WINDOW_SIZE_Y   185
  49
  50 namespace dbp
  51 {
  52     using namespace ::com::sun::star::uno;
  53     using namespace ::com::sun::star::awt;
  54     using namespace ::com::sun::star::lang;
  55     using namespace ::com::sun::star::sdb;
  56     using namespace ::com::sun::star::sdbc;
  57     using namespace ::com::sun::star::sdbcx;
  58     using namespace ::com::sun::star::beans;
  59     using namespace ::com::sun::star::container;
  60     using namespace ::com::sun::star::drawing;
  61     using namespace ::com::sun::star::frame;
  62     using namespace ::com::sun::star::sheet;
  63     using namespace ::com::sun::star::form;
  64     using namespace ::com::sun::star::task;
  65     using namespace ::svt;
  66     using namespace ::comphelper;
  67     using namespace ::dbtools;
  68
  69     struct OAccessRegulator
  70     {
  71         friend class OControlWizardPage;
  72
  73     protected:
  74         OAccessRegulator() { }
  75     };
  76
  77     OControlWizardPage::OControlWizardPage( OControlWizard* _pParent, const OString& rID, const OUString& rUIXMLDescription )
  78         :OControlWizardPage_Base( _pParent, rID, rUIXMLDescription )
  79         ,m_pFormDatasourceLabel(nullptr)
  80         ,m_pFormDatasource(nullptr)
  81         ,m_pFormContentTypeLabel(nullptr)
  82         ,m_pFormContentType(nullptr)
  83         ,m_pFormTableLabel(nullptr)
  84         ,m_pFormTable(nullptr)
  85     {
  86     }
  87
  88     OControlWizardPage::~OControlWizardPage()
  89     {
  90         disposeOnce();
  91     }
  92
  93     void OControlWizardPage::dispose()
  94     {
  95         m_pFormDatasourceLabel.clear();
  96         m_pFormDatasource.clear();
  97         m_pFormContentTypeLabel.clear();
  98         m_pFormContentType.clear();
  99         m_pFormTableLabel.clear();
 100         m_pFormTable.clear();
 101         OControlWizardPage_Base::dispose();
 102     }
 103
 104     OControlWizard* OControlWizardPage::getDialog()
 105     {
 106         return static_cast< OControlWizard* >(GetParent());
 107     }
 108
 109     const OControlWizard* OControlWizardPage::getDialog() const
 110     {
 111         return static_cast< OControlWizard* >(GetParent());
 112     }
 113
 114
 115     bool OControlWizardPage::updateContext()
 116     {
 117         return getDialog()->updateContext(OAccessRegulator());
 118     }
 119
 120
 121     Reference< XConnection > OControlWizardPage::getFormConnection() const
 122     {
 123         return getDialog()->getFormConnection(OAccessRegulator());
 124     }
 125
 126
 127     void OControlWizardPage::setFormConnection( const Reference< XConnection >& _rxConn, bool _bAutoDispose )
 128     {
 129         getDialog()->setFormConnection( OAccessRegulator(), _rxConn, _bAutoDispose );
 130     }
 131
 132
 133     const OControlWizardContext& OControlWizardPage::getContext()
 134     {
 135         return getDialog()->getContext();
 136     }
 137
 138
 139     void OControlWizardPage::fillListBox(ListBox& _rList, const Sequence< OUString >& _rItems)
 140     {
 141         _rList.Clear();
 142         const OUString* pItems = _rItems.getConstArray();
 143         const OUString* pEnd = pItems + _rItems.getLength();
 144         ::svt::WizardTypes::WizardState nPos;
 145         sal_Int32 nIndex = 0;
 146         for (;pItems < pEnd; ++pItems, ++nIndex)
 147         {
 148             nPos = _rList.InsertEntry(*pItems);
 149             _rList.SetEntryData(nPos, reinterpret_cast<void*>(nIndex));
 150         }
 151     }
 152
 153
 154     void OControlWizardPage::fillListBox(ComboBox& _rList, const Sequence< OUString >& _rItems)
 155     {
 156         _rList.Clear();
 157         const OUString* pItems = _rItems.getConstArray();
 158         const OUString* pEnd = pItems + _rItems.getLength();
 159         ::svt::WizardTypes::WizardState nPos;
 160         for (;pItems < pEnd; ++pItems)
 161         {
 162             nPos = _rList.InsertEntry(*pItems);
 163             _rList.SetEntryData(nPos, nullptr);
 164         }
 165     }
 166
 167
 168     void OControlWizardPage::enableFormDatasourceDisplay()
 169     {
 170         if (m_pFormContentType)
 171             // nothing to do
 172             return;
 173
 174         VclFrame *_pFrame = get<VclFrame>("sourceframe");
 175         _pFrame->Show();
 176         get(m_pFormContentType,"contenttype");
 177         get(m_pFormContentTypeLabel,"contenttypelabel");
 178         get(m_pFormDatasource, "datasource");
 179         get(m_pFormDatasourceLabel, "datasourcelabel");
 180         get(m_pFormTable,"formtable");
 181         get(m_pFormTableLabel,"formtablelabel");
 182
 183         const OControlWizardContext& rContext = getContext();
 184         if ( rContext.bEmbedded )
 185         {
 186             m_pFormDatasourceLabel->Hide();
 187             m_pFormDatasource->Hide();
 188             m_pFormContentTypeLabel->SetPosPixel(m_pFormDatasourceLabel->GetPosPixel());
 189             m_pFormContentType->SetPosPixel(m_pFormDatasource->GetPosPixel());
 190             m_pFormTableLabel->SetPosPixel(::Point(m_pFormDatasourceLabel->GetPosPixel().X(),m_pFormTableLabel->GetPosPixel().Y()));
 191             m_pFormTable->SetPosPixel(::Point(m_pFormDatasource->GetPosPixel().X(),m_pFormTable->GetPosPixel().Y()));
 192         }
 193     }
 194
 195     void OControlWizardPage::initializePage()
 196     {
 197         if (m_pFormDatasource && m_pFormContentTypeLabel && m_pFormTable)
 198         {
 199             const OControlWizardContext& rContext = getContext();
 200             OUString sDataSource;
 201             OUString sCommand;
 202             sal_Int32 nCommandType = CommandType::COMMAND;
 203             try
 204             {
 205                 rContext.xForm->getPropertyValue("DataSourceName") >>= sDataSource;
 206                 rContext.xForm->getPropertyValue("Command") >>= sCommand;
 207                 rContext.xForm->getPropertyValue("CommandType") >>= nCommandType;
 208             }
 209             catch(const Exception&)
 210             {
 211                 OSL_FAIL("OControlWizardPage::initializePage: caught an exception!");
 212             }
 213
 214             INetURLObject aURL( sDataSource );
 215             if( aURL.GetProtocol() != INetProtocol::NotValid )
 216                 sDataSource = aURL.GetName(INetURLObject::DecodeMechanism::WithCharset);
 217             m_pFormDatasource->SetText(sDataSource);
 218             m_pFormTable->SetText(sCommand);
 219
 220             const char* pCommandTypeResourceId = nullptr;
 221             switch (nCommandType)
 222             {
 223                 case CommandType::TABLE:
 224                     pCommandTypeResourceId = RID_STR_TYPE_TABLE;
 225                     break;
 226
 227                 case CommandType::QUERY:
 228                     pCommandTypeResourceId = RID_STR_TYPE_QUERY;
 229                     break;
 230
 231                 default:
 232                     pCommandTypeResourceId = RID_STR_TYPE_COMMAND;
 233                     break;
 234             }
 235             m_pFormContentType->SetText(compmodule::ModuleRes(pCommandTypeResourceId));
 236         }
 237
 238         OControlWizardPage_Base::initializePage();
 239     }
 240
 241     OControlWizard::OControlWizard( vcl::Window* _pParent,
 242             const Reference< XPropertySet >& _rxObjectModel, const Reference< XComponentContext >& _rxContext )
 243         :OWizardMachine(_pParent, WizardButtonFlags::CANCEL | WizardButtonFlags::PREVIOUS | WizardButtonFlags::NEXT | WizardButtonFlags::FINISH)
 244         ,m_xContext(_rxContext)
 245     {
 246         m_aContext.xObjectModel = _rxObjectModel;
 247         initContext();
 248
 249         SetPageSizePixel(LogicToPixel(::Size(WINDOW_SIZE_X, WINDOW_SIZE_Y), MapMode(MapUnit::MapAppFont)));
 250         defaultButton(WizardButtonFlags::NEXT);
 251         enableButtons(WizardButtonFlags::FINISH, false);
 252     }
 253
 254     OControlWizard::~OControlWizard()
 255     {
 256     }
 257
 258     short OControlWizard::Execute()
 259     {
 260         // get the class id of the control we're dealing with
 261         sal_Int16 nClassId = FormComponentType::CONTROL;
 262         try
 263         {
 264             getContext().xObjectModel->getPropertyValue("ClassId") >>= nClassId;
 265         }
 266         catch(const Exception&)
 267         {
 268             OSL_FAIL("OControlWizard::activate: could not obtain the class id!");
 269         }
 270         if (!approveControl(nClassId))
 271         {
 272             // TODO: MessageBox or exception
 273             return RET_CANCEL;
 274         }
 275
 276         ActivatePage();
 277
 278         return OControlWizard_Base::Execute();
 279     }
 280
 281
 282     void OControlWizard::implDetermineShape()
 283     {
 284         Reference< XIndexAccess > xPageObjects(m_aContext.xDrawPage, UNO_QUERY);
 285         DBG_ASSERT(xPageObjects.is(), "OControlWizard::implDetermineShape: invalid page!");
 286
 287         // for comparing the model
 288         Reference< XControlModel > xModelCompare(m_aContext.xObjectModel, UNO_QUERY);
 289
 290         if (xPageObjects.is())
 291         {
 292             // loop through all objects of the page
 293             sal_Int32 nObjects = xPageObjects->getCount();
 294             Reference< XControlShape > xControlShape;
 295             Reference< XControlModel > xControlModel;
 296             for (sal_Int32 i=0; i<nObjects; ++i)
 297             {
 298                 if (xPageObjects->getByIndex(i) >>= xControlShape)
 299                 {   // it _is_ a control shape
 300                     xControlModel = xControlShape->getControl();
 301                     DBG_ASSERT(xControlModel.is(), "OControlWizard::implDetermineShape: control shape without model!");
 302                     if (xModelCompare.get() == xControlModel.get())
 303                     {
 304                         m_aContext.xObjectShape = xControlShape;
 305                         break;
 306                     }
 307                 }
 308             }
 309         }
 310     }
 311
 312
 313     void OControlWizard::implDetermineForm()
 314     {
 315         Reference< XChild > xModelAsChild(m_aContext.xObjectModel, UNO_QUERY);
 316         Reference< XInterface > xControlParent;
 317         if (xModelAsChild.is())
 318             xControlParent = xModelAsChild->getParent();
 319
 320         m_aContext.xForm.set(xControlParent, UNO_QUERY);
 321         m_aContext.xRowSet.set(xControlParent, UNO_QUERY);
 322         DBG_ASSERT(m_aContext.xForm.is() && m_aContext.xRowSet.is(),
 323             "OControlWizard::implDetermineForm: missing some interfaces of the control parent!");
 324
 325     }
 326
 327
 328     void OControlWizard::implDeterminePage()
 329     {
 330         try
 331         {
 332             // get the document model
 333             Reference< XChild > xControlAsChild(m_aContext.xObjectModel, UNO_QUERY);
 334             Reference< XChild > xModelSearch(xControlAsChild->getParent(), UNO_QUERY);
 335
 336             Reference< XModel > xModel(xModelSearch, UNO_QUERY);
 337             while (xModelSearch.is() && !xModel.is())
 338             {
 339                 xModelSearch.set(xModelSearch->getParent(), UNO_QUERY);
 340                 xModel.set(xModelSearch, UNO_QUERY);
 341             }
 342
 343             Reference< XDrawPage > xPage;
 344             if (xModel.is())
 345             {
 346                 m_aContext.xDocumentModel = xModel;
 347
 348                 Reference< XDrawPageSupplier > xPageSupp(xModel, UNO_QUERY);
 349                 if (xPageSupp.is())
 350                 {   // it's a document with only one page -> Writer
 351                     xPage = xPageSupp->getDrawPage();
 352                 }
 353                 else
 354                 {
 355                     // get the controller currently working on this model
 356                     Reference< XController > xController = xModel->getCurrentController();
 357                     DBG_ASSERT(xController.is(), "OControlWizard::implDeterminePage: no current controller!");
 358
 359                     // maybe it's a spreadsheet
 360                     Reference< XSpreadsheetView > xView(xController, UNO_QUERY);
 361                     if (xView.is())
 362                     {   // okay, it is one
 363                         Reference< XSpreadsheet > xSheet = xView->getActiveSheet();
 364                         xPageSupp.set(xSheet, UNO_QUERY);
 365                         DBG_ASSERT(xPageSupp.is(), "OControlWizard::implDeterminePage: a spreadsheet which is no page supplier!");
 366                         if (xPageSupp.is())
 367                             xPage = xPageSupp->getDrawPage();
 368                     }
 369                     else
 370                     {   // can be a draw/impress doc only
 371                         Reference< XDrawView > xDrawView(xController, UNO_QUERY);
 372                         DBG_ASSERT(xDrawView.is(), "OControlWizard::implDeterminePage: no alternatives left ... can't determine the page!");
 373                         if (xDrawView.is())
 374                             xPage = xDrawView->getCurrentPage();
 375                     }
 376                 }
 377             }
 378             else
 379             {
 380                 DBG_ASSERT(xPage.is(), "OControlWizard::implDeterminePage: can't determine the page (no model)!");
 381             }
 382             m_aContext.xDrawPage = xPage;
 383         }
 384         catch(const Exception&)
 385         {
 386             OSL_FAIL("OControlWizard::implDeterminePage: caught an exception!");
 387         }
 388     }
 389
 390
 391     void OControlWizard::implGetDSContext()
 392     {
 393         try
 394         {
 395             DBG_ASSERT(m_xContext.is(), "OControlWizard::implGetDSContext: invalid service factory!");
 396
 397             m_aContext.xDatasourceContext = DatabaseContext::create(m_xContext);
 398         }
 399         catch(const Exception&)
 400         {
 401             OSL_FAIL("OControlWizard::implGetDSContext: invalid database context!");
 402         }
 403     }
 404
 405
 406     Reference< XConnection > OControlWizard::getFormConnection(const OAccessRegulator&) const
 407     {
 408         return getFormConnection();
 409     }
 410
 411     Reference< XConnection > OControlWizard::getFormConnection() const
 412     {
 413         Reference< XConnection > xConn;
 414         try
 415         {
 416             if ( !::dbtools::isEmbeddedInDatabase(m_aContext.xForm,xConn) )
 417                 m_aContext.xForm->getPropertyValue("ActiveConnection") >>= xConn;
 418         }
 419         catch(const Exception&)
 420         {
 421             OSL_FAIL("OControlWizard::getFormConnection: caught an exception!");
 422         }
 423         return xConn;
 424     }
 425
 426
 427     void OControlWizard::setFormConnection( const OAccessRegulator& _rAccess, const Reference< XConnection >& _rxConn, bool _bAutoDispose )
 428     {
 429         try
 430         {
 431             Reference< XConnection > xOldConn = getFormConnection(_rAccess);
 432             if (xOldConn.get() == _rxConn.get())
 433                 return;
 434
 435             disposeComponent(xOldConn);
 436
 437             // set the new connection
 438             if ( _bAutoDispose )
 439             {
 440                 // for this, use an AutoDisposer (so the conn is cleaned up when the form dies or gets another connection)
 441                 Reference< XRowSet > xFormRowSet( m_aContext.xForm, UNO_QUERY );
 442                 rtl::Reference<OAutoConnectionDisposer> pAutoDispose = new OAutoConnectionDisposer( xFormRowSet, _rxConn );
 443             }
 444             else
 445             {
 446                 m_aContext.xForm->setPropertyValue("ActiveConnection", makeAny( _rxConn ) );
 447             }
 448         }
 449         catch(const Exception&)
 450         {
 451             OSL_FAIL("OControlWizard::setFormConnection: caught an exception!");
 452         }
 453     }
 454
 455
 456     bool OControlWizard::updateContext(const OAccessRegulator&)
 457     {
 458         return initContext();
 459     }
 460
 461     Reference< XInteractionHandler > OControlWizard::getInteractionHandler(weld::Window* _pWindow) const
 462     {
 463         Reference< XInteractionHandler > xHandler;
 464         try
 465         {
 466             xHandler.set( InteractionHandler::createWithParent(m_xContext, nullptr), UNO_QUERY_THROW );
 467         }
 468         catch(const Exception&) { }
 469         if (!xHandler.is())
 470         {
 471             const OUString sInteractionHandlerServiceName("com.sun.star.task.InteractionHandler");
 472             ShowServiceNotAvailableError(_pWindow, sInteractionHandlerServiceName, true);
 473         }
 474         return xHandler;
 475     }
 476
 477     bool OControlWizard::initContext()
 478     {
 479         DBG_ASSERT(m_aContext.xObjectModel.is(), "OGroupBoxWizard::initContext: have no control model to work with!");
 480         if (!m_aContext.xObjectModel.is())
 481             return false;
 482
 483         // reset the context
 484         m_aContext.xForm.clear();
 485         m_aContext.xRowSet.clear();
 486         m_aContext.xDocumentModel.clear();
 487         m_aContext.xDrawPage.clear();
 488         m_aContext.xObjectShape.clear();
 489         m_aContext.aFieldNames.realloc(0);
 490
 491         m_aContext.xObjectContainer.clear();
 492         m_aContext.aTypes.clear();
 493         m_aContext.bEmbedded = false;
 494
 495         Any aSQLException;
 496         Reference< XPreparedStatement >  xStatement;
 497         try
 498         {
 499             // get the datasource context
 500             implGetDSContext();
 501
 502             // first, determine the form the control belongs to
 503             implDetermineForm();
 504
 505             // need the page, too
 506             implDeterminePage();
 507
 508             // the shape of the control
 509             implDetermineShape();
 510
 511             // get the columns of the object the settings refer to
 512             Reference< XNameAccess >  xColumns;
 513
 514             if (m_aContext.xForm.is())
 515             {
 516                 // collect some properties of the form
 517                 OUString sObjectName = ::comphelper::getString(m_aContext.xForm->getPropertyValue("Command"));
 518                 sal_Int32 nObjectType = ::comphelper::getINT32(m_aContext.xForm->getPropertyValue("CommandType"));
 519
 520                 // calculate the connection the rowset is working with
 521                 Reference< XConnection > xConnection;
 522                 m_aContext.bEmbedded = ::dbtools::isEmbeddedInDatabase( m_aContext.xForm, xConnection );
 523                 if ( !m_aContext.bEmbedded )
 524                     xConnection = ::dbtools::connectRowset( m_aContext.xRowSet, m_xContext );
 525
 526                 // get the fields
 527                 if (xConnection.is())
 528                 {
 529                     switch (nObjectType)
 530                     {
 531                         case 0:
 532                         {
 533                             Reference< XTablesSupplier >  xSupplyTables(xConnection, UNO_QUERY);
 534                             if (xSupplyTables.is() && xSupplyTables->getTables().is() && xSupplyTables->getTables()->hasByName(sObjectName))
 535                             {
 536                                 Reference< XColumnsSupplier >  xSupplyColumns;
 537                                 m_aContext.xObjectContainer = xSupplyTables->getTables();
 538                                 m_aContext.xObjectContainer->getByName(sObjectName) >>= xSupplyColumns;
 539                                 DBG_ASSERT(xSupplyColumns.is(), "OControlWizard::initContext: invalid table columns!");
 540                                 xColumns = xSupplyColumns->getColumns();
 541                             }
 542                         }
 543                         break;
 544                         case 1:
 545                         {
 546                             Reference< XQueriesSupplier >  xSupplyQueries(xConnection, UNO_QUERY);
 547                             if (xSupplyQueries.is() && xSupplyQueries->getQueries().is() && xSupplyQueries->getQueries()->hasByName(sObjectName))
 548                             {
 549                                 Reference< XColumnsSupplier >  xSupplyColumns;
 550                                 m_aContext.xObjectContainer = xSupplyQueries->getQueries();
 551                                 m_aContext.xObjectContainer->getByName(sObjectName) >>= xSupplyColumns;
 552                                 DBG_ASSERT(xSupplyColumns.is(), "OControlWizard::initContext: invalid query columns!");
 553                                 xColumns  = xSupplyColumns->getColumns();
 554                             }
 555                         }
 556                         break;
 557                         default:
 558                         {
 559                             xStatement = xConnection->prepareStatement(sObjectName);
 560
 561                             // not interested in any results, only in the fields
 562                             Reference< XPropertySet > xStatementProps(xStatement, UNO_QUERY);
 563                             xStatementProps->setPropertyValue("MaxRows", makeAny(sal_Int32(0)));
 564
 565                             // TODO: think about handling local SQLExceptions here ...
 566                             Reference< XColumnsSupplier >  xSupplyCols(xStatement->executeQuery(), UNO_QUERY);
 567                             if (xSupplyCols.is())
 568                                 xColumns = xSupplyCols->getColumns();
 569                         }
 570                     }
 571                 }
 572             }
 573
 574             if (xColumns.is())
 575             {
 576                 m_aContext.aFieldNames = xColumns->getElementNames();
 577                 const OUString* pBegin = m_aContext.aFieldNames.getConstArray();
 578                 const OUString* pEnd   = pBegin + m_aContext.aFieldNames.getLength();
 579                 for(;pBegin != pEnd;++pBegin)
 580                 {
 581                     sal_Int32 nFieldType = DataType::OTHER;
 582                     try
 583                     {
 584                         Reference< XPropertySet > xColumn;
 585                         xColumns->getByName(*pBegin) >>= xColumn;
 586                         xColumn->getPropertyValue("Type") >>= nFieldType;
 587                     }
 588                     catch(const Exception&)
 589                     {
 590                         OSL_FAIL("OControlWizard::initContext: unexpected exception while gathering column information!");
 591                     }
 592                     m_aContext.aTypes.emplace(*pBegin,nFieldType);
 593                 }
 594             }
 595         }
 596         catch(const SQLContext& e) { aSQLException <<= e; }
 597         catch(const SQLWarning& e) { aSQLException <<= e; }
 598         catch(const SQLException& e) { aSQLException <<= e; }
 599         catch(const Exception&)
 600         {
 601             OSL_FAIL("OControlWizard::initContext: could not retrieve the control context (caught an exception)!");
 602         }
 603
 604         ::comphelper::disposeComponent(xStatement);
 605
 606         if (aSQLException.hasValue())
 607         {   // an SQLException (or derivee) was thrown ...
 608
 609             // prepend an extra SQLContext explaining what we were doing
 610             SQLContext aContext;
 611             aContext.Message = compmodule::ModuleRes(RID_STR_COULDNOTOPENTABLE);
 612             aContext.NextException = aSQLException;
 613
 614             // create an interaction handler to display this exception
 615             Reference< XInteractionHandler > xHandler = getInteractionHandler(GetFrameWeld());
 616             if ( !xHandler.is() )
 617                 return false;
 618
 619             Reference< XInteractionRequest > xRequest = new OInteractionRequest(makeAny(aContext));
 620             try
 621             {
 622                 xHandler->handle(xRequest);
 623             }
 624             catch(const Exception&) { }
 625             return false;
 626         }
 627
 628         return m_aContext.aFieldNames.hasElements();
 629     }
 630
 631
 632     void OControlWizard::commitControlSettings(OControlWizardSettings const * _pSettings)
 633     {
 634         DBG_ASSERT(m_aContext.xObjectModel.is(), "OControlWizard::commitControlSettings: have no control model to work with!");
 635         if (!m_aContext.xObjectModel.is())
 636             return;
 637
 638         // the only thing we have at the moment is the label
 639         try
 640         {
 641             Reference< XPropertySetInfo > xInfo = m_aContext.xObjectModel->getPropertySetInfo();
 642             if (xInfo.is() && xInfo->hasPropertyByName("Label"))
 643             {
 644                 OUString sControlLabel(_pSettings->sControlLabel);
 645                 m_aContext.xObjectModel->setPropertyValue(
 646                     "Label",
 647                     makeAny(sControlLabel)
 648                 );
 649             }
 650         }
 651         catch(const Exception&)
 652         {
 653             OSL_FAIL("OControlWizard::commitControlSettings: could not commit the basic control settings!");
 654         }
 655     }
 656
 657
 658     void OControlWizard::initControlSettings(OControlWizardSettings* _pSettings)
 659     {
 660         DBG_ASSERT(m_aContext.xObjectModel.is(), "OControlWizard::initControlSettings: have no control model to work with!");
 661         if (!m_aContext.xObjectModel.is())
 662             return;
 663
 664         // initialize some settings from the control model give
 665         try
 666         {
 667             OUString sLabelPropertyName("Label");
 668             Reference< XPropertySetInfo > xInfo = m_aContext.xObjectModel->getPropertySetInfo();
 669             if (xInfo.is() && xInfo->hasPropertyByName(sLabelPropertyName))
 670             {
 671                 OUString sControlLabel;
 672                 m_aContext.xObjectModel->getPropertyValue(sLabelPropertyName) >>= sControlLabel;
 673                 _pSettings->sControlLabel = sControlLabel;
 674             }
 675         }
 676         catch(const Exception&)
 677         {
 678             OSL_FAIL("OControlWizard::initControlSettings: could not retrieve the basic control settings!");
 679         }
 680     }
 681
 682
 683     bool OControlWizard::needDatasourceSelection()
 684     {
 685         // lemme see ...
 686         return !getContext().aFieldNames.hasElements();
 687             // if we got fields, the data source is valid ...
 688     }
 689
 690
 691 }   // namespace dbp
 692
 693
 694 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */