svx/source/form/fmundo.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 <sal/macros.h>
  22 #include "fmundo.hxx"
  23 #include "fmpgeimp.hxx"
  24 #include "svx/dbtoolsclient.hxx"
  25 #include "svx/svditer.hxx"
  26 #include "fmobj.hxx"
  27 #include "fmprop.hrc"
  28 #include "svx/fmresids.hrc"
  29 #include "svx/fmglob.hxx"
  30 #include "svx/dialmgr.hxx"
  31 #include "svx/fmmodel.hxx"
  32 #include "svx/fmpage.hxx"
  33
  34 #include <com/sun/star/util/XModifyBroadcaster.hpp>
  35 #include <com/sun/star/beans/PropertyAttribute.hpp>
  36 #include <com/sun/star/container/XContainer.hpp>
  37 #include <com/sun/star/container/XContainerListener.hpp>
  38 #include <com/sun/star/script/XEventAttacherManager.hpp>
  39 #include <com/sun/star/form/binding/XBindableValue.hpp>
  40 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  41 #include <com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp>
  42
  43 #include "svx/fmtools.hxx"
  44 #include <rtl/logfile.hxx>
  45 #include <svl/macitem.hxx>
  46 #include <tools/shl.hxx>
  47 #include <tools/diagnose_ex.h>
  48 #include <sfx2/objsh.hxx>
  49 #include <sfx2/docfile.hxx>
  50 #include <sfx2/app.hxx>
  51 #include <sfx2/sfx.hrc>
  52 #include <sfx2/event.hxx>
  53 #include <osl/mutex.hxx>
  54 #include <comphelper/property.hxx>
  55 #include <comphelper/uno3.hxx>
  56 #include <comphelper/stl_types.hxx>
  57 #include <comphelper/componentcontext.hxx>
  58
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star::awt;
  61 using namespace ::com::sun::star::beans;
  62 using namespace ::com::sun::star::container;
  63 using namespace ::com::sun::star::script;
  64 using namespace ::com::sun::star::lang;
  65 using namespace ::com::sun::star::form;
  66 using namespace ::com::sun::star::util;
  67 using namespace ::com::sun::star::reflection;
  68 using namespace ::com::sun::star::form::binding;
  69 using namespace ::svxform;
  70
  71
  72 #include <com/sun/star/script/XScriptListener.hpp>
  73 #include <comphelper/processfactory.hxx>
  74 #include <cppuhelper/implbase1.hxx>
  75
  76 typedef cppu::WeakImplHelper1< XScriptListener > ScriptEventListener_BASE;
  77 class ScriptEventListenerWrapper : public ScriptEventListener_BASE
  78 {
  79 public:
  80     ScriptEventListenerWrapper( FmFormModel& _rModel) throw ( RuntimeException )
  81         :m_rModel( _rModel )
  82         ,m_attemptedListenerCreation( false )
  83     {
  84
  85     }
  86     // XEventListener
  87     virtual void SAL_CALL disposing(const EventObject& ) throw( RuntimeException ){}
  88
  89     // XScriptListener
  90     virtual void SAL_CALL firing(const  ScriptEvent& evt) throw(RuntimeException)
  91     {
  92         attemptListenerCreation();
  93         if ( m_vbaListener.is() )
  94         {
  95             m_vbaListener->firing( evt );
  96         }
  97     }
  98
  99     virtual Any SAL_CALL approveFiring(const ScriptEvent& evt) throw( com::sun::star::reflection::InvocationTargetException, RuntimeException)
 100     {
 101         attemptListenerCreation();
 102         if ( m_vbaListener.is() )
 103         {
 104             return m_vbaListener->approveFiring( evt );
 105         }
 106         return Any();
 107     }
 108
 109 private:
 110     void attemptListenerCreation()
 111     {
 112         if ( m_attemptedListenerCreation )
 113             return;
 114         m_attemptedListenerCreation = true;
 115
 116         try
 117         {
 118             ::comphelper::ComponentContext const aContext( ::comphelper::getProcessComponentContext() );
 119             Reference< XScriptListener > const xScriptListener( aContext.createComponent( "ooo.vba.EventListener" ), UNO_QUERY_THROW );
 120             Reference< XPropertySet > const xListenerProps( xScriptListener, UNO_QUERY_THROW );
 121             // SfxObjectShellRef is good here since the model controls the lifetime of the shell
 122             SfxObjectShellRef const xObjectShell = m_rModel.GetObjectShell();
 123             ENSURE_OR_THROW( xObjectShell.Is(), "no object shell!" );
 124             xListenerProps->setPropertyValue( OUString( "Model" ), makeAny( xObjectShell->GetModel() ) );
 125
 126             m_vbaListener = xScriptListener;
 127         }
 128         catch( Exception const & )
 129         {
 130             DBG_UNHANDLED_EXCEPTION();
 131         }
 132     }
 133     FmFormModel&                    m_rModel;
 134     Reference< XScriptListener >    m_vbaListener;
 135     bool                            m_attemptedListenerCreation;
 136
 137
 138 };
 139
 140 //------------------------------------------------------------------------------
 141 // some helper structs for caching property infos
 142 //------------------------------------------------------------------------------
 143 struct PropertyInfo
 144 {
 145     sal_Bool    bIsTransientOrReadOnly  : 1;    // the property is transient or read-only, thus we need no undo action for it
 146     sal_Bool    bIsValueProperty        : 1;    // the property is the special value property, thus it may be handled
 147                                             // as if it's transient or persistent
 148 };
 149
 150 struct PropertySetInfo
 151 {
 152     DECLARE_STL_USTRINGACCESS_MAP(PropertyInfo, AllProperties);
 153
 154     AllProperties   aProps;                 // all properties of this set which we know so far
 155     sal_Bool            bHasEmptyControlSource; // sal_True -> the set has a DataField property, and the current value is an empty string
 156                                             // sal_False -> the set has _no_ such property or it's value isn't empty
 157 };
 158
 159 sal_Bool operator < (const Reference< XPropertySet >& lhs,
 160                  const Reference< XPropertySet >& rhs)
 161 {
 162     return lhs.get() < rhs.get();
 163 }
 164
 165 DECLARE_STL_STDKEY_MAP(Reference< XPropertySet >, PropertySetInfo, PropertySetInfoCache);
 166
 167 //------------------------------------------------------------------------------
 168
 169 String static_STR_UNDO_PROPERTY;
 170 //------------------------------------------------------------------------------
 171 DBG_NAME(FmXUndoEnvironment)
 172 //------------------------------------------------------------------------------
 173 FmXUndoEnvironment::FmXUndoEnvironment(FmFormModel& _rModel)
 174                    :rModel( _rModel )
 175                    ,m_pPropertySetCache( NULL )
 176                    ,m_pScriptingEnv( ::svxform::createDefaultFormScriptingEnvironment( _rModel ) )
 177                    ,m_Locks( 0 )
 178                    ,bReadOnly( sal_False )
 179                    ,m_bDisposed( false )
 180 {
 181     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::FmXUndoEnvironment" );
 182     DBG_CTOR(FmXUndoEnvironment,NULL);
 183     try
 184     {
 185         m_vbaListener =  new ScriptEventListenerWrapper( _rModel );
 186     }
 187     catch( Exception& )
 188     {
 189     }
 190 }
 191
 192 //------------------------------------------------------------------------------
 193 FmXUndoEnvironment::~FmXUndoEnvironment()
 194 {
 195     DBG_DTOR(FmXUndoEnvironment,NULL);
 196     if (m_pPropertySetCache)
 197         delete static_cast<PropertySetInfoCache*>(m_pPropertySetCache);
 198 }
 199
 200 //------------------------------------------------------------------------------
 201 void FmXUndoEnvironment::dispose()
 202 {
 203     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::dispose" );
 204     OSL_ENSURE( !m_bDisposed, "FmXUndoEnvironment::dispose: disposed twice?" );
 205     if ( !m_bDisposed )
 206         return;
 207
 208     Lock();
 209
 210     sal_uInt16 nCount = rModel.GetPageCount();
 211     sal_uInt16 i;
 212     for (i = 0; i < nCount; i++)
 213     {
 214         FmFormPage* pPage = PTR_CAST( FmFormPage, rModel.GetPage(i) );
 215         if ( pPage )
 216         {
 217             Reference< css::form::XForms > xForms = pPage->GetForms( false ).get();
 218             if ( xForms.is() )
 219                 RemoveElement( xForms );
 220         }
 221     }
 222
 223     nCount = rModel.GetMasterPageCount();
 224     for (i = 0; i < nCount; i++)
 225     {
 226         FmFormPage* pPage = PTR_CAST( FmFormPage, rModel.GetMasterPage(i) );
 227         if ( pPage )
 228         {
 229             Reference< css::form::XForms > xForms = pPage->GetForms( false ).get();
 230             if ( xForms.is() )
 231                 RemoveElement( xForms );
 232         }
 233     }
 234
 235     UnLock();
 236
 237     OSL_PRECOND( rModel.GetObjectShell(), "FmXUndoEnvironment::dispose: no object shell anymore!" );
 238     if ( rModel.GetObjectShell() )
 239         EndListening( *rModel.GetObjectShell() );
 240
 241     if ( IsListening( rModel ) )
 242         EndListening( rModel );
 243
 244     m_pScriptingEnv->dispose();
 245
 246     m_bDisposed = true;
 247 }
 248
 249 //------------------------------------------------------------------------------
 250 void FmXUndoEnvironment::ModeChanged()
 251 {
 252     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::ModeChanged" );
 253     OSL_PRECOND( rModel.GetObjectShell(), "FmXUndoEnvironment::ModeChanged: no object shell anymore!" );
 254     if ( !rModel.GetObjectShell() )
 255         return;
 256
 257     if (bReadOnly != (rModel.GetObjectShell()->IsReadOnly() || rModel.GetObjectShell()->IsReadOnlyUI()))
 258     {
 259         bReadOnly = !bReadOnly;
 260
 261         sal_uInt16 nCount = rModel.GetPageCount();
 262         sal_uInt16 i;
 263         for (i = 0; i < nCount; i++)
 264         {
 265             FmFormPage* pPage = PTR_CAST( FmFormPage, rModel.GetPage(i) );
 266             if ( pPage )
 267             {
 268                 Reference< css::form::XForms > xForms = pPage->GetForms( false ).get();
 269                 if ( xForms.is() )
 270                     TogglePropertyListening( xForms );
 271             }
 272         }
 273
 274         nCount = rModel.GetMasterPageCount();
 275         for (i = 0; i < nCount; i++)
 276         {
 277             FmFormPage* pPage = PTR_CAST( FmFormPage, rModel.GetMasterPage(i) );
 278             if ( pPage )
 279             {
 280                 Reference< css::form::XForms > xForms = pPage->GetForms( false ).get();
 281                 if ( xForms.is() )
 282                     TogglePropertyListening( xForms );
 283             }
 284         }
 285
 286         if (!bReadOnly)
 287             StartListening(rModel);
 288         else
 289             EndListening(rModel);
 290     }
 291 }
 292
 293 //------------------------------------------------------------------------------
 294 void FmXUndoEnvironment::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
 295 {
 296     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::Notify" );
 297     if (rHint.ISA(SdrHint))
 298     {
 299         SdrHint* pSdrHint = (SdrHint*)&rHint;
 300         switch( pSdrHint->GetKind() )
 301         {
 302             case HINT_OBJINSERTED:
 303             {
 304                 SdrObject* pSdrObj = (SdrObject*)pSdrHint->GetObject();
 305                 Inserted( pSdrObj );
 306             }   break;
 307             case HINT_OBJREMOVED:
 308             {
 309                 SdrObject* pSdrObj = (SdrObject*)pSdrHint->GetObject();
 310                 Removed( pSdrObj );
 311             }
 312             break;
 313             default:
 314                 break;
 315         }
 316     }
 317     else if (rHint.ISA(SfxSimpleHint))
 318     {
 319         switch ( ((SfxSimpleHint&)rHint).GetId() )
 320         {
 321             case SFX_HINT_DYING:
 322                 dispose();
 323                 rModel.SetObjectShell( NULL );
 324                 break;
 325             case SFX_HINT_MODECHANGED:
 326                 ModeChanged();
 327                 break;
 328         }
 329     }
 330     else if (rHint.ISA(SfxEventHint))
 331     {
 332         switch (((SfxEventHint&)rHint).GetEventId())
 333         {
 334         case SFX_EVENT_CREATEDOC:
 335             case SFX_EVENT_OPENDOC:
 336                 ModeChanged();
 337                 break;
 338         }
 339     }
 340
 341 }
 342
 343 //------------------------------------------------------------------
 344 void FmXUndoEnvironment::Inserted(SdrObject* pObj)
 345 {
 346     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::Inserted" );
 347     if (pObj->GetObjInventor() == FmFormInventor)
 348     {
 349         FmFormObj* pFormObj = PTR_CAST(FmFormObj, pObj);
 350         Inserted( pFormObj );
 351     }
 352     else if (pObj->IsGroupObject())
 353     {
 354         SdrObjListIter aIter(*pObj->GetSubList());
 355         while ( aIter.IsMore() )
 356             Inserted( aIter.Next() );
 357     }
 358 }
 359
 360 //------------------------------------------------------------------------------
 361 namespace
 362 {
 363     sal_Bool lcl_searchElement(const Reference< XIndexAccess>& xCont, const Reference< XInterface >& xElement)
 364     {
 365         if (!xCont.is() || !xElement.is())
 366             return sal_False;
 367
 368         sal_Int32 nCount = xCont->getCount();
 369         Reference< XInterface > xComp;
 370         for (sal_Int32 i = 0; i < nCount; i++)
 371         {
 372             try
 373             {
 374                 xCont->getByIndex(i) >>= xComp;
 375                 if (xComp.is())
 376                 {
 377                     if ( xElement == xComp )
 378                         return sal_True;
 379                     else
 380                     {
 381                         Reference< XIndexAccess> xCont2(xComp, UNO_QUERY);
 382                         if (xCont2.is() && lcl_searchElement(xCont2, xElement))
 383                             return sal_True;
 384                     }
 385                 }
 386             }
 387             catch(const Exception&)
 388             {
 389                 DBG_UNHANDLED_EXCEPTION();
 390             }
 391         }
 392         return sal_False;
 393     }
 394 }
 395
 396 //------------------------------------------------------------------------------
 397 void FmXUndoEnvironment::Inserted(FmFormObj* pObj)
 398 {
 399     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::Inserted" );
 400     DBG_ASSERT( pObj, "FmXUndoEnvironment::Inserted: invalid object!" );
 401     if ( !pObj )
 402         return;
 403
 404     // ist das Control noch einer Form zugeordnet
 405     Reference< XInterface >  xModel(pObj->GetUnoControlModel(), UNO_QUERY);
 406     Reference< XFormComponent >  xContent(xModel, UNO_QUERY);
 407     if (xContent.is() && pObj->GetPage())
 408     {
 409         // if the component doesn't belong to a form, yet, find one to insert into
 410         if (!xContent->getParent().is())
 411         {
 412             try
 413             {
 414                 Reference< XIndexContainer > xObjectParent = pObj->GetOriginalParent();
 415
 416                 FmFormPage& rPage = dynamic_cast< FmFormPage& >( *pObj->GetPage() );
 417                 Reference< XIndexAccess >  xForms( rPage.GetForms(), UNO_QUERY_THROW );
 418
 419                 Reference< XIndexContainer > xNewParent;
 420                 Reference< XForm >           xForm;
 421                 sal_Int32 nPos = -1;
 422                 if ( lcl_searchElement( xForms, xObjectParent ) )
 423                 {
 424                     // the form which was the parent of the object when it was removed is still
 425                     // part of the form component hierachy of the current page
 426                     xNewParent = xObjectParent;
 427                     xForm.set( xNewParent, UNO_QUERY_THROW );
 428                     nPos = ::std::min( pObj->GetOriginalIndex(), xNewParent->getCount() );
 429                 }
 430                 else
 431                 {
 432                     xForm.set( rPage.GetImpl().findPlaceInFormComponentHierarchy( xContent ), UNO_SET_THROW );
 433                     xNewParent.set( xForm, UNO_QUERY_THROW );
 434                     nPos = xNewParent->getCount();
 435                 }
 436
 437                 rPage.GetImpl().setUniqueName( xContent, xForm );
 438                 xNewParent->insertByIndex( nPos, makeAny( xContent ) );
 439
 440                 Reference< XEventAttacherManager >  xManager( xNewParent, UNO_QUERY_THROW );
 441                 xManager->registerScriptEvents( nPos, pObj->GetOriginalEvents() );
 442             }
 443             catch( const Exception& )
 444             {
 445                 DBG_UNHANDLED_EXCEPTION();
 446             }
 447         }
 448
 449         // FormObject zuruecksetzen
 450         pObj->ClearObjEnv();
 451     }
 452 }
 453
 454 //------------------------------------------------------------------
 455 void FmXUndoEnvironment::Removed(SdrObject* pObj)
 456 {
 457     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::Removed" );
 458     if ( pObj->IsVirtualObj() )
 459         // for virtual objects, we've already been notified of the removal of the master
 460         // object, which is sufficient here
 461         return;
 462
 463     if (pObj->GetObjInventor() == FmFormInventor)
 464     {
 465         FmFormObj* pFormObj = PTR_CAST(FmFormObj, pObj);
 466         Removed(pFormObj);
 467     }
 468     else if (pObj->IsGroupObject())
 469     {
 470         SdrObjListIter aIter(*pObj->GetSubList());
 471         while ( aIter.IsMore() )
 472             Removed( aIter.Next() );
 473     }
 474 }
 475
 476 //------------------------------------------------------------------------------
 477 void FmXUndoEnvironment::Removed(FmFormObj* pObj)
 478 {
 479     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::Removed" );
 480     DBG_ASSERT( pObj, "FmXUndoEnvironment::Removed: invalid object!" );
 481     if ( !pObj )
 482         return;
 483
 484     // ist das Control noch einer Form zugeordnet
 485     Reference< XFormComponent >  xContent(pObj->GetUnoControlModel(), UNO_QUERY);
 486     if (xContent.is())
 487     {
 488         // das Object wird aus einer Liste herausgenommen
 489         // existiert ein Vater wird das Object beim beim Vater entfernt und
 490         // am FormObject gemerkt!
 491
 492         // wird das Object wieder eingefuegt und ein Parent existiert, so wird dieser
 493         // Parent wiederum gesetzt
 494         Reference< XIndexContainer >  xForm(xContent->getParent(), UNO_QUERY);
 495         if (xForm.is())
 496         {
 497             Reference< XIndexAccess >  xIndexAccess((XIndexContainer*)xForm.get());
 498             // Feststellen an welcher Position sich das Kind befunden hat
 499             const sal_Int32 nPos = getElementPos(xIndexAccess, xContent);
 500             if (nPos >= 0)
 501             {
 502                 Sequence< ScriptEventDescriptor > aEvts;
 503                 Reference< XEventAttacherManager >  xManager(xForm, UNO_QUERY);
 504                 if (xManager.is())
 505                     aEvts = xManager->getScriptEvents(nPos);
 506
 507                 try
 508                 {
 509                     pObj->SetObjEnv(xForm, nPos, aEvts);
 510                     xForm->removeByIndex(nPos);
 511                 }
 512                 catch(Exception&)
 513                 {
 514                     DBG_UNHANDLED_EXCEPTION();
 515                 }
 516
 517             }
 518         }
 519     }
 520 }
 521
 522 //  XEventListener
 523 //------------------------------------------------------------------------------
 524 void SAL_CALL FmXUndoEnvironment::disposing(const EventObject& e) throw( RuntimeException )
 525 {
 526     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::disposing" );
 527     // check if it's an object we have cached information about
 528     if (m_pPropertySetCache)
 529     {
 530         Reference< XPropertySet > xSourceSet(e.Source, UNO_QUERY);
 531         if (xSourceSet.is())
 532         {
 533             PropertySetInfoCache* pCache = static_cast<PropertySetInfoCache*>(m_pPropertySetCache);
 534             PropertySetInfoCacheIterator aSetPos = pCache->find(xSourceSet);
 535             if (aSetPos != pCache->end())
 536                 pCache->erase(aSetPos);
 537         }
 538     }
 539 }
 540
 541 // XPropertyChangeListener
 542 //------------------------------------------------------------------------------
 543 void SAL_CALL FmXUndoEnvironment::propertyChange(const PropertyChangeEvent& evt) throw(::com::sun::star::uno::RuntimeException)
 544 {
 545     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::propertyChange" );
 546     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 547
 548     if (!IsLocked())
 549     {
 550         Reference< XPropertySet >  xSet(evt.Source, UNO_QUERY);
 551         if (!xSet.is())
 552             return;
 553
 554         // if it's a "default value" property of a control model, set the according "value" property
 555         static OUString pDefaultValueProperties[] = {
 556             OUString(FM_PROP_DEFAULT_TEXT), OUString(FM_PROP_DEFAULTCHECKED), OUString(FM_PROP_DEFAULT_DATE), OUString(FM_PROP_DEFAULT_TIME),
 557             OUString(FM_PROP_DEFAULT_VALUE), OUString(FM_PROP_DEFAULT_SELECT_SEQ), OUString(FM_PROP_EFFECTIVE_DEFAULT)
 558         };
 559         const OUString aValueProperties[] = {
 560             OUString(FM_PROP_TEXT), OUString(FM_PROP_STATE), OUString(FM_PROP_DATE), OUString(FM_PROP_TIME),
 561             OUString(FM_PROP_VALUE), OUString(FM_PROP_SELECT_SEQ), OUString(FM_PROP_EFFECTIVE_VALUE)
 562         };
 563         sal_Int32 nDefaultValueProps = sizeof(pDefaultValueProperties)/sizeof(pDefaultValueProperties[0]);
 564         OSL_ENSURE(sizeof(aValueProperties)/sizeof(aValueProperties[0]) == nDefaultValueProps,
 565             "FmXUndoEnvironment::propertyChange: inconsistence!");
 566         for (sal_Int32 i=0; i<nDefaultValueProps; ++i)
 567         {
 568             if (evt.PropertyName == pDefaultValueProperties[i])
 569             {
 570                 try
 571                 {
 572                     xSet->setPropertyValue(aValueProperties[i], evt.NewValue);
 573                 }
 574                 catch(const Exception&)
 575                 {
 576                     OSL_FAIL("FmXUndoEnvironment::propertyChange: could not adjust the value property!");
 577                 }
 578             }
 579         }
 580
 581         // no Undo for transient and readonly props. But unfortunately "transient" is not only that the
 582         // "transient" flag is set for the property in question, instead is is somewhat more complex
 583         // Transience criterions are:
 584         // - the "transient" flag is set for the property
 585         // - OR the control has a non-empty COntrolSource property, i.e. is intended to be bound
 586         //   to a database column. Note that it doesn't matter here whether the control actually
 587         //   *is* bound to a column
 588         // - OR the control is bound to an external value via XBindableValue/XValueBinding
 589         //   which does not have a "ExternalData" property being <TRUE/>
 590
 591         if (!m_pPropertySetCache)
 592             m_pPropertySetCache = new PropertySetInfoCache;
 593         PropertySetInfoCache* pCache = static_cast<PropertySetInfoCache*>(m_pPropertySetCache);
 594
 595         // let's see if we know something about the set
 596         PropertySetInfoCacheIterator aSetPos = pCache->find(xSet);
 597         if (aSetPos == pCache->end())
 598         {
 599             PropertySetInfo aNewEntry;
 600             if (!::comphelper::hasProperty(FM_PROP_CONTROLSOURCE, xSet))
 601             {
 602                 aNewEntry.bHasEmptyControlSource = sal_False;
 603             }
 604             else
 605             {
 606                 try
 607                 {
 608                     Any aCurrentControlSource = xSet->getPropertyValue(FM_PROP_CONTROLSOURCE);
 609                     aNewEntry.bHasEmptyControlSource = !aCurrentControlSource.hasValue() || ::comphelper::getString(aCurrentControlSource).isEmpty();
 610                 }
 611                 catch(const Exception&)
 612                 {
 613                     DBG_UNHANDLED_EXCEPTION();
 614                 }
 615             }
 616             aSetPos = pCache->insert(PropertySetInfoCache::value_type(xSet,aNewEntry)).first;
 617             DBG_ASSERT(aSetPos != pCache->end(), "FmXUndoEnvironment::propertyChange : just inserted it ... why it's not there ?");
 618         }
 619         else
 620         {   // is it the DataField property ?
 621             if (evt.PropertyName.equals(FM_PROP_CONTROLSOURCE))
 622             {
 623                 aSetPos->second.bHasEmptyControlSource = !evt.NewValue.hasValue() || ::comphelper::getString(evt.NewValue).isEmpty();
 624             }
 625         }
 626
 627         // now we have access to the cached info about the set
 628         // let's see what we know about the property
 629         PropertySetInfo::AllProperties& rPropInfos = aSetPos->second.aProps;
 630         PropertySetInfo::AllPropertiesIterator aPropertyPos = rPropInfos.find(evt.PropertyName);
 631         if (aPropertyPos == rPropInfos.end())
 632         {   // nothing 'til now ... have to change this ....
 633             PropertyInfo aNewEntry;
 634
 635             // the attributes
 636             sal_Int32 nAttributes = xSet->getPropertySetInfo()->getPropertyByName(evt.PropertyName).Attributes;
 637             aNewEntry.bIsTransientOrReadOnly = ((nAttributes & PropertyAttribute::READONLY) != 0) || ((nAttributes & PropertyAttribute::TRANSIENT) != 0);
 638
 639             // check if it is the special "DataFieldProperty"
 640             aNewEntry.bIsValueProperty = sal_False;
 641             try
 642             {
 643                 if (::comphelper::hasProperty(FM_PROP_CONTROLSOURCEPROPERTY, xSet))
 644                 {
 645                     Any aControlSourceProperty = xSet->getPropertyValue(FM_PROP_CONTROLSOURCEPROPERTY);
 646                     OUString sControlSourceProperty;
 647                     aControlSourceProperty >>= sControlSourceProperty;
 648
 649                     aNewEntry.bIsValueProperty = (sControlSourceProperty.equals(evt.PropertyName));
 650                 }
 651             }
 652             catch(const Exception&)
 653             {
 654                 DBG_UNHANDLED_EXCEPTION();
 655             }
 656
 657             // insert the new entry
 658             aPropertyPos = rPropInfos.insert(PropertySetInfo::AllProperties::value_type(evt.PropertyName,aNewEntry)).first;
 659             DBG_ASSERT(aPropertyPos != rPropInfos.end(), "FmXUndoEnvironment::propertyChange : just inserted it ... why it's not there ?");
 660         }
 661
 662         // now we have access to the cached info about the property affected
 663         // and are able to decide whether or not we need an undo action
 664
 665         bool bAddUndoAction = rModel.IsUndoEnabled();
 666         // no UNDO for transient/readonly properties
 667         if ( bAddUndoAction && aPropertyPos->second.bIsTransientOrReadOnly )
 668             bAddUndoAction = false;
 669
 670         if ( bAddUndoAction && aPropertyPos->second.bIsValueProperty )
 671         {
 672             // no UNDO when the "value" property changes, but the ControlSource is non-empty
 673             // (in this case the control is intended to be bound to a database column)
 674             if ( !aSetPos->second.bHasEmptyControlSource )
 675                 bAddUndoAction = false;
 676
 677             // no UNDO if the control is currently bound to an external value
 678             if ( bAddUndoAction )
 679             {
 680                 Reference< XBindableValue > xBindable( evt.Source, UNO_QUERY );
 681                 Reference< XValueBinding > xBinding;
 682                 if ( xBindable.is() )
 683                     xBinding = xBindable->getValueBinding();
 684
 685                 Reference< XPropertySet > xBindingProps;
 686                 Reference< XPropertySetInfo > xBindingPropsPSI;
 687                 if ( xBindable.is() )
 688                     xBindingProps.set( xBinding, UNO_QUERY );
 689                 if ( xBindingProps.is() )
 690                     xBindingPropsPSI = xBindingProps->getPropertySetInfo();
 691                 // TODO: we should cache all those things, else this might be too expensive.
 692                 // However, this requires we're notified of changes in the value binding
 693
 694                 static const OUString s_sExternalData( "ExternalData" );
 695                 if ( xBindingPropsPSI.is() && xBindingPropsPSI->hasPropertyByName( s_sExternalData ) )
 696                 {
 697                     sal_Bool bExternalData = sal_True;
 698                     OSL_VERIFY( xBindingProps->getPropertyValue( s_sExternalData ) >>= bExternalData );
 699                     bAddUndoAction = !bExternalData;
 700                 }
 701                 else
 702                     bAddUndoAction = !xBinding.is();
 703             }
 704         }
 705
 706         if ( bAddUndoAction && ( evt.PropertyName == FM_PROP_STRINGITEMLIST ) )
 707         {
 708             Reference< XListEntrySink > xSink( evt.Source, UNO_QUERY );
 709             if ( xSink.is() && xSink->getListEntrySource().is() )
 710                 // #i41029# / 2005-01-31 / frank.schoenheit@sun.com
 711                 bAddUndoAction = false;
 712         }
 713
 714         if ( bAddUndoAction )
 715         {
 716             aGuard.clear();
 717             // TODO: this is a potential race condition: two threads here could in theory
 718             // add their undo actions out-of-order
 719
 720             SolarMutexGuard aSolarGuard;
 721             rModel.AddUndo(new FmUndoPropertyAction(rModel, evt));
 722         }
 723     }
 724     else
 725     {
 726         // if it's the DataField property we may have to adjust our cache
 727         if (m_pPropertySetCache && evt.PropertyName.equals(FM_PROP_CONTROLSOURCE))
 728         {
 729             Reference< XPropertySet >  xSet(evt.Source, UNO_QUERY);
 730             PropertySetInfoCache* pCache = static_cast<PropertySetInfoCache*>(m_pPropertySetCache);
 731             PropertySetInfo& rSetInfo = (*pCache)[xSet];
 732             rSetInfo.bHasEmptyControlSource = !evt.NewValue.hasValue() || ::comphelper::getString(evt.NewValue).isEmpty();
 733         }
 734     }
 735 }
 736
 737 // XContainerListener
 738 //------------------------------------------------------------------------------
 739 void SAL_CALL FmXUndoEnvironment::elementInserted(const ContainerEvent& evt) throw(::com::sun::star::uno::RuntimeException)
 740 {
 741     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::elementInserted" );
 742     SolarMutexGuard aSolarGuard;
 743     ::osl::MutexGuard aGuard( m_aMutex );
 744
 745     // neues Object zum lauschen
 746     Reference< XInterface >  xIface;
 747     evt.Element >>= xIface;
 748     OSL_ENSURE(xIface.is(), "FmXUndoEnvironment::elementInserted: invalid container notification!");
 749     AddElement(xIface);
 750
 751     implSetModified();
 752 }
 753
 754 //------------------------------------------------------------------------------
 755 void FmXUndoEnvironment::implSetModified()
 756 {
 757     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::implSetModified" );
 758     if ( !IsLocked() && rModel.GetObjectShell() )
 759     {
 760         rModel.GetObjectShell()->SetModified( sal_True );
 761     }
 762 }
 763
 764 //------------------------------------------------------------------------------
 765 void SAL_CALL FmXUndoEnvironment::elementReplaced(const ContainerEvent& evt) throw(::com::sun::star::uno::RuntimeException)
 766 {
 767     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::elementReplaced" );
 768     SolarMutexGuard aSolarGuard;
 769     ::osl::MutexGuard aGuard( m_aMutex );
 770
 771     Reference< XInterface >  xIface;
 772     evt.ReplacedElement >>= xIface;
 773     OSL_ENSURE(xIface.is(), "FmXUndoEnvironment::elementReplaced: invalid container notification!");
 774     RemoveElement(xIface);
 775
 776     evt.Element >>= xIface;
 777     AddElement(xIface);
 778
 779     implSetModified();
 780 }
 781
 782 //------------------------------------------------------------------------------
 783 void SAL_CALL FmXUndoEnvironment::elementRemoved(const ContainerEvent& evt) throw(::com::sun::star::uno::RuntimeException)
 784 {
 785     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::elementRemoved" );
 786     SolarMutexGuard aSolarGuard;
 787     ::osl::MutexGuard aGuard( m_aMutex );
 788
 789     Reference< XInterface >  xIface( evt.Element, UNO_QUERY );
 790     OSL_ENSURE(xIface.is(), "FmXUndoEnvironment::elementRemoved: invalid container notification!");
 791     RemoveElement(xIface);
 792
 793     implSetModified();
 794 }
 795
 796 //------------------------------------------------------------------------------
 797 void SAL_CALL FmXUndoEnvironment::modified( const EventObject& /*aEvent*/ ) throw (RuntimeException)
 798 {
 799     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::modified" );
 800     implSetModified();
 801 }
 802
 803 //------------------------------------------------------------------------------
 804 void FmXUndoEnvironment::AddForms(const Reference< XNameContainer > & rForms)
 805 {
 806     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::AddForms" );
 807     Lock();
 808     Reference< XInterface >  xInt(rForms, UNO_QUERY);
 809     AddElement(xInt);
 810     UnLock();
 811 }
 812
 813 //------------------------------------------------------------------------------
 814 void FmXUndoEnvironment::RemoveForms(const Reference< XNameContainer > & rForms)
 815 {
 816     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::RemoveForms" );
 817     Lock();
 818     Reference< XInterface >  xInt(rForms, UNO_QUERY);
 819     RemoveElement(xInt);
 820     UnLock();
 821 }
 822
 823 //------------------------------------------------------------------------------
 824 void FmXUndoEnvironment::TogglePropertyListening(const Reference< XInterface > & Element)
 825 {
 826     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::TogglePropertyListening" );
 827     // am Container horchen
 828     Reference< XIndexContainer >  xContainer(Element, UNO_QUERY);
 829     if (xContainer.is())
 830     {
 831         sal_uInt32 nCount = xContainer->getCount();
 832         Reference< XInterface >  xIface;
 833         for (sal_uInt32 i = 0; i < nCount; i++)
 834         {
 835             xContainer->getByIndex(i) >>= xIface;
 836             TogglePropertyListening(xIface);
 837         }
 838     }
 839
 840     Reference< XPropertySet >  xSet(Element, UNO_QUERY);
 841     if (xSet.is())
 842     {
 843         if (!bReadOnly)
 844             xSet->addPropertyChangeListener( OUString(), this );
 845         else
 846             xSet->removePropertyChangeListener( OUString(), this );
 847     }
 848 }
 849
 850
 851 //------------------------------------------------------------------------------
 852 void FmXUndoEnvironment::switchListening( const Reference< XIndexContainer >& _rxContainer, bool _bStartListening ) SAL_THROW(())
 853 {
 854     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::switchListening" );
 855     OSL_PRECOND( _rxContainer.is(), "FmXUndoEnvironment::switchListening: invalid container!" );
 856     if ( !_rxContainer.is() )
 857         return;
 858
 859     try
 860     {
 861         // if it's an EventAttacherManager, then we need to listen for
 862         // script events
 863         Reference< XEventAttacherManager > xManager( _rxContainer, UNO_QUERY );
 864         if ( xManager.is() )
 865         {
 866             if ( _bStartListening )
 867             {
 868                 m_pScriptingEnv->registerEventAttacherManager( xManager );
 869                 if ( m_vbaListener.is() )
 870                     xManager->addScriptListener( m_vbaListener );
 871             }
 872             else
 873             {
 874                 m_pScriptingEnv->revokeEventAttacherManager( xManager );
 875                 if ( m_vbaListener.is() )
 876                     xManager->removeScriptListener( m_vbaListener );
 877             }
 878         }
 879
 880         // also handle all children of this element
 881         sal_uInt32 nCount = _rxContainer->getCount();
 882         Reference< XInterface > xInterface;
 883         for ( sal_uInt32 i = 0; i < nCount; ++i )
 884         {
 885             _rxContainer->getByIndex( i ) >>= xInterface;
 886             if ( _bStartListening )
 887                 AddElement( xInterface );
 888             else
 889                 RemoveElement( xInterface );
 890         }
 891
 892         // be notified of any changes in the container elements
 893         Reference< XContainer > xSimpleContainer( _rxContainer, UNO_QUERY );
 894         OSL_ENSURE( xSimpleContainer.is(), "FmXUndoEnvironment::switchListening: how are we expected to be notified of changes in the container?" );
 895         if ( xSimpleContainer.is() )
 896         {
 897             if ( _bStartListening )
 898                 xSimpleContainer->addContainerListener( this );
 899             else
 900                 xSimpleContainer->removeContainerListener( this );
 901         }
 902     }
 903     catch( const Exception& )
 904     {
 905         OSL_FAIL( "FmXUndoEnvironment::switchListening: caught an exception!" );
 906     }
 907 }
 908
 909 //------------------------------------------------------------------------------
 910 void FmXUndoEnvironment::switchListening( const Reference< XInterface >& _rxObject, bool _bStartListening ) SAL_THROW(())
 911 {
 912     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::switchListening" );
 913     OSL_PRECOND( _rxObject.is(), "FmXUndoEnvironment::switchListening: how should I listen at a NULL object?" );
 914
 915     try
 916     {
 917         if ( !bReadOnly )
 918         {
 919             Reference< XPropertySet > xProps( _rxObject, UNO_QUERY );
 920             if ( xProps.is() )
 921             {
 922                 if ( _bStartListening )
 923                     xProps->addPropertyChangeListener( OUString(), this );
 924                 else
 925                     xProps->removePropertyChangeListener( OUString(), this );
 926             }
 927         }
 928
 929         Reference< XModifyBroadcaster > xBroadcaster( _rxObject, UNO_QUERY );
 930         if ( xBroadcaster.is() )
 931         {
 932             if ( _bStartListening )
 933                 xBroadcaster->addModifyListener( this );
 934             else
 935                 xBroadcaster->removeModifyListener( this );
 936         }
 937     }
 938     catch( const Exception& )
 939     {
 940         OSL_FAIL( "FmXUndoEnvironment::switchListening: caught an exception!" );
 941     }
 942 }
 943
 944 //------------------------------------------------------------------------------
 945 void FmXUndoEnvironment::AddElement(const Reference< XInterface >& _rxElement )
 946 {
 947     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::AddElement" );
 948     OSL_ENSURE( !m_bDisposed, "FmXUndoEnvironment::AddElement: not when I'm already disposed!" );
 949
 950     // am Container horchen
 951     Reference< XIndexContainer > xContainer( _rxElement, UNO_QUERY );
 952     if ( xContainer.is() )
 953         switchListening( xContainer, true );
 954
 955     switchListening( _rxElement, true );
 956 }
 957
 958 //------------------------------------------------------------------------------
 959 void FmXUndoEnvironment::RemoveElement(const Reference< XInterface >& _rxElement)
 960 {
 961     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmXUndoEnvironment::RemoveElement" );
 962     if ( m_bDisposed )
 963         return;
 964
 965     switchListening( _rxElement, false );
 966
 967     if (!bReadOnly)
 968     {
 969         // reset the ActiveConnection if the form is to be removed. This will (should) free the resources
 970         // associated with this connection
 971         // 86299 - 05/02/2001 - frank.schoenheit@germany.sun.com
 972         Reference< XForm > xForm( _rxElement, UNO_QUERY );
 973         Reference< XPropertySet > xFormProperties( xForm, UNO_QUERY );
 974         if ( xFormProperties.is() )
 975             if ( !::svxform::OStaticDataAccessTools().isEmbeddedInDatabase( _rxElement ) )
 976                 // (if there is a connection in the context of the component, setting
 977                 // a new connection would be vetoed, anyway)
 978                 // #i34196#
 979                 xFormProperties->setPropertyValue( FM_PROP_ACTIVE_CONNECTION, Any() );
 980     }
 981
 982     Reference< XIndexContainer > xContainer( _rxElement, UNO_QUERY );
 983     if ( xContainer.is() )
 984         switchListening( xContainer, false );
 985 }
 986
 987
 988 //------------------------------------------------------------------------------
 989 FmUndoPropertyAction::FmUndoPropertyAction(FmFormModel& rNewMod, const PropertyChangeEvent& evt)
 990                      :SdrUndoAction(rNewMod)
 991                      ,xObj(evt.Source, UNO_QUERY)
 992                      ,aPropertyName(evt.PropertyName)
 993                      ,aNewValue(evt.NewValue)
 994                      ,aOldValue(evt.OldValue)
 995 {
 996     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoPropertyAction::FmUndoPropertyAction" );
 997     if (rNewMod.GetObjectShell())
 998         rNewMod.GetObjectShell()->SetModified(sal_True);
 999     if(static_STR_UNDO_PROPERTY.Len() == 0)
1000         static_STR_UNDO_PROPERTY = SVX_RESSTR(RID_STR_UNDO_PROPERTY);
1001 }
1002
1003
1004 //------------------------------------------------------------------------------
1005 void FmUndoPropertyAction::Undo()
1006 {
1007     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoPropertyAction::Undo" );
1008     FmXUndoEnvironment& rEnv = ((FmFormModel&)rMod).GetUndoEnv();
1009
1010     if (xObj.is() && !rEnv.IsLocked())
1011     {
1012         rEnv.Lock();
1013         try
1014         {
1015             xObj->setPropertyValue( aPropertyName, aOldValue );
1016         }
1017         catch( const Exception& )
1018         {
1019             OSL_FAIL( "FmUndoPropertyAction::Undo: caught an exception!" );
1020         }
1021         rEnv.UnLock();
1022     }
1023 }
1024
1025 //------------------------------------------------------------------------------
1026 void FmUndoPropertyAction::Redo()
1027 {
1028     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoPropertyAction::Redo" );
1029     FmXUndoEnvironment& rEnv = ((FmFormModel&)rMod).GetUndoEnv();
1030
1031     if (xObj.is() && !rEnv.IsLocked())
1032     {
1033         rEnv.Lock();
1034         try
1035         {
1036             xObj->setPropertyValue( aPropertyName, aNewValue );
1037         }
1038         catch( const Exception& )
1039         {
1040             OSL_FAIL( "FmUndoPropertyAction::Redo: caught an exception!" );
1041         }
1042         rEnv.UnLock();
1043     }
1044 }
1045
1046 //------------------------------------------------------------------------------
1047 OUString FmUndoPropertyAction::GetComment() const
1048 {
1049     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoPropertyAction::GetComment" );
1050     String aStr(static_STR_UNDO_PROPERTY);
1051
1052     aStr.SearchAndReplace( OUString('#'), aPropertyName );
1053     return aStr;
1054 }
1055
1056
1057 DBG_NAME(FmUndoContainerAction);
1058 //------------------------------------------------------------------------------
1059 FmUndoContainerAction::FmUndoContainerAction(FmFormModel& _rMod,
1060                                              Action _eAction,
1061                                              const Reference< XIndexContainer > & xCont,
1062                                              const Reference< XInterface > & xElem,
1063                                              sal_Int32 nIdx)
1064                       :SdrUndoAction( _rMod )
1065                       ,m_xContainer( xCont )
1066                       ,m_nIndex( nIdx )
1067                       ,m_eAction( _eAction )
1068 {
1069     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoContainerAction::FmUndoContainerAction" );
1070     OSL_ENSURE( nIdx >= 0, "FmUndoContainerAction::FmUndoContainerAction: invalid index!" );
1071         // some old code suggested this could be a valid argument. However, this code was
1072         // buggy, and it *seemed* that nobody used it - so it was removed.
1073
1074     DBG_CTOR(FmUndoContainerAction,NULL);
1075     if ( xCont.is() && xElem.is() )
1076     {
1077         // normalize
1078         m_xElement = m_xElement.query( xElem );
1079         if ( m_eAction == Removed )
1080         {
1081             if (m_nIndex >= 0)
1082             {
1083                 Reference< XEventAttacherManager >  xManager( xCont, UNO_QUERY );
1084                 if ( xManager.is() )
1085                     m_aEvents = xManager->getScriptEvents(m_nIndex);
1086             }
1087             else
1088                 m_xElement = NULL;
1089
1090             // we now own the element
1091             m_xOwnElement = m_xElement;
1092         }
1093     }
1094 }
1095
1096 //------------------------------------------------------------------------------
1097 FmUndoContainerAction::~FmUndoContainerAction()
1098 {
1099     // if we own the object ....
1100     DisposeElement( m_xOwnElement );
1101     DBG_DTOR(FmUndoContainerAction,NULL);
1102 }
1103
1104 //------------------------------------------------------------------------------
1105
1106 void FmUndoContainerAction::DisposeElement( const Reference< XInterface > & xElem )
1107 {
1108     Reference< XComponent > xComp( xElem, UNO_QUERY );
1109     if ( xComp.is() )
1110     {
1111         // and the object does not have a parent
1112         Reference< XChild >  xChild( xElem, UNO_QUERY );
1113         if ( xChild.is() && !xChild->getParent().is() )
1114             // -> dispose it
1115             xComp->dispose();
1116     }
1117 }
1118
1119 //------------------------------------------------------------------------------
1120 void FmUndoContainerAction::implReInsert( ) SAL_THROW( ( Exception ) )
1121 {
1122     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoContainerAction::implReInsert" );
1123     if ( m_xContainer->getCount() >= m_nIndex )
1124     {
1125         // insert the element
1126         Any aVal;
1127         if ( m_xContainer->getElementType() == ::getCppuType( static_cast< const Reference< XFormComponent >* >( NULL ) ) )
1128         {
1129             aVal <<= Reference< XFormComponent >( m_xElement, UNO_QUERY );
1130         }
1131         else
1132         {
1133             aVal <<= Reference< XForm >( m_xElement, UNO_QUERY );
1134         }
1135         m_xContainer->insertByIndex( m_nIndex, aVal );
1136
1137         OSL_ENSURE( getElementPos( m_xContainer.get(), m_xElement ) == m_nIndex, "FmUndoContainerAction::implReInsert: insertion did not work!" );
1138
1139         // register the events
1140         Reference< XEventAttacherManager >  xManager( m_xContainer, UNO_QUERY );
1141         if ( xManager.is() )
1142             xManager->registerScriptEvents( m_nIndex, m_aEvents );
1143
1144         // we don't own the object anymore
1145         m_xOwnElement = NULL;
1146     }
1147 }
1148
1149 //------------------------------------------------------------------------------
1150 void FmUndoContainerAction::implReRemove( ) SAL_THROW( ( Exception ) )
1151 {
1152     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoContainerAction::implReRemove" );
1153     Reference< XInterface > xElement;
1154     if ( ( m_nIndex >= 0 ) && ( m_nIndex < m_xContainer->getCount() ) )
1155         m_xContainer->getByIndex( m_nIndex ) >>= xElement;
1156
1157     if ( xElement != m_xElement )
1158     {
1159         // the indexes in the container changed. Okay, so go the long way and
1160         // manually determine the index
1161         m_nIndex = getElementPos( m_xContainer.get(), m_xElement );
1162         if ( m_nIndex != -1 )
1163             xElement = m_xElement;
1164     }
1165
1166     OSL_ENSURE( xElement == m_xElement, "FmUndoContainerAction::implReRemove: cannot find the element which I'm responsible for!" );
1167     if ( xElement == m_xElement )
1168     {
1169         Reference< XEventAttacherManager >  xManager( m_xContainer, UNO_QUERY );
1170         if ( xManager.is() )
1171             m_aEvents = xManager->getScriptEvents( m_nIndex );
1172         m_xContainer->removeByIndex( m_nIndex );
1173         // from now on, we own this object
1174         m_xOwnElement = m_xElement;
1175     }
1176 }
1177
1178 //------------------------------------------------------------------------------
1179 void FmUndoContainerAction::Undo()
1180 {
1181     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoContainerAction::Undo" );
1182     FmXUndoEnvironment& rEnv = static_cast< FmFormModel& >( rMod ).GetUndoEnv();
1183
1184     if ( m_xContainer.is() && !rEnv.IsLocked() && m_xElement.is() )
1185     {
1186         rEnv.Lock();
1187         try
1188         {
1189             switch ( m_eAction )
1190             {
1191             case Inserted:
1192                 implReRemove();
1193                 break;
1194
1195             case Removed:
1196                 implReInsert();
1197                 break;
1198             }
1199         }
1200         catch( const Exception& )
1201         {
1202             OSL_FAIL( "FmUndoContainerAction::Undo: caught an exception!" );
1203         }
1204         rEnv.UnLock();
1205     }
1206 }
1207
1208 //------------------------------------------------------------------------------
1209 void FmUndoContainerAction::Redo()
1210 {
1211     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoContainerAction::Redo" );
1212     FmXUndoEnvironment& rEnv = static_cast< FmFormModel& >( rMod ).GetUndoEnv();
1213     if ( m_xContainer.is() && !rEnv.IsLocked() && m_xElement.is() )
1214     {
1215         rEnv.Lock();
1216         try
1217         {
1218             switch ( m_eAction )
1219             {
1220             case Inserted:
1221                 implReInsert();
1222                 break;
1223
1224             case Removed:
1225                 implReRemove();
1226                 break;
1227             }
1228         }
1229         catch( const Exception& )
1230         {
1231             OSL_FAIL( "FmUndoContainerAction::Redo: caught an exception!" );
1232         }
1233         rEnv.UnLock();
1234     }
1235 }
1236
1237 //------------------------------------------------------------------------------
1238 FmUndoModelReplaceAction::FmUndoModelReplaceAction(FmFormModel& _rMod, SdrUnoObj* _pObject, const Reference< XControlModel > & _xReplaced)
1239     :SdrUndoAction(_rMod)
1240     ,m_xReplaced(_xReplaced)
1241     ,m_pObject(_pObject)
1242 {
1243     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoModelReplaceAction::FmUndoModelReplaceAction" );
1244 }
1245
1246 //------------------------------------------------------------------------------
1247 FmUndoModelReplaceAction::~FmUndoModelReplaceAction()
1248 {
1249     // dispose our element if nobody else is responsible for
1250     DisposeElement(m_xReplaced);
1251 }
1252
1253 //------------------------------------------------------------------------------
1254
1255 void FmUndoModelReplaceAction::DisposeElement( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlModel>& xReplaced )
1256 {
1257     Reference< XComponent >  xComp(xReplaced, UNO_QUERY);
1258     if (xComp.is())
1259     {
1260         Reference< XChild >  xChild(xReplaced, UNO_QUERY);
1261         if (!xChild.is() || !xChild->getParent().is())
1262             xComp->dispose();
1263     }
1264 }
1265
1266 //------------------------------------------------------------------------------
1267 void FmUndoModelReplaceAction::Undo()
1268 {
1269     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoModelReplaceAction::Undo" );
1270     try
1271     {
1272         Reference< XControlModel > xCurrentModel( m_pObject->GetUnoControlModel() );
1273
1274         // replace the model within the parent
1275         Reference< XChild > xCurrentAsChild( xCurrentModel, UNO_QUERY );
1276         Reference< XNameContainer > xCurrentsParent;
1277         if ( xCurrentAsChild.is() )
1278             xCurrentsParent = xCurrentsParent.query( xCurrentAsChild->getParent() );
1279         DBG_ASSERT( xCurrentsParent.is(), "FmUndoModelReplaceAction::Undo: invalid current model!" );
1280
1281         if ( xCurrentsParent.is() )
1282         {
1283             // the form container works with FormComponents
1284             Reference< XFormComponent > xComponent( m_xReplaced, UNO_QUERY );
1285             DBG_ASSERT( xComponent.is(), "FmUndoModelReplaceAction::Undo: the new model is no form component !" );
1286
1287             Reference< XPropertySet > xCurrentAsSet( xCurrentModel, UNO_QUERY );
1288             DBG_ASSERT( ::comphelper::hasProperty(FM_PROP_NAME, xCurrentAsSet ), "FmUndoModelReplaceAction::Undo : one of the models is invalid !");
1289
1290             OUString sName;
1291             xCurrentAsSet->getPropertyValue( FM_PROP_NAME ) >>= sName;
1292             xCurrentsParent->replaceByName( sName, makeAny( xComponent ) );
1293
1294             m_pObject->SetUnoControlModel(m_xReplaced);
1295             m_pObject->SetChanged();
1296
1297             m_xReplaced = xCurrentModel;
1298         }
1299     }
1300     catch(Exception&)
1301     {
1302         OSL_FAIL("FmUndoModelReplaceAction::Undo : could not replace the model !");
1303     }
1304 }
1305
1306 //------------------------------------------------------------------------------
1307 OUString FmUndoModelReplaceAction::GetComment() const
1308 {
1309     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "svx", "Ocke.Janssen@sun.com", "FmUndoModelReplaceAction::GetComment" );
1310     return SVX_RESSTR(RID_STR_UNDO_MODEL_REPLACE);
1311 }
1312
1313 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */