/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_svx.hxx" #include "svx/svxerr.hxx" #include "fmpgeimp.hxx" #include "fmundo.hxx" #include "svx/fmtools.hxx" #include "fmprop.hrc" #include "fmservs.hxx" #include "fmobj.hxx" #include "formcontrolfactory.hxx" #include "svx/svditer.hxx" #include "svx/fmresids.hrc" #include "svx/dbtoolsclient.hxx" #include "treevisitor.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace ::com::sun::star::uno; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::sdbc; using namespace ::com::sun::star::sdb; using namespace ::com::sun::star::container; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::form; using ::com::sun::star::util::XCloneable; using ::com::sun::star::awt::XControlModel; using ::com::sun::star::container::XMap; using ::com::sun::star::container::EnumerableMap; using ::com::sun::star::drawing::XControlShape; using namespace ::svxform; DBG_NAME(FmFormPageImpl) //------------------------------------------------------------------------------ FmFormPageImpl::FmFormPageImpl( FmFormPage& _rPage ) :m_rPage( _rPage ) ,m_bFirstActivation( sal_True ) ,m_bAttemptedFormCreation( false ) ,m_bInFind( false ) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::FmFormPageImpl" ); DBG_CTOR(FmFormPageImpl,NULL); } //------------------------------------------------------------------------------ namespace { typedef Reference< XInterface > FormComponent; class FormComponentInfo { public: size_t childCount( const FormComponent& _component ) const { Reference< XIndexAccess > xContainer( _component, UNO_QUERY ); if ( xContainer.is() ) return xContainer->getCount(); return 0; } FormComponent getChild( const FormComponent& _component, size_t _index ) const { Reference< XIndexAccess > xContainer( _component, UNO_QUERY_THROW ); return FormComponent( xContainer->getByIndex( _index ), UNO_QUERY ); } }; typedef ::std::pair< FormComponent, FormComponent > FormComponentPair; class FormHierarchyComparator { public: FormHierarchyComparator() { } size_t childCount( const FormComponentPair& _components ) const { size_t lhsCount = m_aComponentInfo.childCount( _components.first ); size_t rhsCount = m_aComponentInfo.childCount( _components.second ); if ( lhsCount != rhsCount ) throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Found inconsistent form component hierarchies (1)!" ) ), NULL ); return lhsCount; } FormComponentPair getChild( const FormComponentPair& _components, size_t _index ) const { return FormComponentPair( m_aComponentInfo.getChild( _components.first, _index ), m_aComponentInfo.getChild( _components.second, _index ) ); } private: FormComponentInfo m_aComponentInfo; }; typedef ::std::map< Reference< XControlModel >, Reference< XControlModel >, ::comphelper::OInterfaceCompare< XControlModel > > MapControlModels; class FormComponentAssignment { public: FormComponentAssignment( MapControlModels& _out_controlModelMap ) :m_rControlModelMap( _out_controlModelMap ) { } void process( const FormComponentPair& _component ) { Reference< XControlModel > lhsControlModel( _component.first, UNO_QUERY ); Reference< XControlModel > rhsControlModel( _component.second, UNO_QUERY ); if ( lhsControlModel.is() != rhsControlModel.is() ) throw RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Found inconsistent form component hierarchies (2)!" ) ), NULL ); if ( lhsControlModel.is() ) m_rControlModelMap[ lhsControlModel ] = rhsControlModel; } private: MapControlModels& m_rControlModelMap; }; } //------------------------------------------------------------------------------ void FmFormPageImpl::initFrom( FmFormPageImpl& i_foreignImpl ) { // clone the Forms collection const Reference< XNameContainer > xForeignForms( const_cast< FmFormPageImpl& >( i_foreignImpl ).getForms( false ) ); const Reference< XCloneable > xCloneable( xForeignForms, UNO_QUERY ); if ( !xCloneable.is() ) { // great, nothing to do OSL_ENSURE( !xForeignForms.is(), "FmFormPageImpl::FmFormPageImpl: a non-cloneable forms container!?" ); return; } try { m_xForms.set( xCloneable->createClone(), UNO_QUERY_THROW ); // create a mapping between the original control models and their clones MapControlModels aModelAssignment; typedef TreeVisitor< FormComponentPair, FormHierarchyComparator, FormComponentAssignment > FormComponentVisitor; FormComponentVisitor aVisitor = FormComponentVisitor( FormHierarchyComparator() ); FormComponentAssignment aAssignmentProcessor( aModelAssignment ); aVisitor.process( FormComponentPair( xCloneable, m_xForms ), aAssignmentProcessor ); // assign the cloned models to their SdrObjects SdrObjListIter aForeignIter( i_foreignImpl.m_rPage ); SdrObjListIter aOwnIter( m_rPage ); OSL_ENSURE( aForeignIter.IsMore() == aOwnIter.IsMore(), "FmFormPageImpl::FmFormPageImpl: inconsistent number of objects (1)!" ); while ( aForeignIter.IsMore() && aOwnIter.IsMore() ) { FmFormObj* pForeignObj = dynamic_cast< FmFormObj* >( aForeignIter.Next() ); FmFormObj* pOwnObj = dynamic_cast< FmFormObj* >( aOwnIter.Next() ); bool bForeignIsForm = pForeignObj && ( pForeignObj->GetObjInventor() == FmFormInventor ); bool bOwnIsForm = pOwnObj && ( pOwnObj->GetObjInventor() == FmFormInventor ); ENSURE_OR_BREAK( bForeignIsForm == bOwnIsForm, "FmFormPageImpl::FmFormPageImpl: inconsistent ordering of objects!" ); // if this fires, don't attempt to do further assignments, something's completely messed up if ( !bForeignIsForm ) // no form control -> next round continue; Reference< XControlModel > xForeignModel( pForeignObj->GetUnoControlModel() ); ENSURE_OR_CONTINUE( xForeignModel.is(), "FmFormPageImpl::FmFormPageImpl: control shape without control!" ); // if this fires, the SdrObject does not have a UNO Control Model. This is pathological, but well ... // So the cloned SdrObject will also not have a UNO Control Model. MapControlModels::const_iterator assignment = aModelAssignment.find( xForeignModel ); ENSURE_OR_CONTINUE( assignment != aModelAssignment.end(), "FmFormPageImpl::FmFormPageImpl: no clone found for this model!" ); // if this fires, the source SdrObject has a model, but it is not part of the model hierarchy in // i_foreignImpl.getForms(). // Pathological, too ... pOwnObj->SetUnoControlModel( assignment->second ); } OSL_ENSURE( aForeignIter.IsMore() == aOwnIter.IsMore(), "FmFormPageImpl::FmFormPageImpl: inconsistent number of objects (2)!" ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } } //------------------------------------------------------------------------------ Reference< XMap > FmFormPageImpl::getControlToShapeMap() { Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); if ( xControlShapeMap.is() ) return xControlShapeMap; xControlShapeMap = impl_createControlShapeMap_nothrow(); m_aControlShapeMap = xControlShapeMap; return xControlShapeMap; } //------------------------------------------------------------------------------ namespace { static void lcl_insertFormObject_throw( const FmFormObj& _object, const Reference< XMap >& _map ) { // the control model Reference< XControlModel > xControlModel( _object.GetUnoControlModel(), UNO_QUERY ); OSL_ENSURE( xControlModel.is(), "lcl_insertFormObject_throw: suspicious: no control model!" ); if ( !xControlModel.is() ) return; Reference< XControlShape > xControlShape( const_cast< FmFormObj& >( _object ).getUnoShape(), UNO_QUERY ); OSL_ENSURE( xControlShape.is(), "lcl_insertFormObject_throw: suspicious: no control shape!" ); if ( !xControlShape.is() ) return; _map->put( makeAny( xControlModel ), makeAny( xControlShape ) ); } static void lcl_removeFormObject_throw( const FmFormObj& _object, const Reference< XMap >& _map, bool i_ignoreNonExistence = false ) { // the control model Reference< XControlModel > xControlModel( _object.GetUnoControlModel(), UNO_QUERY ); OSL_ENSURE( xControlModel.is(), "lcl_removeFormObject: suspicious: no control model!" ); if ( !xControlModel.is() ) return; #if OSL_DEBUG_LEVEL > 0 Any aOldAssignment = #endif _map->remove( makeAny( xControlModel ) ); #if OSL_DEBUG_LEVEL > 0 (void)aOldAssignment; #endif OSL_ENSURE( !i_ignoreNonExistence || ( aOldAssignment == makeAny( Reference< XControlShape >( const_cast< FmFormObj& >( _object ).getUnoShape(), UNO_QUERY ) ) ), "lcl_removeFormObject: map was inconsistent!" ); (void)i_ignoreNonExistence; } } //------------------------------------------------------------------------------ Reference< XMap > FmFormPageImpl::impl_createControlShapeMap_nothrow() { Reference< XMap > xMap; try { ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() ); xMap.set( EnumerableMap::create( aContext.getUNOContext(), ::cppu::UnoType< XControlModel >::get(), ::cppu::UnoType< XControlShape >::get() ).get(), UNO_SET_THROW ); SdrObjListIter aPageIter( m_rPage ); while ( aPageIter.IsMore() ) { // only FmFormObjs are what we're interested in FmFormObj* pCurrent = FmFormObj::GetFormObject( aPageIter.Next() ); if ( !pCurrent ) continue; lcl_insertFormObject_throw( *pCurrent, xMap ); } } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } return xMap; } //------------------------------------------------------------------------------ const Reference< XNameContainer >& FmFormPageImpl::getForms( bool _bForceCreate ) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::getForms" ); if ( m_xForms.is() || !_bForceCreate ) return m_xForms; if ( !m_bAttemptedFormCreation ) { m_bAttemptedFormCreation = true; const ::rtl::OUString sFormsCollectionServiceName = ::rtl::OUString::createFromAscii("com.sun.star.form.Forms"); m_xForms = Reference< XNameContainer > ( ::comphelper::getProcessServiceFactory()->createInstance( sFormsCollectionServiceName ), UNO_QUERY ); DBG_ASSERT( m_xForms.is(), "FmFormPageImpl::getForms: could not create a forms collection!" ); if ( m_aFormsCreationHdl.IsSet() ) { m_aFormsCreationHdl.Call( this ); } FmFormModel* pFormsModel = PTR_CAST( FmFormModel, m_rPage.GetModel() ); // give the newly created collection a place in the universe Reference< XChild > xAsChild( m_xForms, UNO_QUERY ); if ( xAsChild.is() ) { SfxObjectShell* pObjShell = pFormsModel ? pFormsModel->GetObjectShell() : NULL; if ( pObjShell ) xAsChild->setParent( pObjShell->GetModel() ); } // tell the UNDO environment that we have a new forms collection if ( pFormsModel ) pFormsModel->GetUndoEnv().AddForms( m_xForms ); } return m_xForms; } //------------------------------------------------------------------------------ FmFormPageImpl::~FmFormPageImpl() { xCurrentForm = NULL; ::comphelper::disposeComponent( m_xForms ); DBG_DTOR(FmFormPageImpl,NULL); } //------------------------------------------------------------------------------ bool FmFormPageImpl::validateCurForm() { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::validateCurForm" ); if ( !xCurrentForm.is() ) return false; Reference< XChild > xAsChild( xCurrentForm, UNO_QUERY ); DBG_ASSERT( xAsChild.is(), "FmFormPageImpl::validateCurForm: a form which is no child??" ); if ( !xAsChild.is() || !xAsChild->getParent().is() ) xCurrentForm.clear(); return xCurrentForm.is(); } //------------------------------------------------------------------------------ void FmFormPageImpl::setCurForm(Reference< ::com::sun::star::form::XForm > xForm) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::setCurForm" ); xCurrentForm = xForm; } //------------------------------------------------------------------------------ Reference< XForm > FmFormPageImpl::getDefaultForm() { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::getDefaultForm" ); Reference< XForm > xForm; Reference< XNameContainer > xForms( getForms() ); // by default, we use our "current form" if ( !validateCurForm() ) { // check whether there is a "standard" form if ( xForms->hasElements() ) { // suche die Standardform ::rtl::OUString sStandardFormname = String( SVX_RES( RID_STR_STDFORMNAME ) ); try { if ( xForms->hasByName( sStandardFormname ) ) xForm.set( xForms->getByName( sStandardFormname ), UNO_QUERY_THROW ); else { Reference< XIndexAccess > xFormsByIndex( xForms, UNO_QUERY_THROW ); xForm.set( xFormsByIndex->getByIndex(0), UNO_QUERY_THROW ); } } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } } } else { xForm = xCurrentForm; } // did not find an existing suitable form -> create a new one if ( !xForm.is() ) { SdrModel* pModel = m_rPage.GetModel(); if( pModel->IsUndoEnabled() ) { XubString aStr(SVX_RES(RID_STR_FORM)); XubString aUndoStr(SVX_RES(RID_STR_UNDO_CONTAINER_INSERT)); aUndoStr.SearchAndReplace('#', aStr); pModel->BegUndo(aUndoStr); } try { xForm.set( ::comphelper::getProcessServiceFactory()->createInstance( FM_SUN_COMPONENT_FORM ), UNO_QUERY ); // a form should always have the command type table as default Reference< XPropertySet > xFormProps( xForm, UNO_QUERY_THROW ); xFormProps->setPropertyValue( FM_PROP_COMMANDTYPE, makeAny( sal_Int32( CommandType::TABLE ) ) ); // and the "Standard" name ::rtl::OUString sName = String( SVX_RES( RID_STR_STDFORMNAME ) ); xFormProps->setPropertyValue( FM_PROP_NAME, makeAny( sName ) ); Reference< XIndexContainer > xContainer( xForms, UNO_QUERY ); if( pModel->IsUndoEnabled() ) { pModel->AddUndo(new FmUndoContainerAction(*(FmFormModel*)pModel, FmUndoContainerAction::Inserted, xContainer, xForm, xContainer->getCount())); } xForms->insertByName( sName, makeAny( xForm ) ); xCurrentForm = xForm; } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); xForm.clear(); } if( pModel->IsUndoEnabled() ) pModel->EndUndo(); } return xForm; } //------------------------------------------------------------------------------ Reference< ::com::sun::star::form::XForm > FmFormPageImpl::findPlaceInFormComponentHierarchy( const Reference< XFormComponent > & rContent, const Reference< XDataSource > & rDatabase, const ::rtl::OUString& rDBTitle, const ::rtl::OUString& rCursorSource, sal_Int32 nCommandType ) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::findPlaceInFormComponentHierarchy" ); // if the control already is child of a form, don't do anything if (!rContent.is() || rContent->getParent().is()) return NULL; Reference< XForm > xForm; // Wenn Datenbank und CursorSource gesetzt sind, dann wird // die Form anhand dieser Kriterien gesucht, ansonsten nur aktuelle // und die StandardForm if (rDatabase.is() && rCursorSource.getLength()) { validateCurForm(); // erst in der aktuellen form suchen xForm = findFormForDataSource( xCurrentForm, rDatabase, rCursorSource, nCommandType ); Reference< ::com::sun::star::container::XIndexAccess > xFormsByIndex( getForms(), UNO_QUERY ); DBG_ASSERT(xFormsByIndex.is(), "FmFormPageImpl::findPlaceInFormComponentHierarchy : no index access for my forms collection !"); sal_Int32 nCount = xFormsByIndex->getCount(); for (sal_Int32 i = 0; !xForm.is() && i < nCount; i++) { Reference< ::com::sun::star::form::XForm > xToSearch; xFormsByIndex->getByIndex(i) >>= xToSearch; xForm = findFormForDataSource( xToSearch, rDatabase, rCursorSource, nCommandType ); } // wenn keine ::com::sun::star::form gefunden, dann eine neue erzeugen if (!xForm.is()) { SdrModel* pModel = m_rPage.GetModel(); const bool bUndo = pModel->IsUndoEnabled(); if( bUndo ) { XubString aStr(SVX_RES(RID_STR_FORM)); XubString aUndoStr(SVX_RES(RID_STR_UNDO_CONTAINER_INSERT)); aUndoStr.SearchAndReplace('#', aStr); pModel->BegUndo(aUndoStr); } xForm = Reference< ::com::sun::star::form::XForm >(::comphelper::getProcessServiceFactory()->createInstance(FM_SUN_COMPONENT_FORM), UNO_QUERY); // a form should always have the command type table as default Reference< ::com::sun::star::beans::XPropertySet > xFormProps(xForm, UNO_QUERY); try { xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, makeAny(sal_Int32(CommandType::TABLE))); } catch(Exception&) { } if (rDBTitle.getLength()) xFormProps->setPropertyValue(FM_PROP_DATASOURCE,makeAny(rDBTitle)); else { Reference< ::com::sun::star::beans::XPropertySet > xDatabaseProps(rDatabase, UNO_QUERY); Any aDatabaseUrl = xDatabaseProps->getPropertyValue(FM_PROP_URL); xFormProps->setPropertyValue(FM_PROP_DATASOURCE, aDatabaseUrl); } xFormProps->setPropertyValue(FM_PROP_COMMAND,makeAny(rCursorSource)); xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, makeAny(nCommandType)); Reference< ::com::sun::star::container::XNameAccess > xNamedSet( getForms(), UNO_QUERY ); const bool bTableOrQuery = ( CommandType::TABLE == nCommandType ) || ( CommandType::QUERY == nCommandType ); ::rtl::OUString sName = FormControlFactory::getUniqueName( xNamedSet, bTableOrQuery ? rCursorSource : ::rtl::OUString( String( SVX_RES( RID_STR_STDFORMNAME ) ) ) ); xFormProps->setPropertyValue( FM_PROP_NAME, makeAny( sName ) ); if( bUndo ) { Reference< ::com::sun::star::container::XIndexContainer > xContainer( getForms(), UNO_QUERY ); pModel->AddUndo(new FmUndoContainerAction(*(FmFormModel*)pModel, FmUndoContainerAction::Inserted, xContainer, xForm, xContainer->getCount())); } getForms()->insertByName( sName, makeAny( xForm ) ); if( bUndo ) pModel->EndUndo(); } xCurrentForm = xForm; } xForm = getDefaultForm(); return xForm; } //------------------------------------------------------------------------------ Reference< XForm > FmFormPageImpl::findFormForDataSource( const Reference< XForm > & rForm, const Reference< XDataSource > & _rxDatabase, const ::rtl::OUString& _rCursorSource, sal_Int32 nCommandType) { RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::findFormForDataSource" ); Reference< XForm > xResultForm; Reference< XRowSet > xDBForm(rForm, UNO_QUERY); Reference< XPropertySet > xFormProps(rForm, UNO_QUERY); if (!xDBForm.is() || !xFormProps.is()) return xResultForm; OSL_ENSURE(_rxDatabase.is(), "FmFormPageImpl::findFormForDataSource: invalid data source!"); ::rtl::OUString sLookupName; // the name of the data source we're looking for ::rtl::OUString sFormDataSourceName; // the name of the data source the current connection in the form is based on try { Reference< XPropertySet > xDSProps(_rxDatabase, UNO_QUERY); if (xDSProps.is()) xDSProps->getPropertyValue(FM_PROP_NAME) >>= sLookupName; xFormProps->getPropertyValue(FM_PROP_DATASOURCE) >>= sFormDataSourceName; // if there's no DataSourceName set at the form, check whether we can deduce one from its // ActiveConnection if (0 == sFormDataSourceName.getLength()) { Reference< XConnection > xFormConnection; xFormProps->getPropertyValue( FM_PROP_ACTIVE_CONNECTION ) >>= xFormConnection; if ( !xFormConnection.is() ) OStaticDataAccessTools().isEmbeddedInDatabase( xFormProps, xFormConnection ); if (xFormConnection.is()) { Reference< XChild > xConnAsChild(xFormConnection, UNO_QUERY); if (xConnAsChild.is()) { Reference< XDataSource > xFormDS(xConnAsChild->getParent(), UNO_QUERY); if (xFormDS.is()) { xDSProps = xDSProps.query(xFormDS); if (xDSProps.is()) xDSProps->getPropertyValue(FM_PROP_NAME) >>= sFormDataSourceName; } } } } } catch(const Exception& e) { (void)e; OSL_ENSURE(sal_False, "FmFormPageImpl::findFormForDataSource: caught an exception!"); } if (sLookupName == sFormDataSourceName) { // jetzt noch ueberpruefen ob CursorSource und Type uebereinstimmen ::rtl::OUString aCursorSource = ::comphelper::getString(xFormProps->getPropertyValue(FM_PROP_COMMAND)); sal_Int32 nType = ::comphelper::getINT32(xFormProps->getPropertyValue(FM_PROP_COMMANDTYPE)); if (!aCursorSource.getLength() || ((nType == nCommandType) && (aCursorSource == _rCursorSource))) // found the form { xResultForm = rForm; // Ist noch keine Datenquelle gesetzt, wird dieses hier nachgeholt if (!aCursorSource.getLength()) { xFormProps->setPropertyValue(FM_PROP_COMMAND, makeAny(_rCursorSource)); xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, makeAny((sal_Int32)nCommandType)); } } } // as long as xResultForm is NULL, search the child forms of rForm Reference< XIndexAccess > xComponents(rForm, UNO_QUERY); sal_Int32 nCount = xComponents->getCount(); for (sal_Int32 i = 0; !xResultForm.is() && i < nCount; ++i) { Reference< ::com::sun::star::form::XForm > xSearchForm; xComponents->getByIndex(i) >>= xSearchForm; // continue searching in the sub form if (xSearchForm.is()) xResultForm = findFormForDataSource( xSearchForm, _rxDatabase, _rCursorSource, nCommandType ); } return xResultForm; } //------------------------------------------------------------------------------ ::rtl::OUString FmFormPageImpl::setUniqueName(const Reference< XFormComponent > & xFormComponent, const Reference< XForm > & xControls) { #if OSL_DEBUG_LEVEL > 0 try { Reference< XChild > xChild( xFormComponent, UNO_QUERY_THROW ); OSL_ENSURE( !xChild->getParent().is(), "FmFormPageImpl::setUniqueName: to be called before insertion!" ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } #endif ::rtl::OUString sName; Reference< ::com::sun::star::beans::XPropertySet > xSet(xFormComponent, UNO_QUERY); if (xSet.is()) { sName = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_NAME ) ); Reference< ::com::sun::star::container::XNameAccess > xNameAcc(xControls, UNO_QUERY); if (!sName.getLength() || xNameAcc->hasByName(sName)) { // setzen eines default Namens ueber die ClassId sal_Int16 nClassId( FormComponentType::CONTROL ); xSet->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId; ::rtl::OUString sDefaultName = FormControlFactory::getDefaultUniqueName_ByComponentType( Reference< XNameAccess >( xControls, UNO_QUERY ), xSet ); // bei Radiobuttons, die einen Namen haben, diesen nicht ueberschreiben! if (!sName.getLength() || nClassId != ::com::sun::star::form::FormComponentType::RADIOBUTTON) { xSet->setPropertyValue(FM_PROP_NAME, makeAny(sDefaultName)); } sName = sDefaultName; } } return sName; } //---------------------------------------------------------------------------------------------------------------------- void FmFormPageImpl::formModelAssigned( const FmFormObj& _object ) { Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); if ( !xControlShapeMap.is() ) // our map does not exist -> not interested in this event return; try { lcl_removeFormObject_throw( _object, xControlShapeMap, false ); lcl_insertFormObject_throw( _object, xControlShapeMap ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } } //---------------------------------------------------------------------------------------------------------------------- void FmFormPageImpl::formObjectInserted( const FmFormObj& _object ) { Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); if ( !xControlShapeMap.is() ) // our map does not exist -> not interested in this event return; try { lcl_insertFormObject_throw( _object, xControlShapeMap ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } } //---------------------------------------------------------------------------------------------------------------------- void FmFormPageImpl::formObjectRemoved( const FmFormObj& _object ) { Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY ); if ( !xControlShapeMap.is() ) // our map does not exist -> not interested in this event return; try { lcl_removeFormObject_throw( _object, xControlShapeMap ); } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } }