xref: /aoo41x/main/svx/source/form/fmshimp.cxx (revision f6e50924)
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 "fmitems.hxx"
28 #include "fmobj.hxx"
29 #include "fmpgeimp.hxx"
30 #include "svx/fmtools.hxx"
31 #include "fmprop.hrc"
32 #include "svx/fmresids.hrc"
33 #include "fmservs.hxx"
34 #include "fmshimp.hxx"
35 #include "fmtextcontrolshell.hxx"
36 #include "fmundo.hxx"
37 #include "fmurl.hxx"
38 #include "fmvwimp.hxx"
39 #include "formtoolbars.hxx"
40 #include "gridcols.hxx"
41 #include "svx/svditer.hxx"
42 #include "svx/dialmgr.hxx"
43 #include "svx/dialogs.hrc"
44 #include "svx/fmglob.hxx"
45 #include "svx/fmmodel.hxx"
46 #include "svx/fmpage.hxx"
47 #include "svx/fmshell.hxx"
48 #include "svx/obj3d.hxx"
49 #include "svx/sdrpagewindow.hxx"
50 #include "svx/svdpagv.hxx"
51 #include "svx/svxdlg.hxx"
52 #include "svx/svxids.hrc"
53 
54 /** === begin UNO includes === **/
55 #include <com/sun/star/awt/XWindow2.hpp>
56 #include <com/sun/star/awt/XCheckBox.hpp>
57 #include <com/sun/star/awt/XListBox.hpp>
58 #include <com/sun/star/awt/XTextComponent.hpp>
59 #include <com/sun/star/beans/NamedValue.hpp>
60 #include <com/sun/star/beans/PropertyAttribute.hpp>
61 #include <com/sun/star/beans/XPropertyState.hpp>
62 #include <com/sun/star/container/XContainer.hpp>
63 #include <com/sun/star/container/XEnumeration.hpp>
64 #include <com/sun/star/container/XEnumerationAccess.hpp>
65 #include <com/sun/star/container/XIndexAccess.hpp>
66 #include <com/sun/star/container/XNamed.hpp>
67 #include <com/sun/star/form/ListSourceType.hpp>
68 #include <com/sun/star/form/XBoundComponent.hpp>
69 #include <com/sun/star/form/XBoundControl.hpp>
70 #include <com/sun/star/form/XGrid.hpp>
71 #include <com/sun/star/form/XGridPeer.hpp>
72 #include <com/sun/star/form/XLoadable.hpp>
73 #include <com/sun/star/form/XReset.hpp>
74 #include <com/sun/star/form/binding/XBindableValue.hpp>
75 #include <com/sun/star/form/binding/XListEntrySink.hpp>
76 #include <com/sun/star/frame/FrameSearchFlag.hpp>
77 #include <com/sun/star/script/XEventAttacherManager.hpp>
78 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
79 #include <com/sun/star/util/XCancellable.hpp>
80 #include <com/sun/star/util/XModeSelector.hpp>
81 #include <com/sun/star/util/XModifyBroadcaster.hpp>
82 #include <com/sun/star/util/XNumberFormatter.hpp>
83 #include <com/sun/star/view/XSelectionSupplier.hpp>
84 #include <com/sun/star/beans/XIntrospection.hpp>
85 /** === end UNO includes === **/
86 
87 #include <comphelper/extract.hxx>
88 #include <comphelper/evtmethodhelper.hxx>
89 #include <comphelper/processfactory.hxx>
90 #include <comphelper/property.hxx>
91 #include <comphelper/stl_types.hxx>
92 #include <connectivity/dbtools.hxx>
93 #include <cppuhelper/servicefactory.hxx>
94 #include <osl/mutex.hxx>
95 #include <rtl/logfile.hxx>
96 #include <sfx2/dispatch.hxx>
97 #include <sfx2/docfile.hxx>
98 #include <sfx2/frame.hxx>
99 #include <sfx2/objsh.hxx>
100 #include <sfx2/viewfrm.hxx>
101 #include <sfx2/viewsh.hxx>
102 #include <toolkit/helper/vclunohelper.hxx>
103 #include <tools/color.hxx>
104 #include <tools/diagnose_ex.h>
105 #include <tools/shl.hxx>
106 #include <tools/urlobj.hxx>
107 #include <vcl/msgbox.hxx>
108 #include <vcl/waitobj.hxx>
109 #include <vos/mutex.hxx>
110 
111 #include <algorithm>
112 #include <functional>
113 
114 // wird fuer Invalidate verwendet -> mitpflegen
115 sal_uInt16 DatabaseSlotMap[] =
116 {
117 	SID_FM_RECORD_FIRST,
118 	SID_FM_RECORD_NEXT,
119 	SID_FM_RECORD_PREV,
120 	SID_FM_RECORD_LAST,
121 	SID_FM_RECORD_NEW,
122 	SID_FM_RECORD_DELETE,
123 	SID_FM_RECORD_ABSOLUTE,
124 	SID_FM_RECORD_TOTAL,
125 	SID_FM_RECORD_SAVE,
126 	SID_FM_RECORD_UNDO,
127 	SID_FM_REMOVE_FILTER_SORT,
128 	SID_FM_SORTUP,
129 	SID_FM_SORTDOWN,
130 	SID_FM_ORDERCRIT,
131 	SID_FM_AUTOFILTER,
132 	SID_FM_FORM_FILTERED,
133 	SID_FM_REFRESH,
134     SID_FM_REFRESH_FORM_CONTROL,
135 	SID_FM_SEARCH,
136 	SID_FM_FILTER_START,
137 	SID_FM_VIEW_AS_GRID,
138 	0
139 };
140 
141 // wird fuer Invalidate verwendet -> mitpflegen
142 // aufsteigend sortieren !!!!!!
143 sal_Int16 DlgSlotMap[] =	// slots des Controllers
144 {
145 	SID_FM_CTL_PROPERTIES,
146 	SID_FM_PROPERTIES,
147 	SID_FM_TAB_DIALOG,
148 	SID_FM_ADD_FIELD,
149 	SID_FM_SHOW_FMEXPLORER,
150 	SID_FM_FIELDS_CONTROL,
151 	SID_FM_SHOW_PROPERTIES,
152 	SID_FM_PROPERTY_CONTROL,
153 	SID_FM_FMEXPLORER_CONTROL,
154 	SID_FM_SHOW_DATANAVIGATOR,
155 	SID_FM_DATANAVIGATOR_CONTROL,
156 	0
157 };
158 
159 sal_Int16 SelObjectSlotMap[] =	// vom SelObject abhaengige Slots
160 {
161 	SID_FM_CONVERTTO_EDIT,
162 	SID_FM_CONVERTTO_BUTTON,
163 	SID_FM_CONVERTTO_FIXEDTEXT,
164 	SID_FM_CONVERTTO_LISTBOX,
165 	SID_FM_CONVERTTO_CHECKBOX,
166 	SID_FM_CONVERTTO_RADIOBUTTON,
167 	SID_FM_CONVERTTO_GROUPBOX,
168 	SID_FM_CONVERTTO_COMBOBOX,
169 	SID_FM_CONVERTTO_IMAGEBUTTON,
170 	SID_FM_CONVERTTO_FILECONTROL,
171 	SID_FM_CONVERTTO_DATE,
172 	SID_FM_CONVERTTO_TIME,
173 	SID_FM_CONVERTTO_NUMERIC,
174 	SID_FM_CONVERTTO_CURRENCY,
175 	SID_FM_CONVERTTO_PATTERN,
176 	SID_FM_CONVERTTO_IMAGECONTROL,
177 	SID_FM_CONVERTTO_FORMATTED,
178     SID_FM_CONVERTTO_SCROLLBAR,
179     SID_FM_CONVERTTO_SPINBUTTON,
180     SID_FM_CONVERTTO_NAVIGATIONBAR,
181 
182 	SID_FM_FMEXPLORER_CONTROL,
183 	SID_FM_DATANAVIGATOR_CONTROL,
184 
185 	0
186 };
187 
188 // die folgenden Arrays muessen kosistent sein, also einander entsprechende Eintraege an der selben relativen Position
189 // innerhalb ihres jeweiligen Arrays stehen
190 sal_Int16 nConvertSlots[] =
191 {
192 	SID_FM_CONVERTTO_EDIT,
193 	SID_FM_CONVERTTO_BUTTON,
194 	SID_FM_CONVERTTO_FIXEDTEXT,
195 	SID_FM_CONVERTTO_LISTBOX,
196 	SID_FM_CONVERTTO_CHECKBOX,
197 	SID_FM_CONVERTTO_RADIOBUTTON,
198 	SID_FM_CONVERTTO_GROUPBOX,
199 	SID_FM_CONVERTTO_COMBOBOX,
200 	SID_FM_CONVERTTO_IMAGEBUTTON,
201 	SID_FM_CONVERTTO_FILECONTROL,
202 	SID_FM_CONVERTTO_DATE,
203 	SID_FM_CONVERTTO_TIME,
204 	SID_FM_CONVERTTO_NUMERIC,
205 	SID_FM_CONVERTTO_CURRENCY,
206 	SID_FM_CONVERTTO_PATTERN,
207 	SID_FM_CONVERTTO_IMAGECONTROL,
208 	SID_FM_CONVERTTO_FORMATTED,
209     SID_FM_CONVERTTO_SCROLLBAR,
210     SID_FM_CONVERTTO_SPINBUTTON,
211     SID_FM_CONVERTTO_NAVIGATIONBAR
212 };
213 
214 sal_Int16 nCreateSlots[] =
215 {
216 	SID_FM_EDIT,
217 	SID_FM_PUSHBUTTON,
218 	SID_FM_FIXEDTEXT,
219 	SID_FM_LISTBOX,
220 	SID_FM_CHECKBOX,
221 	SID_FM_RADIOBUTTON,
222 	SID_FM_GROUPBOX,
223 	SID_FM_COMBOBOX,
224 	SID_FM_IMAGEBUTTON,
225 	SID_FM_FILECONTROL,
226 	SID_FM_DATEFIELD,
227 	SID_FM_TIMEFIELD,
228 	SID_FM_NUMERICFIELD,
229 	SID_FM_CURRENCYFIELD,
230 	SID_FM_PATTERNFIELD,
231 	SID_FM_IMAGECONTROL,
232 	SID_FM_FORMATTEDFIELD,
233     SID_FM_SCROLLBAR,
234     SID_FM_SPINBUTTON,
235     SID_FM_NAVIGATIONBAR
236 };
237 
238 sal_Int16 nObjectTypes[] =
239 {
240 	OBJ_FM_EDIT,
241 	OBJ_FM_BUTTON,
242 	OBJ_FM_FIXEDTEXT,
243 	OBJ_FM_LISTBOX,
244 	OBJ_FM_CHECKBOX,
245 	OBJ_FM_RADIOBUTTON,
246 	OBJ_FM_GROUPBOX,
247 	OBJ_FM_COMBOBOX,
248 	OBJ_FM_IMAGEBUTTON,
249 	OBJ_FM_FILECONTROL,
250 	OBJ_FM_DATEFIELD,
251 	OBJ_FM_TIMEFIELD,
252 	OBJ_FM_NUMERICFIELD,
253 	OBJ_FM_CURRENCYFIELD,
254 	OBJ_FM_PATTERNFIELD,
255 	OBJ_FM_IMAGECONTROL,
256 	OBJ_FM_FORMATTEDFIELD,
257 	OBJ_FM_SCROLLBAR,
258 	OBJ_FM_SPINBUTTON,
259     OBJ_FM_NAVIGATIONBAR
260 };
261 
262 using namespace ::com::sun::star;
263 using namespace ::com::sun::star::ui;
264 using namespace ::com::sun::star::uno;
265 using namespace ::com::sun::star::sdb;
266 using namespace ::com::sun::star::sdbc;
267 using namespace ::com::sun::star::sdbcx;
268 using namespace ::com::sun::star::beans;
269 using namespace ::com::sun::star::container;
270 using namespace ::com::sun::star::form;
271 using namespace ::com::sun::star::form::binding;
272 using namespace ::com::sun::star::form::runtime;
273 using namespace ::com::sun::star::awt;
274 using namespace ::com::sun::star::view;
275 using namespace ::com::sun::star::lang;
276 using namespace ::com::sun::star::util;
277 using namespace ::com::sun::star::frame;
278 using namespace ::com::sun::star::script;
279 using namespace ::svxform;
280 using namespace ::svx;
281 
282 //==============================================================================
283 //= helper
284 //==============================================================================
285 namespace
286 {
287     //..........................................................................
collectInterfacesFromMarkList(const SdrMarkList & _rMarkList,InterfaceBag & _rInterfaces)288     void collectInterfacesFromMarkList( const SdrMarkList& _rMarkList, InterfaceBag& /* [out] */ _rInterfaces )
289     {
290         _rInterfaces.clear();
291 
292         sal_uInt32 nMarkCount = _rMarkList.GetMarkCount();
293         for ( sal_uInt32 i = 0; i < nMarkCount; ++i)
294         {
295             SdrObject* pCurrent = _rMarkList.GetMark( i )->GetMarkedSdrObj();
296 
297             SdrObjListIter* pGroupIterator = NULL;
298             if ( pCurrent->IsGroupObject() )
299             {
300                 pGroupIterator = new SdrObjListIter( *pCurrent->GetSubList() );
301                 pCurrent = pGroupIterator->IsMore() ? pGroupIterator->Next() : NULL;
302             }
303 
304             while ( pCurrent )
305             {
306                 FmFormObj* pAsFormObject = FmFormObj::GetFormObject( pCurrent );
307                     // note this will de-reference virtual objects, if necessary/possible
308                 if ( pAsFormObject )
309                 {
310                     Reference< XInterface > xControlModel( pAsFormObject->GetUnoControlModel(), UNO_QUERY );
311                         // the UNO_QUERY is important for normalization
312                     if ( xControlModel.is() )
313                         _rInterfaces.insert( xControlModel );
314                 }
315 
316                 // next element
317                 pCurrent = pGroupIterator && pGroupIterator->IsMore() ? pGroupIterator->Next() : NULL;
318             }
319 
320             if ( pGroupIterator )
321                 delete pGroupIterator;
322         }
323     }
324 
325     //..........................................................................
GridView2ModelPos(const Reference<XIndexAccess> & rColumns,sal_Int16 nViewPos)326     sal_Int16 GridView2ModelPos(const Reference< XIndexAccess>& rColumns, sal_Int16 nViewPos)
327     {
328         try
329         {
330             if (rColumns.is())
331             {
332                 // loop through all columns
333                 sal_Int16 i;
334                 Reference< XPropertySet> xCur;
335                 for (i=0; i<rColumns->getCount(); ++i)
336                 {
337                     rColumns->getByIndex(i) >>= xCur;
338                     if (!::comphelper::getBOOL(xCur->getPropertyValue(FM_PROP_HIDDEN)))
339                     {
340                         // for every visible col : if nViewPos is greater zero, decrement it, else we
341                         // have found the model position
342                         if (!nViewPos)
343                             break;
344                         else
345                             --nViewPos;
346                     }
347                 }
348                 if (i<rColumns->getCount())
349                     return i;
350             }
351         }
352         catch(const Exception&)
353         {
354             DBG_UNHANDLED_EXCEPTION();
355         }
356         return (sal_Int16)-1;
357     }
358 
359     //..........................................................................
TransferEventScripts(const Reference<XControlModel> & xModel,const Reference<XControl> & xControl,const Sequence<ScriptEventDescriptor> & rTransferIfAvailable)360     void TransferEventScripts(const Reference< XControlModel>& xModel, const Reference< XControl>& xControl,
361 	    const Sequence< ScriptEventDescriptor>& rTransferIfAvailable)
362     {
363 	    // first check if we have a XEventAttacherManager for the model
364 	    Reference< XChild> xModelChild(xModel, UNO_QUERY);
365 	    if (!xModelChild.is())
366 		    return; // nothing to do
367 
368 	    Reference< XEventAttacherManager> xEventManager(xModelChild->getParent(), UNO_QUERY);
369 	    if (!xEventManager.is())
370 		    return; // nothing to do
371 
372 	    if (!rTransferIfAvailable.getLength())
373 		    return; // nothing to do
374 
375 	    // check for the index of the model within it's parent
376 	    Reference< XIndexAccess> xParentIndex(xModelChild->getParent(), UNO_QUERY);
377 	    if (!xParentIndex.is())
378 		    return; // nothing to do
379 	    sal_Int32 nIndex = getElementPos(xParentIndex, xModel);
380 	    if (nIndex<0 || nIndex>=xParentIndex->getCount())
381 		    return; // nothing to do
382 
383 	    // then we need informations about the listeners supported by the control and the model
384 	    Sequence< Type> aModelListeners;
385 	    Sequence< Type> aControlListeners;
386 
387 	    Reference< XIntrospection> xModelIntrospection(::comphelper::getProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.beans.Introspection")), UNO_QUERY);
388 	    Reference< XIntrospection> xControlIntrospection(::comphelper::getProcessServiceFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.beans.Introspection")), UNO_QUERY);
389 
390 	    if (xModelIntrospection.is() && xModel.is())
391 	    {
392 		    Any aModel(makeAny(xModel));
393 		    aModelListeners = xModelIntrospection->inspect(aModel)->getSupportedListeners();
394 	    }
395 
396 	    if (xControlIntrospection.is() && xControl.is())
397 	    {
398 		    Any aControl(makeAny(xControl));
399 		    aControlListeners = xControlIntrospection->inspect(aControl)->getSupportedListeners();
400 	    }
401 
402 	    sal_Int32 nMaxNewLen = aModelListeners.getLength() + aControlListeners.getLength();
403 	    if (!nMaxNewLen)
404 		    return; // the model and the listener don't support any listeners (or we were unable to retrieve these infos)
405 
406 	    Sequence< ScriptEventDescriptor>	aTransferable(nMaxNewLen);
407 	    ScriptEventDescriptor* pTransferable = aTransferable.getArray();
408 
409 	    const ScriptEventDescriptor* pCurrent = rTransferIfAvailable.getConstArray();
410 	    sal_Int32 i,j,k;
411 	    for (i=0; i<rTransferIfAvailable.getLength(); ++i, ++pCurrent)
412 	    {
413 		    // search the model/control idl classes for the event described by pCurrent
414 		    for (	Sequence< Type>* pCurrentArray = &aModelListeners;
415 				    pCurrentArray;
416 				    pCurrentArray = (pCurrentArray == &aModelListeners) ? &aControlListeners : NULL
417 			    )
418 		    {
419 			    const Type* pCurrentListeners = pCurrentArray->getConstArray();
420 			    for (j=0; j<pCurrentArray->getLength(); ++j, ++pCurrentListeners)
421 			    {
422 				    UniString aListener = (*pCurrentListeners).getTypeName();
423 				    xub_StrLen nTokens = aListener.GetTokenCount('.');
424 				    if (nTokens)
425 					    aListener = aListener.GetToken(nTokens - 1, '.');
426 
427 				    if (aListener == pCurrent->ListenerType.getStr())
428 					    // the current ScriptEventDescriptor doesn't match the current listeners class
429 					    continue;
430 
431 				    // now check the methods
432 					Sequence< ::rtl::OUString> aMethodsNames = ::comphelper::getEventMethodsForType(*pCurrentListeners);
433 
434 				    const ::rtl::OUString* pMethodsNames = aMethodsNames.getConstArray();
435 				    for (k=0; k<aMethodsNames.getLength(); ++k, ++pMethodsNames)
436 				    {
437 					    if ((*pMethodsNames).compareTo(pCurrent->EventMethod) != COMPARE_EQUAL)
438 						    // the current ScriptEventDescriptor doesn't match the current listeners current method
439 						    continue;
440 
441 					    // we can transfer the script event : the model (control) supports it
442 					    *pTransferable = *pCurrent;
443 					    ++pTransferable;
444 					    break;
445 				    }
446 				    if (k<aMethodsNames.getLength())
447 					    break;
448 			    }
449 		    }
450 	    }
451 
452 	    sal_Int32 nRealNewLen = pTransferable - aTransferable.getArray();
453 	    aTransferable.realloc(nRealNewLen);
454 
455 	    xEventManager->registerScriptEvents(nIndex, aTransferable);
456     }
457 
458     //------------------------------------------------------------------------------
getServiceNameByControlType(sal_Int16 nType)459     ::rtl::OUString getServiceNameByControlType(sal_Int16 nType)
460     {
461 	    switch (nType)
462 	    {
463 		    case OBJ_FM_EDIT			: return FM_COMPONENT_TEXTFIELD;
464 		    case OBJ_FM_BUTTON			: return FM_COMPONENT_COMMANDBUTTON;
465 		    case OBJ_FM_FIXEDTEXT		: return FM_COMPONENT_FIXEDTEXT;
466 		    case OBJ_FM_LISTBOX 		: return FM_COMPONENT_LISTBOX;
467 		    case OBJ_FM_CHECKBOX		: return FM_COMPONENT_CHECKBOX;
468 		    case OBJ_FM_RADIOBUTTON 	: return FM_COMPONENT_RADIOBUTTON;
469 		    case OBJ_FM_GROUPBOX		: return FM_COMPONENT_GROUPBOX;
470 		    case OBJ_FM_COMBOBOX		: return FM_COMPONENT_COMBOBOX;
471 		    case OBJ_FM_GRID			: return FM_COMPONENT_GRIDCONTROL;
472 		    case OBJ_FM_IMAGEBUTTON 	: return FM_COMPONENT_IMAGEBUTTON;
473 		    case OBJ_FM_FILECONTROL 	: return FM_COMPONENT_FILECONTROL;
474 		    case OBJ_FM_DATEFIELD		: return FM_COMPONENT_DATEFIELD;
475 		    case OBJ_FM_TIMEFIELD		: return FM_COMPONENT_TIMEFIELD;
476 		    case OBJ_FM_NUMERICFIELD	: return FM_COMPONENT_NUMERICFIELD;
477 		    case OBJ_FM_CURRENCYFIELD	: return FM_COMPONENT_CURRENCYFIELD;
478 		    case OBJ_FM_PATTERNFIELD	: return FM_COMPONENT_PATTERNFIELD;
479 		    case OBJ_FM_HIDDEN			: return FM_COMPONENT_HIDDENCONTROL;
480 		    case OBJ_FM_IMAGECONTROL	: return FM_COMPONENT_IMAGECONTROL;
481 		    case OBJ_FM_FORMATTEDFIELD	: return FM_COMPONENT_FORMATTEDFIELD;
482 		    case OBJ_FM_SCROLLBAR       : return FM_SUN_COMPONENT_SCROLLBAR;
483 		    case OBJ_FM_SPINBUTTON      : return FM_SUN_COMPONENT_SPINBUTTON;
484             case OBJ_FM_NAVIGATIONBAR   : return FM_SUN_COMPONENT_NAVIGATIONBAR;
485 	    }
486 	    return ::rtl::OUString();
487     }
488 
489 }
490 
491 //------------------------------------------------------------------------------
492 // check if the control has one of the interfaces we can use for searching
493 // *_pCurrentText will be filled with the current text of the control (as used when searching this control)
IsSearchableControl(const::com::sun::star::uno::Reference<::com::sun::star::uno::XInterface> & _rxControl,::rtl::OUString * _pCurrentText)494 sal_Bool IsSearchableControl( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface>& _rxControl,
495     ::rtl::OUString* _pCurrentText )
496 {
497 	if ( !_rxControl.is() )
498 		return sal_False;
499 
500 	Reference< XTextComponent > xAsText( _rxControl, UNO_QUERY );
501 	if ( xAsText.is() )
502 	{
503 		if ( _pCurrentText )
504 			*_pCurrentText = xAsText->getText();
505 		return sal_True;
506 	}
507 
508 	Reference< XListBox > xListBox( _rxControl, UNO_QUERY );
509 	if ( xListBox.is() )
510 	{
511 		if ( _pCurrentText )
512 			*_pCurrentText = xListBox->getSelectedItem();
513 		return sal_True;
514 	}
515 
516 	Reference< XCheckBox > xCheckBox( _rxControl, UNO_QUERY );
517 	if ( xCheckBox.is() )
518 	{
519 		if ( _pCurrentText )
520 		{
521 			switch ( (TriState)xCheckBox->getState() )
522 			{
523 				case STATE_NOCHECK: *_pCurrentText = ::rtl::OUString::createFromAscii( "0" ); break;
524 				case STATE_CHECK: *_pCurrentText = ::rtl::OUString::createFromAscii( "1" ); break;
525 				default: *_pCurrentText = ::rtl::OUString(); break;
526 			}
527 		}
528 		return sal_True;
529 	}
530 
531 	return sal_False;
532 }
533 
534 //------------------------------------------------------------------------------
ShouldStepInto(const Reference<XInterface> & _rContainer) const535 sal_Bool FmXBoundFormFieldIterator::ShouldStepInto(const Reference< XInterface>& _rContainer) const
536 {
537 	if (_rContainer == m_xStartingPoint)
538 		// would be quite stupid to step over the root ....
539 		return sal_True;
540 
541 	return Reference< XControlModel>(_rContainer, UNO_QUERY).is();
542 }
543 
544 //------------------------------------------------------------------------------
ShouldHandleElement(const Reference<XInterface> & _rElement)545 sal_Bool FmXBoundFormFieldIterator::ShouldHandleElement(const Reference< XInterface>& _rElement)
546 {
547 	if (!_rElement.is())
548 		// NULL element
549 		return sal_False;
550 
551 	if (Reference< XForm>(_rElement, UNO_QUERY).is() || Reference< XGrid>(_rElement, UNO_QUERY).is())
552 		// a forms or a grid
553 		return sal_False;
554 
555 	Reference< XPropertySet> xSet(_rElement, UNO_QUERY);
556 	if (!xSet.is() || !::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
557 		// no "BoundField" property
558 		return sal_False;
559 
560 	Any aVal( xSet->getPropertyValue(FM_PROP_BOUNDFIELD) );
561 	if (aVal.getValueTypeClass() != TypeClass_INTERFACE)
562 		// void or invalid property value
563 		return sal_False;
564 
565 	return aVal.hasValue();
566 }
567 
568 //------------------------------------------------------------------------------
isControlList(const SdrMarkList & rMarkList)569 sal_Bool isControlList(const SdrMarkList& rMarkList)
570 {
571 	// enthaelt die liste nur Controls und mindestens ein control
572 	sal_uInt32 nMarkCount = rMarkList.GetMarkCount();
573 	sal_Bool  bControlList = nMarkCount != 0;
574 
575 	sal_Bool bHadAnyLeafs = sal_False;
576 
577 	for (sal_uInt32 i = 0; i < nMarkCount && bControlList; i++)
578 	{
579 		SdrObject *pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
580 		E3dObject* pAs3DObject = PTR_CAST(E3dObject, pObj);
581 		// E3dObject's do not contain any 2D-objects (by definition)
582 		// we need this extra check here : an E3dObject->IsGroupObject says "YES", but an SdrObjListIter working
583 		// with an E3dObject doesn't give me any Nodes (E3dObject has a sub list, but no members in that list,
584 		// cause there implementation differs from the one of "normal" SdrObject's. Unfortunally SdrObject::IsGroupObject
585 		// doesn't check the element count of the sub list, which is simply a bug in IsGroupObject we can't fix at the moment).
586 		// So at the end of this function bControlList would have the same value it was initialized with above : sal_True
587 		// And this would be wrong :)
588 		// 03.02.00 - 72529 - FS
589 		if (!pAs3DObject)
590 		{
591 			if (pObj->IsGroupObject())
592 			{
593 				SdrObjListIter aIter(*pObj->GetSubList());
594 				while (aIter.IsMore() && bControlList)
595 				{
596 					bControlList = FmFormInventor == aIter.Next()->GetObjInventor();
597 					bHadAnyLeafs = sal_True;
598 				}
599 			}
600 			else
601 			{
602 				bHadAnyLeafs = sal_True;
603 				bControlList = FmFormInventor == pObj->GetObjInventor();
604 			}
605 		}
606 	}
607 
608 	return bControlList && bHadAnyLeafs;
609 }
610 
611 //------------------------------------------------------------------------
GetForm(const Reference<XInterface> & _rxElement)612 Reference< XForm > GetForm(const Reference< XInterface>& _rxElement)
613 {
614     Reference< XForm > xForm( _rxElement, UNO_QUERY );
615     if ( xForm.is() )
616         return xForm;
617 
618     Reference< XChild > xChild( _rxElement, UNO_QUERY );
619 	if ( xChild.is() )
620         return GetForm( xChild->getParent() );
621 
622 	return Reference< XForm >();
623 }
624 
625 //========================================================================
626 // class FmXFormShell_Base_Disambiguation
627 //========================================================================
FmXFormShell_Base_Disambiguation(::osl::Mutex & _rMutex)628 FmXFormShell_Base_Disambiguation::FmXFormShell_Base_Disambiguation( ::osl::Mutex& _rMutex )
629 	:FmXFormShell_BD_BASE( _rMutex )
630 {
631 }
632 
disposing()633 void SAL_CALL FmXFormShell_Base_Disambiguation::disposing()
634 {
635 	WeakComponentImplHelperBase::disposing();
636 	// Note:
637 	// This is a HACK.
638 	// Normally it should be sufficient to call the "disposing" of our direct
639 	// base class, but SUN PRO 5 does not like this and claims there is a conflict
640 	// with the XEventListener::disposing(EventObject) of our various listener
641 	// base classes.
642 }
643 
644 //========================================================================
645 // class FmXFormShell
646 //========================================================================
647 DBG_NAME(FmXFormShell);
648 //------------------------------------------------------------------------
FmXFormShell(FmFormShell & _rShell,SfxViewFrame * _pViewFrame)649 FmXFormShell::FmXFormShell( FmFormShell& _rShell, SfxViewFrame* _pViewFrame )
650 		:FmXFormShell_BASE(m_aMutex)
651 		,FmXFormShell_CFGBASE(::rtl::OUString::createFromAscii("Office.Common/Misc"), CONFIG_MODE_DELAYED_UPDATE)
652 		,m_eNavigate( NavigationBarMode_NONE )
653 		,m_nInvalidationEvent( 0 )
654         ,m_nActivationEvent( 0 )
655 		,m_pShell( &_rShell )
656         ,m_pTextShell( new ::svx::FmTextControlShell( _pViewFrame ) )
657         ,m_aActiveControllerFeatures( ::comphelper::getProcessServiceFactory(), this )
658         ,m_aNavControllerFeatures( ::comphelper::getProcessServiceFactory(), this )
659         ,m_eDocumentType( eUnknownDocumentType )
660 		,m_nLockSlotInvalidation( 0 )
661 		,m_bHadPropertyBrowserInDesignMode( sal_False )
662 		,m_bTrackProperties( sal_True )
663 		,m_bUseWizards( sal_True )
664 		,m_bDatabaseBar( sal_False )
665         ,m_bInActivate( sal_False )
666 		,m_bSetFocus( sal_False )
667 		,m_bFilterMode( sal_False )
668 		,m_bChangingDesignMode( sal_False )
669 		,m_bPreparedClose( sal_False )
670         ,m_bFirstActivation( sal_True )
671 {
672 	DBG_CTOR(FmXFormShell,NULL);
673 	m_aMarkTimer.SetTimeout(100);
674 	m_aMarkTimer.SetTimeoutHdl(LINK(this,FmXFormShell,OnTimeOut));
675 
676 	if ( _pViewFrame )
677 		m_xAttachedFrame = _pViewFrame->GetFrame().GetFrameInterface();
678 
679 	// to prevent deletion of this we acquire our refcounter once
680 	::comphelper::increment(FmXFormShell_BASE::m_refCount);
681 
682 	// correct the refcounter
683 	::comphelper::decrement(FmXFormShell_BASE::m_refCount);
684 
685 	// cache the current configuration settings we're interested in
686 	implAdjustConfigCache();
687 	// and register for changes on this settings
688 	Sequence< ::rtl::OUString > aNames(1);
689 	aNames[0] = ::rtl::OUString::createFromAscii("FormControlPilotsEnabled");
690 	EnableNotification(aNames);
691 }
692 
693 //------------------------------------------------------------------------
~FmXFormShell()694 FmXFormShell::~FmXFormShell()
695 {
696     delete m_pTextShell;
697 	DBG_DTOR(FmXFormShell,NULL);
698 }
699 
700 //------------------------------------------------------------------
getContextDocument() const701 Reference< XModel > FmXFormShell::getContextDocument() const
702 {
703     Reference< XModel > xModel;
704 
705     // determine the type of document we live in
706     try
707     {
708         Reference< XController > xController;
709         if ( m_xAttachedFrame.is() )
710 	        xController = m_xAttachedFrame->getController();
711         if ( xController.is() )
712 	        xModel = xController->getModel();
713     }
714     catch( const Exception& )
715     {
716     	DBG_UNHANDLED_EXCEPTION();
717     }
718     return xModel;
719 }
720 
721 //------------------------------------------------------------------
isEnhancedForm() const722 bool FmXFormShell::isEnhancedForm() const
723 {
724 	return getDocumentType() == eEnhancedForm;
725 }
726 
727 //------------------------------------------------------------------
impl_checkDisposed() const728 bool FmXFormShell::impl_checkDisposed() const
729 {
730     if ( !m_pShell )
731     {
732         OSL_ENSURE( false, "FmXFormShell::impl_checkDisposed: already disposed!" );
733         return true;
734     }
735     return false;
736 }
737 
738 //------------------------------------------------------------------
getDocumentType() const739 ::svxform::DocumentType FmXFormShell::getDocumentType() const
740 {
741     if ( m_eDocumentType != eUnknownDocumentType )
742         return m_eDocumentType;
743 
744     // determine the type of document we live in
745     Reference< XModel > xModel = getContextDocument();
746     if ( xModel.is() )
747         m_eDocumentType = DocumentClassification::classifyDocument( xModel );
748     else
749     {
750         OSL_ENSURE( sal_False, "FmXFormShell::getDocumentType: can't determine the document type!" );
751         m_eDocumentType = eTextDocument;
752             // fallback, just to have a defined state
753     }
754 
755     return m_eDocumentType;
756 }
757 
758 //------------------------------------------------------------------
IsReadonlyDoc() const759 bool FmXFormShell::IsReadonlyDoc() const
760 {
761     if ( impl_checkDisposed() )
762         return true;
763 
764 	FmFormModel* pModel = m_pShell->GetFormModel();
765     if ( pModel && pModel->GetObjectShell() )
766         return pModel->GetObjectShell()->IsReadOnly() || pModel->GetObjectShell()->IsReadOnlyUI();
767     return true;
768 }
769 
770 //------------------------------------------------------------------
queryInterface(const Type & type)771 Any SAL_CALL FmXFormShell::queryInterface( const Type& type) throw ( RuntimeException )
772 {
773 	return FmXFormShell_BASE::queryInterface(type);
774 }
775 //------------------------------------------------------------------------------
getTypes()776 Sequence< Type > SAL_CALL FmXFormShell::getTypes(  ) throw(RuntimeException)
777 {
778 	return FmXFormShell_BASE::getTypes();
779 }
780 //------------------------------------------------------------------------------
getImplementationId()781 Sequence< sal_Int8 > SAL_CALL FmXFormShell::getImplementationId() throw(RuntimeException)
782 {
783     static ::cppu::OImplementationId* pId = 0;
784 	if (! pId)
785 	{
786         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
787 		if (! pId)
788 		{
789 			static ::cppu::OImplementationId aId;
790 			pId = &aId;
791 		}
792 	}
793 	return pId->getImplementationId();
794 }
795 //	EventListener
796 //------------------------------------------------------------------------------
disposing(const EventObject & e)797 void SAL_CALL FmXFormShell::disposing(const EventObject& e) throw( RuntimeException )
798 {
799     impl_checkDisposed();
800 
801 	if (m_xActiveController == e.Source)
802 	{
803 		// wird der Controller freigeben dann alles loslassen
804 		stopListening();
805 		m_xActiveForm = NULL;
806 		m_xActiveController = NULL;
807 		m_xNavigationController = NULL;
808 
809         m_aActiveControllerFeatures.dispose();
810         m_aNavControllerFeatures.dispose();
811 
812         if ( m_pShell )
813 		    m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell);
814 	}
815 
816 	if (e.Source == m_xExternalViewController)
817 	{
818         Reference< runtime::XFormController > xFormController( m_xExternalViewController, UNO_QUERY );
819         OSL_ENSURE( xFormController.is(), "FmXFormShell::disposing: invalid external view controller!" );
820 		if (xFormController.is())
821 			xFormController->removeActivateListener((XFormControllerListener*)this);
822 
823 		Reference< ::com::sun::star::lang::XComponent> xComp(m_xExternalViewController, UNO_QUERY);
824 		if (xComp.is())
825 			xComp->removeEventListener((XEventListener*)(XPropertyChangeListener*)this);
826 
827 		m_xExternalViewController = NULL;
828 		m_xExternalDisplayedForm = NULL;
829 		m_xExtViewTriggerController = NULL;
830 
831 		InvalidateSlot( SID_FM_VIEW_AS_GRID, sal_False );
832 	}
833 }
834 
835 //------------------------------------------------------------------------------
propertyChange(const PropertyChangeEvent & evt)836 void SAL_CALL FmXFormShell::propertyChange(const PropertyChangeEvent& evt) throw(::com::sun::star::uno::RuntimeException)
837 {
838     if ( impl_checkDisposed() )
839         return;
840 
841 	if (evt.PropertyName == FM_PROP_ROWCOUNT)
842 	{
843 		// Das gleich folgenden Update erzwingt ein Neu-Painten der entsprechenden Slots. Wenn ich mich aber hier nicht
844 		// in dem HauptThread der Applikation befinde (weil zum Beispiel ein Cursor gerade Datensaetze zaehlt und mir dabei
845 		// immer diese PropertyChanges beschert), kann sich das mit en normalen Paints im HauptThread der Applikation beissen.
846 		// (Solche Paints passieren zum Beispiel, wenn man einfach nur eine andere Applikation ueber das Office legt und wieder
847 		// zurueckschaltet).
848 		// Deshalb die Benutzung des SolarMutex, der sichert das ab.
849 		::vos::IMutex& rSolarSafety = Application::GetSolarMutex();
850 		if (rSolarSafety.tryToAcquire())
851 		{
852 			m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_RECORD_TOTAL , sal_True, sal_False);
853 			m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Update(SID_FM_RECORD_TOTAL);
854 			rSolarSafety.release();
855 		}
856 		else
857 		{
858 			// with the following the slot is invalidated asynchron
859 			LockSlotInvalidation(sal_True);
860 			InvalidateSlot(SID_FM_RECORD_TOTAL, sal_False);
861 			LockSlotInvalidation(sal_False);
862 		}
863 	}
864 
865 	// this may be called from a non-main-thread so invalidate the shell asynchronously
866 	LockSlotInvalidation(sal_True);
867 	InvalidateSlot(0, 0);		// special meaning : invalidate m_pShell
868 	LockSlotInvalidation(sal_False);
869 }
870 
871 //------------------------------------------------------------------------------
invalidateFeatures(const::std::vector<sal_Int32> & _rFeatures)872 void FmXFormShell::invalidateFeatures( const ::std::vector< sal_Int32 >& _rFeatures )
873 {
874     if ( impl_checkDisposed() )
875         return;
876 
877     OSL_ENSURE( _rFeatures.size() > 0, "FmXFormShell::invalidateFeatures: invalid arguments!" );
878 
879     if ( m_pShell->GetViewShell() && m_pShell->GetViewShell()->GetViewFrame() )
880     {
881         // unfortunately, SFX requires sal_uInt16
882         ::std::vector< sal_uInt16 > aSlotIds;
883         aSlotIds.reserve( _rFeatures.size() );
884         ::std::copy( _rFeatures.begin(),
885             _rFeatures.end(),
886             ::std::insert_iterator< ::std::vector< sal_uInt16 > >( aSlotIds, aSlotIds.begin() )
887         );
888 
889         // furthermore, SFX wants a terminating 0
890         aSlotIds.push_back( 0 );
891 
892         // and, last but not least, SFX wants the ids to be sorted
893         ::std::sort( aSlotIds.begin(), aSlotIds.end() - 1 );
894 
895         sal_uInt16 *pSlotIds = aSlotIds.empty() ? 0 : &(aSlotIds[0]);
896         m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate( pSlotIds );
897     }
898 }
899 
900 //------------------------------------------------------------------------------
formActivated(const EventObject & rEvent)901 void SAL_CALL FmXFormShell::formActivated(const EventObject& rEvent) throw( RuntimeException )
902 {
903     if ( impl_checkDisposed() )
904         return;
905 
906     Reference< runtime::XFormController > xController( rEvent.Source, UNO_QUERY_THROW );
907     m_pTextShell->formActivated( xController );
908     setActiveController( xController );
909 }
910 
911 //------------------------------------------------------------------------------
formDeactivated(const EventObject & rEvent)912 void SAL_CALL FmXFormShell::formDeactivated(const EventObject& rEvent) throw( RuntimeException )
913 {
914     if ( impl_checkDisposed() )
915         return;
916 
917     Reference< runtime::XFormController > xController( rEvent.Source, UNO_QUERY_THROW );
918     m_pTextShell->formDeactivated( xController );
919 }
920 
921 //------------------------------------------------------------------------------
disposing()922 void FmXFormShell::disposing()
923 {
924     impl_checkDisposed();
925 
926 	FmXFormShell_BASE::disposing();
927 
928 	if ( m_pShell && !m_pShell->IsDesignMode() )
929 		setActiveController( NULL, sal_True );
930 		// do NOT save the content of the old form (the second parameter tells this)
931 		// if we're here, then we expect that PrepareClose has been called, and thus the user
932 		// got a chance to commit or reject any changes. So in case we're here and there
933 		// are still uncommitted changes, the user explicitly wanted this.
934 		// 2002-11-11 - 104702 - fs@openoffice.org
935 
936     m_pTextShell->dispose();
937 
938 	m_xAttachedFrame = NULL;
939 
940 	CloseExternalFormViewer();
941 
942 	while ( m_aLoadingPages.size() )
943 	{
944 		Application::RemoveUserEvent( m_aLoadingPages.front().nEventId );
945 		m_aLoadingPages.pop();
946 	}
947 
948 	{
949 		::osl::MutexGuard aGuard(m_aInvalidationSafety);
950 		if (m_nInvalidationEvent)
951 		{
952 			Application::RemoveUserEvent(m_nInvalidationEvent);
953 			m_nInvalidationEvent = 0;
954 		}
955         if ( m_nActivationEvent )
956         {
957             Application::RemoveUserEvent( m_nActivationEvent );
958             m_nActivationEvent = 0;
959         }
960 	}
961 
962 	{
963 		::osl::ClearableMutexGuard aGuard(m_aAsyncSafety);
964 		aGuard.clear();
965 
966 		DBG_ASSERT(!m_nInvalidationEvent, "FmXFormShell::~FmXFormShell : still have an invalidation event !");
967 			// should habe been deleted while beeing disposed
968 
969 		m_aMarkTimer.Stop();
970 	}
971 
972     DisableNotification();
973 
974     RemoveElement( m_xForms );
975 	m_xForms.clear();
976 
977     impl_switchActiveControllerListening( false );
978 	m_xActiveController 		= NULL;
979 	m_xActiveForm				= NULL;
980 
981     m_pShell					= NULL;
982 	m_xNavigationController 	= NULL;
983 	m_xCurrentForm              = NULL;
984 	m_xLastGridFound			= NULL;
985 	m_xAttachedFrame			= NULL;
986 	m_xExternalViewController	= NULL;
987 	m_xExtViewTriggerController = NULL;
988 	m_xExternalDisplayedForm	= NULL;
989 	m_xLastGridFound			= NULL;
990 
991     InterfaceBag aEmpty;
992     m_aCurrentSelection.swap( aEmpty );
993 
994     m_aActiveControllerFeatures.dispose();
995     m_aNavControllerFeatures.dispose();
996 }
997 
998 //------------------------------------------------------------------------------
UpdateSlot(sal_Int16 _nId)999 void FmXFormShell::UpdateSlot( sal_Int16 _nId )
1000 {
1001     if ( impl_checkDisposed() )
1002         return;
1003 
1004     ::osl::MutexGuard aGuard(m_aInvalidationSafety);
1005 
1006     if ( m_nLockSlotInvalidation )
1007     {
1008         OSL_ENSURE( sal_False, "FmXFormShell::UpdateSlot: cannot update if invalidation is currently locked!" );
1009         InvalidateSlot( _nId, sal_False );
1010     }
1011     else
1012     {
1013         OSL_ENSURE( _nId, "FmXFormShell::UpdateSlot: can't update the complete shell!" );
1014 		m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate( _nId, sal_True, sal_True );
1015 		m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Update( _nId );
1016     }
1017 }
1018 
1019 //------------------------------------------------------------------------------
InvalidateSlot(sal_Int16 nId,sal_Bool bWithId)1020 void FmXFormShell::InvalidateSlot( sal_Int16 nId, sal_Bool bWithId )
1021 {
1022     if ( impl_checkDisposed() )
1023         return;
1024 
1025 	::osl::MutexGuard aGuard(m_aInvalidationSafety);
1026 	if (m_nLockSlotInvalidation)
1027 	{
1028 		m_arrInvalidSlots.Insert(nId, m_arrInvalidSlots.Count());
1029 		sal_uInt8 nFlags = ( bWithId ? 0x01 : 0 );
1030 		m_arrInvalidSlots_Flags.push_back(nFlags);
1031 	}
1032 	else
1033 		if (nId)
1034 			m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(nId, sal_True, bWithId);
1035 		else
1036 			m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell);
1037 }
1038 
1039 //------------------------------------------------------------------------------
LockSlotInvalidation(sal_Bool bLock)1040 void FmXFormShell::LockSlotInvalidation(sal_Bool bLock)
1041 {
1042     if ( impl_checkDisposed() )
1043         return;
1044 
1045 	::osl::MutexGuard aGuard(m_aInvalidationSafety);
1046 	DBG_ASSERT(bLock || m_nLockSlotInvalidation>0, "FmXFormShell::LockSlotInvalidation : invalid call !");
1047 
1048 	if (bLock)
1049 		++m_nLockSlotInvalidation;
1050 	else if (!--m_nLockSlotInvalidation)
1051 	{
1052 		// alles, was sich waehrend der gelockten Phase angesammelt hat, (asynchron) invalidieren
1053 		if (!m_nInvalidationEvent)
1054 			m_nInvalidationEvent = Application::PostUserEvent(LINK(this, FmXFormShell, OnInvalidateSlots));
1055 	}
1056 }
1057 
1058 //------------------------------------------------------------------------------
IMPL_LINK(FmXFormShell,OnInvalidateSlots,void *,EMPTYARG)1059 IMPL_LINK(FmXFormShell, OnInvalidateSlots, void*, EMPTYARG)
1060 {
1061     if ( impl_checkDisposed() )
1062         return 0L;
1063 
1064     ::osl::MutexGuard aGuard(m_aInvalidationSafety);
1065 	m_nInvalidationEvent = 0;
1066 
1067 	DBG_ASSERT(m_arrInvalidSlots.Count() == m_arrInvalidSlots_Flags.size(),
1068 		"FmXFormShell::OnInvalidateSlots : inconsistent slot arrays !");
1069 	sal_uInt8 nFlags;
1070 	for (sal_Int16 i=0; i<m_arrInvalidSlots.Count(); ++i)
1071 	{
1072 		nFlags = m_arrInvalidSlots_Flags[i];
1073 
1074 		if (m_arrInvalidSlots[i])
1075 			m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Invalidate(m_arrInvalidSlots[i], sal_True, (nFlags & 0x01));
1076 		else
1077 			m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell);
1078 	}
1079 
1080 	m_arrInvalidSlots.Remove(0, m_arrInvalidSlots.Count());
1081 	m_arrInvalidSlots_Flags.clear();
1082 	return 0L;
1083 }
1084 
1085 //------------------------------------------------------------------------------
ForceUpdateSelection(sal_Bool bAllowInvalidation)1086 void FmXFormShell::ForceUpdateSelection(sal_Bool bAllowInvalidation)
1087 {
1088     if ( impl_checkDisposed() )
1089         return;
1090 
1091     if (IsSelectionUpdatePending())
1092 	{
1093 		m_aMarkTimer.Stop();
1094 
1095 		// die Invalidierung der Slots, die implizit von SetSelection besorgt wird, eventuell abschalten
1096 		if (!bAllowInvalidation)
1097 			LockSlotInvalidation(sal_True);
1098 
1099 		SetSelection(m_pShell->GetFormView()->GetMarkedObjectList());
1100 
1101 		if (!bAllowInvalidation)
1102 			LockSlotInvalidation(sal_False);
1103 	}
1104 }
1105 
1106 //------------------------------------------------------------------------------
GetConversionMenu()1107 PopupMenu* FmXFormShell::GetConversionMenu()
1108 {
1109 	const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
1110 	sal_Bool bIsHiContrastMode	= rSettings.GetHighContrastMode();
1111 
1112 	PopupMenu* pNewMenu = new PopupMenu(SVX_RES( RID_FMSHELL_CONVERSIONMENU ));
1113 
1114 	ImageList aImageList( SVX_RES( bIsHiContrastMode ? RID_SVXIMGLIST_FMEXPL_HC : RID_SVXIMGLIST_FMEXPL) );
1115 	for ( size_t i = 0; i < sizeof( nConvertSlots ) / sizeof( nConvertSlots[0] ); ++i )
1116 	{
1117 		// das entsprechende Image dran
1118 		pNewMenu->SetItemImage(nConvertSlots[i], aImageList.GetImage(nCreateSlots[i]));
1119 	}
1120 
1121 	return pNewMenu;
1122 }
1123 
1124 //------------------------------------------------------------------------------
isControlConversionSlot(sal_uInt16 nSlotId)1125 bool FmXFormShell::isControlConversionSlot( sal_uInt16 nSlotId )
1126 {
1127 	for ( size_t i = 0; i < sizeof( nConvertSlots ) / sizeof( nConvertSlots[0] ); ++i )
1128 		if (nConvertSlots[i] == nSlotId)
1129 			return true;
1130 	return false;
1131 }
1132 
1133 //------------------------------------------------------------------------------
executeControlConversionSlot(sal_uInt16 _nSlotId)1134 bool FmXFormShell::executeControlConversionSlot( sal_uInt16 _nSlotId )
1135 {
1136     OSL_PRECOND( canConvertCurrentSelectionToControl( _nSlotId ), "FmXFormShell::executeControlConversionSlot: illegal call!" );
1137     InterfaceBag::const_iterator aSelectedElement = m_aCurrentSelection.begin();
1138     if ( aSelectedElement == m_aCurrentSelection.end() )
1139         return false;
1140 
1141     return executeControlConversionSlot( Reference< XFormComponent >( *aSelectedElement, UNO_QUERY ), _nSlotId );
1142 }
1143 
1144 //------------------------------------------------------------------------------
executeControlConversionSlot(const Reference<XFormComponent> & _rxObject,sal_uInt16 _nSlotId)1145 bool FmXFormShell::executeControlConversionSlot( const Reference< XFormComponent >& _rxObject, sal_uInt16 _nSlotId )
1146 {
1147     if ( impl_checkDisposed() )
1148         return false;
1149 
1150     OSL_ENSURE( _rxObject.is(), "FmXFormShell::executeControlConversionSlot: invalid object!" );
1151     if ( !_rxObject.is() )
1152         return false;
1153 
1154     SdrPage* pPage = m_pShell->GetCurPage();
1155     FmFormPage* pFormPage = pPage ? dynamic_cast< FmFormPage* >( pPage ) : NULL;
1156     OSL_ENSURE( pFormPage, "FmXFormShell::executeControlConversionSlot: no current (form) page!" );
1157     if ( !pFormPage )
1158         return false;
1159 
1160     OSL_ENSURE( isSolelySelected( _rxObject ),
1161         "FmXFormShell::executeControlConversionSlot: hmm ... shouldn't this parameter be redundant?" );
1162 
1163 	for ( size_t lookupSlot = 0; lookupSlot < sizeof( nConvertSlots ) / sizeof( nConvertSlots[0] ); ++lookupSlot )
1164 	{
1165 		if (nConvertSlots[lookupSlot] == _nSlotId)
1166         {
1167             Reference< XInterface > xNormalizedObject( _rxObject, UNO_QUERY );
1168 
1169             FmFormObj* pFormObject = NULL;
1170             SdrObjListIter aPageIter( *pFormPage );
1171             while ( aPageIter.IsMore() )
1172             {
1173                 SdrObject* pCurrent = aPageIter.Next();
1174                 pFormObject = FmFormObj::GetFormObject( pCurrent );
1175                 if ( !pFormObject )
1176                     continue;
1177 
1178                 Reference< XInterface > xCurrentNormalized( pFormObject->GetUnoControlModel(), UNO_QUERY );
1179                 if ( xCurrentNormalized.get() == xNormalizedObject.get() )
1180                     break;
1181 
1182                 pFormObject = NULL;
1183             }
1184 
1185             if ( !pFormObject )
1186                 return false;
1187 
1188             ::rtl::OUString sNewName( getServiceNameByControlType( nObjectTypes[ lookupSlot ] ) );
1189 	        Reference< XControlModel> xNewModel( ::comphelper::getProcessServiceFactory()->createInstance( sNewName ), UNO_QUERY );
1190 	        if (!xNewModel.is())
1191 		        return false;
1192 
1193 	        Reference< XControlModel> xOldModel( pFormObject->GetUnoControlModel() );
1194 	        Reference< XServiceInfo> xModelInfo(xOldModel, UNO_QUERY);
1195 
1196 	        // Properties uebertragen
1197 	        Reference< XPropertySet> xOldSet(xOldModel, UNO_QUERY);
1198 	        Reference< XPropertySet> xNewSet(xNewModel, UNO_QUERY);
1199 
1200 
1201 	        Locale aNewLanguage = Application::GetSettings().GetUILocale();
1202 	        TransferFormComponentProperties(xOldSet, xNewSet, aNewLanguage);
1203 
1204 	        Sequence< ::com::sun::star::script::ScriptEventDescriptor> aOldScripts;
1205 	        Reference< XChild> xChild(xOldModel, UNO_QUERY);
1206 	        if (xChild.is())
1207 	        {
1208 		        Reference< XIndexAccess> xParent(xChild->getParent(), UNO_QUERY);
1209 
1210 		        // remember old script events
1211 		        Reference< ::com::sun::star::script::XEventAttacherManager> xEvManager(xChild->getParent(), UNO_QUERY);
1212 		        if (xParent.is() && xEvManager.is())
1213 		        {
1214 			        sal_Int32 nIndex = getElementPos(xParent, xOldModel);
1215 			        if (nIndex>=0 && nIndex<xParent->getCount())
1216 				        aOldScripts = xEvManager->getScriptEvents(nIndex);
1217 		        }
1218 
1219 		        // replace the mdoel within the parent container
1220 		        Reference< XIndexContainer> xIndexParent(xChild->getParent(), UNO_QUERY);   //Modified by BerryJia for fixing Bug102516 Time(China):2002-9-5 16:00
1221 		        if (xIndexParent.is())
1222 		        {
1223 			        // the form container works with FormComponents
1224 			        Reference< XFormComponent> xComponent(xNewModel, UNO_QUERY);
1225 			        DBG_ASSERT(xComponent.is(), "FmXFormShell::executeControlConversionSlot: the new model is no form component !");
1226 			        Any aNewModel(makeAny(xComponent));
1227 			        try
1228 			        {
1229 				        //Modified by BerryJia for fixing Bug102516 Time(China):2002-9-5 16:00
1230 				        sal_Int32 nIndex = getElementPos(xParent, xOldModel);
1231 				        if (nIndex>=0 && nIndex<xParent->getCount())
1232 					        xIndexParent->replaceByIndex(nIndex, aNewModel);
1233 				        else
1234 				        {
1235 					        DBG_ERROR("FmXFormShell::executeControlConversionSlot: could not replace the model !");
1236 					        Reference< ::com::sun::star::lang::XComponent> xNewComponent(xNewModel, UNO_QUERY);
1237 					        if (xNewComponent.is())
1238 						        xNewComponent->dispose();
1239 					        return false;
1240 				        }
1241 			        }
1242 			        catch(Exception&)
1243 			        {
1244 				        DBG_ERROR("FmXFormShell::executeControlConversionSlot: could not replace the model !");
1245 				        Reference< ::com::sun::star::lang::XComponent> xNewComponent(xNewModel, UNO_QUERY);
1246 				        if (xNewComponent.is())
1247 					        xNewComponent->dispose();
1248 				        return false;
1249 			        }
1250 
1251 		        }
1252 	        }
1253 
1254 	        // special handling for the LabelControl-property : can only be set when the model is placed
1255 	        // within the forms hierarchy
1256 	        if (::comphelper::hasProperty(FM_PROP_CONTROLLABEL, xOldSet) && ::comphelper::hasProperty(FM_PROP_CONTROLLABEL, xNewSet))
1257 	        {
1258 		        try
1259 		        {
1260 			        xNewSet->setPropertyValue(FM_PROP_CONTROLLABEL, xOldSet->getPropertyValue(FM_PROP_CONTROLLABEL));
1261 		        }
1262 		        catch(Exception&)
1263 		        {
1264 		        }
1265 
1266 	        }
1267 
1268 	        // neues Model setzen
1269 	        pFormObject->SetChanged();
1270 	        pFormObject->SetUnoControlModel(xNewModel);
1271 
1272 	        // transfer script events
1273 	        // (do this _after_ SetUnoControlModel as we need the new (implicitly created) control)
1274 	        if (aOldScripts.getLength())
1275 	        {
1276 		        // das Control zum Model suchen
1277                 Reference< XControlContainer > xControlContainer( getControlContainerForView() );
1278 
1279 		        Sequence< Reference< XControl> > aControls( xControlContainer->getControls() );
1280 		        const Reference< XControl>* pControls = aControls.getConstArray();
1281 
1282 		        sal_uInt32 nLen = aControls.getLength();
1283 		        Reference< XControl> xControl;
1284 		        for (sal_uInt32 i=0 ; i<nLen; ++i)
1285 		        {
1286 			        if (pControls[i]->getModel() == xNewModel)
1287 			        {
1288 				        xControl = pControls[i];
1289 				        break;
1290 			        }
1291 		        }
1292 		        TransferEventScripts(xNewModel, xControl, aOldScripts);
1293 	        }
1294 
1295             // transfer value bindings, if possible
1296             {
1297 	            Reference< XBindableValue > xOldBindable( xOldModel, UNO_QUERY );
1298 	            Reference< XBindableValue > xNewBindable( xNewModel, UNO_QUERY );
1299                 if ( xOldBindable.is() )
1300                 {
1301                     try
1302                     {
1303                         if ( xNewBindable.is() )
1304                             xNewBindable->setValueBinding( xOldBindable->getValueBinding() );
1305                         xOldBindable->setValueBinding( NULL );
1306                     }
1307 		            catch(const Exception&)
1308                     {
1309                         DBG_UNHANDLED_EXCEPTION();
1310                     }
1311                 }
1312             }
1313             // same for list entry sources
1314             {
1315                 Reference< XListEntrySink > xOldSink( xOldModel, UNO_QUERY );
1316                 Reference< XListEntrySink > xNewSink( xNewModel, UNO_QUERY );
1317                 if ( xOldSink.is() )
1318                 {
1319                     try
1320                     {
1321                         if ( xNewSink.is() )
1322                             xNewSink->setListEntrySource( xOldSink->getListEntrySource() );
1323                         xOldSink->setListEntrySource( NULL );
1324                     }
1325 		            catch(const Exception&)
1326 		            {
1327                         DBG_UNHANDLED_EXCEPTION();
1328 		            }
1329                 }
1330             }
1331 
1332             // create an undo action
1333 	        FmFormModel* pModel = m_pShell->GetFormModel();
1334 	        DBG_ASSERT(pModel != NULL, "FmXFormShell::executeControlConversionSlot: my shell has no model !");
1335 	        if (pModel && pModel->IsUndoEnabled() )
1336 			{
1337 		        pModel->AddUndo(new FmUndoModelReplaceAction(*pModel, pFormObject, xOldModel));
1338 			}
1339 			else
1340 			{
1341 				FmUndoModelReplaceAction::DisposeElement( xOldModel );
1342 			}
1343 
1344 	        return true;
1345         }
1346 	}
1347 	return false;
1348 }
1349 
1350 //------------------------------------------------------------------------------
canConvertCurrentSelectionToControl(sal_Int16 nConversionSlot)1351 bool FmXFormShell::canConvertCurrentSelectionToControl( sal_Int16 nConversionSlot )
1352 {
1353     if ( m_aCurrentSelection.empty() )
1354         return false;
1355 
1356     InterfaceBag::const_iterator aCheck = m_aCurrentSelection.begin();
1357     Reference< XServiceInfo > xElementInfo( *aCheck, UNO_QUERY );
1358     if ( !xElementInfo.is() )
1359         // no service info -> cannot determine this
1360         return false;
1361 
1362     if (  ++aCheck != m_aCurrentSelection.end() )
1363         // more than one element
1364         return false;
1365 
1366     if ( Reference< XForm >::query( xElementInfo ).is() )
1367         // it's a form
1368         return false;
1369 
1370 	sal_Int16 nObjectType = getControlTypeByObject( xElementInfo );
1371 
1372 	if (  ( OBJ_FM_HIDDEN == nObjectType )
1373        || ( OBJ_FM_CONTROL == nObjectType )
1374        || ( OBJ_FM_GRID == nObjectType )
1375        )
1376         return false;   // those types cannot be converted
1377 
1378 	DBG_ASSERT(sizeof(nConvertSlots)/sizeof(nConvertSlots[0]) == sizeof(nObjectTypes)/sizeof(nObjectTypes[0]),
1379 		"FmXFormShell::canConvertCurrentSelectionToControl: nConvertSlots & nObjectTypes must have the same size !");
1380 
1381 	for ( size_t i = 0; i < sizeof( nConvertSlots ) / sizeof( nConvertSlots[0] ); ++i )
1382 		if (nConvertSlots[i] == nConversionSlot)
1383 			return nObjectTypes[i] != nObjectType;
1384 
1385 	return sal_True;	// all other slots: assume "yes"
1386 }
1387 
1388 //------------------------------------------------------------------------------
checkControlConversionSlotsForCurrentSelection(Menu & rMenu)1389 void FmXFormShell::checkControlConversionSlotsForCurrentSelection( Menu& rMenu )
1390 {
1391 	for (sal_Int16 i=0; i<rMenu.GetItemCount(); ++i)
1392 		// der Context ist schon von einem Typ, der dem Eitnrag entspricht -> disable
1393 		rMenu.EnableItem( rMenu.GetItemId(i), canConvertCurrentSelectionToControl( rMenu.GetItemId( i ) ) );
1394 }
1395 
1396 //------------------------------------------------------------------------------
LoopGrids(sal_Int16 nWhat)1397 void FmXFormShell::LoopGrids(sal_Int16 nWhat)
1398 {
1399     if ( impl_checkDisposed() )
1400         return;
1401 
1402 	Reference< XIndexContainer> xControlModels(m_xActiveForm, UNO_QUERY);
1403 	if (xControlModels.is())
1404     {
1405 		for (sal_Int16 i=0; i<xControlModels->getCount(); ++i)
1406 		{
1407 			Reference< XPropertySet> xModelSet;
1408 			xControlModels->getByIndex(i) >>= xModelSet;
1409 			if (!xModelSet.is())
1410 				continue;
1411 
1412 			if (!::comphelper::hasProperty(FM_PROP_CLASSID, xModelSet))
1413 				continue;
1414 			sal_Int16 nClassId = ::comphelper::getINT16(xModelSet->getPropertyValue(FM_PROP_CLASSID));
1415 			if (FormComponentType::GRIDCONTROL != nClassId)
1416 				continue;
1417 
1418 			if (!::comphelper::hasProperty(FM_PROP_CURSORCOLOR, xModelSet) || !::comphelper::hasProperty(FM_PROP_ALWAYSSHOWCURSOR, xModelSet) || !::comphelper::hasProperty(FM_PROP_DISPLAYSYNCHRON, xModelSet))
1419 				continue;
1420 
1421 			switch (nWhat & GA_SYNC_MASK)
1422 			{
1423 				case GA_DISABLE_SYNC:
1424 					{
1425 						sal_Bool bB(sal_False);
1426 						xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, Any(&bB,getBooleanCppuType()));
1427 					}
1428 					break;
1429 				case GA_FORCE_SYNC:
1430 				{
1431 					Any aOldVal( xModelSet->getPropertyValue(FM_PROP_DISPLAYSYNCHRON) );
1432 					sal_Bool bB(sal_True);
1433 					xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, Any(&bB,getBooleanCppuType()));
1434 					xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, aOldVal);
1435 				}
1436 				break;
1437 				case GA_ENABLE_SYNC:
1438 					{
1439 						sal_Bool bB(sal_True);
1440 						xModelSet->setPropertyValue(FM_PROP_DISPLAYSYNCHRON, Any(&bB,getBooleanCppuType()));
1441 					}
1442 					break;
1443 			}
1444 
1445 			if (nWhat & GA_DISABLE_ROCTRLR)
1446 			{
1447 				sal_Bool bB(sal_False);
1448 				xModelSet->setPropertyValue(FM_PROP_ALWAYSSHOWCURSOR, Any(&bB,getBooleanCppuType()));
1449 				Reference< XPropertyState> xModelPropState(xModelSet, UNO_QUERY);
1450 				if (xModelPropState.is())
1451 					xModelPropState->setPropertyToDefault(FM_PROP_CURSORCOLOR);
1452 				else
1453 					xModelSet->setPropertyValue(FM_PROP_CURSORCOLOR, Any());		// this should be the default
1454 			}
1455 			else if (nWhat & GA_ENABLE_ROCTRLR)
1456 			{
1457 				sal_Bool bB(sal_True);
1458 				xModelSet->setPropertyValue(FM_PROP_ALWAYSSHOWCURSOR, Any(&bB,getBooleanCppuType()));
1459 				xModelSet->setPropertyValue(FM_PROP_CURSORCOLOR, makeAny(sal_Int32(COL_LIGHTRED)));
1460 			}
1461 		}
1462     }
1463 }
1464 
1465 //------------------------------------------------------------------------------
getControlContainerForView()1466 Reference< XControlContainer > FmXFormShell::getControlContainerForView()
1467 {
1468     if ( impl_checkDisposed() )
1469         return NULL;
1470 
1471     SdrPageView* pPageView = NULL;
1472     if ( m_pShell && m_pShell->GetFormView() )
1473 	    pPageView = m_pShell->GetFormView()->GetSdrPageView();
1474 
1475     Reference< XControlContainer> xControlContainer;
1476     if ( pPageView )
1477 	    xControlContainer = pPageView->GetPageWindow(0)->GetControlContainer();
1478 
1479     return xControlContainer;
1480 }
1481 
1482 //------------------------------------------------------------------------------
ExecuteTabOrderDialog(const Reference<XTabControllerModel> & _rxForForm)1483 void FmXFormShell::ExecuteTabOrderDialog( const Reference< XTabControllerModel >& _rxForForm )
1484 {
1485     if ( impl_checkDisposed() )
1486         return;
1487 
1488     OSL_PRECOND( _rxForForm.is(), "FmXFormShell::ExecuteTabOrderDialog: invalid tabbing model!" );
1489     if ( !_rxForForm.is() )
1490         return;
1491 
1492     try
1493     {
1494         Sequence< Any > aDialogArgs( 3 );
1495         aDialogArgs[0] <<= NamedValue(
1496             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TabbingModel" ) ),
1497             makeAny( _rxForForm )
1498         );
1499         aDialogArgs[1] <<= NamedValue(
1500             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ControlContext" ) ),
1501             makeAny( getControlContainerForView() )
1502         );
1503 
1504         Reference< XWindow > xParentWindow;
1505         if ( m_pShell->GetViewShell() && m_pShell->GetViewShell()->GetViewFrame() )
1506             xParentWindow = VCLUnoHelper::GetInterface ( &m_pShell->GetViewShell()->GetViewFrame()->GetWindow() );
1507         aDialogArgs[2] <<= NamedValue(
1508             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ParentWindow" ) ),
1509             makeAny( xParentWindow )
1510         );
1511 
1512         Reference< dialogs::XExecutableDialog > xDialog(
1513             ::comphelper::getProcessServiceFactory()->createInstanceWithArguments(
1514                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.form.ui.TabOrderDialog" ) ),
1515                 aDialogArgs
1516             ),
1517             UNO_QUERY
1518         );
1519         OSL_ENSURE( xDialog.is(), "FmXFormShell::ExecuteTabOrderDialog: could not create the dialog!" );
1520 
1521         if ( xDialog.is() )
1522             xDialog->execute();
1523     }
1524     catch( const Exception& )
1525     {
1526     	OSL_ENSURE( sal_False, "FmXFormShell::ExecuteTabOrderDialog: caught an exception!" );
1527     }
1528 }
1529 
1530 //------------------------------------------------------------------------------
ExecuteSearch()1531 void FmXFormShell::ExecuteSearch()
1532 {
1533     if ( impl_checkDisposed() )
1534         return;
1535 
1536 	// eine Sammlung aller (logischen) Formulare
1537     FmFormArray aEmpty;
1538     m_aSearchForms.swap( aEmpty );
1539     ::std::vector< String > aContextNames;
1540     impl_collectFormSearchContexts_nothrow( m_pShell->GetCurPage()->GetForms(), ::rtl::OUString(), m_aSearchForms, aContextNames );
1541     OSL_POSTCOND( m_aSearchForms.size() == aContextNames.size(),
1542         "FmXFormShell::ExecuteSearch: nonsense!" );
1543     if ( m_aSearchForms.size() != aContextNames.size() )
1544         return;
1545 
1546 	// filter out the forms which do not contain valid controls at all
1547     {
1548         FmFormArray aValidForms;
1549         ::std::vector< String > aValidContexts;
1550 	    FmFormArray::const_iterator form = m_aSearchForms.begin();
1551         ::std::vector< String >::const_iterator contextName = aContextNames.begin();
1552         for ( ; form != m_aSearchForms.end(); ++form, ++contextName )
1553         {
1554 		    FmSearchContext aTestContext;
1555 		    aTestContext.nContext = static_cast< sal_Int16 >( form - m_aSearchForms.begin() );
1556 		    sal_uInt32 nValidControls = OnSearchContextRequest( &aTestContext );
1557 		    if ( nValidControls > 0 )
1558 		    {
1559                 aValidForms.push_back( *form );
1560                 aValidContexts.push_back( *contextName );
1561 		    }
1562         }
1563 
1564         m_aSearchForms.swap( aValidForms );
1565         aContextNames.swap( aValidContexts );
1566     }
1567 
1568 	if (m_aSearchForms.empty() )
1569 	{	// es gibt keine Controls, die alle Bedingungen fuer eine Suche erfuellen
1570 		ErrorBox(NULL, WB_OK, SVX_RESSTR(RID_STR_NODATACONTROLS)).Execute();
1571 		return;
1572 	}
1573 
1574 	// jetzt brauche ich noch einen 'initial context'
1575 	sal_Int16 nInitialContext = 0;
1576 	Reference< XForm> xActiveForm( getActiveForm());
1577 	for ( size_t i=0; i<m_aSearchForms.size(); ++i )
1578 	{
1579 		if (m_aSearchForms.at(i) == xActiveForm)
1580 		{
1581 			nInitialContext = (sal_Int16)i;
1582 			break;
1583 		}
1584 	}
1585 
1586 	// wenn der Dialog initial den Text des aktiven Controls anbieten soll, muss dieses ein XTextComponent-Interface habe,
1587 	// ausserdem macht das nur Sinn, wenn das aktuelle Feld auch an ein Tabellen- (oder was-auch-immer-)Feld gebunden ist
1588 	UniString strActiveField;
1589 	UniString strInitialText;
1590 	// ... das bekomme ich von meinem FormController
1591 	DBG_ASSERT(m_xActiveController.is(), "FmXFormShell::ExecuteSearch : no active controller !");
1592 	Reference< XControl> xActiveControl( m_xActiveController->getCurrentControl());
1593 	if (xActiveControl.is())
1594 	{
1595 		// das Control kann mir sein Model sagen ...
1596 		Reference< XControlModel> xActiveModel( xActiveControl->getModel());
1597 		DBG_ASSERT(xActiveModel.is(), "FmXFormShell::ExecuteSearch : active control has no model !");
1598 
1599 		// das Model frage ich nach der ControlSource-Eigenschaft ...
1600 		Reference< XPropertySet> xProperties(xActiveControl->getModel(), UNO_QUERY);
1601 		if (::comphelper::hasProperty(FM_PROP_CONTROLSOURCE, xProperties) && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xProperties))
1602 		{
1603 			Reference< XPropertySet> xField;
1604 			xProperties->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
1605 			if (xField.is())	// (nur wenn das Ding wirklich gebunden ist)
1606 			{
1607 				// und das Control selber nach einem TextComponent-Interface (damit ich mir dort den Text abholen kann)
1608 				Reference< XTextComponent> xText(xActiveControl, UNO_QUERY);
1609 				if (xText.is())
1610 				{
1611 					strActiveField = getLabelName(xProperties).getStr();
1612 					strInitialText = xText->getText().getStr();
1613 				}
1614 			}
1615 		}
1616 		else
1617 		{
1618 			// das Control selber hat keine ControlSource, aber vielleicht ist es ein GridControl
1619 			Reference< XGrid> xGrid(xActiveControl, UNO_QUERY);
1620 			if (xGrid.is())
1621 			{
1622 				// fuer strActiveField brauche ich die die ControlSource der Column, dafuer den Columns-Container, dafuer die
1623 				// GridPeer
1624 				Reference< XGridPeer> xGridPeer(xActiveControl->getPeer(), UNO_QUERY);
1625 				Reference< XIndexAccess> xColumns;
1626 				if (xGridPeer.is())
1627 					xColumns = Reference< XIndexAccess>(xGridPeer->getColumns(),UNO_QUERY);
1628 
1629 				sal_Int16 nViewCol = xGrid->getCurrentColumnPosition();
1630 				sal_Int16 nModelCol = GridView2ModelPos(xColumns, nViewCol);
1631 				Reference< XPropertySet> xCurrentCol;
1632 				if(xColumns.is())
1633 					xColumns->getByIndex(nModelCol) >>= xCurrentCol;
1634 				if (xCurrentCol.is())
1635 					strActiveField = ::comphelper::getString(xCurrentCol->getPropertyValue(FM_PROP_LABEL)).getStr();
1636 
1637 				// the text fo the current column
1638 				Reference< XIndexAccess> xColControls(xGridPeer, UNO_QUERY);
1639 				Reference< XInterface> xCurControl;
1640 				xColControls->getByIndex(nViewCol) >>= xCurControl;
1641 				::rtl::OUString sInitialText;
1642 				if (IsSearchableControl(xCurControl, &sInitialText))
1643 					strInitialText = sInitialText.getStr();
1644 			}
1645 		}
1646 	}
1647 
1648 	// um eventuelle GridControls, die ich kenne, kuemmern
1649 	LoopGrids(GA_DISABLE_SYNC /*| GA_ENABLE_ROCTRLR*/);
1650 
1651 	// jetzt bin ich reif fuer den Dialog
1652 	// wenn die potentiellen Deadlocks, die durch die Benutzung des Solar-Mutex in MTs VCLX...-Klasen entstehen, irgendwann mal
1653 	// ausgeraeumt sind, sollte hier ein SM_USETHREAD rein, denn die Suche in einem eigenen Thread ist doch etwas fluessiger
1654 	// sollte allerdings irgendwie von dem unterliegenden Cursor abhaengig gemacht werden, DAO zum Beispiel ist nicht thread-sicher
1655 	SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1656     AbstractFmSearchDialog* pDialog = NULL;
1657     if ( pFact )
1658 	    pDialog = pFact->CreateFmSearchDialog( &m_pShell->GetViewShell()->GetViewFrame()->GetWindow(), strInitialText, aContextNames, nInitialContext, LINK( this, FmXFormShell, OnSearchContextRequest ) );
1659     DBG_ASSERT( pDialog, "FmXFormShell::ExecuteSearch: could not create the search dialog!" );
1660     if ( pDialog )
1661     {
1662 	    pDialog->SetActiveField( strActiveField );
1663 	    pDialog->SetFoundHandler( LINK( this, FmXFormShell, OnFoundData ) );
1664 	    pDialog->SetCanceledNotFoundHdl( LINK( this, FmXFormShell, OnCanceledNotFound ) );
1665 	    pDialog->Execute();
1666 	    delete pDialog;
1667     }
1668 
1669 	// GridControls wieder restaurieren
1670 	LoopGrids(GA_ENABLE_SYNC | GA_DISABLE_ROCTRLR);
1671 
1672 	m_pShell->GetFormView()->UnMarkAll(m_pShell->GetFormView()->GetSdrPageView());
1673 		// da ich in OnFoundData (fals ich dort war) Controls markiert habe
1674 }
1675 
1676 //------------------------------------------------------------------------------
GetY2KState(sal_uInt16 & n)1677 sal_Bool FmXFormShell::GetY2KState(sal_uInt16& n)
1678 {
1679     if ( impl_checkDisposed() )
1680         return sal_False;
1681 
1682 	if (m_pShell->IsDesignMode())
1683 		// im Design-Modus (ohne aktive Controls) soll sich das Haupt-Dokument darum kuemmern
1684 		return sal_False;
1685 
1686 	Reference< XForm> xForm( getActiveForm());
1687 	if (!xForm.is())
1688 		// kein aktuelles Formular (also insbesondere kein aktuelles Control) -> das Haupt-Dokument soll sich kuemmern
1689 		return sal_False;
1690 
1691 	Reference< XRowSet> xDB(xForm, UNO_QUERY);
1692 	DBG_ASSERT(xDB.is(), "FmXFormShell::GetY2KState : current form has no dbform-interface !");
1693 
1694 	Reference< XNumberFormatsSupplier> xSupplier( getNumberFormats(OStaticDataAccessTools().getRowSetConnection(xDB), sal_False));
1695 	if (xSupplier.is())
1696 	{
1697 		Reference< XPropertySet> xSet(xSupplier->getNumberFormatSettings());
1698 		if (xSet.is())
1699 		{
1700 			try
1701 			{
1702 				Any aVal( xSet->getPropertyValue(::rtl::OUString::createFromAscii("TwoDigitDateStart")) );
1703 				aVal >>= n;
1704 				return sal_True;
1705 			}
1706 			catch(Exception&)
1707 			{
1708 			}
1709 
1710 		}
1711 	}
1712 	return sal_False;
1713 }
1714 
1715 //------------------------------------------------------------------------------
SetY2KState(sal_uInt16 n)1716 void FmXFormShell::SetY2KState(sal_uInt16 n)
1717 {
1718     if ( impl_checkDisposed() )
1719         return;
1720 
1721 	Reference< XForm > xActiveForm( getActiveForm());
1722 	Reference< XRowSet > xActiveRowSet( xActiveForm, UNO_QUERY );
1723 	if ( xActiveRowSet.is() )
1724 	{
1725 		Reference< XNumberFormatsSupplier > xSupplier( getNumberFormats( getRowSetConnection( xActiveRowSet ), sal_False ) );
1726 		if (xSupplier.is())
1727 		{
1728 			Reference< XPropertySet> xSet(xSupplier->getNumberFormatSettings());
1729 			if (xSet.is())
1730 			{
1731 				try
1732 				{
1733 					Any aVal;
1734 					aVal <<= n;
1735 					xSet->setPropertyValue(::rtl::OUString::createFromAscii("TwoDigitDateStart"), aVal);
1736 				}
1737 				catch(Exception&)
1738 				{
1739 					DBG_ERROR("FmXFormShell::SetY2KState: Exception occured!");
1740 				}
1741 
1742 			}
1743 			return;
1744 		}
1745 	}
1746 
1747 	// kein aktives Formular gefunden -> alle aktuell vorhandenen Formulare durchiterieren
1748 	Reference< XIndexAccess> xCurrentForms( m_xForms);
1749 	if (!xCurrentForms.is())
1750 	{	// im alive-Modus sind meine Forms nicht gesetzt, wohl aber die an der Page
1751 		if (m_pShell->GetCurPage())
1752 			xCurrentForms = Reference< XIndexAccess>( m_pShell->GetCurPage()->GetForms( false ), UNO_QUERY );
1753 	}
1754 	if (!xCurrentForms.is())
1755 		return;
1756 
1757 	::comphelper::IndexAccessIterator aIter(xCurrentForms);
1758 	Reference< XInterface> xCurrentElement( aIter.Next());
1759 	while (xCurrentElement.is())
1760 	{
1761 		// ist das aktuelle Element eine DatabaseForm ?
1762 		Reference< XRowSet> xElementAsRowSet( xCurrentElement, UNO_QUERY );
1763 		if ( xElementAsRowSet.is() )
1764 		{
1765 			Reference< XNumberFormatsSupplier > xSupplier( getNumberFormats( getRowSetConnection( xElementAsRowSet ), sal_False ) );
1766 			if (!xSupplier.is())
1767 				continue;
1768 
1769 			Reference< XPropertySet> xSet(xSupplier->getNumberFormatSettings());
1770 			if (xSet.is())
1771 			{
1772 				try
1773 				{
1774 					Any aVal;
1775 					aVal <<= n;
1776 					xSet->setPropertyValue(::rtl::OUString::createFromAscii("TwoDigitDateStart"), aVal);
1777 				}
1778 				catch(Exception&)
1779 				{
1780 					DBG_ERROR("FmXFormShell::SetY2KState: Exception occured!");
1781 				}
1782 
1783 			}
1784 		}
1785 		xCurrentElement = aIter.Next();
1786 	}
1787 }
1788 
1789 //------------------------------------------------------------------------------
CloseExternalFormViewer()1790 void FmXFormShell::CloseExternalFormViewer()
1791 {
1792     if ( impl_checkDisposed() )
1793         return;
1794 
1795 	if (!m_xExternalViewController.is())
1796 		return;
1797 
1798 	Reference< ::com::sun::star::frame::XFrame> xExternalViewFrame( m_xExternalViewController->getFrame());
1799 	Reference< ::com::sun::star::frame::XDispatchProvider> xCommLink(xExternalViewFrame, UNO_QUERY);
1800 	if (!xCommLink.is())
1801 		return;
1802 
1803 	xExternalViewFrame->setComponent(NULL,NULL);
1804 	::comphelper::disposeComponent(xExternalViewFrame);
1805 	m_xExternalViewController	= NULL;
1806 	m_xExtViewTriggerController = NULL;
1807 	m_xExternalDisplayedForm	= NULL;
1808 }
1809 
1810 //------------------------------------------------------------------------------
getInternalForm(const Reference<XResultSet> & _xForm) const1811 Reference< XResultSet> FmXFormShell::getInternalForm(const Reference< XResultSet>& _xForm) const
1812 {
1813     if ( impl_checkDisposed() )
1814         return NULL;
1815 
1816 	Reference< runtime::XFormController> xExternalCtrlr(m_xExternalViewController, UNO_QUERY);
1817 	if (xExternalCtrlr.is() && (_xForm == xExternalCtrlr->getModel()))
1818 	{
1819 		DBG_ASSERT(m_xExternalDisplayedForm.is(), "FmXFormShell::getInternalForm : invalid external form !");
1820 		return m_xExternalDisplayedForm;
1821 	}
1822 	return _xForm;
1823 }
1824 
1825 //------------------------------------------------------------------------------
getInternalForm(const Reference<XForm> & _xForm) const1826 Reference< XForm> FmXFormShell::getInternalForm(const Reference< XForm>& _xForm) const
1827 {
1828     if ( impl_checkDisposed() )
1829         return NULL;
1830 
1831 	Reference< runtime::XFormController > xExternalCtrlr(m_xExternalViewController, UNO_QUERY);
1832 	if (xExternalCtrlr.is() && (_xForm == xExternalCtrlr->getModel()))
1833 	{
1834 		DBG_ASSERT(m_xExternalDisplayedForm.is(), "FmXFormShell::getInternalForm : invalid external form !");
1835 		return Reference< XForm>(m_xExternalDisplayedForm, UNO_QUERY);
1836 	}
1837 	return _xForm;
1838 }
1839 
1840 //------------------------------------------------------------------------
1841 namespace
1842 {
lcl_isNavigationRelevant(sal_Int32 _nWhich)1843     static bool lcl_isNavigationRelevant( sal_Int32 _nWhich )
1844     {
1845 	    return  ( _nWhich == SID_FM_RECORD_FIRST )
1846 	        ||  ( _nWhich == SID_FM_RECORD_PREV )
1847             ||  ( _nWhich == SID_FM_RECORD_NEXT )
1848 	        ||  ( _nWhich == SID_FM_RECORD_LAST )
1849 	        ||  ( _nWhich == SID_FM_RECORD_NEW );
1850     }
1851 }
1852 
1853 //------------------------------------------------------------------------------
IsFormSlotEnabled(sal_Int32 _nSlot,FeatureState * _pCompleteState)1854 bool FmXFormShell::IsFormSlotEnabled( sal_Int32 _nSlot, FeatureState* _pCompleteState )
1855 {
1856     const ::svx::ControllerFeatures& rController =
1857             lcl_isNavigationRelevant( _nSlot )
1858         ?   getNavControllerFeatures()
1859         :   getActiveControllerFeatures();
1860 
1861     if ( !_pCompleteState )
1862         return rController->isEnabled( _nSlot );
1863 
1864     rController->getState( _nSlot, *_pCompleteState );
1865     return _pCompleteState->Enabled;
1866 }
1867 
1868 //------------------------------------------------------------------------------
ExecuteFormSlot(sal_Int32 _nSlot)1869 void FmXFormShell::ExecuteFormSlot( sal_Int32 _nSlot )
1870 {
1871     const ::svx::ControllerFeatures& rController =
1872             lcl_isNavigationRelevant( _nSlot )
1873         ?   getNavControllerFeatures()
1874         :   getActiveControllerFeatures();
1875 
1876     rController->execute( _nSlot );
1877 
1878     if ( _nSlot == SID_FM_RECORD_UNDO )
1879     {
1880         // if we're doing an UNDO, *and* if the affected form is the form which we also display
1881         // as external view, then we need to reset the controls of the external form, too
1882 		if ( getInternalForm( getActiveForm() ) == m_xExternalDisplayedForm )
1883         {
1884 	        Reference< XIndexAccess > xContainer( m_xExternalDisplayedForm, UNO_QUERY );
1885 		    if ( xContainer.is() )
1886 		    {
1887 			    Reference< XReset > xReset;
1888 			    for ( sal_Int32 i = 0; i < xContainer->getCount(); ++i )
1889 			    {
1890 				    if ( ( xContainer->getByIndex( i ) >>= xReset ) && xReset.is() )
1891 				    {
1892                         // no resets on sub forms
1893 					    Reference< XForm > xAsForm( xReset, UNO_QUERY );
1894 					    if ( !xAsForm.is() )
1895 						    xReset->reset();
1896 				    }
1897 			    }
1898 		    }
1899 		}
1900 	}
1901 }
1902 
1903 //------------------------------------------------------------------------------
impl_switchActiveControllerListening(const bool _bListen)1904 void FmXFormShell::impl_switchActiveControllerListening( const bool _bListen )
1905 {
1906     Reference< XComponent> xComp( m_xActiveController, UNO_QUERY );
1907     if ( !xComp.is() )
1908         return;
1909 
1910     if ( _bListen )
1911         xComp->addEventListener( (XFormControllerListener*)this );
1912     else
1913         xComp->removeEventListener( (XFormControllerListener*)this );
1914 }
1915 
1916 //------------------------------------------------------------------------------
setActiveController(const Reference<runtime::XFormController> & xController,sal_Bool _bNoSaveOldContent)1917 void FmXFormShell::setActiveController( const Reference< runtime::XFormController >& xController, sal_Bool _bNoSaveOldContent )
1918 {
1919     if ( impl_checkDisposed() )
1920         return;
1921 
1922 	if (m_bChangingDesignMode)
1923 		return;
1924 	DBG_ASSERT(!m_pShell->IsDesignMode(), "nur im alive mode verwenden");
1925 
1926 	// Ist die Routine ein zweites Mal gerufen worden,
1927 	// dann sollte der Focus nicht mehr umgesetzt werden
1928 	if (m_bInActivate)
1929 	{
1930 		m_bSetFocus = xController != m_xActiveController;
1931 		return;
1932 	}
1933 
1934 	if (xController != m_xActiveController)
1935 	{
1936 		::osl::ClearableMutexGuard aGuard(m_aAsyncSafety);
1937 		// switch all nav dispatchers belonging to the form of the current nav controller to 'non active'
1938 		Reference< XResultSet> xNavigationForm;
1939 		if (m_xNavigationController.is())
1940 			xNavigationForm = Reference< XResultSet>(m_xNavigationController->getModel(), UNO_QUERY);
1941 		aGuard.clear();
1942 
1943 		m_bInActivate = sal_True;
1944 
1945 		// check if the 2 controllers serve different forms
1946 		Reference< XResultSet> xOldForm;
1947 		if (m_xActiveController.is())
1948 			xOldForm = Reference< XResultSet>(m_xActiveController->getModel(), UNO_QUERY);
1949 		Reference< XResultSet> xNewForm;
1950 		if (xController.is())
1951 			xNewForm = Reference< XResultSet>(xController->getModel(), UNO_QUERY);
1952 		xOldForm = getInternalForm(xOldForm);
1953 		xNewForm = getInternalForm(xNewForm);
1954 
1955 		sal_Bool bDifferentForm = ( xOldForm.get() != xNewForm.get() );
1956 		sal_Bool bNeedSave = bDifferentForm && !_bNoSaveOldContent;
1957 			// we save the content of the old form if we move to a new form, and saving old content is allowed
1958 
1959 		if ( m_xActiveController.is() && bNeedSave )
1960 		{
1961 			// beim Wechsel des Controllers den Inhalt speichern, ein Commit
1962 			// wurde bereits ausgefuehrt
1963             if ( m_aActiveControllerFeatures->commitCurrentControl() )
1964 			{
1965 				m_bSetFocus = sal_True;
1966                 if ( m_aActiveControllerFeatures->isModifiedRow() )
1967                 {
1968                     sal_Bool bIsNew = m_aActiveControllerFeatures->isInsertionRow();
1969                     sal_Bool bResult = m_aActiveControllerFeatures->commitCurrentRecord();
1970                     if ( !bResult && m_bSetFocus )
1971                     {
1972                         // if we couldn't save the current record, set the focus back to the
1973                         // current control
1974 						Reference< XWindow > xWindow( m_xActiveController->getCurrentControl(), UNO_QUERY );
1975                         if ( xWindow.is() )
1976 						    xWindow->setFocus();
1977 						m_bInActivate = sal_False;
1978 						return;
1979 					}
1980                     else if ( bResult && bIsNew )
1981 					{
1982                         Reference< XResultSet > xCursor( m_aActiveControllerFeatures->getCursor().get() );
1983                         if ( xCursor.is() )
1984                         {
1985 						    DO_SAFE( xCursor->last(); );
1986                         }
1987 					}
1988 				}
1989 			}
1990 		}
1991 
1992 		stopListening();
1993 
1994         impl_switchActiveControllerListening( false );
1995 
1996         m_aActiveControllerFeatures.dispose();
1997 		m_xActiveController = xController;
1998         if ( m_xActiveController.is() )
1999             m_aActiveControllerFeatures.assign( m_xActiveController );
2000 
2001         impl_switchActiveControllerListening( true );
2002 
2003         if ( m_xActiveController.is() )
2004 			m_xActiveForm = getInternalForm( Reference< XForm >( m_xActiveController->getModel(), UNO_QUERY ) );
2005 		else
2006 			m_xActiveForm = NULL;
2007 
2008 		startListening();
2009 
2010 		// activate all dispatchers belonging to form of the new navigation controller
2011 		xNavigationForm = NULL;
2012 		if (m_xNavigationController.is())
2013 			xNavigationForm = Reference< XResultSet>(m_xNavigationController->getModel(), UNO_QUERY);
2014 
2015 		m_bInActivate = sal_False;
2016 
2017 		m_pShell->UIFeatureChanged();
2018 		m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell);
2019 
2020 		InvalidateSlot(SID_FM_FILTER_NAVIGATOR_CONTROL, sal_True);
2021 	}
2022 }
2023 
2024 //------------------------------------------------------------------------------
getCurrentSelection(InterfaceBag & _rSelection) const2025 void FmXFormShell::getCurrentSelection( InterfaceBag& /* [out] */ _rSelection ) const
2026 {
2027     _rSelection = m_aCurrentSelection;
2028 }
2029 
2030 //------------------------------------------------------------------------------
setCurrentSelectionFromMark(const SdrMarkList & _rMarkList)2031 bool FmXFormShell::setCurrentSelectionFromMark( const SdrMarkList& _rMarkList )
2032 {
2033     m_aLastKnownMarkedControls.clear();
2034 
2035     if ( ( _rMarkList.GetMarkCount() > 0 ) && isControlList( _rMarkList ) )
2036         collectInterfacesFromMarkList( _rMarkList, m_aLastKnownMarkedControls );
2037 
2038     return setCurrentSelection( m_aLastKnownMarkedControls );
2039 }
2040 
2041 //------------------------------------------------------------------------------
selectLastMarkedControls()2042 bool FmXFormShell::selectLastMarkedControls()
2043 {
2044     return setCurrentSelection( m_aLastKnownMarkedControls );
2045 }
2046 
2047 //------------------------------------------------------------------------------
setCurrentSelection(const InterfaceBag & _rSelection)2048 bool FmXFormShell::setCurrentSelection( const InterfaceBag& _rSelection )
2049 {
2050     if ( impl_checkDisposed() )
2051         return false;
2052 
2053     DBG_ASSERT( m_pShell->IsDesignMode(), "FmXFormShell::setCurrentSelection: only to be used in design mode!" );
2054 
2055     if ( _rSelection.empty() && m_aCurrentSelection.empty() )
2056         // nothing to do
2057         return false;
2058 
2059     if ( _rSelection.size() == m_aCurrentSelection.size() )
2060     {
2061         InterfaceBag::const_iterator aNew = _rSelection.begin();
2062         InterfaceBag::const_iterator aOld = m_aCurrentSelection.begin();
2063         for ( ; aNew != _rSelection.end(); ++aNew, ++aOld )
2064         {
2065             OSL_ENSURE( Reference< XInterface >( *aNew, UNO_QUERY ).get() == aNew->get(), "FmXFormShell::setCurrentSelection: new interface not normalized!" );
2066             OSL_ENSURE( Reference< XInterface >( *aOld, UNO_QUERY ).get() == aOld->get(), "FmXFormShell::setCurrentSelection: old interface not normalized!" );
2067 
2068             if ( aNew->get() != aOld->get() )
2069                 break;
2070         }
2071 
2072         if ( aNew == _rSelection.end() )
2073             // both bags equal
2074             return false;
2075     }
2076 
2077     // the following is some strange code to ensure that when you have two grid controls in a document,
2078     // only one of them can have a selected column.
2079     // TODO: this should happen elsewhere, but not here - shouldn't it?
2080     if ( !m_aCurrentSelection.empty() )
2081     {
2082 		Reference< XChild > xCur; if ( m_aCurrentSelection.size() == 1 ) xCur = xCur.query( *m_aCurrentSelection.begin() );
2083 		Reference< XChild > xNew; if ( _rSelection.size() == 1 ) xNew = xNew.query( *_rSelection.begin() );
2084 
2085         // is there nothing to be selected, or the parents differ, and the parent of the current object
2086         // is a selection supplier, then deselect
2087 		if ( xCur.is() && ( !xNew.is() || ( xCur->getParent() != xNew->getParent() ) ) )
2088         {
2089 			Reference< XSelectionSupplier > xSel( xCur->getParent(), UNO_QUERY );
2090 			if ( xSel.is() )
2091 				xSel->select( Any() );
2092 		}
2093 	}
2094 
2095     m_aCurrentSelection = _rSelection;
2096 
2097     // determine the form which all the selected obj�cts belong to, if any
2098     Reference< XForm > xNewCurrentForm;
2099     for ( InterfaceBag::const_iterator loop = m_aCurrentSelection.begin();
2100           loop != m_aCurrentSelection.end();
2101           ++loop
2102         )
2103     {
2104         Reference< XForm > xThisRoundsForm( GetForm( *loop ) );
2105         OSL_ENSURE( xThisRoundsForm.is(), "FmXFormShell::setCurrentSelection: *everything* should belong to a form!" );
2106 
2107         if ( !xNewCurrentForm.is() )
2108         {   // the first form we encounterd
2109             xNewCurrentForm = xThisRoundsForm;
2110         }
2111         else if ( xNewCurrentForm != xThisRoundsForm )
2112         {   // different forms -> no "current form" at all
2113             xNewCurrentForm.clear();
2114             break;
2115         }
2116     }
2117 
2118     if ( !m_aCurrentSelection.empty() )
2119         impl_updateCurrentForm( xNewCurrentForm );
2120 
2121     // ensure some slots are updated
2122 	for ( size_t i = 0; i < sizeof( SelObjectSlotMap ) / sizeof( SelObjectSlotMap[0] ); ++i )
2123 		InvalidateSlot( SelObjectSlotMap[i], sal_False);
2124 
2125     return true;
2126 }
2127 
2128 //------------------------------------------------------------------------------
isSolelySelected(const Reference<XInterface> & _rxObject)2129 bool FmXFormShell::isSolelySelected( const Reference< XInterface >& _rxObject )
2130 {
2131     return ( m_aCurrentSelection.size() == 1 ) && ( *m_aCurrentSelection.begin() == _rxObject );
2132 }
2133 
2134 //------------------------------------------------------------------------------
forgetCurrentForm()2135 void FmXFormShell::forgetCurrentForm()
2136 {
2137     if ( !m_xCurrentForm.is() )
2138         return;
2139 
2140     // reset ...
2141     impl_updateCurrentForm( NULL );
2142 
2143     // ... and try finding a new current form
2144     // #i88186# / 2008-04-12 / frank.schoenheit@sun.com
2145     impl_defaultCurrentForm_nothrow();
2146 }
2147 
2148 //------------------------------------------------------------------------------
impl_updateCurrentForm(const Reference<XForm> & _rxNewCurForm)2149 void FmXFormShell::impl_updateCurrentForm( const Reference< XForm >& _rxNewCurForm )
2150 {
2151     if ( impl_checkDisposed() )
2152         return;
2153 
2154     m_xCurrentForm = _rxNewCurForm;
2155 
2156     // propagate to the FormPage(Impl)
2157     FmFormPage* pPage = m_pShell->GetCurPage();
2158 	if ( pPage )
2159 		pPage->GetImpl().setCurForm( m_xCurrentForm );
2160 
2161     // ensure the UI which depends on the current form is up-to-date
2162     for ( size_t i = 0; i < sizeof( DlgSlotMap ) / sizeof( DlgSlotMap[0] ); ++i )
2163 		InvalidateSlot( DlgSlotMap[i], sal_False );
2164 }
2165 
2166 //------------------------------------------------------------------------------
startListening()2167 void FmXFormShell::startListening()
2168 {
2169     if ( impl_checkDisposed() )
2170         return;
2171 
2172 	Reference< XRowSet> xDatabaseForm(m_xActiveForm, UNO_QUERY);
2173 	if (xDatabaseForm.is() && getRowSetConnection(xDatabaseForm).is())
2174 	{
2175 		Reference< XPropertySet> xActiveFormSet(m_xActiveForm, UNO_QUERY);
2176 		if (xActiveFormSet.is())
2177 		{
2178 			// wenn es eine Datenquelle gibt, dann den Listener aufbauen
2179             // TODO: this is strange - shouldn't this depend on a isLoaded instead of
2180             // a "has command value"? Finally, the command value only means that it was
2181             // intended to be loaded, not that it actually *is* loaded
2182 			::rtl::OUString aSource = ::comphelper::getString(xActiveFormSet->getPropertyValue(FM_PROP_COMMAND));
2183 			if (aSource.getLength())
2184 			{
2185 				m_bDatabaseBar = sal_True;
2186 
2187 				xActiveFormSet->getPropertyValue(FM_PROP_NAVIGATION) >>= m_eNavigate;
2188 
2189 				switch (m_eNavigate)
2190 				{
2191 					case NavigationBarMode_PARENT:
2192 					{
2193 						// suchen des Controllers, ueber den eine Navigation moeglich ist
2194 						Reference< XChild> xChild(m_xActiveController, UNO_QUERY);
2195 						Reference< runtime::XFormController > xParent;
2196 						while (xChild.is())
2197 						{
2198 							xChild = Reference< XChild>(xChild->getParent(), UNO_QUERY);
2199 							xParent  = Reference< runtime::XFormController >(xChild, UNO_QUERY);
2200 							Reference< XPropertySet> xParentSet;
2201 							if (xParent.is())
2202 								xParentSet = Reference< XPropertySet>(xParent->getModel(), UNO_QUERY);
2203 							if (xParentSet.is())
2204 							{
2205 								xParentSet->getPropertyValue(FM_PROP_NAVIGATION) >>= m_eNavigate;
2206 								if (m_eNavigate == NavigationBarMode_CURRENT)
2207 									break;
2208 							}
2209 						}
2210 						m_xNavigationController = xParent;
2211 					}
2212                     break;
2213 
2214 					case NavigationBarMode_CURRENT:
2215 						m_xNavigationController = m_xActiveController;
2216 						break;
2217 
2218 					default:
2219 						m_xNavigationController = NULL;
2220 						m_bDatabaseBar = sal_False;
2221 				}
2222 
2223                 m_aNavControllerFeatures.dispose();
2224                 if ( m_xNavigationController.is() && ( m_xNavigationController != m_xActiveController ) )
2225                     m_aNavControllerFeatures.assign( m_xNavigationController );
2226 
2227 				// an dem Controller, der die Navigation regelt, wg. RecordCount lauschen
2228 				Reference< XPropertySet> xNavigationSet;
2229 				if (m_xNavigationController.is())
2230 				{
2231 					xNavigationSet = Reference< XPropertySet>(m_xNavigationController->getModel(), UNO_QUERY);
2232 					if (xNavigationSet.is())
2233 						xNavigationSet->addPropertyChangeListener(FM_PROP_ROWCOUNT,this);
2234 				}
2235 				return;
2236 			}
2237 		}
2238 	}
2239 
2240 	m_eNavigate  = NavigationBarMode_NONE;
2241 	m_bDatabaseBar = sal_False;
2242 	m_xNavigationController = NULL;
2243 }
2244 
2245 //------------------------------------------------------------------------------
stopListening()2246 void FmXFormShell::stopListening()
2247 {
2248     if ( impl_checkDisposed() )
2249         return;
2250 
2251 	Reference< XRowSet> xDatabaseForm(m_xActiveForm, UNO_QUERY);
2252 	if ( xDatabaseForm.is() )
2253 	{
2254 		if (m_xNavigationController.is())
2255 		{
2256 			Reference< XPropertySet> xSet(m_xNavigationController->getModel(), UNO_QUERY);
2257 			if (xSet.is())
2258 				xSet->removePropertyChangeListener(FM_PROP_ROWCOUNT, this);
2259 
2260 		}
2261 	}
2262 
2263 	m_bDatabaseBar = sal_False;
2264 	m_eNavigate  = NavigationBarMode_NONE;
2265 	m_xNavigationController = NULL;
2266 }
2267 
2268 //------------------------------------------------------------------------------
ShowSelectionProperties(sal_Bool bShow)2269 void FmXFormShell::ShowSelectionProperties( sal_Bool bShow )
2270 {
2271     if ( impl_checkDisposed() )
2272         return;
2273 
2274 	// if the window is already visible, only update the state
2275 	sal_Bool bHasChild = m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_SHOW_PROPERTIES );
2276 	if ( bHasChild && bShow )
2277 		UpdateSlot( SID_FM_PROPERTY_CONTROL );
2278 
2279 	// else toggle state
2280 	else
2281 		m_pShell->GetViewShell()->GetViewFrame()->ToggleChildWindow(SID_FM_SHOW_PROPERTIES);
2282 
2283 	InvalidateSlot( SID_FM_PROPERTIES, sal_False );
2284 	InvalidateSlot( SID_FM_CTL_PROPERTIES, sal_False );
2285 }
2286 
2287 //------------------------------------------------------------------------------
IMPL_LINK(FmXFormShell,OnFoundData,FmFoundRecordInformation *,pfriWhere)2288 IMPL_LINK(FmXFormShell, OnFoundData, FmFoundRecordInformation*, pfriWhere)
2289 {
2290     if ( impl_checkDisposed() )
2291         return 0;
2292 
2293 	DBG_ASSERT((pfriWhere->nContext >= 0) && (pfriWhere->nContext < (sal_Int16)m_aSearchForms.size()),
2294 		"FmXFormShell::OnFoundData : ungueltiger Kontext !");
2295 	Reference< XForm> xForm( m_aSearchForms.at(pfriWhere->nContext));
2296 	DBG_ASSERT(xForm.is(), "FmXFormShell::OnFoundData : ungueltige Form !");
2297 
2298 	Reference< XRowLocate> xCursor(xForm, UNO_QUERY);
2299 	if (!xCursor.is())
2300 		return 0;		// was soll ich da machen ?
2301 
2302 	// zum Datensatz
2303 	try
2304 	{
2305 		xCursor->moveToBookmark(pfriWhere->aPosition);
2306 	}
2307 	catch(const SQLException&)
2308 	{
2309 		OSL_ENSURE(0,"Can position on bookmark!");
2310 	}
2311 
2312 	LoopGrids(GA_FORCE_SYNC);
2313 
2314 	// und zum Feld (dazu habe ich vor dem Start des Suchens die XVclComponent-Interfaces eingesammelt)
2315 	DBG_ASSERT(pfriWhere->nFieldPos < m_arrSearchedControls.Count(), "FmXFormShell::OnFoundData : ungueltige Daten uebergeben !");
2316 	SdrObject* pObject = m_arrSearchedControls.GetObject(pfriWhere->nFieldPos);
2317 	DBG_ASSERT(pObject != NULL, "FmXFormShell::OnFoundData : unerwartet : ungueltiges VclControl-Interface");
2318 
2319 	m_pShell->GetFormView()->UnMarkAll(m_pShell->GetFormView()->GetSdrPageView());
2320 	m_pShell->GetFormView()->MarkObj(pObject, m_pShell->GetFormView()->GetSdrPageView());
2321 
2322     FmFormObj* pFormObject = FmFormObj::GetFormObject( pObject );
2323     Reference< XControlModel > xControlModel( pFormObject ? pFormObject->GetUnoControlModel() : Reference< XControlModel >() );
2324 	DBG_ASSERT( xControlModel.is(), "FmXFormShell::OnFoundData: invalid control!" );
2325     if ( !xControlModel.is() )
2326         return 0;
2327 
2328 	// disable the permanent cursor for the last grid we found a record
2329 	if (m_xLastGridFound.is() && (m_xLastGridFound != xControlModel))
2330 	{
2331 		Reference< XPropertySet> xOldSet(m_xLastGridFound, UNO_QUERY);
2332 		xOldSet->setPropertyValue(FM_PROP_ALWAYSSHOWCURSOR, makeAny( (sal_Bool)sal_False ) );
2333 		Reference< XPropertyState> xOldSetState(xOldSet, UNO_QUERY);
2334 		if (xOldSetState.is())
2335 			xOldSetState->setPropertyToDefault(FM_PROP_CURSORCOLOR);
2336 		else
2337 			xOldSet->setPropertyValue(FM_PROP_CURSORCOLOR, Any());
2338 	}
2339 
2340 	// wenn das Feld sich in einem GridControl befindet, muss ich dort noch in die entsprechende Spalte gehen
2341 	sal_Int32 nGridColumn = m_arrRelativeGridColumn.GetObject(pfriWhere->nFieldPos);
2342 	if (nGridColumn != -1)
2343 	{	// dummer weise muss ich mir das Control erst wieder besorgen
2344 		Reference< XControl> xControl( impl_getControl( xControlModel, *pFormObject ) );
2345 		Reference< XGrid> xGrid(xControl, UNO_QUERY);
2346 		DBG_ASSERT(xGrid.is(), "FmXFormShell::OnFoundData : ungueltiges Control !");
2347 		// wenn eine der Asserts anschlaegt, habe ich beim Aufbauen von m_arrSearchedControls wohl was falsch gemacht
2348 
2349 		// enable a permanent cursor for the grid so we can see the found text
2350 		Reference< XPropertySet> xModelSet(xControlModel, UNO_QUERY);
2351 		DBG_ASSERT(xModelSet.is(), "FmXFormShell::OnFoundData : invalid control model (no property set) !");
2352 		xModelSet->setPropertyValue( FM_PROP_ALWAYSSHOWCURSOR, makeAny( (sal_Bool)sal_True ) );
2353 		xModelSet->setPropertyValue( FM_PROP_CURSORCOLOR, makeAny( sal_Int32( COL_LIGHTRED ) ) );
2354 		m_xLastGridFound = xControlModel;
2355 
2356         if ( xGrid.is() )
2357 		    xGrid->setCurrentColumnPosition((sal_Int16)nGridColumn);
2358 	}
2359 
2360 	// als der Cursor neu positioniert wurde, habe ich (in positioned) meine Formularleisten-Slots invalidiert, aber das greift
2361 	// hier dummerweise nicht, da i.A. ja der (modale) Suchdialog oben ist ... also Gewalt ...
2362 	sal_uInt16 nPos = 0;
2363 	while (DatabaseSlotMap[nPos])
2364 		m_pShell->GetViewShell()->GetViewFrame()->GetBindings().Update(DatabaseSlotMap[nPos++]);
2365 		// leider geht das Update im Gegensatz zum Invalidate nur mit einzelnen Slots)
2366 
2367 	return 0;
2368 }
2369 
2370 //------------------------------------------------------------------------------
IMPL_LINK(FmXFormShell,OnCanceledNotFound,FmFoundRecordInformation *,pfriWhere)2371 IMPL_LINK(FmXFormShell, OnCanceledNotFound, FmFoundRecordInformation*, pfriWhere)
2372 {
2373     if ( impl_checkDisposed() )
2374         return 0;
2375 
2376 	DBG_ASSERT((pfriWhere->nContext >= 0) && (pfriWhere->nContext < (sal_Int16)m_aSearchForms.size()),
2377 		"FmXFormShell::OnCanceledNotFound : ungueltiger Kontext !");
2378 	Reference< XForm> xForm( m_aSearchForms.at(pfriWhere->nContext));
2379 	DBG_ASSERT(xForm.is(), "FmXFormShell::OnCanceledNotFound : ungueltige Form !");
2380 
2381 	Reference< XRowLocate> xCursor(xForm, UNO_QUERY);
2382 	if (!xCursor.is())
2383 		return 0;		// was soll ich da machen ?
2384 
2385 	// zum Datensatz
2386 	try
2387 	{
2388 		xCursor->moveToBookmark(pfriWhere->aPosition);
2389 	}
2390 	catch(const SQLException&)
2391 	{
2392 		OSL_ENSURE(0,"Can position on bookmark!");
2393 	}
2394 
2395 
2396 	m_pShell->GetFormView()->UnMarkAll(m_pShell->GetFormView()->GetSdrPageView());
2397 	return 0L;
2398 }
2399 
2400 //------------------------------------------------------------------------------
IMPL_LINK(FmXFormShell,OnSearchContextRequest,FmSearchContext *,pfmscContextInfo)2401 IMPL_LINK(FmXFormShell, OnSearchContextRequest, FmSearchContext*, pfmscContextInfo)
2402 {
2403     if ( impl_checkDisposed() )
2404         return 0;
2405 
2406 	DBG_ASSERT(pfmscContextInfo->nContext < (sal_Int16)m_aSearchForms.size(), "FmXFormShell::OnSearchContextRequest : invalid parameter !");
2407 	Reference< XForm> xForm( m_aSearchForms.at(pfmscContextInfo->nContext));
2408 	DBG_ASSERT(xForm.is(), "FmXFormShell::OnSearchContextRequest : unexpected : invalid context !");
2409 
2410 	Reference< XResultSet> xIter(xForm, UNO_QUERY);
2411 	DBG_ASSERT(xIter.is(), "FmXFormShell::OnSearchContextRequest : unexpected : context has no iterator !");
2412 
2413 	// --------------------------------------------------------------------------------------------
2414 	// die Liste der zu involvierenden Felder zusammenstellen (sind die ControlSources aller Felder, die eine solche Eigenschaft habe)
2415 	UniString strFieldList, sFieldDisplayNames;
2416 	m_arrSearchedControls.Remove(0, m_arrSearchedControls.Count());
2417 	m_arrRelativeGridColumn.Remove(0, m_arrRelativeGridColumn.Count());
2418 
2419 	// folgendes kleines Problem : Ich brauche, um gefundene Felder zu markieren, SdrObjekte. Um hier festzustellen, welche Controls
2420 	// ich in die Suche einbeziehen soll, brauche ich Controls (also XControl-Interfaces). Ich muss also ueber eines von beiden
2421 	// iterieren und mir das jeweils andere besorgen. Dummerweise gibt es keine direkte Verbindung zwischen beiden Welten (abgesehen
2422 	// von einem GetUnoControl an SdrUnoObject, das aber ein OutputDevice verlangt, womit ich nichts anfangen kann).
2423 	// Allerdings komme ich sowohl von einem Control als auch von einem SdrObject zum Model, und damit ist mir mit einer doppelten
2424 	// Schleife die Zuordnung SdrObject<->Control moeglich.
2425 	// Die Alternative zu dieser (unschoenen und sicher auch nicht ganz fixen) Loesung waere, auf das Cachen der SdrObjects zu
2426 	// verzichten, was dann aber in OnFoundData zu wesentlicher Mehrarbeit fuehren wuerde (da ich mir dort jedesmal das SdrObject
2427 	// erst besorgen muesste). Da aber OnFoundData i.d.R. oefter aufgerufen wird als ExecuteSearch, erledige ich das hier.
2428 
2429 	Reference< XNameAccess> xValidFormFields;
2430 	Reference< XColumnsSupplier> xSupplyCols(xIter, UNO_QUERY);
2431 	DBG_ASSERT(xSupplyCols.is(), "FmXFormShell::OnSearchContextRequest : invalid cursor : no columns supplier !");
2432 	if (xSupplyCols.is())
2433 		xValidFormFields = xSupplyCols->getColumns();
2434 	DBG_ASSERT(xValidFormFields.is(), "FmXFormShell::OnSearchContextRequest : form has no fields !");
2435 
2436 	// aktuelle(r) Page/Controller
2437 	FmFormPage* pCurrentPage = m_pShell->GetCurPage();
2438 	DBG_ASSERT(pCurrentPage!=NULL, "FmXFormShell::OnSearchContextRequest : no page !");
2439 	// alle Sdr-Controls dieser Seite durchsuchen ...
2440 	::rtl::OUString sControlSource, aName;
2441 
2442     SdrObjListIter aPageIter( *pCurrentPage );
2443     while ( aPageIter.IsMore() )
2444     {
2445         SdrObject* pCurrent = aPageIter.Next();
2446         FmFormObj* pFormObject = FmFormObj::GetFormObject( pCurrent );
2447             // note that in case pCurrent is a virtual object, pFormObject points to the referenced object
2448 
2449         if ( !pFormObject )
2450             continue;
2451 
2452         // the current object's model, in different tastes
2453         Reference< XControlModel> xControlModel( pFormObject->GetUnoControlModel() );
2454         Reference< XFormComponent > xCurrentFormComponent( xControlModel, UNO_QUERY );
2455         DBG_ASSERT( xCurrentFormComponent.is(), "FmXFormShell::OnSearchContextRequest: invalid objects!" );
2456         if ( !xCurrentFormComponent.is() )
2457             continue;
2458 
2459         // does the component belong to the form which we're interested in?
2460         if ( xCurrentFormComponent->getParent() != xForm )
2461             continue;
2462 
2463         // ... nach der ControlSource-Eigenschaft fragen
2464         SearchableControlIterator iter( xCurrentFormComponent );
2465         Reference< XControl> xControl;
2466             // das Control, das als Model xControlModel hat
2467             // (das folgende while kann mehrmals durchlaufen werden, ohne dass das Control sich aendert, dann muss
2468             // ich nicht jedesmal neu suchen)
2469 
2470         Reference< XInterface > xSearchable( iter.Next() );
2471         while ( xSearchable.is() )
2472         {
2473             sControlSource = iter.getCurrentValue();
2474             if ( sControlSource.getLength() == 0 )
2475             {	// das aktuelle Element hat keine ControlSource, also ist es ein GridControl (das ist das einzige, was
2476                 // der SearchableControlIterator noch zulaesst)
2477                 xControl = impl_getControl( xControlModel, *pFormObject );
2478                 DBG_ASSERT(xControl.is(), "FmXFormShell::OnSearchContextRequest : didn't ::std::find a control with requested model !");
2479 
2480                 Reference< XGridPeer> xGridPeer;
2481                 if ( xControl.is() )
2482                     xGridPeer.set( xControl->getPeer(), UNO_QUERY );
2483                 do
2484                 {
2485                     if (!xGridPeer.is())
2486                         break;
2487 
2488                     Reference< XIndexAccess> xPeerContainer(xGridPeer, UNO_QUERY);
2489                     if (!xPeerContainer.is())
2490                         break;
2491 
2492                     Reference< XIndexAccess> xModelColumns(xGridPeer->getColumns(), UNO_QUERY);
2493                     DBG_ASSERT(xModelColumns.is(), "FmXFormShell::OnSearchContextRequest : there is a grid control without columns !");
2494                         // the case 'no columns' should be indicated with an empty container, I think ...
2495                     DBG_ASSERT(xModelColumns->getCount() >= xPeerContainer->getCount(), "FmXFormShell::OnSearchContextRequest : impossible : have more view than model columns !");
2496 
2497                     Reference< XInterface> xCurrentColumn;
2498                     for (sal_Int16 nViewPos=0; nViewPos<xPeerContainer->getCount(); ++nViewPos)
2499                     {
2500                         xPeerContainer->getByIndex(nViewPos) >>= xCurrentColumn;
2501                         if (!xCurrentColumn.is())
2502                             continue;
2503 
2504                         // can we use this column control fo searching ?
2505                         if (!IsSearchableControl(xCurrentColumn))
2506                             continue;
2507 
2508                         sal_Int16 nModelPos = GridView2ModelPos(xModelColumns, nViewPos);
2509                         Reference< XPropertySet> xCurrentColModel;
2510                         xModelColumns->getByIndex(nModelPos) >>= xCurrentColModel;
2511                         aName = ::comphelper::getString(xCurrentColModel->getPropertyValue(FM_PROP_CONTROLSOURCE));
2512                         // the cursor has a field matching the control source ?
2513                         if (xValidFormFields->hasByName(aName))
2514                         {
2515                             strFieldList += aName.getStr();
2516                             strFieldList += ';';
2517 
2518                             sFieldDisplayNames += ::comphelper::getString(xCurrentColModel->getPropertyValue(FM_PROP_LABEL)).getStr();
2519                             sFieldDisplayNames += ';';
2520 
2521                             pfmscContextInfo->arrFields.push_back(xCurrentColumn);
2522 
2523                             // und das SdrObjekt zum Feld
2524                             m_arrSearchedControls.C40_INSERT(SdrObject, pCurrent, m_arrSearchedControls.Count());
2525                             // die Nummer der Spalte
2526                             m_arrRelativeGridColumn.Insert(nViewPos, m_arrRelativeGridColumn.Count());
2527                         }
2528                     }
2529                 } while (sal_False);
2530             }
2531             else
2532             {
2533                 if (sControlSource.getLength() && xValidFormFields->hasByName(sControlSource))
2534                 {
2535                     // jetzt brauche ich das Control zum SdrObject
2536                     if (!xControl.is())
2537                     {
2538                         xControl = impl_getControl( xControlModel, *pFormObject );
2539                         DBG_ASSERT(xControl.is(), "FmXFormShell::OnSearchContextRequest : didn't ::std::find a control with requested model !");
2540                     }
2541 
2542                     if (IsSearchableControl(xControl))
2543                     {	// alle Tests ueberstanden -> in die Liste mit aufnehmen
2544                         strFieldList += sControlSource.getStr();
2545                         strFieldList += ';';
2546 
2547                         // the label which should appear for the control :
2548                         sFieldDisplayNames += getLabelName(Reference< XPropertySet>(xControlModel, UNO_QUERY)).getStr();
2549                         sFieldDisplayNames += ';';
2550 
2551                         // das SdrObjekt merken (beschleunigt die Behandlung in OnFoundData)
2552                         m_arrSearchedControls.C40_INSERT(SdrObject, pCurrent, m_arrSearchedControls.Count());
2553 
2554                         // die Nummer der Spalte (hier ein Dummy, nur fuer GridControls interesant)
2555                         m_arrRelativeGridColumn.Insert(-1, m_arrRelativeGridColumn.Count());
2556 
2557                         // und fuer die formatierte Suche ...
2558                         pfmscContextInfo->arrFields.push_back(Reference< XInterface>(xControl, UNO_QUERY));
2559                     }
2560                 }
2561             }
2562 
2563             xSearchable = iter.Next();
2564         }
2565     }
2566 
2567 	strFieldList.EraseTrailingChars(';');
2568 	sFieldDisplayNames.EraseTrailingChars(';');
2569 
2570 	if (pfmscContextInfo->arrFields.empty())
2571 	{
2572 		pfmscContextInfo->arrFields.clear();
2573 		pfmscContextInfo->xCursor = NULL;
2574 		pfmscContextInfo->strUsedFields.Erase();
2575 		return 0L;
2576 	}
2577 
2578 	pfmscContextInfo->xCursor = xIter;
2579 	pfmscContextInfo->strUsedFields = strFieldList;
2580 	pfmscContextInfo->sFieldDisplayNames = sFieldDisplayNames;
2581 
2582 	// 66463 - 31.05.99 - FS
2583 	// wenn der Cursor sich in einem anderen RecordMode als STANDARD befindet, ruecksetzen
2584 	Reference< XPropertySet> xCursorSet(pfmscContextInfo->xCursor, UNO_QUERY);
2585 	Reference< XResultSetUpdate> xUpdateCursor(pfmscContextInfo->xCursor, UNO_QUERY);
2586 	if (xUpdateCursor.is() && xCursorSet.is() && xCursorSet.is())
2587 	{
2588 		if (::comphelper::getBOOL(xCursorSet->getPropertyValue(FM_PROP_ISNEW)))
2589 			xUpdateCursor->moveToCurrentRow();
2590 		else if (::comphelper::getBOOL(xCursorSet->getPropertyValue(FM_PROP_ISMODIFIED)))
2591 			xUpdateCursor->cancelRowUpdates();
2592 	}
2593 
2594 	return pfmscContextInfo->arrFields.size();
2595 }
2596 
2597   // XContainerListener
2598 //------------------------------------------------------------------------------
elementInserted(const ContainerEvent & evt)2599 void FmXFormShell::elementInserted(const ContainerEvent& evt) throw(::com::sun::star::uno::RuntimeException)
2600 {
2601     if ( impl_checkDisposed() )
2602         return;
2603 
2604 	// neues Object zum lauschen
2605 	Reference< XInterface> xTemp;
2606 	evt.Element >>= xTemp;
2607 	AddElement(xTemp);
2608 	m_pShell->DetermineForms(sal_True);
2609 }
2610 
2611 //------------------------------------------------------------------------------
elementReplaced(const ContainerEvent & evt)2612 void FmXFormShell::elementReplaced(const ContainerEvent& evt) throw(::com::sun::star::uno::RuntimeException)
2613 {
2614     if ( impl_checkDisposed() )
2615         return;
2616 
2617 	Reference< XInterface> xTemp;
2618 	evt.ReplacedElement >>= xTemp;
2619 	RemoveElement(xTemp);
2620 	evt.Element >>= xTemp;
2621 	AddElement(xTemp);
2622 }
2623 
2624 //------------------------------------------------------------------------------
elementRemoved(const ContainerEvent & evt)2625 void FmXFormShell::elementRemoved(const ContainerEvent& evt) throw(::com::sun::star::uno::RuntimeException)
2626 {
2627     if ( impl_checkDisposed() )
2628         return;
2629 
2630 	Reference< XInterface> xTemp;
2631 	evt.Element >>= xTemp;
2632 	RemoveElement(xTemp);
2633     m_pShell->DetermineForms(sal_True);
2634 }
2635 
2636 //------------------------------------------------------------------------------
UpdateForms(sal_Bool _bInvalidate)2637 void FmXFormShell::UpdateForms( sal_Bool _bInvalidate )
2638 {
2639     if ( impl_checkDisposed() )
2640         return;
2641 
2642     Reference< XIndexAccess > xForms;
2643 
2644     FmFormPage* pPage = m_pShell->GetCurPage();
2645     if ( pPage )
2646     {
2647         if ( m_pShell->m_bDesignMode )
2648             xForms = xForms.query( pPage->GetForms( false ) );
2649     }
2650 
2651     if ( m_xForms != xForms )
2652     {
2653 	    RemoveElement( m_xForms );
2654 	    m_xForms = xForms;
2655 	    AddElement( m_xForms );
2656     }
2657 
2658     m_pShell->DetermineForms( _bInvalidate );
2659 }
2660 
2661 //------------------------------------------------------------------------------
AddElement(const Reference<XInterface> & _xElement)2662 void FmXFormShell::AddElement(const Reference< XInterface>& _xElement)
2663 {
2664     if ( impl_checkDisposed() )
2665         return;
2666     impl_AddElement_nothrow(_xElement);
2667 }
2668 // -----------------------------------------------------------------------------
impl_AddElement_nothrow(const Reference<XInterface> & Element)2669 void FmXFormShell::impl_AddElement_nothrow(const Reference< XInterface>& Element)
2670 {
2671 	// am Container horchen
2672 	const Reference< XIndexContainer> xContainer(Element, UNO_QUERY);
2673 	if (xContainer.is())
2674 	{
2675 		const sal_uInt32 nCount = xContainer->getCount();
2676 		Reference< XInterface> xElement;
2677 		for (sal_uInt32 i = 0; i < nCount; ++i)
2678 		{
2679 			xElement.set(xContainer->getByIndex(i),UNO_QUERY);
2680 			impl_AddElement_nothrow(xElement);
2681 		}
2682 
2683 		const Reference< XContainer> xCont(Element, UNO_QUERY);
2684 		if (xCont.is())
2685 			xCont->addContainerListener(this);
2686 	}
2687 
2688 	const Reference< ::com::sun::star::view::XSelectionSupplier> xSelSupplier(Element, UNO_QUERY);
2689 	if (xSelSupplier.is())
2690 		xSelSupplier->addSelectionChangeListener(this);
2691 }
2692 
2693 //------------------------------------------------------------------------------
RemoveElement(const Reference<XInterface> & Element)2694 void FmXFormShell::RemoveElement(const Reference< XInterface>& Element)
2695 {
2696     if ( impl_checkDisposed() )
2697         return;
2698     impl_RemoveElement_nothrow(Element);
2699 }
2700 //------------------------------------------------------------------------------
impl_RemoveElement_nothrow(const Reference<XInterface> & Element)2701 void FmXFormShell::impl_RemoveElement_nothrow(const Reference< XInterface>& Element)
2702 {
2703 	const Reference< ::com::sun::star::view::XSelectionSupplier> xSelSupplier(Element, UNO_QUERY);
2704 	if (xSelSupplier.is())
2705 		xSelSupplier->removeSelectionChangeListener(this);
2706 
2707 	// Verbindung zu Kindern aufheben
2708 	const Reference< XIndexContainer> xContainer(Element, UNO_QUERY);
2709 	if (xContainer.is())
2710 	{
2711 		const Reference< XContainer> xCont(Element, UNO_QUERY);
2712 		if (xCont.is())
2713 			xCont->removeContainerListener(this);
2714 
2715 		const sal_uInt32 nCount = xContainer->getCount();
2716 		Reference< XInterface> xElement;
2717 		for (sal_uInt32 i = 0; i < nCount; i++)
2718 		{
2719 			xElement.set(xContainer->getByIndex(i),UNO_QUERY);
2720 			impl_RemoveElement_nothrow(xElement);
2721 		}
2722 	}
2723 
2724     InterfaceBag::iterator wasSelectedPos = m_aCurrentSelection.find( Element );
2725 	if ( wasSelectedPos != m_aCurrentSelection.end() )
2726         m_aCurrentSelection.erase( wasSelectedPos );
2727 }
2728 
2729 //------------------------------------------------------------------------------
selectionChanged(const EventObject & rEvent)2730 void FmXFormShell::selectionChanged(const EventObject& rEvent) throw(::com::sun::star::uno::RuntimeException)
2731 {
2732     if ( impl_checkDisposed() )
2733         return;
2734 
2735     Reference< XSelectionSupplier > xSupplier( rEvent.Source, UNO_QUERY );
2736 	Reference< XInterface > xSelObj( xSupplier->getSelection(), UNO_QUERY );
2737 	// es wurde eine Selektion weggenommen, dieses kann nur durch die Shell vorgenommen werden
2738 	if ( !xSelObj.is() )
2739 		return;
2740 
2741 	EnableTrackProperties(sal_False);
2742 
2743 	sal_Bool bMarkChanged = m_pShell->GetFormView()->checkUnMarkAll(rEvent.Source);
2744 	Reference< XForm > xNewForm( GetForm( rEvent.Source ) );
2745 
2746     InterfaceBag aNewSelection;
2747     aNewSelection.insert( Reference< XInterface >( xSelObj, UNO_QUERY ) );
2748 
2749 	if ( setCurrentSelection( aNewSelection ) && IsPropBrwOpen() )
2750 		ShowSelectionProperties( sal_True );
2751 
2752 	EnableTrackProperties(sal_True);
2753 
2754     if ( bMarkChanged )
2755 		m_pShell->NotifyMarkListChanged( m_pShell->GetFormView() );
2756 }
2757 
2758 //------------------------------------------------------------------------------
2759 IMPL_LINK(FmXFormShell, OnTimeOut, void*, /*EMPTYTAG*/)
2760 {
2761     if ( impl_checkDisposed() )
2762         return 0;
2763 
2764 	if (m_pShell->IsDesignMode() && m_pShell->GetFormView())
2765 		SetSelection(m_pShell->GetFormView()->GetMarkedObjectList());
2766 
2767 	return 0;
2768 }
2769 
2770 //------------------------------------------------------------------------
SetSelectionDelayed()2771 void FmXFormShell::SetSelectionDelayed()
2772 {
2773     if ( impl_checkDisposed() )
2774         return;
2775 
2776 	if (m_pShell->IsDesignMode() && IsTrackPropertiesEnabled() && !m_aMarkTimer.IsActive())
2777 		m_aMarkTimer.Start();
2778 }
2779 
2780 //------------------------------------------------------------------------
SetSelection(const SdrMarkList & rMarkList)2781 void FmXFormShell::SetSelection(const SdrMarkList& rMarkList)
2782 {
2783     if ( impl_checkDisposed() )
2784         return;
2785 
2786 	DetermineSelection(rMarkList);
2787 	m_pShell->NotifyMarkListChanged(m_pShell->GetFormView());
2788 }
2789 
2790 //------------------------------------------------------------------------
DetermineSelection(const SdrMarkList & rMarkList)2791 void FmXFormShell::DetermineSelection(const SdrMarkList& rMarkList)
2792 {
2793 	if ( setCurrentSelectionFromMark( rMarkList ) && IsPropBrwOpen() )
2794 		ShowSelectionProperties( sal_True );
2795 }
2796 
2797 //------------------------------------------------------------------------------
IsPropBrwOpen() const2798 sal_Bool FmXFormShell::IsPropBrwOpen() const
2799 {
2800     if ( impl_checkDisposed() )
2801         return sal_False;
2802 
2803 	return( ( m_pShell->GetViewShell() && m_pShell->GetViewShell()->GetViewFrame() ) ?
2804 			m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow(SID_FM_SHOW_PROPERTIES) : sal_False );
2805 }
2806 
2807 //------------------------------------------------------------------------------
2808 class FmXFormShell::SuspendPropertyTracking
2809 {
2810 private:
2811 	FmXFormShell&   m_rShell;
2812 	sal_Bool		m_bEnabled;
2813 
2814 public:
SuspendPropertyTracking(FmXFormShell & _rShell)2815 	SuspendPropertyTracking( FmXFormShell& _rShell )
2816 		:m_rShell( _rShell )
2817 		,m_bEnabled( sal_False )
2818 	{
2819 		if ( m_rShell.IsTrackPropertiesEnabled() )
2820 		{
2821 			m_rShell.EnableTrackProperties( sal_False );
2822 			m_bEnabled = sal_True;
2823 		}
2824 	}
2825 
~SuspendPropertyTracking()2826 	~SuspendPropertyTracking( )
2827 	{
2828 		if ( m_bEnabled )	// note that ( sal_False != m_bEnabled ) implies ( NULL != m_pShell )
2829 			m_rShell.EnableTrackProperties( sal_True );
2830 	}
2831 };
2832 
2833 //------------------------------------------------------------------------------
SetDesignMode(sal_Bool bDesign)2834 void FmXFormShell::SetDesignMode(sal_Bool bDesign)
2835 {
2836     if ( impl_checkDisposed() )
2837         return;
2838 
2839 	DBG_ASSERT(m_pShell->GetFormView(), "FmXFormShell::SetDesignMode : invalid call (have no shell or no view) !");
2840 	m_bChangingDesignMode = sal_True;
2841 
2842 	// 67506 - 15.07.99 - FS
2843 	// if we're switching off the design mode we have to force the property browser to be closed
2844 	// so it can commit it's changes _before_ we load the forms
2845 	if (!bDesign)
2846 	{
2847 		m_bHadPropertyBrowserInDesignMode = m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow(SID_FM_SHOW_PROPERTIES);
2848 		if (m_bHadPropertyBrowserInDesignMode)
2849 			m_pShell->GetViewShell()->GetViewFrame()->ToggleChildWindow(SID_FM_SHOW_PROPERTIES);
2850 	}
2851 
2852 	FmFormView* pFormView = m_pShell->GetFormView();
2853 	if (bDesign)
2854 	{
2855 		// we are currently filtering, so stop filtering
2856 		if (m_bFilterMode)
2857 			stopFiltering(sal_False);
2858 
2859 		// an den Objekten meiner MarkList als Listener abmelden
2860 		pFormView->GetImpl()->stopMarkListWatching();
2861 	}
2862 	else
2863 	{
2864 		m_aMarkTimer.Stop();
2865 
2866 		SuspendPropertyTracking aSuspend( *this );
2867 		pFormView->GetImpl()->saveMarkList( sal_True );
2868 	}
2869 
2870 	if (bDesign && m_xExternalViewController.is())
2871 		CloseExternalFormViewer();
2872 
2873 	pFormView->ChangeDesignMode(bDesign);
2874 
2875 	// Listener benachrichtigen
2876 	FmDesignModeChangedHint aChangedHint( bDesign );
2877 	m_pShell->Broadcast(aChangedHint);
2878 
2879 	m_pShell->m_bDesignMode = bDesign;
2880     UpdateForms( sal_False );
2881 
2882     m_pTextShell->designModeChanged( m_pShell->m_bDesignMode );
2883 
2884 	if (bDesign)
2885 	{
2886 		SdrMarkList aList;
2887 		{
2888 			// during changing the mark list, don't track the selected objects in the property browser
2889 			SuspendPropertyTracking aSuspend( *this );
2890 			// restore the marks
2891 			pFormView->GetImpl()->restoreMarkList( aList );
2892 		}
2893 
2894 		// synchronize with the restored mark list
2895 		if ( aList.GetMarkCount() )
2896 			SetSelection( aList );
2897 	}
2898 	else
2899 	{
2900 		// am Model der View als Listener anmelden (damit ich mitbekomme, wenn jemand waehrend des Alive-Modus
2901 		// Controls loescht, die ich eigentlich mit saveMarkList gespeichert habe) (60343)
2902 		pFormView->GetImpl()->startMarkListWatching();
2903 	}
2904 
2905 	m_pShell->UIFeatureChanged();
2906 
2907 	// 67506 - 15.07.99 - FS
2908 	if (bDesign && m_bHadPropertyBrowserInDesignMode)
2909 	{
2910 		// The UIFeatureChanged performes an update (a check of the available features) asynchronously.
2911 		// So we can't call ShowSelectionProperties directly as the according feature isn't enabled yet.
2912 		// That's why we use an asynchron execution on the dispatcher.
2913 		// (And that's why this has to be done AFTER the UIFeatureChanged.)
2914 		m_pShell->GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_SHOW_PROPERTY_BROWSER, SFX_CALLMODE_ASYNCHRON );
2915 	}
2916 	m_bChangingDesignMode = sal_False;
2917 }
2918 
2919 //------------------------------------------------------------------------------
impl_getControl(const Reference<XControlModel> & i_rxModel,const FmFormObj & i_rKnownFormObj)2920 Reference< XControl> FmXFormShell::impl_getControl( const Reference< XControlModel >& i_rxModel, const FmFormObj& i_rKnownFormObj )
2921 {
2922     if ( impl_checkDisposed() )
2923         return NULL;
2924 
2925     Reference< XControl > xControl;
2926     try
2927     {
2928         Reference< XControlContainer> xControlContainer( getControlContainerForView(), UNO_SET_THROW );
2929 
2930         Sequence< Reference< XControl > > seqControls( xControlContainer->getControls() );
2931 	    const Reference< XControl >* pControls = seqControls.getArray();
2932 	    // ... die ich dann durchsuchen kann
2933 	    for (sal_Int32 i=0; i<seqControls.getLength(); ++i)
2934 	    {
2935             xControl.set( pControls[i], UNO_SET_THROW );
2936 		    Reference< XControlModel > xCurrentModel( xControl->getModel() );
2937             if ( xCurrentModel == i_rxModel )
2938                 break;
2939             xControl.clear();
2940 	    }
2941 
2942         if ( !xControl.is() )
2943         {
2944             // fallabck (some controls might not have been created, yet, since they were never visible so far)
2945             Reference< XControl > xContainerControl( xControlContainer, UNO_QUERY_THROW );
2946             const Window* pContainerWindow = VCLUnoHelper::GetWindow( xContainerControl->getPeer() );
2947             ENSURE_OR_THROW( pContainerWindow, "unexpected control container implementation" );
2948 
2949             const SdrView* pSdrView = m_pShell ? m_pShell->GetFormView() : NULL;
2950             ENSURE_OR_THROW( pSdrView, "no current view" );
2951 
2952             xControl.set( i_rKnownFormObj.GetUnoControl( *pSdrView, *pContainerWindow ), UNO_QUERY_THROW );
2953         }
2954     }
2955     catch( const Exception& )
2956     {
2957     	DBG_UNHANDLED_EXCEPTION();
2958     }
2959 
2960     OSL_ENSURE( xControl.is(), "FmXFormShell::impl_getControl: no control found!" );
2961     return xControl;
2962 }
2963 
2964 //------------------------------------------------------------------------------
impl_collectFormSearchContexts_nothrow(const Reference<XInterface> & _rxStartingPoint,const::rtl::OUString & _rCurrentLevelPrefix,FmFormArray & _out_rForms,::std::vector<String> & _out_rNames)2965 void FmXFormShell::impl_collectFormSearchContexts_nothrow( const Reference< XInterface>& _rxStartingPoint,
2966     const ::rtl::OUString& _rCurrentLevelPrefix, FmFormArray& _out_rForms, ::std::vector< String >& _out_rNames )
2967 {
2968     try
2969     {
2970 	    Reference< XIndexAccess> xContainer( _rxStartingPoint, UNO_QUERY );
2971         if ( !xContainer.is() )
2972             return;
2973 
2974         sal_Int32 nCount( xContainer->getCount() );
2975         if ( nCount == 0 )
2976             return;
2977 
2978         ::rtl::OUString sCurrentFormName;
2979         ::rtl::OUStringBuffer aNextLevelPrefix;
2980 		for ( sal_Int32 i=0; i<nCount; ++i )
2981 		{
2982 			// is the current child a form?
2983 		    Reference< XForm > xCurrentAsForm( xContainer->getByIndex(i), UNO_QUERY );
2984             if ( !xCurrentAsForm.is() )
2985                 continue;
2986 
2987             Reference< XNamed > xNamed( xCurrentAsForm, UNO_QUERY_THROW );
2988             sCurrentFormName = xNamed->getName();
2989 
2990             // the name of the current form
2991             ::rtl::OUStringBuffer sCompleteCurrentName( sCurrentFormName );
2992             if ( _rCurrentLevelPrefix.getLength() )
2993 			{
2994                 sCompleteCurrentName.appendAscii( " (" );
2995 				sCompleteCurrentName.append     ( _rCurrentLevelPrefix );
2996                 sCompleteCurrentName.appendAscii( ")" );
2997 			}
2998 
2999 			// the prefix for the next level
3000             aNextLevelPrefix = _rCurrentLevelPrefix;
3001 			if ( _rCurrentLevelPrefix.getLength() )
3002 				aNextLevelPrefix.append( (sal_Unicode)'/' );
3003             aNextLevelPrefix.append( sCurrentFormName );
3004 
3005 			// remember both the form and it's "display name"
3006 			_out_rForms.push_back( xCurrentAsForm );
3007             _out_rNames.push_back( sCompleteCurrentName.makeStringAndClear() );
3008 
3009 			// und absteigen
3010 			impl_collectFormSearchContexts_nothrow( xCurrentAsForm, aNextLevelPrefix.makeStringAndClear(), _out_rForms, _out_rNames );
3011 	    }
3012     }
3013     catch( const Exception& )
3014     {
3015     	DBG_UNHANDLED_EXCEPTION();
3016     }
3017 }
3018 
3019 //------------------------------------------------------------------------------
startFiltering()3020 void FmXFormShell::startFiltering()
3021 {
3022     if ( impl_checkDisposed() )
3023         return;
3024 
3025 	// setting all forms in filter mode
3026 	FmXFormView* pXView = m_pShell->GetFormView()->GetImpl();
3027 
3028 	// if the active controller is our external one we have to use the trigger controller
3029 	Reference< XControlContainer> xContainer;
3030 	if (getActiveController() == m_xExternalViewController)
3031 	{
3032 		DBG_ASSERT(m_xExtViewTriggerController.is(), "FmXFormShell::startFiltering : inconsistent : active external controller, but noone triggered this !");
3033 		xContainer = m_xExtViewTriggerController->getContainer();
3034 	}
3035 	else
3036 		xContainer = getActiveController()->getContainer();
3037 
3038 	PFormViewPageWindowAdapter pAdapter = pXView->findWindow( xContainer );
3039 	if ( pAdapter.is() )
3040 	{
3041 		const ::std::vector< Reference< runtime::XFormController> >& rControllerList = pAdapter->GetList();
3042 		for (   ::std::vector< Reference< runtime::XFormController> >::const_iterator j = rControllerList.begin();
3043 			    j != rControllerList.end();
3044                 ++j
3045             )
3046 		{
3047 			Reference< XModeSelector> xModeSelector(*j, UNO_QUERY);
3048 			if (xModeSelector.is())
3049 				xModeSelector->setMode( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterMode" ) ) );
3050 		}
3051 	}
3052 
3053 	m_bFilterMode = sal_True;
3054 
3055 	m_pShell->UIFeatureChanged();
3056     SfxViewFrame* pViewFrame = m_pShell->GetViewShell()->GetViewFrame();
3057 	pViewFrame->GetBindings().InvalidateShell( *m_pShell );
3058 
3059 	if  (   pViewFrame->KnowsChildWindow( SID_FM_FILTER_NAVIGATOR )
3060         &&  !pViewFrame->HasChildWindow( SID_FM_FILTER_NAVIGATOR )
3061         )
3062 	{
3063 		pViewFrame->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR );
3064 	}
3065 }
3066 
3067 //------------------------------------------------------------------------------
saveFilter(const Reference<runtime::XFormController> & _rxController)3068 void saveFilter(const Reference< runtime::XFormController >& _rxController)
3069 {
3070 	Reference< XPropertySet> xFormAsSet(_rxController->getModel(), UNO_QUERY);
3071 	Reference< XPropertySet> xControllerAsSet(_rxController, UNO_QUERY);
3072 	Reference< XIndexAccess> xControllerAsIndex(_rxController, UNO_QUERY);
3073 
3074 	// call the subcontroller
3075 	Reference< runtime::XFormController > xController;
3076 	for (sal_Int32 i = 0, nCount = xControllerAsIndex->getCount(); i < nCount; ++i)
3077 	{
3078 		xControllerAsIndex->getByIndex(i) >>= xController;
3079 		saveFilter(xController);
3080 	}
3081 
3082 	try
3083 	{
3084 
3085 		xFormAsSet->setPropertyValue(FM_PROP_FILTER, xControllerAsSet->getPropertyValue(FM_PROP_FILTER));
3086 		xFormAsSet->setPropertyValue(FM_PROP_APPLYFILTER, makeAny( (sal_Bool)sal_True ) );
3087 	}
3088 	catch (const Exception& )
3089 	{
3090 		DBG_UNHANDLED_EXCEPTION();
3091 	}
3092 
3093 }
3094 
3095 //------------------------------------------------------------------------------
stopFiltering(sal_Bool bSave)3096 void FmXFormShell::stopFiltering(sal_Bool bSave)
3097 {
3098     if ( impl_checkDisposed() )
3099         return;
3100 
3101 	m_bFilterMode = sal_False;
3102 
3103 	FmXFormView* pXView = m_pShell->GetFormView()->GetImpl();
3104 
3105 	// if the active controller is our external one we have to use the trigger controller
3106 	Reference< XControlContainer> xContainer;
3107 	if (getActiveController() == m_xExternalViewController)
3108 	{
3109 		DBG_ASSERT(m_xExtViewTriggerController.is(), "FmXFormShell::stopFiltering : inconsistent : active external controller, but noone triggered this !");
3110 		xContainer = m_xExtViewTriggerController->getContainer();
3111 	}
3112 	else
3113 		xContainer = getActiveController()->getContainer();
3114 
3115 	PFormViewPageWindowAdapter pAdapter = pXView->findWindow(xContainer);
3116 	if ( pAdapter.is() )
3117 	{
3118 		const ::std::vector< Reference< runtime::XFormController > >& rControllerList = pAdapter->GetList();
3119 		::std::vector < ::rtl::OUString >	aOriginalFilters;
3120 		::std::vector < sal_Bool >			aOriginalApplyFlags;
3121 
3122 		if (bSave)
3123 		{
3124 			for (::std::vector< Reference< runtime::XFormController > > ::const_iterator j = rControllerList.begin();
3125 				 j != rControllerList.end(); ++j)
3126 			{
3127 				if (bSave)
3128 				{	// remember the current filter settings in case we're goin to reload the forms below (which may fail)
3129 					try
3130 					{
3131 						Reference< XPropertySet > xFormAsSet((*j)->getModel(), UNO_QUERY);
3132 						aOriginalFilters.push_back(::comphelper::getString(xFormAsSet->getPropertyValue(FM_PROP_FILTER)));
3133 						aOriginalApplyFlags.push_back(::comphelper::getBOOL(xFormAsSet->getPropertyValue(FM_PROP_APPLYFILTER)));
3134 					}
3135 					catch(Exception&)
3136 					{
3137 						DBG_ERROR("FmXFormShell::stopFiltering : could not get the original filter !");
3138 						// put dummies into the arrays so the they have the right size
3139 
3140 						if (aOriginalFilters.size() == aOriginalApplyFlags.size())
3141 							// the first getPropertyValue failed -> use two dummies
3142 							aOriginalFilters.push_back( ::rtl::OUString() );
3143 						aOriginalApplyFlags.push_back( sal_False );
3144 					}
3145 				}
3146 				saveFilter(*j);
3147 			}
3148 		}
3149 		for (::std::vector< Reference< runtime::XFormController > > ::const_iterator j = rControllerList.begin();
3150 			 j != rControllerList.end(); ++j)
3151 		{
3152 
3153 			Reference< XModeSelector> xModeSelector(*j, UNO_QUERY);
3154 			if (xModeSelector.is())
3155 				xModeSelector->setMode( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DataMode" ) ) );
3156 		}
3157 		if (bSave)	// execute the filter
3158 		{
3159 			const ::std::vector< Reference< runtime::XFormController > > & rControllers = pAdapter->GetList();
3160 			for (::std::vector< Reference< runtime::XFormController > > ::const_iterator j = rControllers.begin();
3161 				 j != rControllers.end(); ++j)
3162 			{
3163 				Reference< XLoadable> xReload((*j)->getModel(), UNO_QUERY);
3164 				if (!xReload.is())
3165 					continue;
3166 				Reference< XPropertySet > xFormSet(xReload, UNO_QUERY);
3167 
3168 				try
3169 				{
3170 					xReload->reload();
3171 				}
3172 				catch(Exception&)
3173 				{
3174 					DBG_ERROR("FmXFormShell::stopFiltering: Exception occured!");
3175 				}
3176 
3177 				if (!isRowSetAlive(xFormSet))
3178 				{	// something went wrong -> restore the original state
3179 					::rtl::OUString sOriginalFilter = aOriginalFilters[ j - rControllers.begin() ];
3180 					sal_Bool bOriginalApplyFlag = aOriginalApplyFlags[ j - rControllers.begin() ];
3181 					try
3182 					{
3183 						xFormSet->setPropertyValue(FM_PROP_FILTER, makeAny(sOriginalFilter));
3184 						xFormSet->setPropertyValue(FM_PROP_APPLYFILTER, makeAny(bOriginalApplyFlag));
3185 						xReload->reload();
3186 					}
3187 					catch(const Exception&)
3188 					{
3189 						DBG_UNHANDLED_EXCEPTION();
3190 					}
3191 				}
3192 			}
3193 		}
3194 	}
3195 
3196 	m_pShell->UIFeatureChanged();
3197 	m_pShell->GetViewShell()->GetViewFrame()->GetBindings().InvalidateShell(*m_pShell);
3198 }
3199 
3200 //------------------------------------------------------------------------------
clearFilter(const Reference<runtime::XFormController> & _rxController)3201 void clearFilter(const Reference< runtime::XFormController >& _rxController)
3202 {
3203 	Reference< XPropertySet> xControllerAsSet(_rxController, UNO_QUERY);
3204 	Reference< XIndexAccess> xControllerAsIndex(_rxController, UNO_QUERY);
3205 
3206 	// call the subcontroller
3207 	Reference< runtime::XFormController > xController;
3208 	for (sal_Int32 i = 0, nCount = xControllerAsIndex->getCount();
3209 		 i < nCount; i++)
3210 	{
3211 		xControllerAsIndex->getByIndex(i) >>= xController;
3212 		clearFilter(xController);
3213 	}
3214 
3215 	// clear the filter
3216 	Reference< XIndexContainer> xContainer;
3217 	xControllerAsSet->getPropertyValue(FM_PROP_FILTERSUPPLIER) >>= xContainer;
3218 	if (xContainer.is())
3219 	{
3220 		// clear the current filter
3221 		Sequence< PropertyValue> aCondition;
3222 
3223 		// as there is always an empty row, if we have a filter:
3224 		if (xContainer->getCount())
3225 		{
3226 			xControllerAsSet->setPropertyValue(FM_PROP_CURRENTFILTER, makeAny(sal_Int32(xContainer->getCount() - 1)));
3227 			while (xContainer->getCount() > 1)
3228 				xContainer->removeByIndex(0);
3229 		}
3230 	}
3231 }
3232 
3233 //------------------------------------------------------------------------------
clearFilter()3234 void FmXFormShell::clearFilter()
3235 {
3236     if ( impl_checkDisposed() )
3237         return;
3238 
3239 	FmXFormView* pXView = m_pShell->GetFormView()->GetImpl();
3240 
3241 	// if the active controller is our external one we have to use the trigger controller
3242 	Reference< XControlContainer> xContainer;
3243 	if (getActiveController() == m_xExternalViewController)
3244 	{
3245 		DBG_ASSERT(m_xExtViewTriggerController.is(), "FmXFormShell::clearFilter : inconsistent : active external controller, but noone triggered this !");
3246 		xContainer = m_xExtViewTriggerController->getContainer();
3247 	}
3248 	else
3249 		xContainer = getActiveController()->getContainer();
3250 
3251 	PFormViewPageWindowAdapter pAdapter = pXView->findWindow(xContainer);
3252 	if ( pAdapter.is() )
3253 	{
3254 		const ::std::vector< Reference< runtime::XFormController > > & rControllerList = pAdapter->GetList();
3255 		for (   ::std::vector< Reference< runtime::XFormController > > ::const_iterator j = rControllerList.begin();
3256 			    j != rControllerList.end();
3257                 ++j
3258             )
3259 		{
3260 			::clearFilter(*j);
3261 		}
3262 	}
3263 }
3264 
3265 //------------------------------------------------------------------------------
CreateExternalView()3266 void FmXFormShell::CreateExternalView()
3267 {
3268     if ( impl_checkDisposed() )
3269         return;
3270 
3271 	DBG_ASSERT(m_xAttachedFrame.is(), "FmXFormShell::CreateExternalView : no frame !");
3272 
3273 	// the frame the external view is displayed in
3274 	sal_Bool bAlreadyExistent = m_xExternalViewController.is();
3275 	Reference< ::com::sun::star::frame::XFrame> xExternalViewFrame;
3276 	::rtl::OUString sFrameName = ::rtl::OUString::createFromAscii("_beamer");
3277 	sal_Int32 nSearchFlags = ::com::sun::star::frame::FrameSearchFlag::CHILDREN | ::com::sun::star::frame::FrameSearchFlag::CREATE;
3278 
3279 	Reference< runtime::XFormController > xCurrentNavController( getNavController());
3280 		// the creation of the "partwindow" may cause a deactivate of the document which will result in our nav controller to be set to NULL
3281 
3282 	// _first_ check if we have any valid fields we can use for the grid view
3283 	// FS - 21.10.99 - 69219
3284     {
3285 	    FmXBoundFormFieldIterator aModelIterator(xCurrentNavController->getModel());
3286 	    Reference< XPropertySet> xCurrentModelSet;
3287 	    sal_Bool bHaveUsableControls = sal_False;
3288 	    while ((xCurrentModelSet = Reference< XPropertySet>(aModelIterator.Next(), UNO_QUERY)).is())
3289 	    {
3290 		    // the FmXBoundFormFieldIterator only supplies controls with a valid control source
3291 		    // so we just have to check the field type
3292 		    sal_Int16 nClassId = ::comphelper::getINT16(xCurrentModelSet->getPropertyValue(FM_PROP_CLASSID));
3293 		    switch (nClassId)
3294 		    {
3295 			    case FormComponentType::IMAGECONTROL:
3296 			    case FormComponentType::CONTROL:
3297 				    continue;
3298 		    }
3299 		    bHaveUsableControls = sal_True;
3300 		    break;
3301 	    }
3302 
3303 	    if (!bHaveUsableControls)
3304 	    {
3305 		    ErrorBox(NULL, WB_OK, SVX_RESSTR(RID_STR_NOCONTROLS_FOR_EXTERNALDISPLAY)).Execute();
3306 		    return;
3307 	    }
3308     }
3309 
3310 	// load the component for external form views
3311 	if (!bAlreadyExistent)
3312 	{
3313 		URL aWantToDispatch;
3314 		aWantToDispatch.Complete = FMURL_COMPONENT_FORMGRIDVIEW;
3315 
3316 		Reference< ::com::sun::star::frame::XDispatchProvider> xProv(m_xAttachedFrame, UNO_QUERY);
3317 		Reference< ::com::sun::star::frame::XDispatch> xDisp;
3318 		if (xProv.is())
3319 			xDisp = xProv->queryDispatch(aWantToDispatch, sFrameName, nSearchFlags);
3320 		if (xDisp.is())
3321 		{
3322 			xDisp->dispatch(aWantToDispatch, Sequence< PropertyValue>());
3323 		}
3324 
3325 		// with this the component should be loaded, now search the frame where it resides in
3326 		xExternalViewFrame = m_xAttachedFrame->findFrame(sFrameName, ::com::sun::star::frame::FrameSearchFlag::CHILDREN);
3327 		if (xExternalViewFrame.is())
3328 		{
3329 			m_xExternalViewController = xExternalViewFrame->getController();
3330 			Reference< ::com::sun::star::lang::XComponent> xComp(m_xExternalViewController, UNO_QUERY);
3331 			if (xComp.is())
3332 				xComp->addEventListener((XEventListener*)(XPropertyChangeListener*)this);
3333 		}
3334 	}
3335 	else
3336 	{
3337 		xExternalViewFrame = m_xExternalViewController->getFrame();
3338 		Reference< ::com::sun::star::frame::XDispatchProvider> xCommLink(xExternalViewFrame, UNO_QUERY);
3339 
3340 		// if we display the active form we interpret the slot as "remove it"
3341 		Reference< XForm> xCurrentModel(xCurrentNavController->getModel(), UNO_QUERY);
3342 		if ((xCurrentModel == m_xExternalDisplayedForm) || (getInternalForm(xCurrentModel) == m_xExternalDisplayedForm))
3343 		{
3344 			if ( m_xExternalViewController == getActiveController() )
3345             {
3346                 Reference< runtime::XFormController > xAsFormController( m_xExternalViewController, UNO_QUERY );
3347                 ControllerFeatures aHelper( ::comphelper::getProcessServiceFactory(), xAsFormController, NULL );
3348                 aHelper->commitCurrentControl();
3349             }
3350 
3351 			Reference< runtime::XFormController > xNewController(m_xExtViewTriggerController);
3352 			CloseExternalFormViewer();
3353 			setActiveController(xNewController);
3354 			return;
3355 		}
3356 
3357 		URL aClearURL;
3358 		aClearURL.Complete = FMURL_GRIDVIEW_CLEARVIEW;
3359 
3360 		Reference< ::com::sun::star::frame::XDispatch> xClear( xCommLink->queryDispatch(aClearURL, ::rtl::OUString::createFromAscii(""), 0));
3361 		if (xClear.is())
3362 			xClear->dispatch(aClearURL, Sequence< PropertyValue>());
3363 	}
3364 
3365     // TODO: We need an interceptor at the xSupplier, which forwards all queryDispatch requests to the FormController
3366     // instance for which this "external view" was triggered
3367 
3368 	// get the dispatch interface of the frame so we can communicate (interceptable) with the controller
3369 	Reference< ::com::sun::star::frame::XDispatchProvider> xCommLink(xExternalViewFrame, UNO_QUERY);
3370 
3371 	if (m_xExternalViewController.is())
3372 	{
3373 		DBG_ASSERT(xCommLink.is(), "FmXFormShell::CreateExternalView : the component doesn't have the necessary interfaces !");
3374 		// collect the dispatchers we will need
3375 		URL aAddColumnURL;
3376 		aAddColumnURL.Complete = FMURL_GRIDVIEW_ADDCOLUMN;
3377 		Reference< ::com::sun::star::frame::XDispatch> xAddColumnDispatch( xCommLink->queryDispatch(aAddColumnURL, ::rtl::OUString::createFromAscii(""), 0));
3378 		URL aAttachURL;
3379 		aAttachURL.Complete = FMURL_GRIDVIEW_ATTACHTOFORM;
3380 		Reference< ::com::sun::star::frame::XDispatch> xAttachDispatch( xCommLink->queryDispatch(aAttachURL, ::rtl::OUString::createFromAscii(""), 0));
3381 
3382 		if (xAddColumnDispatch.is() && xAttachDispatch.is())
3383 		{
3384 			DBG_ASSERT(xCurrentNavController.is(), "FmXFormShell::CreateExternalView : invalid call : have no nav controller !");
3385 			// first : dispatch the descriptions for the columns to add
3386 			Sequence< Reference< XControl> > aCurrentControls(xCurrentNavController->getControls());
3387 
3388 			sal_Int16 nAddedColumns = 0;
3389 
3390 			// for radio buttons we need some special structures
3391 			DECLARE_STL_USTRINGACCESS_MAP(Sequence< ::rtl::OUString>, MapUString2UstringSeq);
3392 			DECLARE_STL_ITERATORS(MapUString2UstringSeq);
3393 			DECLARE_STL_USTRINGACCESS_MAP(::rtl::OUString, FmMapUString2UString);
3394 			DECLARE_STL_USTRINGACCESS_MAP(sal_Int16, FmMapUString2Int16);
3395 			DECLARE_STL_ITERATORS(FmMapUString2Int16);
3396 
3397 			MapUString2UstringSeq	aRadioValueLists;
3398 			MapUString2UstringSeq	aRadioListSources;
3399 			FmMapUString2UString	aRadioControlSources;
3400 			FmMapUString2Int16		aRadioPositions;
3401 
3402 			FmXBoundFormFieldIterator aModelIterator(xCurrentNavController->getModel());
3403 			Reference< XPropertySet> xCurrentModelSet;
3404 			Any aCurrentBoundField;
3405 			::rtl::OUString sColumnType,aGroupName,sControlSource;
3406 			Sequence< Property> aProps;
3407 			Reference< XPropertySet> xCurrentBoundField;
3408 			while ((xCurrentModelSet = Reference< XPropertySet>(aModelIterator.Next(), UNO_QUERY)).is())
3409 			{
3410 				xCurrentModelSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xCurrentBoundField;
3411 				OSL_ENSURE(xCurrentModelSet.is(),"xCurrentModelSet is null!");
3412 				// create a description of the column to be created
3413 				// first : determine it's type
3414 
3415 				sal_Int16 nClassId = ::comphelper::getINT16(xCurrentModelSet->getPropertyValue(FM_PROP_CLASSID));
3416 				switch (nClassId)
3417 				{
3418 					case FormComponentType::RADIOBUTTON:
3419 					{
3420 						// get the label of the button (this is the access key for our structures)
3421 						aGroupName = getLabelName(xCurrentModelSet);
3422 
3423 						// add the reference value of the radio button to the list source sequence
3424 						Sequence< ::rtl::OUString>& aThisGroupLabels = aRadioListSources[aGroupName];
3425 						sal_Int32 nNewSizeL = aThisGroupLabels.getLength() + 1;
3426 						aThisGroupLabels.realloc(nNewSizeL);
3427 						aThisGroupLabels.getArray()[nNewSizeL - 1] = ::comphelper::getString(xCurrentModelSet->getPropertyValue(FM_PROP_REFVALUE));
3428 
3429 						// add the label to the value list sequence
3430 						Sequence< ::rtl::OUString>& aThisGroupControlSources = aRadioValueLists[aGroupName];
3431 						sal_Int32 nNewSizeC = aThisGroupControlSources.getLength() + 1;
3432 						aThisGroupControlSources.realloc(nNewSizeC);
3433 						aThisGroupControlSources.getArray()[nNewSizeC - 1] = ::comphelper::getString(xCurrentModelSet->getPropertyValue(FM_PROP_LABEL));
3434 
3435 						// remember the controls source of the radio group
3436 						sControlSource = ::comphelper::getString(xCurrentModelSet->getPropertyValue(FM_PROP_CONTROLSOURCE));
3437 						if (aRadioControlSources.find(aGroupName) == aRadioControlSources.end())
3438 							aRadioControlSources[aGroupName] = sControlSource;
3439 #ifdef DBG_UTIL
3440 						else
3441 							DBG_ASSERT(aRadioControlSources[aGroupName] == sControlSource,
3442 							"FmXFormShell::CreateExternalView : inconsistent radio buttons detected !");
3443 							// (radio buttons with the same name should have the same control source)
3444 #endif
3445 						// remember the position within the columns
3446 						if (aRadioPositions.find(aGroupName) == aRadioPositions.end())
3447 							aRadioPositions[aGroupName] = (sal_Int16)nAddedColumns;
3448 
3449 						// any further handling is done below
3450 					}
3451 					continue;
3452 
3453 					case FormComponentType::IMAGECONTROL:
3454 					case FormComponentType::CONTROL:
3455 						// no grid columns for these types (though they have a control source)
3456 						continue;
3457 					case FormComponentType::CHECKBOX:
3458 						sColumnType = FM_COL_CHECKBOX; break;
3459 					case FormComponentType::LISTBOX:
3460 						sColumnType = FM_COL_LISTBOX; break;
3461 					case FormComponentType::COMBOBOX:
3462 						sColumnType = FM_COL_COMBOBOX; break;
3463 					case FormComponentType::DATEFIELD:
3464 						sColumnType = FM_COL_DATEFIELD; break;
3465 					case FormComponentType::TIMEFIELD:
3466 						sColumnType = FM_COL_TIMEFIELD; break;
3467 					case FormComponentType::NUMERICFIELD:
3468 						sColumnType = FM_COL_NUMERICFIELD; break;
3469 					case FormComponentType::CURRENCYFIELD:
3470 						sColumnType = FM_COL_CURRENCYFIELD; break;
3471 					case FormComponentType::PATTERNFIELD:
3472 						sColumnType = FM_COL_PATTERNFIELD; break;
3473 
3474 					case FormComponentType::TEXTFIELD:
3475 						{
3476 							sColumnType = FM_COL_TEXTFIELD;
3477 							// we know at least two different controls which are TextFields : the basic edit field and the formatted
3478 							// field. we distinguish them by their service name
3479 							Reference< XServiceInfo> xInfo(xCurrentModelSet, UNO_QUERY);
3480 							if (xInfo.is())
3481 							{
3482 								sal_Int16 nObjectType = getControlTypeByObject(xInfo);
3483 								if (OBJ_FM_FORMATTEDFIELD == nObjectType)
3484 									sColumnType = FM_COL_FORMATTEDFIELD;
3485 							}
3486 						}
3487 						break;
3488 					default:
3489 						sColumnType = FM_COL_TEXTFIELD; break;
3490 				}
3491 
3492 				const sal_Int16 nDispatchArgs = 3;
3493 				Sequence< PropertyValue> aDispatchArgs(nDispatchArgs);
3494 				PropertyValue* pDispatchArgs = aDispatchArgs.getArray();
3495 
3496 				// properties describing "meta data" about the column
3497 				// the type
3498 				pDispatchArgs->Name = FMARG_ADDCOL_COLUMNTYPE;
3499 				pDispatchArgs->Value <<= sColumnType;
3500 				++pDispatchArgs;
3501 
3502 				// the pos : append the col
3503 				pDispatchArgs->Name = FMARG_ADDCOL_COLUMNPOS;
3504 				pDispatchArgs->Value <<= nAddedColumns;
3505 				++pDispatchArgs;
3506 
3507 				// the properties to forward to the new column
3508 				Sequence< PropertyValue> aColumnProps(1);
3509 				PropertyValue* pColumnProps = aColumnProps.getArray();
3510 
3511 				// the label
3512 				pColumnProps->Name = FM_PROP_LABEL;
3513 				pColumnProps->Value <<= getLabelName(xCurrentModelSet);
3514 				++pColumnProps;
3515 
3516 				// for all other props : transfer them
3517 				Reference< XPropertySetInfo> xControlModelInfo( xCurrentModelSet->getPropertySetInfo());
3518 				DBG_ASSERT(xControlModelInfo.is(), "FmXFormShell::CreateExternalView : the control model has no property info ! This will crash !");
3519 				aProps = xControlModelInfo->getProperties();
3520 				const Property* pProps = aProps.getConstArray();
3521 
3522 				// realloc the control description sequence
3523 				sal_Int32 nExistentDescs = pColumnProps - aColumnProps.getArray();
3524 				aColumnProps.realloc(nExistentDescs + aProps.getLength());
3525 				pColumnProps = aColumnProps.getArray() + nExistentDescs;
3526 
3527 				for (sal_Int32 i=0; i<aProps.getLength(); ++i, ++pProps)
3528 				{
3529 					if (pProps->Name.equals(FM_PROP_LABEL))
3530 						// already set
3531 						continue;
3532 					if (pProps->Name.equals(FM_PROP_DEFAULTCONTROL))
3533 						// allow the column's own "default control"
3534 						continue;
3535 					if (pProps->Attributes & PropertyAttribute::READONLY)
3536 						// assume that properties which are readonly for the control are ro for the column to be created, too
3537 						continue;
3538 
3539 					pColumnProps->Name = pProps->Name;
3540 					pColumnProps->Value = xCurrentModelSet->getPropertyValue(pProps->Name);
3541 					++pColumnProps;
3542 				}
3543 				aColumnProps.realloc(pColumnProps - aColumnProps.getArray());
3544 
3545 				// columns props are a dispatch argument
3546 				pDispatchArgs->Name = ::rtl::OUString::createFromAscii("ColumnProperties"); // TODO : fmurl.*
3547 				pDispatchArgs->Value = makeAny(aColumnProps);
3548 				++pDispatchArgs;
3549 				DBG_ASSERT(nDispatchArgs == (pDispatchArgs - aDispatchArgs.getConstArray()),
3550 					"FmXFormShell::CreateExternalView : forgot to adjust nDispatchArgs ?");
3551 
3552 				// dispatch the "add column"
3553 				xAddColumnDispatch->dispatch(aAddColumnURL, aDispatchArgs);
3554 				++nAddedColumns;
3555 			}
3556 
3557 			// now for the radio button handling
3558 			sal_Int16 nOffset(0);
3559 			// properties describing the "direct" column properties
3560 			const sal_Int16 nListBoxDescription = 6;
3561 			Sequence< PropertyValue> aListBoxDescription(nListBoxDescription);
3562 			for (	ConstFmMapUString2UStringIterator aCtrlSource = aRadioControlSources.begin();
3563 					aCtrlSource != aRadioControlSources.end();
3564 					++aCtrlSource, ++nOffset
3565 				)
3566 			{
3567 
3568 				PropertyValue* pListBoxDescription = aListBoxDescription.getArray();
3569 				// label
3570 				pListBoxDescription->Name = FM_PROP_LABEL;
3571 				pListBoxDescription->Value <<= (*aCtrlSource).first;
3572 				++pListBoxDescription;
3573 
3574 				// control source
3575 				pListBoxDescription->Name = FM_PROP_CONTROLSOURCE;
3576 				pListBoxDescription->Value <<= (*aCtrlSource).second;
3577 				++pListBoxDescription;
3578 
3579 				// bound column
3580 				pListBoxDescription->Name = FM_PROP_BOUNDCOLUMN;
3581 				pListBoxDescription->Value <<= (sal_Int16)1;
3582 				++pListBoxDescription;
3583 
3584 				// content type
3585 				pListBoxDescription->Name = FM_PROP_LISTSOURCETYPE;
3586 				 ListSourceType eType = ListSourceType_VALUELIST;
3587 				 pListBoxDescription->Value = makeAny(eType);
3588 				++pListBoxDescription;
3589 
3590 				// list source
3591 				MapUString2UstringSeq::const_iterator aCurrentListSource = aRadioListSources.find((*aCtrlSource).first);
3592 				DBG_ASSERT(aCurrentListSource != aRadioListSources.end(),
3593 					"FmXFormShell::CreateExternalView : inconsistent radio descriptions !");
3594 				pListBoxDescription->Name = FM_PROP_LISTSOURCE;
3595 				pListBoxDescription->Value = makeAny((*aCurrentListSource).second);
3596 				++pListBoxDescription;
3597 
3598 				// value list
3599 				MapUString2UstringSeq::const_iterator aCurrentValueList = aRadioValueLists.find((*aCtrlSource).first);
3600 				DBG_ASSERT(aCurrentValueList != aRadioValueLists.end(),
3601 					"FmXFormShell::CreateExternalView : inconsistent radio descriptions !");
3602 				pListBoxDescription->Name = FM_PROP_STRINGITEMLIST;
3603 				pListBoxDescription->Value = makeAny(((*aCurrentValueList).second));
3604 				++pListBoxDescription;
3605 
3606 				DBG_ASSERT(nListBoxDescription == (pListBoxDescription - aListBoxDescription.getConstArray()),
3607 					"FmXFormShell::CreateExternalView : forgot to adjust nListBoxDescription ?");
3608 
3609 				// properties describing the column "meta data"
3610 				const sal_Int16 nDispatchArgs = 3;
3611 				Sequence< PropertyValue> aDispatchArgs(nDispatchArgs);
3612 				PropertyValue* pDispatchArgs = aDispatchArgs.getArray();
3613 
3614 				// column type : listbox
3615 				pDispatchArgs->Name = FMARG_ADDCOL_COLUMNTYPE;
3616 				::rtl::OUString fColName = FM_COL_LISTBOX;
3617 				pDispatchArgs->Value <<= fColName;
3618 //				pDispatchArgs->Value <<= (::rtl::OUString)FM_COL_LISTBOX;
3619 				++pDispatchArgs;
3620 
3621 				// column position
3622 				pDispatchArgs->Name = FMARG_ADDCOL_COLUMNPOS;
3623 				FmMapUString2Int16::const_iterator aOffset = aRadioPositions.find((*aCtrlSource).first);
3624 				DBG_ASSERT(aOffset != aRadioPositions.end(),
3625 					"FmXFormShell::CreateExternalView : inconsistent radio descriptions !");
3626 				sal_Int16 nPosition = (*aOffset).second;
3627 				nPosition = nPosition + nOffset;
3628 					// we alread inserted nOffset additinal columns ....
3629 				pDispatchArgs->Value <<= nPosition;
3630 				++pDispatchArgs;
3631 
3632 				// the
3633 				pDispatchArgs->Name = ::rtl::OUString::createFromAscii("ColumnProperties"); // TODO : fmurl.*
3634 				pDispatchArgs->Value = makeAny(aListBoxDescription);
3635 				++pDispatchArgs;
3636 				DBG_ASSERT(nDispatchArgs == (pDispatchArgs - aDispatchArgs.getConstArray()),
3637 					"FmXFormShell::CreateExternalView : forgot to adjust nDispatchArgs ?");
3638 
3639 				// dispatch the "add column"
3640 				xAddColumnDispatch->dispatch(aAddColumnURL, aDispatchArgs);
3641 				++nAddedColumns;
3642 			}
3643 
3644 
3645 			DBG_ASSERT(nAddedColumns > 0, "FmXFormShell::CreateExternalView : no controls (inconsistent) !");
3646 				// we should have checked if we have any usable controls (see above).
3647 
3648 			// "load" the "form" of the external view
3649 			PropertyValue aArg;
3650 			aArg.Name = FMARG_ATTACHTO_MASTERFORM;
3651 			Reference< XResultSet> xForm(xCurrentNavController->getModel(), UNO_QUERY);
3652 			aArg.Value <<= xForm;
3653 
3654 			m_xExternalDisplayedForm = Reference< XResultSet>(xForm, UNO_QUERY);
3655 				// do this before dispatching the "attach" command, as the atach may result in a call to our queryDispatch (for the FormSlots)
3656 				// whichs needs the m_xExternalDisplayedForm
3657 
3658 			xAttachDispatch->dispatch(aAttachURL, Sequence< PropertyValue>(&aArg, 1));
3659 
3660 			m_xExtViewTriggerController = xCurrentNavController;
3661 
3662 			// we want to know modifications done in the external view
3663 			// if the external controller is a XFormController we can use all our default handlings for it
3664 			Reference< runtime::XFormController > xFormController( m_xExternalViewController, UNO_QUERY );
3665             OSL_ENSURE( xFormController.is(), "FmXFormShell::CreateExternalView:: invalid external view controller!" );
3666 			if (xFormController.is())
3667 				xFormController->addActivateListener((XFormControllerListener*)this);
3668 		}
3669 	}
3670 #ifdef DBG_UTIL
3671 	else
3672 	{
3673 		DBG_ERROR("FmXFormShell::CreateExternalView : could not create the external form view !");
3674 	}
3675 #endif
3676 	InvalidateSlot( SID_FM_VIEW_AS_GRID, sal_False );
3677 }
3678 
3679 //------------------------------------------------------------------------
implAdjustConfigCache()3680 void FmXFormShell::implAdjustConfigCache()
3681 {
3682 	// get (cache) the wizard usage flag
3683 	Sequence< ::rtl::OUString > aNames(1);
3684 	aNames[0] = ::rtl::OUString::createFromAscii("FormControlPilotsEnabled");
3685 	Sequence< Any > aFlags = GetProperties(aNames);
3686 	if (1 == aFlags.getLength())
3687 		m_bUseWizards = ::cppu::any2bool(aFlags[0]);
3688 }
3689 
3690 //------------------------------------------------------------------------
Notify(const com::sun::star::uno::Sequence<rtl::OUString> & _rPropertyNames)3691 void FmXFormShell::Notify( const com::sun::star::uno::Sequence< rtl::OUString >& _rPropertyNames)
3692 {
3693     if ( impl_checkDisposed() )
3694         return;
3695 
3696     const ::rtl::OUString* pSearch = _rPropertyNames.getConstArray();
3697 	const ::rtl::OUString* pSearchTil = pSearch + _rPropertyNames.getLength();
3698 	for (;pSearch < pSearchTil; ++pSearch)
3699 		if (0 == pSearch->compareToAscii("FormControlPilotsEnabled"))
3700 		{
3701 			implAdjustConfigCache();
3702 			InvalidateSlot( SID_FM_USE_WIZARDS, sal_True );
3703 		}
3704 }
3705 
Commit()3706 void FmXFormShell::Commit()
3707 {
3708 }
3709 
3710 //------------------------------------------------------------------------
SetWizardUsing(sal_Bool _bUseThem)3711 void FmXFormShell::SetWizardUsing(sal_Bool _bUseThem)
3712 {
3713 	m_bUseWizards = _bUseThem;
3714 
3715 	Sequence< ::rtl::OUString > aNames(1);
3716 	aNames[0] = ::rtl::OUString::createFromAscii("FormControlPilotsEnabled");
3717 	Sequence< Any > aValues(1);
3718 	aValues[0] = ::cppu::bool2any(m_bUseWizards);
3719 	PutProperties(aNames, aValues);
3720 }
3721 
3722 //------------------------------------------------------------------------
viewDeactivated(FmFormView & _rCurrentView,sal_Bool _bDeactivateController)3723 void FmXFormShell::viewDeactivated( FmFormView& _rCurrentView, sal_Bool _bDeactivateController /* = sal_True */ )
3724 {
3725 
3726 	if ( _rCurrentView.GetImpl() && !_rCurrentView.IsDesignMode() )
3727 	{
3728 		_rCurrentView.GetImpl()->Deactivate( _bDeactivateController );
3729 	}
3730 
3731 	// if we have an async load operation pending for the 0-th page for this view,
3732 	// we need to cancel this
3733 	// 103727 - 2002-09-26 - fs@openoffice.org
3734     FmFormPage* pPage = _rCurrentView.GetCurPage();
3735 	if ( pPage )
3736 	{
3737 		// move all events from our queue to a new one, omit the events for the deactivated
3738 		// page
3739 		::std::queue< FmLoadAction > aNewEvents;
3740 		while ( !m_aLoadingPages.empty() )
3741 		{
3742 			FmLoadAction aAction = m_aLoadingPages.front();
3743 			m_aLoadingPages.pop();
3744 			if ( pPage != aAction.pPage )
3745 			{
3746 				aNewEvents.push( aAction );
3747 			}
3748 			else
3749 			{
3750 				Application::RemoveUserEvent( aAction.nEventId );
3751 			}
3752 		}
3753 		m_aLoadingPages = aNewEvents;
3754 	}
3755 
3756     // remove callbacks at the page
3757     if ( pPage )
3758     {
3759         pPage->GetImpl().SetFormsCreationHdl( Link() );
3760     }
3761     UpdateForms( sal_True );
3762 }
3763 
3764 //------------------------------------------------------------------------
3765 IMPL_LINK( FmXFormShell, OnFirstTimeActivation, void*, /*NOTINTERESTEDIN*/ )
3766 {
3767     if ( impl_checkDisposed() )
3768         return 0L;
3769 
3770     m_nActivationEvent = 0;
3771     SfxObjectShell* pDocument = m_pShell->GetObjectShell();
3772 
3773     if  ( pDocument && !pDocument->HasName() )
3774     {
3775         if ( isEnhancedForm() )
3776         {
3777             // show the data navigator
3778 	        if ( !m_pShell->GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_SHOW_DATANAVIGATOR ) )
3779 		        m_pShell->GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_SHOW_DATANAVIGATOR );
3780         }
3781     }
3782 
3783     return 0L;
3784 }
3785 
3786 //------------------------------------------------------------------------
3787 IMPL_LINK( FmXFormShell, OnFormsCreated, FmFormPage*, /*_pPage*/ )
3788 {
3789     UpdateForms( sal_True );
3790     return 0L;
3791 }
3792 
3793 //------------------------------------------------------------------------
viewActivated(FmFormView & _rCurrentView,sal_Bool _bSyncAction)3794 void FmXFormShell::viewActivated( FmFormView& _rCurrentView, sal_Bool _bSyncAction /* = sal_False */ )
3795 {
3796 
3797     FmFormPage* pPage = _rCurrentView.GetCurPage();
3798 
3799     // activate our view if we are activated ourself
3800 	// FS - 30.06.99 - 67308
3801 	if ( _rCurrentView.GetImpl() && !_rCurrentView.IsDesignMode() )
3802 	{
3803 		// load forms for the page the current view belongs to
3804 		if ( pPage )
3805 		{
3806 			if ( !pPage->GetImpl().hasEverBeenActivated() )
3807 				loadForms( pPage, FORMS_LOAD | ( _bSyncAction ? FORMS_SYNC : FORMS_ASYNC ) );
3808 			pPage->GetImpl().setHasBeenActivated( );
3809 		}
3810 
3811 		// first-time initializations for the views
3812 		if ( !_rCurrentView.GetImpl()->hasEverBeenActivated( ) )
3813 		{
3814 			_rCurrentView.GetImpl()->onFirstViewActivation( PTR_CAST( FmFormModel, _rCurrentView.GetModel() ) );
3815 			_rCurrentView.GetImpl()->setHasBeenActivated( );
3816 		}
3817 
3818 		// activate the current view
3819 		_rCurrentView.GetImpl()->Activate( _bSyncAction );
3820 	}
3821 
3822     // set callbacks at the page
3823     if ( pPage )
3824     {
3825         pPage->GetImpl().SetFormsCreationHdl( LINK( this, FmXFormShell, OnFormsCreated ) );
3826     }
3827 
3828     UpdateForms( sal_True );
3829 
3830     if ( !hasEverBeenActivated() )
3831     {
3832         m_nActivationEvent = Application::PostUserEvent( LINK( this, FmXFormShell, OnFirstTimeActivation ) );
3833         setHasBeenActivated();
3834     }
3835 
3836     // find a default "current form", if there is none, yet
3837     // #i88186# / 2008-04-12 / frank.schoenheit@sun.com
3838     impl_defaultCurrentForm_nothrow();
3839 }
3840 
3841 //------------------------------------------------------------------------------
impl_defaultCurrentForm_nothrow()3842 void FmXFormShell::impl_defaultCurrentForm_nothrow()
3843 {
3844     if ( impl_checkDisposed() )
3845         return;
3846 
3847     if ( m_xCurrentForm.is() )
3848         // no action required
3849         return;
3850 
3851     FmFormView* pFormView = m_pShell->GetFormView();
3852     FmFormPage* pPage = pFormView ? pFormView->GetCurPage() : NULL;
3853     if ( !pPage )
3854         return;
3855 
3856     try
3857     {
3858         Reference< XIndexAccess > xForms( pPage->GetForms( false ), UNO_QUERY );
3859         if ( !xForms.is() || !xForms->hasElements() )
3860             return;
3861 
3862         Reference< XForm > xNewCurrentForm( xForms->getByIndex(0), UNO_QUERY_THROW );
3863         impl_updateCurrentForm( xNewCurrentForm );
3864     }
3865     catch( const Exception& )
3866     {
3867     	DBG_UNHANDLED_EXCEPTION();
3868     }
3869 }
3870 
3871 //------------------------------------------------------------------------------
smartControlReset(const Reference<XIndexAccess> & _rxModels)3872 void FmXFormShell::smartControlReset( const Reference< XIndexAccess >& _rxModels )
3873 {
3874 	if (!_rxModels.is())
3875 	{
3876 		DBG_ERROR("FmXFormShell::smartControlReset: invalid container!");
3877 		return;
3878 	}
3879 
3880 	static const ::rtl::OUString sClassIdPropertyName = FM_PROP_CLASSID;
3881 	static const ::rtl::OUString sBoundFieldPropertyName = FM_PROP_BOUNDFIELD;
3882 	sal_Int32 nCount = _rxModels->getCount();
3883 	Reference< XPropertySet > xCurrent;
3884 	Reference< XPropertySetInfo > xCurrentInfo;
3885 	Reference< XPropertySet > xBoundField;
3886 
3887 	for (sal_Int32 i=0; i<nCount; ++i)
3888 	{
3889 		_rxModels->getByIndex(i) >>= xCurrent;
3890 		if (xCurrent.is())
3891 			xCurrentInfo = xCurrent->getPropertySetInfo();
3892 		else
3893 			xCurrentInfo.clear();
3894 		if (!xCurrentInfo.is())
3895 			continue;
3896 
3897 		if (xCurrentInfo->hasPropertyByName(sClassIdPropertyName))
3898 		{	// it's a control model
3899 
3900 			// check if this control is bound to a living database field
3901 			if (xCurrentInfo->hasPropertyByName(sBoundFieldPropertyName))
3902 				xCurrent->getPropertyValue(sBoundFieldPropertyName) >>= xBoundField;
3903 			else
3904 				xBoundField.clear();
3905 
3906             // reset only if it's *not* bound
3907             bool bReset = !xBoundField.is();
3908 
3909             // and additionally, check if it has an external value binding
3910             Reference< XBindableValue > xBindable( xCurrent, UNO_QUERY );
3911             if ( xBindable.is() && xBindable->getValueBinding().is() )
3912                 bReset = false;
3913 
3914 			if ( bReset )
3915 			{
3916 				Reference< XReset > xControlReset( xCurrent, UNO_QUERY );
3917 				if ( xControlReset.is() )
3918 					xControlReset->reset();
3919 			}
3920 		}
3921 		else
3922 		{
3923 			Reference< XIndexAccess > xContainer(xCurrent, UNO_QUERY);
3924 			if (xContainer.is())
3925 				smartControlReset(xContainer);
3926 		}
3927 	}
3928 }
3929 
3930 //------------------------------------------------------------------------
3931 IMPL_LINK( FmXFormShell, OnLoadForms, FmFormPage*, /*_pPage*/ )
3932 {
3933 	FmLoadAction aAction = m_aLoadingPages.front();
3934 	m_aLoadingPages.pop();
3935 
3936 	loadForms( aAction.pPage, aAction.nFlags & ~FORMS_ASYNC );
3937 	return 0L;
3938 }
3939 
3940 //------------------------------------------------------------------------------
3941 namespace
3942 {
lcl_isLoadable(const Reference<XInterface> & _rxLoadable)3943     sal_Bool lcl_isLoadable( const Reference< XInterface >& _rxLoadable )
3944     {
3945 	    // determines whether a form should be loaded or not
3946 	    // if there is no datasource or connection there is no reason to load a form
3947 	    Reference< XPropertySet > xSet( _rxLoadable, UNO_QUERY );
3948 	    if ( !xSet.is() )
3949             return sal_False;
3950 	    try
3951 	    {
3952 		    Reference< XConnection > xConn;
3953             if ( OStaticDataAccessTools().isEmbeddedInDatabase( _rxLoadable.get(), xConn ) )
3954                 return sal_True;
3955 
3956 		    // is there already a active connection
3957 		    xSet->getPropertyValue(FM_PROP_ACTIVE_CONNECTION) >>= xConn;
3958             if ( xConn.is() )
3959                 return sal_True;
3960 
3961             ::rtl::OUString sPropertyValue;
3962             OSL_VERIFY( xSet->getPropertyValue( FM_PROP_DATASOURCE ) >>= sPropertyValue );
3963             if ( sPropertyValue.getLength() )
3964                 return sal_True;
3965 
3966             OSL_VERIFY( xSet->getPropertyValue( FM_PROP_URL ) >>= sPropertyValue );
3967             if ( sPropertyValue.getLength() )
3968                 return sal_True;
3969 	    }
3970 	    catch(const Exception&)
3971 	    {
3972             DBG_UNHANDLED_EXCEPTION();
3973 	    }
3974 	    return sal_False;
3975     }
3976 }
3977 
3978 //------------------------------------------------------------------------
loadForms(FmFormPage * _pPage,const sal_uInt16 _nBehaviour)3979 void FmXFormShell::loadForms( FmFormPage* _pPage, const sal_uInt16 _nBehaviour /* FORMS_LOAD | FORMS_SYNC */ )
3980 {
3981 	DBG_ASSERT( ( _nBehaviour & ( FORMS_ASYNC | FORMS_UNLOAD ) )  != ( FORMS_ASYNC | FORMS_UNLOAD ),
3982 		"FmXFormShell::loadForms: async loading not supported - this will heavily fail!" );
3983 
3984 	if ( _nBehaviour & FORMS_ASYNC )
3985 	{
3986 		m_aLoadingPages.push( FmLoadAction(
3987 			_pPage,
3988 			_nBehaviour,
3989 			Application::PostUserEvent( LINK( this, FmXFormShell, OnLoadForms ), _pPage )
3990 		) );
3991 		return;
3992 	}
3993 
3994 	DBG_ASSERT( _pPage, "FmXFormShell::loadForms: invalid page!" );
3995 	if ( _pPage )
3996 	{
3997 		// lock the undo env so the forms can change non-transient properties while loading
3998 		// (without this my doc's modified flag would be set)
3999 		FmFormModel* pModel = PTR_CAST( FmFormModel, _pPage->GetModel() );
4000 		DBG_ASSERT( pModel, "FmXFormShell::loadForms: invalid model!" );
4001 		if ( pModel )
4002 			pModel->GetUndoEnv().Lock();
4003 
4004 		// load all forms
4005 		Reference< XIndexAccess >  xForms;
4006 		xForms = xForms.query( _pPage->GetForms( false ) );
4007 
4008 		if ( xForms.is() )
4009 		{
4010 			Reference< XLoadable >  xForm;
4011             sal_Bool                bFormWasLoaded = sal_False;
4012 			for ( sal_Int32 j = 0, nCount = xForms->getCount(); j < nCount; ++j )
4013 			{
4014 				xForms->getByIndex( j ) >>= xForm;
4015                 bFormWasLoaded = sal_False;
4016 				// a database form must be loaded for
4017                 try
4018                 {
4019 				    if ( 0 == ( _nBehaviour & FORMS_UNLOAD ) )
4020 				    {
4021 					    if ( lcl_isLoadable( xForm ) && !xForm->isLoaded() )
4022 						    xForm->load();
4023 				    }
4024 				    else
4025 				    {
4026 					    if ( xForm->isLoaded() )
4027                         {
4028                             bFormWasLoaded = sal_True;
4029 						    xForm->unload();
4030                         }
4031 				    }
4032                 }
4033                 catch( const Exception& )
4034                 {
4035                 	DBG_UNHANDLED_EXCEPTION();
4036                 }
4037 
4038                 // reset the form if it was loaded
4039                 if ( bFormWasLoaded )
4040 				{
4041 					Reference< XIndexAccess > xContainer( xForm, UNO_QUERY );
4042 					DBG_ASSERT( xContainer.is(), "FmXFormShell::loadForms: the form is no container!" );
4043 					if ( xContainer.is() )
4044 						smartControlReset( xContainer );
4045 				}
4046 			}
4047 		}
4048 
4049 		if ( pModel )
4050 			// unlock the environment
4051 			pModel->GetUndoEnv().UnLock();
4052 	}
4053 }
4054 
4055 //------------------------------------------------------------------------
ExecuteTextAttribute(SfxRequest & _rReq)4056 void FmXFormShell::ExecuteTextAttribute( SfxRequest& _rReq )
4057 {
4058     m_pTextShell->ExecuteTextAttribute( _rReq );
4059 }
4060 
4061 //------------------------------------------------------------------------
GetTextAttributeState(SfxItemSet & _rSet)4062 void FmXFormShell::GetTextAttributeState( SfxItemSet& _rSet )
4063 {
4064     m_pTextShell->GetTextAttributeState( _rSet );
4065 }
4066 
4067 //------------------------------------------------------------------------
IsActiveControl(bool _bCountRichTextOnly) const4068 bool FmXFormShell::IsActiveControl( bool _bCountRichTextOnly ) const
4069 {
4070     return m_pTextShell->IsActiveControl( _bCountRichTextOnly );
4071 }
4072 
4073 //------------------------------------------------------------------------
ForgetActiveControl()4074 void FmXFormShell::ForgetActiveControl()
4075 {
4076     m_pTextShell->ForgetActiveControl();
4077 }
4078 
4079 //------------------------------------------------------------------------
SetControlActivationHandler(const Link & _rHdl)4080 void FmXFormShell::SetControlActivationHandler( const Link& _rHdl )
4081 {
4082     m_pTextShell->SetControlActivationHandler( _rHdl );
4083 }
4084 //------------------------------------------------------------------------
handleShowPropertiesRequest()4085 void FmXFormShell::handleShowPropertiesRequest()
4086 {
4087     if ( onlyControlsAreMarked() )
4088         ShowSelectionProperties( sal_True );
4089 }
4090 
4091 //------------------------------------------------------------------------
handleMouseButtonDown(const SdrViewEvent & _rViewEvent)4092 void FmXFormShell::handleMouseButtonDown( const SdrViewEvent& _rViewEvent )
4093 {
4094     // catch simple double clicks
4095     if ( ( _rViewEvent.nMouseClicks == 2 ) && ( _rViewEvent.nMouseCode == MOUSE_LEFT ) )
4096     {
4097         if ( _rViewEvent.eHit == SDRHIT_MARKEDOBJECT )
4098         {
4099             if ( onlyControlsAreMarked() )
4100                 ShowSelectionProperties( sal_True );
4101         }
4102     }
4103 }
4104 
4105 //------------------------------------------------------------------------------
HasControlFocus() const4106 bool FmXFormShell::HasControlFocus() const
4107 {
4108     bool bHasControlFocus = false;
4109 
4110     try
4111     {
4112         Reference< XFormController > xController( getActiveController() );
4113         Reference< XControl > xCurrentControl;
4114         if ( xController.is() )
4115             xCurrentControl.set( xController->getCurrentControl() );
4116         if ( xCurrentControl.is() )
4117         {
4118             Reference< XWindow2 > xPeerWindow( xCurrentControl->getPeer(), UNO_QUERY_THROW );
4119             bHasControlFocus = xPeerWindow->hasFocus();
4120         }
4121     }
4122     catch( const Exception& )
4123     {
4124     	DBG_UNHANDLED_EXCEPTION();
4125     }
4126 
4127     return bHasControlFocus;
4128 }
4129 
4130 //==============================================================================
4131 //==============================================================================
SearchableControlIterator(Reference<XInterface> xStartingPoint)4132 SearchableControlIterator::SearchableControlIterator(Reference< XInterface> xStartingPoint)
4133 	:IndexAccessIterator(xStartingPoint)
4134 {
4135 }
4136 
4137 //------------------------------------------------------------------------------
ShouldHandleElement(const Reference<XInterface> & xElement)4138 sal_Bool SearchableControlIterator::ShouldHandleElement(const Reference< XInterface>& xElement)
4139 {
4140 	// wenn das Ding eine ControlSource und einen BoundField-Property hat
4141 	Reference< XPropertySet> xProperties(xElement, UNO_QUERY);
4142 	if (::comphelper::hasProperty(FM_PROP_CONTROLSOURCE, xProperties) && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xProperties))
4143 	{
4144 		// und das BoundField gueltig ist
4145 		Reference< XPropertySet> xField;
4146 		xProperties->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
4147 		if (xField.is())
4148 		{
4149 			// nehmen wir's
4150 			m_sCurrentValue = ::comphelper::getString(xProperties->getPropertyValue(FM_PROP_CONTROLSOURCE));
4151 			return sal_True;
4152 		}
4153 	}
4154 
4155 	// wenn es ein Grid-Control ist
4156 	if (::comphelper::hasProperty(FM_PROP_CLASSID, xProperties))
4157 	{
4158 		Any aClassId( xProperties->getPropertyValue(FM_PROP_CLASSID) );
4159 		if (::comphelper::getINT16(aClassId) == FormComponentType::GRIDCONTROL)
4160 		{
4161 			m_sCurrentValue = ::rtl::OUString();
4162 			return sal_True;
4163 		}
4164 	}
4165 
4166 	return sal_False;
4167 }
4168 
4169 //------------------------------------------------------------------------------
ShouldStepInto(const Reference<XInterface> &) const4170 sal_Bool SearchableControlIterator::ShouldStepInto(const Reference< XInterface>& /*xContainer*/) const
4171 {
4172 	return sal_True;
4173 }
4174 
4175 //==============================================================================
4176 //==============================================================================
4177 
4178 SV_IMPL_PTRARR(StatusForwarderArray, SfxStatusForwarder*)
4179 
4180 SFX_IMPL_MENU_CONTROL(ControlConversionMenuController, SfxBoolItem);
4181 
4182 //------------------------------------------------------------------------------
ControlConversionMenuController(sal_uInt16 _nId,Menu & _rMenu,SfxBindings & _rBindings)4183 ControlConversionMenuController::ControlConversionMenuController( sal_uInt16 _nId, Menu& _rMenu, SfxBindings& _rBindings )
4184 	:SfxMenuControl( _nId, _rBindings )
4185 	,m_pMainMenu( &_rMenu )
4186 	,m_pConversionMenu( NULL )
4187 {
4188 	if ( _nId == SID_FM_CHANGECONTROLTYPE )
4189 	{
4190 		m_pConversionMenu = FmXFormShell::GetConversionMenu();
4191 		_rMenu.SetPopupMenu( _nId, m_pConversionMenu );
4192 
4193 		for (sal_Int16 i=0; i<m_pConversionMenu->GetItemCount(); ++i)
4194 		{
4195 			_rBindings.Invalidate(m_pConversionMenu->GetItemId(i));
4196 			SfxStatusForwarder* pForwarder = new SfxStatusForwarder(m_pConversionMenu->GetItemId(i), *this);
4197 			m_aStatusForwarders.C40_INSERT(SfxStatusForwarder, pForwarder, m_aStatusForwarders.Count());
4198 		}
4199 	}
4200 }
4201 
4202 //------------------------------------------------------------------------------
~ControlConversionMenuController()4203 ControlConversionMenuController::~ControlConversionMenuController()
4204 {
4205 	m_pMainMenu->SetPopupMenu(SID_FM_CHANGECONTROLTYPE, NULL);
4206 	delete m_pConversionMenu;
4207 }
4208 
4209 //------------------------------------------------------------------------------
StateChanged(sal_uInt16 nSID,SfxItemState eState,const SfxPoolItem * pState)4210 void ControlConversionMenuController::StateChanged(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState)
4211 {
4212 	if (nSID == GetId())
4213 		SfxMenuControl::StateChanged(nSID, eState, pState);
4214 	else if (FmXFormShell::isControlConversionSlot(nSID))
4215 	{
4216 		if ((m_pConversionMenu->GetItemPos(nSID) != MENU_ITEM_NOTFOUND) && (eState == SFX_ITEM_DISABLED))
4217 		{
4218 			m_pConversionMenu->RemoveItem(m_pConversionMenu->GetItemPos(nSID));
4219 		}
4220 		else if ((m_pConversionMenu->GetItemPos(nSID) == MENU_ITEM_NOTFOUND) && (eState != SFX_ITEM_DISABLED))
4221 		{
4222 			// We can't simply re-insert the item because we have a clear order for all the our items.
4223 			// So first we have to determine the position of the item to insert.
4224 			PopupMenu* pSource = FmXFormShell::GetConversionMenu();
4225 			sal_uInt16 nSourcePos = pSource->GetItemPos(nSID);
4226 			DBG_ASSERT(nSourcePos != MENU_ITEM_NOTFOUND, "ControlConversionMenuController::StateChanged : FmXFormShell supplied an invalid menu !");
4227 			sal_uInt16 nPrevInSource = nSourcePos;
4228 			sal_uInt16 nPrevInConversion = MENU_ITEM_NOTFOUND;
4229 			while (nPrevInSource>0)
4230 			{
4231 				sal_Int16 nPrevId = pSource->GetItemId(--nPrevInSource);
4232 
4233 				// do we have the source's predecessor in our conversion menu, too ?
4234 				nPrevInConversion = m_pConversionMenu->GetItemPos(nPrevId);
4235 				if (nPrevInConversion != MENU_ITEM_NOTFOUND)
4236 					break;
4237 			}
4238 			if (MENU_ITEM_NOTFOUND == nPrevInConversion)
4239 				// none of the items which precede the nSID-slot in the source menu are present in our conversion menu
4240 				nPrevInConversion = sal::static_int_cast< sal_uInt16 >(-1);	// put the item at the first position
4241 			m_pConversionMenu->InsertItem(nSID, pSource->GetItemText(nSID), pSource->GetItemBits(nSID), ++nPrevInConversion);
4242 			m_pConversionMenu->SetItemImage(nSID, pSource->GetItemImage(nSID));
4243 			m_pConversionMenu->SetHelpId(nSID, pSource->GetHelpId(nSID));
4244 
4245 			delete pSource;
4246 		}
4247 		m_pMainMenu->EnableItem(SID_FM_CHANGECONTROLTYPE, m_pConversionMenu->GetItemCount() > 0);
4248 	}
4249 	else
4250 	{
4251 		DBG_ERROR("ControlConversionMenuController::StateChanged : unknown id !");
4252 	}
4253 }
4254 
4255 //==============================================================================
4256