svx/source/form/fmpgeimp.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
  21 #include "svx/svxerr.hxx"
  22 #include "fmpgeimp.hxx"
  23 #include "fmundo.hxx"
  24 #include "svx/fmtools.hxx"
  25 #include "fmprop.hrc"
  26 #include "fmservs.hxx"
  27 #include "fmobj.hxx"
  28 #include "formcontrolfactory.hxx"
  29 #include "svx/svditer.hxx"
  30 #include "svx/fmresids.hrc"
  31 #include "svx/dbtoolsclient.hxx"
  32 #include "treevisitor.hxx"
  33
  34 #include <com/sun/star/sdb/CommandType.hpp>
  35 #include <com/sun/star/util/XCloneable.hpp>
  36 #include <com/sun/star/container/EnumerableMap.hpp>
  37 #include <com/sun/star/drawing/XControlShape.hpp>
  38 #include <com/sun/star/form/Forms.hpp>
  39
  40 #include <sfx2/objsh.hxx>
  41 #include <svx/fmglob.hxx>
  42 #include <svx/fmpage.hxx>
  43 #include <svx/fmmodel.hxx>
  44 #include <tools/resid.hxx>
  45 #include <tools/diagnose_ex.h>
  46 #include <tools/shl.hxx>
  47 #include <vcl/stdtext.hxx>
  48 #include <svx/dialmgr.hxx>
  49 #include <comphelper/processfactory.hxx>
  50 #include <comphelper/uno3.hxx>
  51 #include <comphelper/types.hxx>
  52 #include <unotools/streamwrap.hxx>
  53 #include <rtl/logfile.hxx>
  54
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::com::sun::star::lang;
  57 using namespace ::com::sun::star::sdbc;
  58 using namespace ::com::sun::star::sdb;
  59 using namespace ::com::sun::star::container;
  60 using namespace ::com::sun::star::beans;
  61 using namespace ::com::sun::star::form;
  62 using ::com::sun::star::util::XCloneable;
  63 using ::com::sun::star::awt::XControlModel;
  64 using ::com::sun::star::container::XMap;
  65 using ::com::sun::star::container::EnumerableMap;
  66 using ::com::sun::star::drawing::XControlShape;
  67 using namespace ::svxform;
  68
  69 DBG_NAME(FmFormPageImpl)
  70 //------------------------------------------------------------------------------
  71 FmFormPageImpl::FmFormPageImpl( FmFormPage& _rPage )
  72                :m_rPage( _rPage )
  73                ,m_bFirstActivation( sal_True )
  74                ,m_bAttemptedFormCreation( false )
  75                ,m_bInFind( false )
  76 {
  77     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::FmFormPageImpl" );
  78     DBG_CTOR(FmFormPageImpl,NULL);
  79 }
  80
  81 //------------------------------------------------------------------------------
  82 namespace
  83 {
  84     typedef Reference< XInterface > FormComponent;
  85
  86     class FormComponentInfo
  87     {
  88     public:
  89         size_t childCount( const FormComponent& _component ) const
  90         {
  91             Reference< XIndexAccess > xContainer( _component, UNO_QUERY );
  92             if ( xContainer.is() )
  93                 return xContainer->getCount();
  94             return 0;
  95         }
  96
  97         FormComponent getChild( const FormComponent& _component, size_t _index ) const
  98         {
  99             Reference< XIndexAccess > xContainer( _component, UNO_QUERY_THROW );
 100             return FormComponent( xContainer->getByIndex( _index ), UNO_QUERY );
 101         }
 102     };
 103
 104     typedef ::std::pair< FormComponent, FormComponent > FormComponentPair;
 105
 106     class FormHierarchyComparator
 107     {
 108     public:
 109         FormHierarchyComparator()
 110         {
 111         }
 112
 113         size_t childCount( const FormComponentPair& _components ) const
 114         {
 115             size_t lhsCount = m_aComponentInfo.childCount( _components.first );
 116             size_t rhsCount = m_aComponentInfo.childCount( _components.second );
 117             if  ( lhsCount != rhsCount )
 118                 throw RuntimeException( OUString( "Found inconsistent form component hierarchies (1)!" ), NULL );
 119             return lhsCount;
 120         }
 121
 122         FormComponentPair getChild( const FormComponentPair& _components, size_t _index ) const
 123         {
 124             return FormComponentPair(
 125                 m_aComponentInfo.getChild( _components.first, _index ),
 126                 m_aComponentInfo.getChild( _components.second, _index )
 127             );
 128         }
 129     private:
 130         FormComponentInfo   m_aComponentInfo;
 131     };
 132
 133     typedef ::std::map< Reference< XControlModel >, Reference< XControlModel >, ::comphelper::OInterfaceCompare< XControlModel > > MapControlModels;
 134
 135     class FormComponentAssignment
 136     {
 137     public:
 138         FormComponentAssignment( MapControlModels& _out_controlModelMap )
 139             :m_rControlModelMap( _out_controlModelMap )
 140         {
 141         }
 142
 143         void    process( const FormComponentPair& _component )
 144         {
 145             Reference< XControlModel > lhsControlModel( _component.first, UNO_QUERY );
 146             Reference< XControlModel > rhsControlModel( _component.second, UNO_QUERY );
 147             if ( lhsControlModel.is() != rhsControlModel.is() )
 148                 throw RuntimeException( OUString( "Found inconsistent form component hierarchies (2)!" ), NULL );
 149
 150             if ( lhsControlModel.is() )
 151                 m_rControlModelMap[ lhsControlModel ] = rhsControlModel;
 152         }
 153
 154     private:
 155         MapControlModels&   m_rControlModelMap;
 156     };
 157 }
 158
 159 //------------------------------------------------------------------------------
 160 void FmFormPageImpl::initFrom( FmFormPageImpl& i_foreignImpl )
 161 {
 162     // clone the Forms collection
 163     const Reference< css::form::XForms > xForeignForms( const_cast< FmFormPageImpl& >( i_foreignImpl ).getForms( false ) );
 164
 165     if ( !xForeignForms.is() )
 166         return;
 167
 168     try
 169     {
 170         m_xForms.set( xForeignForms->createClone(), UNO_QUERY_THROW );
 171
 172         // create a mapping between the original control models and their clones
 173         MapControlModels aModelAssignment;
 174
 175         typedef TreeVisitor< FormComponentPair, FormHierarchyComparator, FormComponentAssignment >   FormComponentVisitor;
 176         FormComponentVisitor aVisitor = FormComponentVisitor( FormHierarchyComparator() );
 177
 178         FormComponentAssignment aAssignmentProcessor( aModelAssignment );
 179         aVisitor.process( FormComponentPair( xForeignForms, m_xForms ), aAssignmentProcessor );
 180
 181         // assign the cloned models to their SdrObjects
 182         SdrObjListIter aForeignIter( i_foreignImpl.m_rPage );
 183         SdrObjListIter aOwnIter( m_rPage );
 184
 185         OSL_ENSURE( aForeignIter.IsMore() == aOwnIter.IsMore(), "FmFormPageImpl::FmFormPageImpl: inconsistent number of objects (1)!" );
 186         while ( aForeignIter.IsMore() && aOwnIter.IsMore() )
 187         {
 188             FmFormObj* pForeignObj = dynamic_cast< FmFormObj* >( aForeignIter.Next() );
 189             FmFormObj* pOwnObj = dynamic_cast< FmFormObj* >( aOwnIter.Next() );
 190
 191             bool bForeignIsForm = pForeignObj && ( pForeignObj->GetObjInventor() == FmFormInventor );
 192             bool bOwnIsForm = pOwnObj && ( pOwnObj->GetObjInventor() == FmFormInventor );
 193
 194             if ( bForeignIsForm != bOwnIsForm )
 195             {
 196                 // if this fires, don't attempt to do further assignments, something's completely messed up
 197                 SAL_WARN( "svx.form", "FmFormPageImpl::FmFormPageImpl: inconsistent ordering of objects!" );
 198                 break;
 199             }
 200
 201             if ( !bForeignIsForm )
 202                 // no form control -> next round
 203                 continue;
 204
 205             Reference< XControlModel > xForeignModel( pForeignObj->GetUnoControlModel() );
 206             if ( !xForeignModel.is() )
 207             {
 208                 // if this fires, the SdrObject does not have a UNO Control Model. This is pathological, but well ...
 209                 // So the cloned SdrObject will also not have a UNO Control Model.
 210                 SAL_WARN( "svx.form", "FmFormPageImpl::FmFormPageImpl: control shape without control!" );
 211                 continue;
 212             }
 213
 214             MapControlModels::const_iterator assignment = aModelAssignment.find( xForeignModel );
 215             if ( assignment == aModelAssignment.end() )
 216             {
 217                 // if this fires, the source SdrObject has a model, but it is not part of the model hierarchy in
 218                 // i_foreignImpl.getForms().
 219                 // Pathological, too ...
 220                 SAL_WARN( "svx.form", "FmFormPageImpl::FmFormPageImpl: no clone found for this model!" );
 221                 continue;
 222             }
 223
 224             pOwnObj->SetUnoControlModel( assignment->second );
 225         }
 226         OSL_ENSURE( aForeignIter.IsMore() == aOwnIter.IsMore(), "FmFormPageImpl::FmFormPageImpl: inconsistent number of objects (2)!" );
 227     }
 228     catch( const Exception& )
 229     {
 230         DBG_UNHANDLED_EXCEPTION();
 231     }
 232 }
 233
 234 //------------------------------------------------------------------------------
 235 Reference< XMap > FmFormPageImpl::getControlToShapeMap()
 236 {
 237     Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY );
 238     if ( xControlShapeMap.is() )
 239         return xControlShapeMap;
 240
 241     xControlShapeMap = impl_createControlShapeMap_nothrow();
 242     m_aControlShapeMap = xControlShapeMap;
 243     return xControlShapeMap;
 244 }
 245
 246 //------------------------------------------------------------------------------
 247 namespace
 248 {
 249     static void lcl_insertFormObject_throw( const FmFormObj& _object, const Reference< XMap >& _map )
 250     {
 251         // the control model
 252         Reference< XControlModel > xControlModel( _object.GetUnoControlModel(), UNO_QUERY );
 253         OSL_ENSURE( xControlModel.is(), "lcl_insertFormObject_throw: suspicious: no control model!" );
 254         if ( !xControlModel.is() )
 255             return;
 256
 257         Reference< XControlShape > xControlShape( const_cast< FmFormObj& >( _object ).getUnoShape(), UNO_QUERY );
 258         OSL_ENSURE( xControlShape.is(), "lcl_insertFormObject_throw: suspicious: no control shape!" );
 259         if ( !xControlShape.is() )
 260             return;
 261
 262         _map->put( makeAny( xControlModel ), makeAny( xControlShape ) );
 263     }
 264
 265     static void lcl_removeFormObject_throw( const FmFormObj& _object, const Reference< XMap >& _map, bool i_ignoreNonExistence = false )
 266     {
 267         // the control model
 268         Reference< XControlModel > xControlModel( _object.GetUnoControlModel(), UNO_QUERY );
 269         OSL_ENSURE( xControlModel.is(), "lcl_removeFormObject: suspicious: no control model!" );
 270         if ( !xControlModel.is() )
 271             return;
 272
 273     #if OSL_DEBUG_LEVEL > 0
 274         Any aOldAssignment =
 275     #endif
 276             _map->remove( makeAny( xControlModel ) );
 277     #if OSL_DEBUG_LEVEL > 0
 278         (void)aOldAssignment;
 279     #endif
 280         OSL_ENSURE( !i_ignoreNonExistence ||
 281             ( aOldAssignment == makeAny( Reference< XControlShape >( const_cast< FmFormObj& >( _object ).getUnoShape(), UNO_QUERY ) ) ),
 282                 "lcl_removeFormObject: map was inconsistent!" );
 283         (void)i_ignoreNonExistence;
 284     }
 285 }
 286
 287 //------------------------------------------------------------------------------
 288 Reference< XMap > FmFormPageImpl::impl_createControlShapeMap_nothrow()
 289 {
 290     Reference< XMap > xMap;
 291
 292     try
 293     {
 294         xMap.set( EnumerableMap::create( comphelper::getProcessComponentContext(),
 295             ::cppu::UnoType< XControlModel >::get(),
 296             ::cppu::UnoType< XControlShape >::get()
 297         ).get(), UNO_SET_THROW );
 298
 299         SdrObjListIter aPageIter( m_rPage );
 300         while ( aPageIter.IsMore() )
 301         {
 302             // only FmFormObjs are what we're interested in
 303             FmFormObj* pCurrent = FmFormObj::GetFormObject( aPageIter.Next() );
 304             if ( !pCurrent )
 305                 continue;
 306
 307             lcl_insertFormObject_throw( *pCurrent, xMap );
 308         }
 309     }
 310     catch( const Exception& )
 311     {
 312         DBG_UNHANDLED_EXCEPTION();
 313     }
 314     return xMap;
 315 }
 316
 317 //------------------------------------------------------------------------------
 318 const Reference< css::form::XForms >& FmFormPageImpl::getForms( bool _bForceCreate )
 319 {
 320     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::getForms" );
 321     if ( m_xForms.is() || !_bForceCreate )
 322         return m_xForms;
 323
 324     if ( !m_bAttemptedFormCreation )
 325     {
 326         m_bAttemptedFormCreation = true;
 327
 328         Reference<XComponentContext> xContext = comphelper::getProcessComponentContext();
 329         m_xForms = css::form::Forms::create( xContext );
 330
 331         if ( m_aFormsCreationHdl.IsSet() )
 332         {
 333             m_aFormsCreationHdl.Call( this );
 334         }
 335
 336         FmFormModel* pFormsModel = PTR_CAST( FmFormModel, m_rPage.GetModel() );
 337
 338         // give the newly created collection a place in the universe
 339         SfxObjectShell* pObjShell = pFormsModel ? pFormsModel->GetObjectShell() : NULL;
 340         if ( pObjShell )
 341             m_xForms->setParent( pObjShell->GetModel() );
 342
 343         // tell the UNDO environment that we have a new forms collection
 344         if ( pFormsModel )
 345             pFormsModel->GetUndoEnv().AddForms( Reference<XNameContainer>(m_xForms,UNO_QUERY_THROW) );
 346     }
 347     return m_xForms;
 348 }
 349
 350 //------------------------------------------------------------------------------
 351 FmFormPageImpl::~FmFormPageImpl()
 352 {
 353     xCurrentForm = NULL;
 354
 355     ::comphelper::disposeComponent( m_xForms );
 356     DBG_DTOR(FmFormPageImpl,NULL);
 357 }
 358
 359 //------------------------------------------------------------------------------
 360 bool FmFormPageImpl::validateCurForm()
 361 {
 362     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::validateCurForm" );
 363     if ( !xCurrentForm.is() )
 364         return false;
 365
 366     Reference< XChild > xAsChild( xCurrentForm, UNO_QUERY );
 367     DBG_ASSERT( xAsChild.is(), "FmFormPageImpl::validateCurForm: a form which is no child??" );
 368     if ( !xAsChild.is() || !xAsChild->getParent().is() )
 369         xCurrentForm.clear();
 370
 371     return xCurrentForm.is();
 372 }
 373
 374 //------------------------------------------------------------------------------
 375 void FmFormPageImpl::setCurForm(Reference< ::com::sun::star::form::XForm >  xForm)
 376 {
 377     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::setCurForm" );
 378     xCurrentForm = xForm;
 379 }
 380
 381 //------------------------------------------------------------------------------
 382 Reference< XForm >  FmFormPageImpl::getDefaultForm()
 383 {
 384     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::getDefaultForm" );
 385     Reference< XForm > xForm;
 386
 387     Reference< XForms > xForms( getForms() );
 388
 389     // by default, we use our "current form"
 390     if ( !validateCurForm() )
 391     {
 392         // check whether there is a "standard" form
 393         if ( Reference<XNameAccess>(xForms,UNO_QUERY_THROW)->hasElements() )
 394         {
 395             // suche die Standardform
 396             OUString sStandardFormname = String( SVX_RES( RID_STR_STDFORMNAME ) );
 397
 398             try
 399             {
 400                 if ( xForms->hasByName( sStandardFormname ) )
 401                     xForm.set( xForms->getByName( sStandardFormname ), UNO_QUERY_THROW );
 402                 else
 403                 {
 404                     xForm.set( xForms->getByIndex(0), UNO_QUERY_THROW );
 405                 }
 406             }
 407             catch( const Exception& )
 408             {
 409                 DBG_UNHANDLED_EXCEPTION();
 410             }
 411         }
 412     }
 413     else
 414     {
 415         xForm = xCurrentForm;
 416     }
 417
 418     // did not find an existing suitable form -> create a new one
 419     if ( !xForm.is() )
 420     {
 421         SdrModel* pModel = m_rPage.GetModel();
 422
 423         if( pModel->IsUndoEnabled() )
 424         {
 425             XubString aStr(SVX_RES(RID_STR_FORM));
 426             XubString aUndoStr(SVX_RES(RID_STR_UNDO_CONTAINER_INSERT));
 427             aUndoStr.SearchAndReplace(OUString('#'), aStr);
 428             pModel->BegUndo(aUndoStr);
 429         }
 430
 431         try
 432         {
 433             xForm.set( ::comphelper::getProcessServiceFactory()->createInstance( FM_SUN_COMPONENT_FORM ), UNO_QUERY );
 434
 435             // a form should always have the command type table as default
 436             Reference< XPropertySet > xFormProps( xForm, UNO_QUERY_THROW );
 437             xFormProps->setPropertyValue( FM_PROP_COMMANDTYPE, makeAny( sal_Int32( CommandType::TABLE ) ) );
 438
 439             // and the "Standard" name
 440             OUString sName = String( SVX_RES( RID_STR_STDFORMNAME ) );
 441             xFormProps->setPropertyValue( FM_PROP_NAME, makeAny( sName ) );
 442
 443             Reference< XIndexContainer > xContainer( xForms, UNO_QUERY );
 444             if( pModel->IsUndoEnabled() )
 445             {
 446                 pModel->AddUndo(new FmUndoContainerAction(*(FmFormModel*)pModel,
 447                                                            FmUndoContainerAction::Inserted,
 448                                                            xContainer,
 449                                                            xForm,
 450                                                            xContainer->getCount()));
 451             }
 452             xForms->insertByName( sName, makeAny( xForm ) );
 453             xCurrentForm = xForm;
 454         }
 455         catch( const Exception& )
 456         {
 457             DBG_UNHANDLED_EXCEPTION();
 458             xForm.clear();
 459         }
 460
 461         if( pModel->IsUndoEnabled() )
 462             pModel->EndUndo();
 463     }
 464
 465     return xForm;
 466 }
 467
 468 //------------------------------------------------------------------------------
 469 Reference< ::com::sun::star::form::XForm >  FmFormPageImpl::findPlaceInFormComponentHierarchy(
 470     const Reference< XFormComponent > & rContent, const Reference< XDataSource > & rDatabase,
 471     const OUString& rDBTitle, const OUString& rCursorSource, sal_Int32 nCommandType )
 472 {
 473     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::findPlaceInFormComponentHierarchy" );
 474     // if the control already is child of a form, don't do anything
 475     if (!rContent.is() || rContent->getParent().is())
 476         return NULL;
 477
 478     Reference< XForm >  xForm;
 479
 480     // Wenn Datenbank und CursorSource gesetzt sind, dann wird
 481     // die Form anhand dieser Kriterien gesucht, ansonsten nur aktuelle
 482     // und die StandardForm
 483     if (rDatabase.is() && !rCursorSource.isEmpty())
 484     {
 485         validateCurForm();
 486
 487         // erst in der aktuellen form suchen
 488         xForm = findFormForDataSource( xCurrentForm, rDatabase, rCursorSource, nCommandType );
 489
 490         Reference< ::com::sun::star::container::XIndexAccess >  xFormsByIndex( getForms(), UNO_QUERY );
 491         DBG_ASSERT(xFormsByIndex.is(), "FmFormPageImpl::findPlaceInFormComponentHierarchy : no index access for my forms collection !");
 492         sal_Int32 nCount = xFormsByIndex->getCount();
 493         for (sal_Int32 i = 0; !xForm.is() && i < nCount; i++)
 494         {
 495             Reference< ::com::sun::star::form::XForm >  xToSearch;
 496             xFormsByIndex->getByIndex(i) >>= xToSearch;
 497             xForm = findFormForDataSource( xToSearch, rDatabase, rCursorSource, nCommandType );
 498         }
 499
 500         // wenn keine ::com::sun::star::form gefunden, dann eine neue erzeugen
 501         if (!xForm.is())
 502         {
 503             SdrModel* pModel = m_rPage.GetModel();
 504
 505             const bool bUndo = pModel->IsUndoEnabled();
 506
 507             if( bUndo )
 508             {
 509                 XubString aStr(SVX_RES(RID_STR_FORM));
 510                 XubString aUndoStr(SVX_RES(RID_STR_UNDO_CONTAINER_INSERT));
 511                 aUndoStr.SearchAndReplace(OUString('#'), aStr);
 512                 pModel->BegUndo(aUndoStr);
 513             }
 514
 515             xForm = Reference< ::com::sun::star::form::XForm >(::comphelper::getProcessServiceFactory()->createInstance(FM_SUN_COMPONENT_FORM), UNO_QUERY);
 516             // a form should always have the command type table as default
 517             Reference< ::com::sun::star::beans::XPropertySet > xFormProps(xForm, UNO_QUERY);
 518             try { xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, makeAny(sal_Int32(CommandType::TABLE))); }
 519             catch(Exception&) { }
 520
 521             if (!rDBTitle.isEmpty())
 522                 xFormProps->setPropertyValue(FM_PROP_DATASOURCE,makeAny(rDBTitle));
 523             else
 524             {
 525                 Reference< ::com::sun::star::beans::XPropertySet >  xDatabaseProps(rDatabase, UNO_QUERY);
 526                 Any aDatabaseUrl = xDatabaseProps->getPropertyValue(FM_PROP_URL);
 527                 xFormProps->setPropertyValue(FM_PROP_DATASOURCE, aDatabaseUrl);
 528             }
 529
 530             xFormProps->setPropertyValue(FM_PROP_COMMAND,makeAny(rCursorSource));
 531             xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, makeAny(nCommandType));
 532
 533             Reference< ::com::sun::star::container::XNameAccess >  xNamedSet( getForms(), UNO_QUERY );
 534
 535             const bool bTableOrQuery = ( CommandType::TABLE == nCommandType ) || ( CommandType::QUERY == nCommandType );
 536             OUString sName = FormControlFactory::getUniqueName( xNamedSet,
 537                 bTableOrQuery ? rCursorSource : OUString( String( SVX_RES( RID_STR_STDFORMNAME ) ) ) );
 538
 539             xFormProps->setPropertyValue( FM_PROP_NAME, makeAny( sName ) );
 540
 541             if( bUndo )
 542             {
 543                 Reference< ::com::sun::star::container::XIndexContainer >  xContainer( getForms(), UNO_QUERY );
 544                 pModel->AddUndo(new FmUndoContainerAction(*(FmFormModel*)pModel,
 545                                                          FmUndoContainerAction::Inserted,
 546                                                          xContainer,
 547                                                          xForm,
 548                                                          xContainer->getCount()));
 549             }
 550
 551             getForms()->insertByName( sName, makeAny( xForm ) );
 552
 553             if( bUndo )
 554                 pModel->EndUndo();
 555         }
 556         xCurrentForm = xForm;
 557     }
 558
 559     xForm = getDefaultForm();
 560     return xForm;
 561 }
 562
 563 //------------------------------------------------------------------------------
 564 Reference< XForm >  FmFormPageImpl::findFormForDataSource(
 565         const Reference< XForm > & rForm, const Reference< XDataSource > & _rxDatabase,
 566         const OUString& _rCursorSource, sal_Int32 nCommandType)
 567 {
 568     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmFormPageImpl::findFormForDataSource" );
 569     Reference< XForm >          xResultForm;
 570     Reference< XRowSet >        xDBForm(rForm, UNO_QUERY);
 571     Reference< XPropertySet >   xFormProps(rForm, UNO_QUERY);
 572     if (!xDBForm.is() || !xFormProps.is())
 573         return xResultForm;
 574
 575     OSL_ENSURE(_rxDatabase.is(), "FmFormPageImpl::findFormForDataSource: invalid data source!");
 576     OUString sLookupName;            // the name of the data source we're looking for
 577     OUString sFormDataSourceName;    // the name of the data source the current connection in the form is based on
 578     try
 579     {
 580         Reference< XPropertySet > xDSProps(_rxDatabase, UNO_QUERY);
 581         if (xDSProps.is())
 582             xDSProps->getPropertyValue(FM_PROP_NAME) >>= sLookupName;
 583
 584         xFormProps->getPropertyValue(FM_PROP_DATASOURCE) >>= sFormDataSourceName;
 585         // if there's no DataSourceName set at the form, check whether we can deduce one from its
 586         // ActiveConnection
 587         if (sFormDataSourceName.isEmpty())
 588         {
 589             Reference< XConnection > xFormConnection;
 590             xFormProps->getPropertyValue( FM_PROP_ACTIVE_CONNECTION ) >>= xFormConnection;
 591             if ( !xFormConnection.is() )
 592                 OStaticDataAccessTools().isEmbeddedInDatabase( xFormProps, xFormConnection );
 593             if (xFormConnection.is())
 594             {
 595                 Reference< XChild > xConnAsChild(xFormConnection, UNO_QUERY);
 596                 if (xConnAsChild.is())
 597                 {
 598                     Reference< XDataSource > xFormDS(xConnAsChild->getParent(), UNO_QUERY);
 599                     if (xFormDS.is())
 600                     {
 601                         xDSProps = xDSProps.query(xFormDS);
 602                         if (xDSProps.is())
 603                             xDSProps->getPropertyValue(FM_PROP_NAME) >>= sFormDataSourceName;
 604                     }
 605                 }
 606             }
 607         }
 608     }
 609     catch(const Exception& e)
 610     {
 611         (void)e;
 612         OSL_FAIL("FmFormPageImpl::findFormForDataSource: caught an exception!");
 613     }
 614
 615     if (sLookupName == sFormDataSourceName)
 616     {
 617         // jetzt noch ueberpruefen ob CursorSource und Type uebereinstimmen
 618         OUString aCursorSource = ::comphelper::getString(xFormProps->getPropertyValue(FM_PROP_COMMAND));
 619         sal_Int32 nType = ::comphelper::getINT32(xFormProps->getPropertyValue(FM_PROP_COMMANDTYPE));
 620         if (aCursorSource.isEmpty() || ((nType == nCommandType) && (aCursorSource == _rCursorSource))) // found the form
 621         {
 622             xResultForm = rForm;
 623             // Ist noch keine Datenquelle gesetzt, wird dieses hier nachgeholt
 624             if (aCursorSource.isEmpty())
 625             {
 626                 xFormProps->setPropertyValue(FM_PROP_COMMAND, makeAny(_rCursorSource));
 627                 xFormProps->setPropertyValue(FM_PROP_COMMANDTYPE, makeAny((sal_Int32)nCommandType));
 628             }
 629         }
 630     }
 631
 632     // as long as xResultForm is NULL, search the child forms of rForm
 633     Reference< XIndexAccess >  xComponents(rForm, UNO_QUERY);
 634     sal_Int32 nCount = xComponents->getCount();
 635     for (sal_Int32 i = 0; !xResultForm.is() && i < nCount; ++i)
 636     {
 637         Reference< ::com::sun::star::form::XForm >  xSearchForm;
 638         xComponents->getByIndex(i) >>= xSearchForm;
 639         // continue searching in the sub form
 640         if (xSearchForm.is())
 641             xResultForm = findFormForDataSource( xSearchForm, _rxDatabase, _rCursorSource, nCommandType );
 642     }
 643     return xResultForm;
 644 }
 645
 646 //------------------------------------------------------------------------------
 647 OUString FmFormPageImpl::setUniqueName(const Reference< XFormComponent > & xFormComponent, const Reference< XForm > & xControls)
 648 {
 649 #if OSL_DEBUG_LEVEL > 0
 650     try
 651     {
 652         Reference< XChild > xChild( xFormComponent, UNO_QUERY_THROW );
 653         OSL_ENSURE( !xChild->getParent().is(), "FmFormPageImpl::setUniqueName: to be called before insertion!" );
 654     }
 655     catch( const Exception& )
 656     {
 657         DBG_UNHANDLED_EXCEPTION();
 658     }
 659 #endif
 660     OUString sName;
 661     Reference< ::com::sun::star::beans::XPropertySet >  xSet(xFormComponent, UNO_QUERY);
 662     if (xSet.is())
 663     {
 664         sName = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_NAME ) );
 665         Reference< ::com::sun::star::container::XNameAccess >  xNameAcc(xControls, UNO_QUERY);
 666
 667         if (sName.isEmpty() || xNameAcc->hasByName(sName))
 668         {
 669             // setzen eines default Namens ueber die ClassId
 670             sal_Int16 nClassId( FormComponentType::CONTROL );
 671             xSet->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId;
 672
 673             OUString sDefaultName = FormControlFactory::getDefaultUniqueName_ByComponentType(
 674                 Reference< XNameAccess >( xControls, UNO_QUERY ), xSet );
 675
 676             // bei Radiobuttons, die einen Namen haben, diesen nicht ueberschreiben!
 677             if (sName.isEmpty() || nClassId != ::com::sun::star::form::FormComponentType::RADIOBUTTON)
 678             {
 679                 xSet->setPropertyValue(FM_PROP_NAME, makeAny(sDefaultName));
 680             }
 681
 682             sName = sDefaultName;
 683         }
 684     }
 685     return sName;
 686 }
 687
 688 //----------------------------------------------------------------------------------------------------------------------
 689 void FmFormPageImpl::formModelAssigned( const FmFormObj& _object )
 690 {
 691     Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY );
 692     if ( !xControlShapeMap.is() )
 693         // our map does not exist -> not interested in this event
 694         return;
 695
 696     try
 697     {
 698         lcl_removeFormObject_throw( _object,  xControlShapeMap, false );
 699         lcl_insertFormObject_throw( _object,  xControlShapeMap );
 700     }
 701     catch( const Exception& )
 702     {
 703         DBG_UNHANDLED_EXCEPTION();
 704     }
 705 }
 706
 707 //----------------------------------------------------------------------------------------------------------------------
 708 void FmFormPageImpl::formObjectInserted( const FmFormObj& _object )
 709 {
 710     Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY );
 711     if ( !xControlShapeMap.is() )
 712         // our map does not exist -> not interested in this event
 713         return;
 714
 715     try
 716     {
 717         lcl_insertFormObject_throw( _object,  xControlShapeMap );
 718     }
 719     catch( const Exception& )
 720     {
 721         DBG_UNHANDLED_EXCEPTION();
 722     }
 723 }
 724
 725 //----------------------------------------------------------------------------------------------------------------------
 726 void FmFormPageImpl::formObjectRemoved( const FmFormObj& _object )
 727 {
 728     Reference< XMap > xControlShapeMap( m_aControlShapeMap.get(), UNO_QUERY );
 729     if ( !xControlShapeMap.is() )
 730         // our map does not exist -> not interested in this event
 731         return;
 732
 733     try
 734     {
 735         lcl_removeFormObject_throw( _object, xControlShapeMap );
 736     }
 737     catch( const Exception& )
 738     {
 739         DBG_UNHANDLED_EXCEPTION();
 740     }
 741 }
 742
 743 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */