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