wangxin/loongoffice
1
0
Fork 0
forked from amazingfate/loongoffice
Code Pull Requests Activity
Files
87784da170cc31da2f4cf3fbf474295361afef76
loongoffice/extensions/source/dbpilots/controlwizard.cxx
Frank Schoenheit [fs] d2b0dc2ee3 unoawt: completely separated the controller functionality of a wizard page from the wizard page itself, 
by moving the canAdvance method from OWizardPage to the IWizardPage interface, which in this course has
been renamed to IWizardPageController.
This will later on allow to have implementations where the TabPage is provided by an external component
(e.g. as UNO Service), but the controlling of those pages is still intercepted and handled internally.
2010-05-25 10:17:24 +02:00

778 lines
32 KiB
C++
Raw Blame History

/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_extensions.hxx"
#include "controlwizard.hxx"
#include <tools/debug.hxx>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
#include <com/sun/star/sdb/XQueriesSupplier.hpp>
#include <com/sun/star/sdbc/XPreparedStatement.hpp>
#include <com/sun/star/container/XChild.hpp>
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/sheet/XSpreadsheetView.hpp>
#include <com/sun/star/drawing/XDrawView.hpp>
#include <com/sun/star/drawing/XDrawPageSupplier.hpp>
#include <com/sun/star/sdb/CommandType.hpp>
#include <com/sun/star/sdbc/SQLWarning.hpp>
#include <com/sun/star/sdb/SQLContext.hpp>
#include <comphelper/types.hxx>
#include <connectivity/dbtools.hxx>
#include <vcl/msgbox.hxx>
#include <comphelper/interaction.hxx>
#include <vcl/stdtext.hxx>
#include <svtools/localresaccess.hxx>
#include <connectivity/conncleanup.hxx>
#include <com/sun/star/sdbc/DataType.hpp>
#include <tools/urlobj.hxx>
//.........................................................................
namespace dbp
{
//.........................................................................
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::awt;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdbcx;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::drawing;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::sheet;
using namespace ::com::sun::star::form;
using namespace ::com::sun::star::task;
using namespace ::svt;
using namespace ::comphelper;
using namespace ::dbtools;
//=====================================================================
//= OAccessRegulator
//=====================================================================
struct OAccessRegulator
{
friend class OControlWizardPage;
protected:
OAccessRegulator() { }
};
//=====================================================================
//= OControlWizardPage
//=====================================================================
//---------------------------------------------------------------------
OControlWizardPage::OControlWizardPage( OControlWizard* _pParent, const ResId& _rResId )
:OControlWizardPage_Base( _pParent, _rResId )
,m_pFormSettingsSeparator(NULL)
,m_pFormDatasourceLabel(NULL)
,m_pFormDatasource(NULL)
,m_pFormContentTypeLabel(NULL)
,m_pFormContentType(NULL)
,m_pFormTableLabel(NULL)
,m_pFormTable(NULL)
{
}
//---------------------------------------------------------------------
OControlWizardPage::~OControlWizardPage()
{
delete m_pFormSettingsSeparator;
delete m_pFormDatasourceLabel;
delete m_pFormDatasource;
delete m_pFormContentTypeLabel;
delete m_pFormContentType;
delete m_pFormTableLabel;
delete m_pFormTable;
}
//---------------------------------------------------------------------
OControlWizard* OControlWizardPage::getDialog()
{
return static_cast< OControlWizard* >(GetParent());
}
//---------------------------------------------------------------------
const OControlWizard* OControlWizardPage::getDialog() const
{
return static_cast< OControlWizard* >(GetParent());
}
//---------------------------------------------------------------------
sal_Bool OControlWizardPage::updateContext()
{
return getDialog()->updateContext(OAccessRegulator());
}
//---------------------------------------------------------------------
Reference< XConnection > OControlWizardPage::getFormConnection() const
{
return getDialog()->getFormConnection(OAccessRegulator());
}
//---------------------------------------------------------------------
void OControlWizardPage::setFormConnection( const Reference< XConnection >& _rxConn, sal_Bool _bAutoDispose )
{
getDialog()->setFormConnection( OAccessRegulator(), _rxConn, _bAutoDispose );
}
//---------------------------------------------------------------------
const OControlWizardContext& OControlWizardPage::getContext()
{
return getDialog()->getContext();
}
//---------------------------------------------------------------------
void OControlWizardPage::fillListBox(ListBox& _rList, const Sequence< ::rtl::OUString >& _rItems, sal_Bool _bClear)
{
if (_bClear)
_rList.Clear();
const ::rtl::OUString* pItems = _rItems.getConstArray();
const ::rtl::OUString* pEnd = pItems + _rItems.getLength();
::svt::WizardTypes::WizardState nPos;
sal_Int32 nIndex = 0;
for (;pItems < pEnd; ++pItems, ++nIndex)
{
nPos = _rList.InsertEntry(*pItems);
_rList.SetEntryData(nPos, reinterpret_cast<void*>(nIndex));
}
}
//---------------------------------------------------------------------
void OControlWizardPage::fillListBox(ComboBox& _rList, const Sequence< ::rtl::OUString >& _rItems, sal_Bool _bClear)
{
if (_bClear)
_rList.Clear();
const ::rtl::OUString* pItems = _rItems.getConstArray();
const ::rtl::OUString* pEnd = pItems + _rItems.getLength();
::svt::WizardTypes::WizardState nPos;
sal_Int32 nIndex = 0;
for (;pItems < pEnd; ++pItems)
{
nPos = _rList.InsertEntry(*pItems);
_rList.SetEntryData(nPos, reinterpret_cast<void*>(nIndex));
}
}
//---------------------------------------------------------------------
void OControlWizardPage::enableFormDatasourceDisplay()
{
if (m_pFormSettingsSeparator)
// nothing to do
return;
ModuleRes aModuleRes(RID_PAGE_FORM_DATASOURCE_STATUS);
OLocalResourceAccess aLocalControls(aModuleRes, RSC_TABPAGE);
m_pFormSettingsSeparator = new FixedLine(this, ModuleRes(FL_FORMSETINGS));
m_pFormDatasourceLabel = new FixedText(this, ModuleRes(FT_FORMDATASOURCELABEL));
m_pFormDatasource = new FixedText(this, ModuleRes(FT_FORMDATASOURCE));
m_pFormContentTypeLabel = new FixedText(this, ModuleRes(FT_FORMCONTENTTYPELABEL));
m_pFormContentType = new FixedText(this, ModuleRes(FT_FORMCONTENTTYPE));
m_pFormTableLabel = new FixedText(this, ModuleRes(FT_FORMTABLELABEL));
m_pFormTable = new FixedText(this, ModuleRes(FT_FORMTABLE));
const OControlWizardContext& rContext = getContext();
if ( rContext.bEmbedded )
{
m_pFormDatasourceLabel->Hide();
m_pFormDatasource->Hide();
m_pFormContentTypeLabel->SetPosPixel(m_pFormDatasourceLabel->GetPosPixel());
m_pFormContentType->SetPosPixel(m_pFormDatasource->GetPosPixel());
m_pFormTableLabel->SetPosPixel(::Point(m_pFormDatasourceLabel->GetPosPixel().X(),m_pFormTableLabel->GetPosPixel().Y()));
m_pFormTable->SetPosPixel(::Point(m_pFormDatasource->GetPosPixel().X(),m_pFormTable->GetPosPixel().Y()));
}
}
//---------------------------------------------------------------------
void OControlWizardPage::adjustControlForNoDSDisplay(Control* _pControl, sal_Bool _bConstLowerDistance)
{
::Size aDistanceToMove = LogicToPixel( ::Size( 0, 37 ), MAP_APPFONT );
::Point aPos = _pControl->GetPosPixel();
aPos.Y() -= aDistanceToMove.Height();
_pControl->SetPosPixel(aPos);
if (_bConstLowerDistance)
{
::Size aSize = _pControl->GetSizePixel();
aSize.Height() += aDistanceToMove.Height();
_pControl->SetSizePixel(aSize);
}
}
//---------------------------------------------------------------------
void OControlWizardPage::initializePage()
{
if (m_pFormDatasource && m_pFormContentTypeLabel && m_pFormTable)
{
const OControlWizardContext& rContext = getContext();
::rtl::OUString sDataSource;
::rtl::OUString sCommand;
sal_Int32 nCommandType = CommandType::COMMAND;
try
{
rContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("DataSourceName")) >>= sDataSource;
rContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("Command")) >>= sCommand;
rContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("CommandType")) >>= nCommandType;
}
catch(const Exception&)
{
DBG_ERROR("OControlWizardPage::initializePage: caught an exception!");
}
INetURLObject aURL( sDataSource );
if( aURL.GetProtocol() != INET_PROT_NOT_VALID )
sDataSource = aURL.GetName(INetURLObject::DECODE_WITH_CHARSET);
m_pFormDatasource->SetText(sDataSource);
m_pFormTable->SetText(sCommand);
::svt::WizardTypes::WizardState nCommandTypeResourceId = 0;
switch (nCommandType)
{
case CommandType::TABLE:
nCommandTypeResourceId = RID_STR_TYPE_TABLE;
break;
case CommandType::QUERY:
nCommandTypeResourceId = RID_STR_TYPE_QUERY;
break;
default:
nCommandTypeResourceId = RID_STR_TYPE_COMMAND;
break;
}
m_pFormContentType->SetText(String(ModuleRes(nCommandTypeResourceId)));
}
OControlWizardPage_Base::initializePage();
}
//=====================================================================
//= OControlWizard
//=====================================================================
//---------------------------------------------------------------------
OControlWizard::OControlWizard( Window* _pParent, const ResId& _rId,
const Reference< XPropertySet >& _rxObjectModel, const Reference< XMultiServiceFactory >& _rxORB )
:OWizardMachine(_pParent, _rId, WZB_CANCEL | WZB_PREVIOUS | WZB_NEXT | WZB_FINISH)
,m_xORB(_rxORB)
{
m_aContext.xObjectModel = _rxObjectModel;
initContext();
SetPageSizePixel(LogicToPixel(::Size(WINDOW_SIZE_X, WINDOW_SIZE_Y), MAP_APPFONT));
ShowButtonFixedLine(sal_True);
defaultButton(WZB_NEXT);
enableButtons(WZB_FINISH, sal_False);
}
//---------------------------------------------------------------------
OControlWizard::~OControlWizard()
{
}
//---------------------------------------------------------------------
short OControlWizard::Execute()
{
// get the class id of the control we're dealing with
sal_Int16 nClassId = FormComponentType::CONTROL;
try
{
getContext().xObjectModel->getPropertyValue(::rtl::OUString::createFromAscii("ClassId")) >>= nClassId;
}
catch(Exception&)
{
DBG_ERROR("OControlWizard::activate: could not obtain the class id!");
}
if (!approveControl(nClassId))
{
// TODO: MessageBox or exception
return RET_CANCEL;
}
ActivatePage();
return OControlWizard_Base::Execute();
}
//---------------------------------------------------------------------
void OControlWizard::ActivatePage()
{
OControlWizard_Base::ActivatePage();
}
//---------------------------------------------------------------------
void OControlWizard::implDetermineShape()
{
Reference< XIndexAccess > xPageObjects(m_aContext.xDrawPage, UNO_QUERY);
DBG_ASSERT(xPageObjects.is(), "OControlWizard::implDetermineShape: invalid page!");
// for comparing the model
Reference< XControlModel > xModelCompare(m_aContext.xObjectModel, UNO_QUERY);
if (xPageObjects.is())
{
// loop through all objects of the page
sal_Int32 nObjects = xPageObjects->getCount();
Reference< XControlShape > xControlShape;
Reference< XControlModel > xControlModel;
for (sal_Int32 i=0; i<nObjects; ++i)
{
if (xPageObjects->getByIndex(i) >>= xControlShape)
{ // it _is_ a control shape
xControlModel = xControlShape->getControl();
DBG_ASSERT(xControlModel.is(), "OControlWizard::implDetermineShape: control shape without model!");
if (xModelCompare.get() == xControlModel.get())
{
m_aContext.xObjectShape = xControlShape;
break;
}
}
}
}
}
//---------------------------------------------------------------------
void OControlWizard::implDetermineForm()
{
Reference< XChild > xModelAsChild(m_aContext.xObjectModel, UNO_QUERY);
Reference< XInterface > xControlParent;
if (xModelAsChild.is())
xControlParent = xModelAsChild->getParent();
m_aContext.xForm = Reference< XPropertySet >(xControlParent, UNO_QUERY);
m_aContext.xRowSet = Reference< XRowSet >(xControlParent, UNO_QUERY);
DBG_ASSERT(m_aContext.xForm.is() && m_aContext.xRowSet.is(),
"OControlWizard::implDetermineForm: missing some interfaces of the control parent!");
}
//---------------------------------------------------------------------
void OControlWizard::implDeterminePage()
{
try
{
// get the document model
Reference< XChild > xControlAsChild(m_aContext.xObjectModel, UNO_QUERY);
Reference< XChild > xModelSearch(xControlAsChild->getParent(), UNO_QUERY);
Reference< XModel > xModel(xModelSearch, UNO_QUERY);
while (xModelSearch.is() && !xModel.is())
{
xModelSearch = Reference< XChild >(xModelSearch->getParent(), UNO_QUERY);
xModel = Reference< XModel >(xModelSearch, UNO_QUERY);
}
Reference< XDrawPage > xPage;
if (xModel.is())
{
m_aContext.xDocumentModel = xModel;
Reference< XDrawPageSupplier > xPageSupp(xModel, UNO_QUERY);
if (xPageSupp.is())
{ // it's a document with only one page -> Writer
xPage = xPageSupp->getDrawPage();
}
else
{
// get the controller currently working on this model
Reference< XController > xController = xModel->getCurrentController();
DBG_ASSERT(xController.is(), "OControlWizard::implDeterminePage: no current controller!");
// maybe it's a spredsheet
Reference< XSpreadsheetView > xView(xController, UNO_QUERY);
if (xView.is())
{ // okay, it is one
Reference< XSpreadsheet > xSheet = xView->getActiveSheet();
xPageSupp = Reference< XDrawPageSupplier >(xSheet, UNO_QUERY);
DBG_ASSERT(xPageSupp.is(), "OControlWizard::implDeterminePage: a spreadsheet which is no page supplier!");
if (xPageSupp.is())
xPage = xPageSupp->getDrawPage();
}
else
{ // can be a draw/impress doc only
Reference< XDrawView > xDrawView(xController, UNO_QUERY);
DBG_ASSERT(xDrawView.is(), "OControlWizard::implDeterminePage: no alternatives left ... can't determine the page!");
if (xDrawView.is())
xPage = xDrawView->getCurrentPage();
}
}
}
else
{
DBG_ASSERT(xPage.is(), "OControlWizard::implDeterminePage: can't determine the page (no model)!");
}
m_aContext.xDrawPage = xPage;
}
catch(Exception&)
{
DBG_ERROR("OControlWizard::implDeterminePage: caught an exception!");
}
}
//---------------------------------------------------------------------
void OControlWizard::implGetDSContext()
{
Reference< XMultiServiceFactory > xORB = getServiceFactory();
try
{
DBG_ASSERT(xORB.is(), "OControlWizard::implGetDSContext: invalid service factory!");
Reference< XInterface > xContext;
if (xORB.is())
xContext = xORB->createInstance(::rtl::OUString::createFromAscii("com.sun.star.sdb.DatabaseContext"));
DBG_ASSERT(xContext.is(), "OControlWizard::implGetDSContext: invalid database context!");
m_aContext.xDatasourceContext = Reference< XNameAccess >(xContext, UNO_QUERY);
DBG_ASSERT(m_aContext.xDatasourceContext.is() || !xContext.is(), "OControlWizard::implGetDSContext: invalid database context (missing the XNameAccess)!");
}
catch(Exception&)
{
DBG_ERROR("OControlWizard::implGetDSContext: invalid database context!");
}
}
//---------------------------------------------------------------------
Reference< XConnection > OControlWizard::getFormConnection(const OAccessRegulator&) const
{
return getFormConnection();
}
//---------------------------------------------------------------------
Reference< XConnection > OControlWizard::getFormConnection() const
{
Reference< XConnection > xConn;
try
{
if ( !::dbtools::isEmbeddedInDatabase(m_aContext.xForm,xConn) )
m_aContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("ActiveConnection")) >>= xConn;
}
catch(const Exception&)
{
DBG_ERROR("OControlWizard::getFormConnection: caught an exception!");
}
return xConn;
}
//---------------------------------------------------------------------
void OControlWizard::setFormConnection( const OAccessRegulator& _rAccess, const Reference< XConnection >& _rxConn, sal_Bool _bAutoDispose )
{
try
{
Reference< XConnection > xOldConn = getFormConnection(_rAccess);
if (xOldConn.get() == _rxConn.get())
return;
disposeComponent(xOldConn);
// set the new connection
if ( _bAutoDispose )
{
// for this, use a AutoDisposer (so the conn is cleaned up when the form dies or get's another connection)
Reference< XRowSet > xFormRowSet( m_aContext.xForm, UNO_QUERY );
OAutoConnectionDisposer* pAutoDispose = new OAutoConnectionDisposer( xFormRowSet, _rxConn );
Reference< XPropertyChangeListener > xEnsureDelete( pAutoDispose );
}
else
{
m_aContext.xForm->setPropertyValue( ::rtl::OUString::createFromAscii("ActiveConnection"), makeAny( _rxConn ) );
}
}
catch(const Exception&)
{
DBG_ERROR("OControlWizard::setFormConnection: caught an exception!");
}
}
//---------------------------------------------------------------------
sal_Bool OControlWizard::updateContext(const OAccessRegulator&)
{
return initContext();
}
//---------------------------------------------------------------------
Reference< XInteractionHandler > OControlWizard::getInteractionHandler(Window* _pWindow) const
{
const ::rtl::OUString sInteractionHandlerServiceName = ::rtl::OUString::createFromAscii("com.sun.star.task.InteractionHandler");
Reference< XInteractionHandler > xHandler;
try
{
if (getServiceFactory().is())
xHandler = Reference< XInteractionHandler >(getServiceFactory()->createInstance(sInteractionHandlerServiceName), UNO_QUERY);
}
catch(Exception&) { }
if (!xHandler.is())
ShowServiceNotAvailableError(_pWindow, sInteractionHandlerServiceName, sal_True);
return xHandler;
}
//---------------------------------------------------------------------
sal_Bool OControlWizard::initContext()
{
DBG_ASSERT(m_aContext.xObjectModel.is(), "OGroupBoxWizard::initContext: have no control model to work with!");
if (!m_aContext.xObjectModel.is())
return sal_False;
// reset the context
m_aContext.xForm.clear();
m_aContext.xRowSet.clear();
m_aContext.xDocumentModel.clear();
m_aContext.xDrawPage.clear();
m_aContext.xObjectShape.clear();
m_aContext.aFieldNames.realloc(0);
m_aContext.xObjectContainer.clear();
m_aContext.aTypes.clear();
m_aContext.bEmbedded = sal_False;
Any aSQLException;
Reference< XPreparedStatement > xStatement;
try
{
// get the datasource context
implGetDSContext();
// first, determine the form the control belongs to
implDetermineForm();
// need the page, too
implDeterminePage();
// the shape of the control
implDetermineShape();
// get the columns of the object the settins refer to
Reference< XNameAccess > xColumns;
if (m_aContext.xForm.is())
{
// collect some properties of the form
::rtl::OUString sObjectName = ::comphelper::getString(m_aContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("Command")));
sal_Int32 nObjectType = ::comphelper::getINT32(m_aContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("CommandType")));
// calculate the connection the rowset is working with
Reference< XConnection > xConnection;
m_aContext.bEmbedded = ::dbtools::isEmbeddedInDatabase( m_aContext.xForm, xConnection );
if ( !m_aContext.bEmbedded )
xConnection = ::dbtools::connectRowset( m_aContext.xRowSet, getServiceFactory(), sal_True );
// get the fields
if (xConnection.is())
{
switch (nObjectType)
{
case 0:
{
Reference< XTablesSupplier > xSupplyTables(xConnection, UNO_QUERY);
if (xSupplyTables.is() && xSupplyTables->getTables().is() && xSupplyTables->getTables()->hasByName(sObjectName))
{
Reference< XColumnsSupplier > xSupplyColumns;
m_aContext.xObjectContainer = xSupplyTables->getTables();
m_aContext.xObjectContainer->getByName(sObjectName) >>= xSupplyColumns;
DBG_ASSERT(xSupplyColumns.is(), "OControlWizard::initContext: invalid table columns!");
xColumns = xSupplyColumns->getColumns();
}
}
break;
case 1:
{
Reference< XQueriesSupplier > xSupplyQueries(xConnection, UNO_QUERY);
if (xSupplyQueries.is() && xSupplyQueries->getQueries().is() && xSupplyQueries->getQueries()->hasByName(sObjectName))
{
Reference< XColumnsSupplier > xSupplyColumns;
m_aContext.xObjectContainer = xSupplyQueries->getQueries();
m_aContext.xObjectContainer->getByName(sObjectName) >>= xSupplyColumns;
DBG_ASSERT(xSupplyColumns.is(), "OControlWizard::initContext: invalid query columns!");
xColumns = xSupplyColumns->getColumns();
}
}
break;
default:
{
xStatement = xConnection->prepareStatement(sObjectName);
// not interested in any results, only in the fields
Reference< XPropertySet > xStatementProps(xStatement, UNO_QUERY);
xStatementProps->setPropertyValue(::rtl::OUString::createFromAscii("MaxRows"), makeAny(sal_Int32(0)));
// TODO: think about handling local SQLExceptions here ...
Reference< XColumnsSupplier > xSupplyCols(xStatement->executeQuery(), UNO_QUERY);
if (xSupplyCols.is())
xColumns = xSupplyCols->getColumns();
}
}
}
}
if (xColumns.is())
{
m_aContext.aFieldNames = xColumns->getElementNames();
static const ::rtl::OUString s_sFieldTypeProperty = ::rtl::OUString::createFromAscii("Type");
const ::rtl::OUString* pBegin = m_aContext.aFieldNames.getConstArray();
const ::rtl::OUString* pEnd = pBegin + m_aContext.aFieldNames.getLength();
for(;pBegin != pEnd;++pBegin)
{
sal_Int32 nFieldType = DataType::OTHER;
try
{
Reference< XPropertySet > xColumn;
xColumns->getByName(*pBegin) >>= xColumn;
xColumn->getPropertyValue(s_sFieldTypeProperty) >>= nFieldType;
}
catch(Exception&)
{
DBG_ERROR("OControlWizard::initContext: unexpected exception while gathering column information!");
}
m_aContext.aTypes.insert(OControlWizardContext::TNameTypeMap::value_type(*pBegin,nFieldType));
}
}
}
catch(SQLContext& e) { aSQLException <<= e; }
catch(SQLWarning& e) { aSQLException <<= e; }
catch(SQLException& e) { aSQLException <<= e; }
catch(Exception&)
{
DBG_ERROR("OControlWizard::initContext: could not retrieve the control context (caught an exception)!");
}
::comphelper::disposeComponent(xStatement);
if (aSQLException.hasValue())
{ // an SQLException (or derivee) was thrown ...
// prepend an extra SQLContext explaining what we were doing
SQLContext aContext;
aContext.Message = String(ModuleRes(RID_STR_COULDNOTOPENTABLE));
aContext.NextException = aSQLException;
// create an interaction handler to display this exception
Reference< XInteractionHandler > xHandler = getInteractionHandler(this);
if ( !xHandler.is() )
return sal_False;
Reference< XInteractionRequest > xRequest = new OInteractionRequest(makeAny(aContext));
try
{
xHandler->handle(xRequest);
}
catch(Exception&) { }
return sal_False;
}
return 0 != m_aContext.aFieldNames.getLength();
}
//---------------------------------------------------------------------
void OControlWizard::commitControlSettings(OControlWizardSettings* _pSettings)
{
DBG_ASSERT(m_aContext.xObjectModel.is(), "OControlWizard::commitControlSettings: have no control model to work with!");
if (!m_aContext.xObjectModel.is())
return;
// the only thing we have at the moment is the label
try
{
::rtl::OUString sLabelPropertyName = ::rtl::OUString::createFromAscii("Label");
Reference< XPropertySetInfo > xInfo = m_aContext.xObjectModel->getPropertySetInfo();
if (xInfo.is() && xInfo->hasPropertyByName(sLabelPropertyName))
{
::rtl::OUString sControlLabel(_pSettings->sControlLabel);
m_aContext.xObjectModel->setPropertyValue(
::rtl::OUString::createFromAscii("Label"),
makeAny(sControlLabel)
);
}
}
catch(Exception&)
{
DBG_ERROR("OControlWizard::commitControlSettings: could not commit the basic control settings!");
}
}
//---------------------------------------------------------------------
void OControlWizard::initControlSettings(OControlWizardSettings* _pSettings)
{
DBG_ASSERT(m_aContext.xObjectModel.is(), "OControlWizard::initControlSettings: have no control model to work with!");
if (!m_aContext.xObjectModel.is())
return;
// initialize some settings from the control model give
try
{
::rtl::OUString sLabelPropertyName = ::rtl::OUString::createFromAscii("Label");
Reference< XPropertySetInfo > xInfo = m_aContext.xObjectModel->getPropertySetInfo();
if (xInfo.is() && xInfo->hasPropertyByName(sLabelPropertyName))
{
::rtl::OUString sControlLabel;
m_aContext.xObjectModel->getPropertyValue(sLabelPropertyName) >>= sControlLabel;
_pSettings->sControlLabel = sControlLabel;
}
}
catch(Exception&)
{
DBG_ERROR("OControlWizard::initControlSettings: could not retrieve the basic control settings!");
}
}
//---------------------------------------------------------------------
sal_Bool OControlWizard::needDatasourceSelection()
{
// lemme see ...
return (0 == getContext().aFieldNames.getLength());
// if we got fields, the data source is valid ...
// try
// {
// // first, we need a valid data source name
// ::rtl::OUString sDataSourceName;
// m_aContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("DataSourceName")) >>= sDataSourceName;
// if (m_aContext.xDatasourceContext.is() && m_aContext.xDatasourceContext->hasByName(sDataSourceName))
// { // at least the data source name is valid ...
// // then, a CommandType "table" would be nice ...
// sal_Int32 nCommandType = CommandType::COMMAND;
// m_aContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("CommandType")) >>= nCommandType;
// if (CommandType::TABLE == nCommandType)
// { // okay ....
// // now the table itself should be valid
// ::rtl::OUString sTableName;
// m_aContext.xForm->getPropertyValue(::rtl::OUString::createFromAscii("Command")) >>= sTableName;
// if (m_aContext.xObjectContainer.is() && m_aContext.xObjectContainer->hasByName(sTableName))
// return sal_False;
// }
// }
// }
// catch(Exception&)
// {
// DBG_ERROR("OControlWizard::needDatasourceSelection: caught an exception while checking the form settings!");
// }
// return sal_True;
}
//.........................................................................
} // namespace dbp
//.........................................................................
View Git Blame Copy Permalink