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