?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 4.3.0.0.beta1, tag libreoffice-4.3.0.0.beta1
[LibreOffice.git] / svx / source / form / formcontroller.cxx
blob0d4457cb9a31906e0f64b011e595d3081f88f8e9
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include "fmcontrolbordermanager.hxx"
22 #include "fmcontrollayout.hxx"
23 #include "formcontroller.hxx"
24 #include "formfeaturedispatcher.hxx"
25 #include "fmdocumentclassification.hxx"
26 #include "formcontrolling.hxx"
27 #include "fmprop.hrc"
28 #include "svx/dialmgr.hxx"
29 #include "svx/fmresids.hrc"
30 #include "fmservs.hxx"
31 #include "svx/fmtools.hxx"
32 #include "fmurl.hxx"
33
34 #include <com/sun/star/awt/FocusChangeReason.hpp>
35 #include <com/sun/star/awt/XCheckBox.hpp>
36 #include <com/sun/star/awt/XComboBox.hpp>
37 #include <com/sun/star/awt/XListBox.hpp>
38 #include <com/sun/star/awt/XVclWindowPeer.hpp>
39 #include <com/sun/star/awt/TabController.hpp>
40 #include <com/sun/star/beans/NamedValue.hpp>
41 #include <com/sun/star/beans/PropertyAttribute.hpp>
42 #include <com/sun/star/container/XIdentifierReplace.hpp>
43 #include <com/sun/star/form/TabulatorCycle.hpp>
44 #include <com/sun/star/form/validation/XValidatableFormComponent.hpp>
45 #include <com/sun/star/form/XBoundComponent.hpp>
46 #include <com/sun/star/form/XBoundControl.hpp>
47 #include <com/sun/star/form/XGridControl.hpp>
48 #include <com/sun/star/form/XLoadable.hpp>
49 #include <com/sun/star/form/XReset.hpp>
50 #include <com/sun/star/form/control/FilterControl.hpp>
51 #include <com/sun/star/frame/XController.hpp>
52 #include <com/sun/star/sdb/ParametersRequest.hpp>
53 #include <com/sun/star/sdb/RowChangeAction.hpp>
54 #include <com/sun/star/sdb/XInteractionSupplyParameters.hpp>
55 #include <com/sun/star/sdbc/ColumnValue.hpp>
56 #include <com/sun/star/sdbc/DataType.hpp>
57 #include <com/sun/star/task/InteractionHandler.hpp>
58 #include <com/sun/star/util/XURLTransformer.hpp>
59 #include <com/sun/star/form/runtime/FormOperations.hpp>
60 #include <com/sun/star/form/runtime/FormFeature.hpp>
61 #include <com/sun/star/container/XContainer.hpp>
62 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
63 #include <com/sun/star/util/NumberFormatter.hpp>
64 #include <com/sun/star/sdb/SQLContext.hpp>
65 #include <com/sun/star/sdb/XColumn.hpp>
66
67 #include <comphelper/enumhelper.hxx>
68 #include <comphelper/interaction.hxx>
69 #include <comphelper/namedvaluecollection.hxx>
70 #include <comphelper/processfactory.hxx>
71 #include <comphelper/propagg.hxx>
72 #include <comphelper/property.hxx>
73 #include <comphelper/sequence.hxx>
74 #include <comphelper/uno3.hxx>
75 #include <comphelper/flagguard.hxx>
76 #include <cppuhelper/queryinterface.hxx>
77 #include <cppuhelper/supportsservice.hxx>
78 #include <cppuhelper/typeprovider.hxx>
79 #include <connectivity/IParseContext.hxx>
80 #include <toolkit/controls/unocontrol.hxx>
81 #include <toolkit/helper/vclunohelper.hxx>
82 #include <tools/debug.hxx>
83 #include <tools/diagnose_ex.h>
84 #include <tools/shl.hxx>
85 #include <vcl/msgbox.hxx>
86 #include <vcl/svapp.hxx>
87 #include <vcl/settings.hxx>
88 #include <osl/mutex.hxx>
89
90 #include <algorithm>
91
92 #include <o3tl/compat_functional.hxx>
93
94 using namespace ::com::sun::star;
95 using namespace ::comphelper;
96 using namespace ::connectivity;
97 using namespace ::connectivity::simple;
98
99
100 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL
101 FormController_NewInstance_Impl( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & _rxORB )
102 throw (css::uno::Exception)
103 {
104 return *( new ::svxform::FormController( comphelper::getComponentContext(_rxORB) ) );
105 }
106
107 namespace svxform
108 {
109
110 using ::com::sun::star::sdb::XColumn;
111 using ::com::sun::star::awt::XControl;
112 using ::com::sun::star::awt::XTabController;
113 using ::com::sun::star::awt::TabController;
114 using ::com::sun::star::awt::XToolkit;
115 using ::com::sun::star::awt::XWindowPeer;
116 using ::com::sun::star::form::XGrid;
117 using ::com::sun::star::beans::XPropertySet;
118 using ::com::sun::star::uno::UNO_SET_THROW;
119 using ::com::sun::star::uno::UNO_QUERY_THROW;
120 using ::com::sun::star::container::XIndexAccess;
121 using ::com::sun::star::uno::Exception;
122 using ::com::sun::star::uno::XInterface;
123 using ::com::sun::star::uno::UNO_QUERY;
124 using ::com::sun::star::uno::Sequence;
125 using ::com::sun::star::uno::Reference;
126 using ::com::sun::star::beans::XPropertySetInfo;
127 using ::com::sun::star::beans::PropertyValue;
128 using ::com::sun::star::uno::RuntimeException;
129 using ::com::sun::star::lang::IndexOutOfBoundsException;
130 using ::com::sun::star::sdb::XInteractionSupplyParameters;
131 using ::com::sun::star::awt::XTextComponent;
132 using ::com::sun::star::awt::XTextListener;
133 using ::com::sun::star::uno::Any;
134 using ::com::sun::star::frame::XDispatch;
135 using ::com::sun::star::lang::XMultiServiceFactory;
136 using ::com::sun::star::uno::XAggregation;
137 using ::com::sun::star::uno::Type;
138 using ::com::sun::star::lang::IllegalArgumentException;
139 using ::com::sun::star::sdbc::XConnection;
140 using ::com::sun::star::sdbc::XRowSet;
141 using ::com::sun::star::sdbc::XDatabaseMetaData;
142 using ::com::sun::star::util::XNumberFormatsSupplier;
143 using ::com::sun::star::util::NumberFormatter;
144 using ::com::sun::star::util::XNumberFormatter;
145 using ::com::sun::star::sdbcx::XColumnsSupplier;
146 using ::com::sun::star::container::XNameAccess;
147 using ::com::sun::star::lang::EventObject;
148 using ::com::sun::star::beans::Property;
149 using ::com::sun::star::container::XEnumeration;
150 using ::com::sun::star::form::XFormComponent;
151 using ::com::sun::star::form::runtime::XFormOperations;
152 using ::com::sun::star::form::runtime::FilterEvent;
153 using ::com::sun::star::form::runtime::XFilterControllerListener;
154 using ::com::sun::star::awt::XControlContainer;
155 using ::com::sun::star::container::XIdentifierReplace;
156 using ::com::sun::star::lang::WrappedTargetException;
157 using ::com::sun::star::form::XFormControllerListener;
158 using ::com::sun::star::awt::XWindow;
159 using ::com::sun::star::sdbc::XResultSet;
160 using ::com::sun::star::awt::XControlModel;
161 using ::com::sun::star::awt::XTabControllerModel;
162 using ::com::sun::star::beans::PropertyChangeEvent;
163 using ::com::sun::star::form::validation::XValidatableFormComponent;
164 using ::com::sun::star::form::XLoadable;
165 using ::com::sun::star::script::XEventAttacherManager;
166 using ::com::sun::star::form::XBoundControl;
167 using ::com::sun::star::beans::XPropertyChangeListener;
168 using ::com::sun::star::awt::TextEvent;
169 using ::com::sun::star::form::XBoundComponent;
170 using ::com::sun::star::awt::XCheckBox;
171 using ::com::sun::star::awt::XComboBox;
172 using ::com::sun::star::awt::XListBox;
173 using ::com::sun::star::awt::ItemEvent;
174 using ::com::sun::star::util::XModifyListener;
175 using ::com::sun::star::form::XReset;
176 using ::com::sun::star::frame::XDispatchProviderInterception;
177 using ::com::sun::star::form::XGridControl;
178 using ::com::sun::star::awt::XVclWindowPeer;
179 using ::com::sun::star::form::validation::XValidator;
180 using ::com::sun::star::awt::FocusEvent;
181 using ::com::sun::star::sdb::SQLContext;
182 using ::com::sun::star::container::XChild;
183 using ::com::sun::star::form::TabulatorCycle_RECORDS;
184 using ::com::sun::star::container::ContainerEvent;
185 using ::com::sun::star::lang::DisposedException;
186 using ::com::sun::star::lang::Locale;
187 using ::com::sun::star::beans::NamedValue;
188 using ::com::sun::star::lang::NoSupportException;
189 using ::com::sun::star::sdb::RowChangeEvent;
190 using ::com::sun::star::frame::XStatusListener;
191 using ::com::sun::star::frame::XDispatchProviderInterceptor;
192 using ::com::sun::star::sdb::SQLErrorEvent;
193 using ::com::sun::star::form::DatabaseParameterEvent;
194 using ::com::sun::star::sdb::ParametersRequest;
195 using ::com::sun::star::task::XInteractionRequest;
196 using ::com::sun::star::util::URL;
197 using ::com::sun::star::frame::FeatureStateEvent;
198 using ::com::sun::star::form::runtime::XFormControllerContext;
199 using ::com::sun::star::task::InteractionHandler;
200 using ::com::sun::star::task::XInteractionHandler;
201 using ::com::sun::star::form::runtime::FormOperations;
202 using ::com::sun::star::container::XContainer;
203 using ::com::sun::star::sdbc::SQLWarning;
204
205 namespace ColumnValue = ::com::sun::star::sdbc::ColumnValue;
206 namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute;
207 namespace FocusChangeReason = ::com::sun::star::awt::FocusChangeReason;
208 namespace RowChangeAction = ::com::sun::star::sdb::RowChangeAction;
209 namespace FormFeature = ::com::sun::star::form::runtime::FormFeature;
210 namespace DataType = ::com::sun::star::sdbc::DataType;
211
212
213 // ColumnInfo
214
215 struct ColumnInfo
216 {
217 // information about the column itself
218 Reference< XColumn > xColumn;
219 sal_Int32 nNullable;
220 bool bAutoIncrement;
221 bool bReadOnly;
222 OUString sName;
223
224 // information about the control(s) bound to this column
225
226 /// the first control which is bound to the given column, and which requires input
227 Reference< XControl > xFirstControlWithInputRequired;
228 /** the first grid control which contains a column which is bound to the given database column, and requires
229 input
230 */
231 Reference< XGrid > xFirstGridWithInputRequiredColumn;
232 /** if xFirstControlWithInputRequired is a grid control, then nRequiredGridColumn specifies the position
233 of the grid column which is actually bound
234 */
235 sal_Int32 nRequiredGridColumn;
236
237 ColumnInfo()
238 :xColumn()
239 ,nNullable( ColumnValue::NULLABLE_UNKNOWN )
240 ,bAutoIncrement( false )
241 ,bReadOnly( false )
242 ,sName()
243 ,xFirstControlWithInputRequired()
244 ,xFirstGridWithInputRequiredColumn()
245 ,nRequiredGridColumn( -1 )
246 {
247 }
248 };
249
250
251 //= ColumnInfoCache
252
253 class ColumnInfoCache
254 {
255 public:
256 ColumnInfoCache( const Reference< XColumnsSupplier >& _rxColSupplier );
257
258 size_t getColumnCount() const { return m_aColumns.size(); }
259 const ColumnInfo& getColumnInfo( size_t _pos );
260
261 bool controlsInitialized() const { return m_bControlsInitialized; }
262 void initializeControls( const Sequence< Reference< XControl > >& _rControls );
263 void deinitializeControls();
264
265 private:
266 typedef ::std::vector< ColumnInfo > ColumnInfos;
267 ColumnInfos m_aColumns;
268 bool m_bControlsInitialized;
269 };
270
271
272 ColumnInfoCache::ColumnInfoCache( const Reference< XColumnsSupplier >& _rxColSupplier )
273 :m_aColumns()
274 ,m_bControlsInitialized( false )
275 {
276 try
277 {
278 m_aColumns.clear();
279
280 Reference< XIndexAccess > xColumns( _rxColSupplier->getColumns(), UNO_QUERY_THROW );
281 sal_Int32 nColumnCount = xColumns->getCount();
282 m_aColumns.reserve( nColumnCount );
283
284 Reference< XPropertySet > xColumnProps;
285 for ( sal_Int32 i = 0; i < nColumnCount; ++i )
286 {
287 ColumnInfo aColInfo;
288 aColInfo.xColumn.set( xColumns->getByIndex(i), UNO_QUERY_THROW );
289
290 xColumnProps.set( aColInfo.xColumn, UNO_QUERY_THROW );
291 OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_ISNULLABLE ) >>= aColInfo.nNullable );
292 OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_AUTOINCREMENT ) >>= aColInfo.bAutoIncrement );
293 OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_NAME ) >>= aColInfo.sName );
294 OSL_VERIFY( xColumnProps->getPropertyValue( FM_PROP_ISREADONLY ) >>= aColInfo.bReadOnly );
295
296 m_aColumns.push_back( aColInfo );
297 }
298 }
299 catch( const Exception& )
300 {
301 DBG_UNHANDLED_EXCEPTION();
302 }
303 }
304
305
306 namespace
307 {
308 bool lcl_isBoundTo( const Reference< XPropertySet >& _rxControlModel, const Reference< XInterface >& _rxNormDBField )
309 {
310 Reference< XInterface > xNormBoundField( _rxControlModel->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY );
311 return ( xNormBoundField.get() == _rxNormDBField.get() );
312 }
313
314 bool lcl_isInputRequired( const Reference< XPropertySet >& _rxControlModel )
315 {
316 bool bInputRequired = true;
317 OSL_VERIFY( _rxControlModel->getPropertyValue( FM_PROP_INPUT_REQUIRED ) >>= bInputRequired );
318 return bInputRequired;
319 }
320
321 void lcl_resetColumnControlInfo( ColumnInfo& _rColInfo )
322 {
323 _rColInfo.xFirstControlWithInputRequired.clear();
324 _rColInfo.xFirstGridWithInputRequiredColumn.clear();
325 _rColInfo.nRequiredGridColumn = -1;
326 }
327 }
328
329
330 void ColumnInfoCache::deinitializeControls()
331 {
332 for ( ColumnInfos::iterator col = m_aColumns.begin();
333 col != m_aColumns.end();
334 ++col
335 )
336 {
337 lcl_resetColumnControlInfo( *col );
338 }
339 }
340
341
342 void ColumnInfoCache::initializeControls( const Sequence< Reference< XControl > >& _rControls )
343 {
344 try
345 {
346 // for every of our known columns, find the controls which are bound to this column
347 for ( ColumnInfos::iterator col = m_aColumns.begin();
348 col != m_aColumns.end();
349 ++col
350 )
351 {
352 OSL_ENSURE( !col->xFirstControlWithInputRequired.is() && !col->xFirstGridWithInputRequiredColumn.is()
353 && ( col->nRequiredGridColumn == -1 ), "ColumnInfoCache::initializeControls: called me twice?" );
354
355 lcl_resetColumnControlInfo( *col );
356
357 const Reference< XControl >* pControl( _rControls.getConstArray() );
358 const Reference< XControl >* pControlEnd( pControl + _rControls.getLength() );
359 for ( ; pControl != pControlEnd; ++pControl )
360 {
361 if ( !pControl->is() )
362 continue;
363
364 Reference< XPropertySet > xModel( (*pControl)->getModel(), UNO_QUERY_THROW );
365 Reference< XPropertySetInfo > xModelPSI( xModel->getPropertySetInfo(), UNO_SET_THROW );
366
367 // special handling for grid controls
368 Reference< XGrid > xGrid( *pControl, UNO_QUERY );
369 if ( xGrid.is() )
370 {
371 Reference< XIndexAccess > xGridColAccess( xModel, UNO_QUERY_THROW );
372 sal_Int32 gridColCount = xGridColAccess->getCount();
373 sal_Int32 gridCol = 0;
374 for ( gridCol = 0; gridCol < gridColCount; ++gridCol )
375 {
376 Reference< XPropertySet > xGridColumnModel( xGridColAccess->getByIndex( gridCol ), UNO_QUERY_THROW );
377
378 if ( !lcl_isBoundTo( xGridColumnModel, col->xColumn )
379 || !lcl_isInputRequired( xGridColumnModel )
380 )
381 continue; // with next grid column
382
383 break;
384 }
385
386 if ( gridCol < gridColCount )
387 {
388 // found a grid column which is bound to the given
389 col->xFirstGridWithInputRequiredColumn = xGrid;
390 col->nRequiredGridColumn = gridCol;
391 break;
392 }
393
394 continue; // with next control
395 }
396
397 if ( !xModelPSI->hasPropertyByName( FM_PROP_BOUNDFIELD )
398 || !lcl_isBoundTo( xModel, col->xColumn )
399 || !lcl_isInputRequired( xModel )
400 )
401 continue; // with next control
402
403 break;
404 }
405
406 if ( pControl == pControlEnd )
407 // did not find a control which is bound to this particular column, and for which the input is required
408 continue; // with next DB column
409
410 col->xFirstControlWithInputRequired = *pControl;
411 }
412 }
413 catch( const Exception& )
414 {
415 DBG_UNHANDLED_EXCEPTION();
416 }
417
418 m_bControlsInitialized = true;
419 }
420
421
422 const ColumnInfo& ColumnInfoCache::getColumnInfo( size_t _pos )
423 {
424 if ( _pos >= m_aColumns.size() )
425 throw IndexOutOfBoundsException();
426
427 return m_aColumns[ _pos ];
428 }
429
430
431 // OParameterContinuation
432
433 class OParameterContinuation : public OInteraction< XInteractionSupplyParameters >
434 {
435 Sequence< PropertyValue > m_aValues;
436
437 public:
438 OParameterContinuation() { }
439
440 Sequence< PropertyValue > getValues() const { return m_aValues; }
441
442 // XInteractionSupplyParameters
443 virtual void SAL_CALL setParameters( const Sequence< PropertyValue >& _rValues ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
444 };
445
446
447 void SAL_CALL OParameterContinuation::setParameters( const Sequence< PropertyValue >& _rValues ) throw(RuntimeException, std::exception)
448 {
449 m_aValues = _rValues;
450 }
451
452
453 // FmXAutoControl
454
455 struct FmFieldInfo
456 {
457 OUString aFieldName;
458 Reference< XPropertySet > xField;
459 Reference< XTextComponent > xText;
460
461 FmFieldInfo(const Reference< XPropertySet >& _xField, const Reference< XTextComponent >& _xText)
462 :xField(_xField)
463 ,xText(_xText)
464 {xField->getPropertyValue(FM_PROP_NAME) >>= aFieldName;}
465 };
466
467
468 // FmXAutoControl
469
470 class FmXAutoControl: public UnoControl
471
472 {
473 public:
474 FmXAutoControl() :UnoControl()
475 {
476 }
477
478 virtual OUString GetComponentServiceName() SAL_OVERRIDE {return OUString("Edit");}
479 virtual void SAL_CALL createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer > & rParentPeer ) throw( RuntimeException, std::exception ) SAL_OVERRIDE;
480
481 protected:
482 virtual void ImplSetPeerProperty( const OUString& rPropName, const Any& rVal ) SAL_OVERRIDE;
483 };
484
485
486 void FmXAutoControl::createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer > & rParentPeer ) throw( RuntimeException, std::exception )
487 {
488 UnoControl::createPeer( rxToolkit, rParentPeer );
489
490 Reference< XTextComponent > xText(getPeer() , UNO_QUERY);
491 if (xText.is())
492 {
493 xText->setText(SVX_RESSTR(RID_STR_AUTOFIELD));
494 xText->setEditable(sal_False);
495 }
496 }
497
498
499 void FmXAutoControl::ImplSetPeerProperty( const OUString& rPropName, const Any& rVal )
500 {
501 // these properties are ignored
502 if (rPropName == FM_PROP_TEXT)
503 return;
504
505 UnoControl::ImplSetPeerProperty( rPropName, rVal );
506 }
507
508
509 IMPL_LINK( FormController, OnActivateTabOrder, void*, /*EMPTYTAG*/ )
510 {
511 activateTabOrder();
512 return 1;
513 }
514
515
516 struct UpdateAllListeners : public ::std::unary_function< Reference< XDispatch >, bool >
517 {
518 bool operator()( const Reference< XDispatch >& _rxDispatcher ) const
519 {
520 static_cast< ::svx::OSingleFeatureDispatcher* >( _rxDispatcher.get() )->updateAllListeners();
521 // the return is a dummy only so we can use this struct in a o3tl::compose1 call
522 return true;
523 }
524 };
525
526 IMPL_LINK( FormController, OnInvalidateFeatures, void*, /*_pNotInterestedInThisParam*/ )
527 {
528 ::osl::MutexGuard aGuard( m_aMutex );
529 for ( ::std::set< sal_Int16 >::const_iterator aLoop = m_aInvalidFeatures.begin();
530 aLoop != m_aInvalidFeatures.end();
531 ++aLoop
532 )
533 {
534 DispatcherContainer::const_iterator aDispatcherPos = m_aFeatureDispatchers.find( *aLoop );
535 if ( aDispatcherPos != m_aFeatureDispatchers.end() )
536 {
537 // TODO: for the real and actual listener notifications, we should release
538 // our mutex
539 UpdateAllListeners( )( aDispatcherPos->second );
540 }
541 }
542 return 1;
543 }
544
545 /*************************************************************************/
546
547
548 FormController::FormController(const Reference< css::uno::XComponentContext > & _rxORB )
549 :FormController_BASE( m_aMutex )
550 ,OPropertySetHelper( FormController_BASE::rBHelper )
551 ,OSQLParserClient( _rxORB )
552 ,m_xComponentContext( _rxORB )
553 ,m_aActivateListeners(m_aMutex)
554 ,m_aModifyListeners(m_aMutex)
555 ,m_aErrorListeners(m_aMutex)
556 ,m_aDeleteListeners(m_aMutex)
557 ,m_aRowSetApproveListeners(m_aMutex)
558 ,m_aParameterListeners(m_aMutex)
559 ,m_aFilterListeners(m_aMutex)
560 ,m_pControlBorderManager( new ::svxform::ControlBorderManager )
561 ,m_xFormOperations()
562 ,m_aMode( OUString( "DataMode" ) )
563 ,m_aLoadEvent( LINK( this, FormController, OnLoad ) )
564 ,m_aToggleEvent( LINK( this, FormController, OnToggleAutoFields ) )
565 ,m_aActivationEvent( LINK( this, FormController, OnActivated ) )
566 ,m_aDeactivationEvent( LINK( this, FormController, OnDeactivated ) )
567 ,m_nCurrentFilterPosition(-1)
568 ,m_bCurrentRecordModified(false)
569 ,m_bCurrentRecordNew(false)
570 ,m_bLocked(false)
571 ,m_bDBConnection(false)
572 ,m_bCycle(false)
573 ,m_bCanInsert(false)
574 ,m_bCanUpdate(false)
575 ,m_bCommitLock(false)
576 ,m_bModified(false)
577 ,m_bControlsSorted(false)
578 ,m_bFiltering(false)
579 ,m_bAttachEvents(true)
580 ,m_bDetachEvents(true)
581 ,m_bAttemptedHandlerCreation( false )
582 ,m_bSuspendFilterTextListening( false )
583 {
584
585 ::comphelper::increment(m_refCount);
586 {
587 m_xTabController = TabController::create( m_xComponentContext );
588 m_xAggregate = Reference< XAggregation >( m_xTabController, UNO_QUERY_THROW );
589 m_xAggregate->setDelegator( *this );
590 }
591 ::comphelper::decrement(m_refCount);
592
593 m_aTabActivationTimer.SetTimeout( 500 );
594 m_aTabActivationTimer.SetTimeoutHdl( LINK( this, FormController, OnActivateTabOrder ) );
595
596 m_aFeatureInvalidationTimer.SetTimeout( 200 );
597 m_aFeatureInvalidationTimer.SetTimeoutHdl( LINK( this, FormController, OnInvalidateFeatures ) );
598 }
599
600
601 FormController::~FormController()
602 {
603 {
604 ::osl::MutexGuard aGuard( m_aMutex );
605
606 m_aLoadEvent.CancelPendingCall();
607 m_aToggleEvent.CancelPendingCall();
608 m_aActivationEvent.CancelPendingCall();
609 m_aDeactivationEvent.CancelPendingCall();
610
611 if ( m_aTabActivationTimer.IsActive() )
612 m_aTabActivationTimer.Stop();
613 }
614
615 if ( m_aFeatureInvalidationTimer.IsActive() )
616 m_aFeatureInvalidationTimer.Stop();
617
618 disposeAllFeaturesAndDispatchers();
619
620 if ( m_xFormOperations.is() )
621 m_xFormOperations->dispose();
622 m_xFormOperations.clear();
623
624 // Freigeben der Aggregation
625 if ( m_xAggregate.is() )
626 {
627 m_xAggregate->setDelegator( NULL );
628 m_xAggregate.clear();
629 }
630
631 DELETEZ( m_pControlBorderManager );
632
633 }
634
635
636 void SAL_CALL FormController::acquire() throw ()
637 {
638 FormController_BASE::acquire();
639 }
640
641
642 void SAL_CALL FormController::release() throw ()
643 {
644 FormController_BASE::release();
645 }
646
647
648 Any SAL_CALL FormController::queryInterface( const Type& _rType ) throw(RuntimeException, std::exception)
649 {
650 Any aRet = FormController_BASE::queryInterface( _rType );
651 if ( !aRet.hasValue() )
652 aRet = OPropertySetHelper::queryInterface( _rType );
653 if ( !aRet.hasValue() )
654 aRet = m_xAggregate->queryAggregation( _rType );
655 return aRet;
656 }
657
658
659 Sequence< sal_Int8 > SAL_CALL FormController::getImplementationId() throw( RuntimeException, std::exception )
660 {
661 return css::uno::Sequence<sal_Int8>();
662 }
663
664 Sequence< Type > SAL_CALL FormController::getTypes( ) throw(RuntimeException, std::exception)
665 {
666 return comphelper::concatSequences(
667 FormController_BASE::getTypes(),
668 ::cppu::OPropertySetHelper::getTypes()
669 );
670 }
671
672 // XServiceInfo
673 sal_Bool SAL_CALL FormController::supportsService(const OUString& ServiceName) throw( RuntimeException, std::exception )
674 {
675 return cppu::supportsService(this, ServiceName);
676 }
677
678 OUString SAL_CALL FormController::getImplementationName() throw( RuntimeException, std::exception )
679 {
680 return OUString("org.openoffice.comp.svx.FormController");
681 }
682
683 Sequence< OUString> SAL_CALL FormController::getSupportedServiceNames(void) throw( RuntimeException, std::exception )
684 {
685 // service names which are supported only, but cannot be used to created an
686 // instance at a service factory
687 Sequence< OUString > aNonCreatableServiceNames( 1 );
688 aNonCreatableServiceNames[ 0 ] = "com.sun.star.form.FormControllerDispatcher";
689
690 // services which can be used to created an instance at a service factory
691 Sequence< OUString > aCreatableServiceNames( getSupportedServiceNames_Static() );
692 return ::comphelper::concatSequences( aCreatableServiceNames, aNonCreatableServiceNames );
693 }
694
695
696 sal_Bool SAL_CALL FormController::approveReset(const EventObject& /*rEvent*/) throw( RuntimeException, std::exception )
697 {
698 return sal_True;
699 }
700
701
702 void SAL_CALL FormController::resetted(const EventObject& rEvent) throw( RuntimeException, std::exception )
703 {
704 ::osl::MutexGuard aGuard(m_aMutex);
705 if (getCurrentControl().is() && (getCurrentControl()->getModel() == rEvent.Source))
706 m_bModified = false;
707 }
708
709
710 Sequence< OUString> FormController::getSupportedServiceNames_Static(void)
711 {
712 static Sequence< OUString> aServices;
713 if (!aServices.getLength())
714 {
715 aServices.realloc(2);
716 aServices.getArray()[0] = "com.sun.star.form.runtime.FormController";
717 aServices.getArray()[1] = "com.sun.star.awt.control.TabController";
718 }
719 return aServices;
720 }
721
722
723 namespace
724 {
725 struct ResetComponentText : public ::std::unary_function< Reference< XTextComponent >, void >
726 {
727 void operator()( const Reference< XTextComponent >& _rxText )
728 {
729 _rxText->setText( OUString() );
730 }
731 };
732
733 struct RemoveComponentTextListener : public ::std::unary_function< Reference< XTextComponent >, void >
734 {
735 RemoveComponentTextListener( const Reference< XTextListener >& _rxListener )
736 :m_xListener( _rxListener )
737 {
738 }
739
740 void operator()( const Reference< XTextComponent >& _rxText )
741 {
742 _rxText->removeTextListener( m_xListener );
743 }
744
745 private:
746 Reference< XTextListener > m_xListener;
747 };
748 }
749
750
751 void FormController::impl_setTextOnAllFilter_throw()
752 {
753 m_bSuspendFilterTextListening = true;
754 ::comphelper::FlagGuard aResetFlag( m_bSuspendFilterTextListening );
755
756 // reset the text for all controls
757 ::std::for_each( m_aFilterComponents.begin(), m_aFilterComponents.end(), ResetComponentText() );
758
759 if ( m_aFilterRows.empty() )
760 // nothing to do anymore
761 return;
762
763 if ( m_nCurrentFilterPosition < 0 )
764 return;
765
766 // set the text for all filters
767 OSL_ENSURE( m_aFilterRows.size() > (size_t)m_nCurrentFilterPosition,
768 "FormController::impl_setTextOnAllFilter_throw: m_nCurrentFilterPosition too big" );
769
770 if ( (size_t)m_nCurrentFilterPosition < m_aFilterRows.size() )
771 {
772 FmFilterRow& rRow = m_aFilterRows[ m_nCurrentFilterPosition ];
773 for ( FmFilterRow::const_iterator iter2 = rRow.begin();
774 iter2 != rRow.end();
775 ++iter2
776 )
777 {
778 iter2->first->setText( iter2->second );
779 }
780 }
781 }
782 // OPropertySetHelper
783
784 sal_Bool FormController::convertFastPropertyValue( Any & /*rConvertedValue*/, Any & /*rOldValue*/,
785 sal_Int32 /*nHandle*/, const Any& /*rValue*/ )
786 throw( IllegalArgumentException )
787 {
788 return sal_False;
789 }
790
791
792 void FormController::setFastPropertyValue_NoBroadcast( sal_Int32 /*nHandle*/, const Any& /*rValue*/ )
793 throw( Exception, std::exception )
794 {
795 }
796
797
798 void FormController::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
799 {
800 switch (nHandle)
801 {
802 case FM_ATTR_FILTER:
803 {
804 OUStringBuffer aFilter;
805 OStaticDataAccessTools aStaticTools;
806 Reference<XConnection> xConnection(aStaticTools.getRowSetConnection(Reference< XRowSet>(m_xModelAsIndex, UNO_QUERY)));
807 if (xConnection.is())
808 {
809 Reference< XDatabaseMetaData> xMetaData(xConnection->getMetaData());
810 Reference< XNumberFormatsSupplier> xFormatSupplier( aStaticTools.getNumberFormats( xConnection, true ) );
811 Reference< XNumberFormatter> xFormatter = NumberFormatter::create(m_xComponentContext);
812 xFormatter->attachNumberFormatsSupplier(xFormatSupplier);
813
814 Reference< XColumnsSupplier> xSupplyCols(m_xModelAsIndex, UNO_QUERY);
815 Reference< XNameAccess> xFields(xSupplyCols->getColumns(), UNO_QUERY);
816
817 // now add the filter rows
818 try
819 {
820 for ( FmFilterRows::const_iterator row = m_aFilterRows.begin(); row != m_aFilterRows.end(); ++row )
821 {
822 const FmFilterRow& rRow = *row;
823
824 if ( rRow.empty() )
825 continue;
826
827 OUStringBuffer aRowFilter;
828 for ( FmFilterRow::const_iterator condition = rRow.begin(); condition != rRow.end(); ++condition )
829 {
830 // get the field of the controls map
831 Reference< XControl > xControl( condition->first, UNO_QUERY_THROW );
832 Reference< XPropertySet > xModelProps( xControl->getModel(), UNO_QUERY_THROW );
833 Reference< XPropertySet > xField( xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ), UNO_QUERY_THROW );
834
835 OUString sFilterValue( condition->second );
836
837 OUString sErrorMsg, sCriteria;
838 const ::rtl::Reference< ISQLParseNode > xParseNode =
839 predicateTree( sErrorMsg, sFilterValue, xFormatter, xField );
840 OSL_ENSURE( xParseNode.is(), "FormController::getFastPropertyValue: could not parse the field value predicate!" );
841 if ( xParseNode.is() )
842 {
843 // don't use a parse context here, we need it unlocalized
844 xParseNode->parseNodeToStr( sCriteria, xConnection, NULL );
845 if ( condition != rRow.begin() )
846 aRowFilter.appendAscii( " AND " );
847 aRowFilter.append( sCriteria );
848 }
849 }
850 if ( !aRowFilter.isEmpty() )
851 {
852 if ( !aFilter.isEmpty() )
853 aFilter.appendAscii( " OR " );
854
855 aFilter.appendAscii( "( " );
856 aFilter.append( aRowFilter.makeStringAndClear() );
857 aFilter.appendAscii( " )" );
858 }
859 }
860 }
861 catch( const Exception& )
862 {
863 DBG_UNHANDLED_EXCEPTION();
864 aFilter.setLength(0);
865 }
866 }
867 rValue <<= aFilter.makeStringAndClear();
868 }
869 break;
870
871 case FM_ATTR_FORM_OPERATIONS:
872 rValue <<= m_xFormOperations;
873 break;
874 }
875 }
876
877
878 Reference< XPropertySetInfo > FormController::getPropertySetInfo() throw( RuntimeException, std::exception )
879 {
880 static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
881 return xInfo;
882 }
883
884
885 #define DECL_PROP_CORE(varname, type) \
886 pDesc[nPos++] = Property(FM_PROP_##varname, FM_ATTR_##varname, ::getCppuType((const type*)0),
887
888
889 #define DECL_PROP1(varname, type, attrib1) \
890 DECL_PROP_CORE(varname, type) PropertyAttribute::attrib1)
891
892
893 void FormController::fillProperties(
894 Sequence< Property >& /* [out] */ _rProps,
895 Sequence< Property >& /* [out] */ /*_rAggregateProps*/
896 ) const
897 {
898 _rProps.realloc(2);
899 sal_Int32 nPos = 0;
900 Property* pDesc = _rProps.getArray();
901 DECL_PROP1(FILTER, OUString, READONLY);
902 DECL_PROP1(FORM_OPERATIONS, Reference< XFormOperations >, READONLY);
903 }
904
905
906 ::cppu::IPropertyArrayHelper& FormController::getInfoHelper()
907 {
908 return *getArrayHelper();
909 }
910
911 // XFilterController
912
913 void SAL_CALL FormController::addFilterControllerListener( const Reference< XFilterControllerListener >& _Listener ) throw( RuntimeException, std::exception )
914 {
915 m_aFilterListeners.addInterface( _Listener );
916 }
917
918
919 void SAL_CALL FormController::removeFilterControllerListener( const Reference< XFilterControllerListener >& _Listener ) throw( RuntimeException, std::exception )
920 {
921 m_aFilterListeners.removeInterface( _Listener );
922 }
923
924
925 ::sal_Int32 SAL_CALL FormController::getFilterComponents() throw( ::com::sun::star::uno::RuntimeException, std::exception )
926 {
927 ::osl::MutexGuard aGuard( m_aMutex );
928 impl_checkDisposed_throw();
929
930 return m_aFilterComponents.size();
931 }
932
933
934 ::sal_Int32 SAL_CALL FormController::getDisjunctiveTerms() throw( ::com::sun::star::uno::RuntimeException, std::exception )
935 {
936 ::osl::MutexGuard aGuard( m_aMutex );
937 impl_checkDisposed_throw();
938
939 return m_aFilterRows.size();
940 }
941
942
943 void SAL_CALL FormController::setPredicateExpression( ::sal_Int32 _Component, ::sal_Int32 _Term, const OUString& _PredicateExpression ) throw( RuntimeException, IndexOutOfBoundsException, std::exception )
944 {
945 ::osl::MutexGuard aGuard( m_aMutex );
946 impl_checkDisposed_throw();
947
948 if ( ( _Component < 0 ) || ( _Component >= getFilterComponents() ) || ( _Term < 0 ) || ( _Term >= getDisjunctiveTerms() ) )
949 throw IndexOutOfBoundsException( OUString(), *this );
950
951 Reference< XTextComponent > xText( m_aFilterComponents[ _Component ] );
952 xText->setText( _PredicateExpression );
953
954 FmFilterRow& rFilterRow = m_aFilterRows[ _Term ];
955 if ( !_PredicateExpression.isEmpty() )
956 rFilterRow[ xText ] = _PredicateExpression;
957 else
958 rFilterRow.erase( xText );
959 }
960
961
962 Reference< XControl > FormController::getFilterComponent( ::sal_Int32 _Component ) throw( RuntimeException, IndexOutOfBoundsException, std::exception )
963 {
964 ::osl::MutexGuard aGuard( m_aMutex );
965 impl_checkDisposed_throw();
966
967 if ( ( _Component < 0 ) || ( _Component >= getFilterComponents() ) )
968 throw IndexOutOfBoundsException( OUString(), *this );
969
970 return Reference< XControl >( m_aFilterComponents[ _Component ], UNO_QUERY );
971 }
972
973
974 Sequence< Sequence< OUString > > FormController::getPredicateExpressions() throw( RuntimeException, std::exception )
975 {
976 ::osl::MutexGuard aGuard( m_aMutex );
977 impl_checkDisposed_throw();
978
979 Sequence< Sequence< OUString > > aExpressions( m_aFilterRows.size() );
980 sal_Int32 termIndex = 0;
981 for ( FmFilterRows::const_iterator row = m_aFilterRows.begin();
982 row != m_aFilterRows.end();
983 ++row, ++termIndex
984 )
985 {
986 const FmFilterRow& rRow( *row );
987
988 Sequence< OUString > aConjunction( m_aFilterComponents.size() );
989 sal_Int32 componentIndex = 0;
990 for ( FilterComponents::const_iterator comp = m_aFilterComponents.begin();
991 comp != m_aFilterComponents.end();
992 ++comp, ++componentIndex
993 )
994 {
995 FmFilterRow::const_iterator predicate = rRow.find( *comp );
996 if ( predicate != rRow.end() )
997 aConjunction[ componentIndex ] = predicate->second;
998 }
999
1000 aExpressions[ termIndex ] = aConjunction;
1001 }
1002
1003 return aExpressions;
1004 }
1005
1006
1007 void SAL_CALL FormController::removeDisjunctiveTerm( ::sal_Int32 _Term ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1008 {
1009 // SYNCHRONIZED -->
1010 ::osl::ClearableMutexGuard aGuard( m_aMutex );
1011 impl_checkDisposed_throw();
1012
1013 if ( ( _Term < 0 ) || ( _Term >= getDisjunctiveTerms() ) )
1014 throw IndexOutOfBoundsException( OUString(), *this );
1015
1016 // if the to-be-deleted row is our current row, we need to shift
1017 if ( _Term == m_nCurrentFilterPosition )
1018 {
1019 if ( m_nCurrentFilterPosition < sal_Int32( m_aFilterRows.size() - 1 ) )
1020 ++m_nCurrentFilterPosition;
1021 else
1022 --m_nCurrentFilterPosition;
1023 }
1024
1025 FmFilterRows::iterator pos = m_aFilterRows.begin() + _Term;
1026 m_aFilterRows.erase( pos );
1027
1028 // adjust m_nCurrentFilterPosition if the removed row preceded it
1029 if ( _Term < m_nCurrentFilterPosition )
1030 --m_nCurrentFilterPosition;
1031
1032 SAL_WARN_IF( !( ( m_nCurrentFilterPosition < 0 ) != ( m_aFilterRows.empty() ) ),
1033 "svx.form", "FormController::removeDisjunctiveTerm: inconsistency!" );
1034
1035 // update the texts in the filter controls
1036 impl_setTextOnAllFilter_throw();
1037
1038 FilterEvent aEvent;
1039 aEvent.Source = *this;
1040 aEvent.DisjunctiveTerm = _Term;
1041 aGuard.clear();
1042 // <-- SYNCHRONIZED
1043
1044 m_aFilterListeners.notifyEach( &XFilterControllerListener::disjunctiveTermRemoved, aEvent );
1045 }
1046
1047
1048 void SAL_CALL FormController::appendEmptyDisjunctiveTerm() throw (RuntimeException, std::exception)
1049 {
1050 // SYNCHRONIZED -->
1051 ::osl::ClearableMutexGuard aGuard( m_aMutex );
1052 impl_checkDisposed_throw();
1053
1054 impl_appendEmptyFilterRow( aGuard );
1055 // <-- SYNCHRONIZED
1056 }
1057
1058
1059 ::sal_Int32 SAL_CALL FormController::getActiveTerm() throw (RuntimeException, std::exception)
1060 {
1061 ::osl::MutexGuard aGuard( m_aMutex );
1062 impl_checkDisposed_throw();
1063
1064 return m_nCurrentFilterPosition;
1065 }
1066
1067
1068 void SAL_CALL FormController::setActiveTerm( ::sal_Int32 _ActiveTerm ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1069 {
1070 ::osl::MutexGuard aGuard( m_aMutex );
1071 impl_checkDisposed_throw();
1072
1073 if ( ( _ActiveTerm < 0 ) || ( _ActiveTerm >= getDisjunctiveTerms() ) )
1074 throw IndexOutOfBoundsException( OUString(), *this );
1075
1076 if ( _ActiveTerm == getActiveTerm() )
1077 return;
1078
1079 m_nCurrentFilterPosition = _ActiveTerm;
1080 impl_setTextOnAllFilter_throw();
1081 }
1082
1083 // XElementAccess
1084
1085 sal_Bool SAL_CALL FormController::hasElements(void) throw( RuntimeException, std::exception )
1086 {
1087 ::osl::MutexGuard aGuard( m_aMutex );
1088 return !m_aChildren.empty();
1089 }
1090
1091
1092 Type SAL_CALL FormController::getElementType(void) throw( RuntimeException, std::exception )
1093 {
1094 return cppu::UnoType<XFormController>::get();
1095
1096 }
1097
1098 // XEnumerationAccess
1099
1100 Reference< XEnumeration > SAL_CALL FormController::createEnumeration(void) throw( RuntimeException, std::exception )
1101 {
1102 ::osl::MutexGuard aGuard( m_aMutex );
1103 return new ::comphelper::OEnumerationByIndex(this);
1104 }
1105
1106 // XIndexAccess
1107
1108 sal_Int32 SAL_CALL FormController::getCount(void) throw( RuntimeException, std::exception )
1109 {
1110 ::osl::MutexGuard aGuard( m_aMutex );
1111 return m_aChildren.size();
1112 }
1113
1114
1115 Any SAL_CALL FormController::getByIndex(sal_Int32 Index) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
1116 {
1117 ::osl::MutexGuard aGuard( m_aMutex );
1118 if (Index < 0 ||
1119 Index >= (sal_Int32)m_aChildren.size())
1120 throw IndexOutOfBoundsException();
1121
1122 return makeAny( m_aChildren[ Index ] );
1123 }
1124
1125 // EventListener
1126
1127 void SAL_CALL FormController::disposing(const EventObject& e) throw( RuntimeException, std::exception )
1128 {
1129 // Ist der Container disposed worden
1130 ::osl::MutexGuard aGuard( m_aMutex );
1131 Reference< XControlContainer > xContainer(e.Source, UNO_QUERY);
1132 if (xContainer.is())
1133 {
1134 setContainer(Reference< XControlContainer > ());
1135 }
1136 else
1137 {
1138 // ist ein Control disposed worden
1139 Reference< XControl > xControl(e.Source, UNO_QUERY);
1140 if (xControl.is())
1141 {
1142 if (getContainer().is())
1143 removeControl(xControl);
1144 }
1145 }
1146 }
1147
1148 // OComponentHelper
1149
1150 void FormController::disposeAllFeaturesAndDispatchers() SAL_THROW(())
1151 {
1152 for ( DispatcherContainer::iterator aDispatcher = m_aFeatureDispatchers.begin();
1153 aDispatcher != m_aFeatureDispatchers.end();
1154 ++aDispatcher
1155 )
1156 {
1157 try
1158 {
1159 ::comphelper::disposeComponent( aDispatcher->second );
1160 }
1161 catch( const Exception& )
1162 {
1163 DBG_UNHANDLED_EXCEPTION();
1164 }
1165 }
1166 m_aFeatureDispatchers.clear();
1167 }
1168
1169
1170 void FormController::disposing(void)
1171 {
1172 EventObject aEvt( *this );
1173
1174 // if we're still active, simulate a "deactivated" event
1175 if ( m_xActiveControl.is() )
1176 m_aActivateListeners.notifyEach( &XFormControllerListener::formDeactivated, aEvt );
1177
1178 // notify all our listeners
1179 m_aActivateListeners.disposeAndClear(aEvt);
1180 m_aModifyListeners.disposeAndClear(aEvt);
1181 m_aErrorListeners.disposeAndClear(aEvt);
1182 m_aDeleteListeners.disposeAndClear(aEvt);
1183 m_aRowSetApproveListeners.disposeAndClear(aEvt);
1184 m_aParameterListeners.disposeAndClear(aEvt);
1185 m_aFilterListeners.disposeAndClear(aEvt);
1186
1187 removeBoundFieldListener();
1188 stopFiltering();
1189
1190 m_pControlBorderManager->restoreAll();
1191
1192 m_aFilterRows.clear();
1193
1194 ::osl::MutexGuard aGuard( m_aMutex );
1195 m_xActiveControl = NULL;
1196 implSetCurrentControl( NULL );
1197
1198 // clean up our children
1199 for (FmFormControllers::const_iterator i = m_aChildren.begin();
1200 i != m_aChildren.end(); ++i)
1201 {
1202 // search the position of the model within the form
1203 Reference< XFormComponent > xForm((*i)->getModel(), UNO_QUERY);
1204 sal_uInt32 nPos = m_xModelAsIndex->getCount();
1205 Reference< XFormComponent > xTemp;
1206 for( ; nPos; )
1207 {
1208
1209 m_xModelAsIndex->getByIndex( --nPos ) >>= xTemp;
1210 if ( xForm.get() == xTemp.get() )
1211 {
1212 Reference< XInterface > xIfc( *i, UNO_QUERY );
1213 m_xModelAsManager->detach( nPos, xIfc );
1214 break;
1215 }
1216 }
1217
1218 Reference< XComponent > (*i, UNO_QUERY)->dispose();
1219 }
1220 m_aChildren.clear();
1221
1222 disposeAllFeaturesAndDispatchers();
1223
1224 if ( m_xFormOperations.is() )
1225 m_xFormOperations->dispose();
1226 m_xFormOperations.clear();
1227
1228 if (m_bDBConnection)
1229 unload();
1230
1231 setContainer( NULL );
1232 setModel( NULL );
1233 setParent( NULL );
1234
1235 ::comphelper::disposeComponent( m_xComposer );
1236
1237 m_bDBConnection = false;
1238 }
1239
1240
1241 namespace
1242 {
1243 static bool lcl_shouldUseDynamicControlBorder( const Reference< XInterface >& _rxForm, const Any& _rDynamicColorProp )
1244 {
1245 bool bDoUse = false;
1246 if ( !( _rDynamicColorProp >>= bDoUse ) )
1247 {
1248 DocumentType eDocType = DocumentClassification::classifyHostDocument( _rxForm );
1249 return ControlLayouter::useDynamicBorderColor( eDocType );
1250 }
1251 return bDoUse;
1252 }
1253 }
1254
1255
1256 void SAL_CALL FormController::propertyChange(const PropertyChangeEvent& evt) throw( RuntimeException, std::exception )
1257 {
1258 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1259 if ( evt.PropertyName == FM_PROP_BOUNDFIELD )
1260 {
1261 Reference<XPropertySet> xOldBound;
1262 evt.OldValue >>= xOldBound;
1263 if ( !xOldBound.is() && evt.NewValue.hasValue() )
1264 {
1265 Reference< XControlModel > xControlModel(evt.Source,UNO_QUERY);
1266 Reference< XControl > xControl = findControl(m_aControls,xControlModel,false,false);
1267 if ( xControl.is() )
1268 {
1269 startControlModifyListening( xControl );
1270 Reference<XPropertySet> xProp(xControlModel,UNO_QUERY);
1271 if ( xProp.is() )
1272 xProp->removePropertyChangeListener(FM_PROP_BOUNDFIELD, this);
1273 }
1274 }
1275 }
1276 else
1277 {
1278 bool bModifiedChanged = (evt.PropertyName == FM_PROP_ISMODIFIED);
1279 bool bNewChanged = (evt.PropertyName == FM_PROP_ISNEW);
1280 if (bModifiedChanged || bNewChanged)
1281 {
1282 ::osl::MutexGuard aGuard( m_aMutex );
1283 if (bModifiedChanged)
1284 m_bCurrentRecordModified = ::comphelper::getBOOL(evt.NewValue);
1285 else
1286 m_bCurrentRecordNew = ::comphelper::getBOOL(evt.NewValue);
1287
1288 // toggle the locking
1289 if (m_bLocked != determineLockState())
1290 {
1291 m_bLocked = !m_bLocked;
1292 setLocks();
1293 if (isListeningForChanges())
1294 startListening();
1295 else
1296 stopListening();
1297 }
1298
1299 if ( bNewChanged )
1300 m_aToggleEvent.Call();
1301
1302 if (!m_bCurrentRecordModified)
1303 m_bModified = false;
1304 }
1305 else if ( evt.PropertyName == FM_PROP_DYNAMIC_CONTROL_BORDER )
1306 {
1307 bool bEnable = lcl_shouldUseDynamicControlBorder( evt.Source, evt.NewValue );
1308 if ( bEnable )
1309 {
1310 m_pControlBorderManager->enableDynamicBorderColor();
1311 if ( m_xActiveControl.is() )
1312 m_pControlBorderManager->focusGained( m_xActiveControl.get() );
1313 }
1314 else
1315 {
1316 m_pControlBorderManager->disableDynamicBorderColor();
1317 }
1318 }
1319 }
1320 }
1321
1322
1323 bool FormController::replaceControl( const Reference< XControl >& _rxExistentControl, const Reference< XControl >& _rxNewControl )
1324 {
1325 bool bSuccess = false;
1326 try
1327 {
1328 Reference< XIdentifierReplace > xContainer( getContainer(), UNO_QUERY );
1329 DBG_ASSERT( xContainer.is(), "FormController::replaceControl: yes, it's not required by the service description, but XItentifierReplaces would be nice!" );
1330 if ( xContainer.is() )
1331 {
1332 // look up the ID of _rxExistentControl
1333 Sequence< sal_Int32 > aIdentifiers( xContainer->getIdentifiers() );
1334 const sal_Int32* pIdentifiers = aIdentifiers.getConstArray();
1335 const sal_Int32* pIdentifiersEnd = aIdentifiers.getConstArray() + aIdentifiers.getLength();
1336 for ( ; pIdentifiers != pIdentifiersEnd; ++pIdentifiers )
1337 {
1338 Reference< XControl > xCheck( xContainer->getByIdentifier( *pIdentifiers ), UNO_QUERY );
1339 if ( xCheck == _rxExistentControl )
1340 break;
1341 }
1342 DBG_ASSERT( pIdentifiers != pIdentifiersEnd, "FormController::replaceControl: did not find the control in the container!" );
1343 if ( pIdentifiers != pIdentifiersEnd )
1344 {
1345 bool bReplacedWasActive = ( m_xActiveControl.get() == _rxExistentControl.get() );
1346 bool bReplacedWasCurrent = ( m_xCurrentControl.get() == _rxExistentControl.get() );
1347
1348 if ( bReplacedWasActive )
1349 {
1350 m_xActiveControl = NULL;
1351 implSetCurrentControl( NULL );
1352 }
1353 else if ( bReplacedWasCurrent )
1354 {
1355 implSetCurrentControl( _rxNewControl );
1356 }
1357
1358 // carry over the model
1359 _rxNewControl->setModel( _rxExistentControl->getModel() );
1360
1361 xContainer->replaceByIdentifer( *pIdentifiers, makeAny( _rxNewControl ) );
1362 bSuccess = true;
1363
1364 if ( bReplacedWasActive )
1365 {
1366 Reference< XWindow > xControlWindow( _rxNewControl, UNO_QUERY );
1367 if ( xControlWindow.is() )
1368 xControlWindow->setFocus();
1369 }
1370 }
1371 }
1372 }
1373 catch( const Exception& )
1374 {
1375 DBG_UNHANDLED_EXCEPTION();
1376 }
1377
1378 Reference< XControl > xDisposeIt( bSuccess ? _rxExistentControl : _rxNewControl );
1379 ::comphelper::disposeComponent( xDisposeIt );
1380 return bSuccess;
1381 }
1382
1383
1384 void FormController::toggleAutoFields(bool bAutoFields)
1385 {
1386 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1387
1388
1389 Sequence< Reference< XControl > > aControlsCopy( m_aControls );
1390 const Reference< XControl >* pControls = aControlsCopy.getConstArray();
1391 sal_Int32 nControls = aControlsCopy.getLength();
1392
1393 if (bAutoFields)
1394 {
1395 // as we don't want new controls to be attached to the scripting environment
1396 // we change attach flags
1397 m_bAttachEvents = false;
1398 for (sal_Int32 i = nControls; i > 0;)
1399 {
1400 Reference< XControl > xControl = pControls[--i];
1401 if (xControl.is())
1402 {
1403 Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY);
1404 if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
1405 {
1406 // does the model use a bound field ?
1407 Reference< XPropertySet > xField;
1408 xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
1409
1410 // is it a autofield?
1411 if ( xField.is()
1412 && ::comphelper::hasProperty( FM_PROP_AUTOINCREMENT, xField )
1413 && ::comphelper::getBOOL( xField->getPropertyValue( FM_PROP_AUTOINCREMENT ) )
1414 )
1415 {
1416 replaceControl( xControl, new FmXAutoControl() );
1417 }
1418 }
1419 }
1420 }
1421 m_bAttachEvents = true;
1422 }
1423 else
1424 {
1425 m_bDetachEvents = false;
1426 for (sal_Int32 i = nControls; i > 0;)
1427 {
1428 Reference< XControl > xControl = pControls[--i];
1429 if (xControl.is())
1430 {
1431 Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY);
1432 if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
1433 {
1434 // does the model use a bound field ?
1435 Reference< XPropertySet > xField;
1436 xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
1437
1438 // is it a autofield?
1439 if ( xField.is()
1440 && ::comphelper::hasProperty( FM_PROP_AUTOINCREMENT, xField )
1441 && ::comphelper::getBOOL( xField->getPropertyValue(FM_PROP_AUTOINCREMENT ) )
1442 )
1443 {
1444 OUString sServiceName;
1445 OSL_VERIFY( xSet->getPropertyValue( FM_PROP_DEFAULTCONTROL ) >>= sServiceName );
1446 Reference< XControl > xNewControl( m_xComponentContext->getServiceManager()->createInstanceWithContext( sServiceName, m_xComponentContext ), UNO_QUERY );
1447 replaceControl( xControl, xNewControl );
1448 }
1449 }
1450 }
1451 }
1452 m_bDetachEvents = true;
1453 }
1454 }
1455
1456
1457 IMPL_LINK_NOARG(FormController, OnToggleAutoFields)
1458 {
1459 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1460
1461 toggleAutoFields(m_bCurrentRecordNew);
1462 return 1L;
1463 }
1464
1465 // XTextListener
1466
1467 void SAL_CALL FormController::textChanged(const TextEvent& e) throw( RuntimeException, std::exception )
1468 {
1469 // SYNCHRONIZED -->
1470 ::osl::ClearableMutexGuard aGuard( m_aMutex );
1471 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1472 if ( !m_bFiltering )
1473 {
1474 impl_onModify();
1475 return;
1476 }
1477
1478 if ( m_bSuspendFilterTextListening )
1479 return;
1480
1481 Reference< XTextComponent > xText(e.Source,UNO_QUERY);
1482 OUString aText = xText->getText();
1483
1484 if ( m_aFilterRows.empty() )
1485 appendEmptyDisjunctiveTerm();
1486
1487 // Suchen der aktuellen Row
1488 if ( ( (size_t)m_nCurrentFilterPosition >= m_aFilterRows.size() ) || ( m_nCurrentFilterPosition < 0 ) )
1489 {
1490 OSL_ENSURE( false, "FormController::textChanged: m_nCurrentFilterPosition is wrong!" );
1491 return;
1492 }
1493
1494 FmFilterRow& rRow = m_aFilterRows[ m_nCurrentFilterPosition ];
1495
1496 // do we have a new filter
1497 if (!aText.isEmpty())
1498 rRow[xText] = aText;
1499 else
1500 {
1501 // do we have the control in the row
1502 FmFilterRow::iterator iter = rRow.find(xText);
1503 // erase the entry out of the row
1504 if (iter != rRow.end())
1505 rRow.erase(iter);
1506 }
1507
1508 // multiplex the event to our FilterControllerListeners
1509 FilterEvent aEvent;
1510 aEvent.Source = *this;
1511 aEvent.FilterComponent = ::std::find( m_aFilterComponents.begin(), m_aFilterComponents.end(), xText ) - m_aFilterComponents.begin();
1512 aEvent.DisjunctiveTerm = getActiveTerm();
1513 aEvent.PredicateExpression = aText;
1514
1515 aGuard.clear();
1516 // <-- SYNCHRONIZED
1517
1518 // notify the changed filter expression
1519 m_aFilterListeners.notifyEach( &XFilterControllerListener::predicateExpressionChanged, aEvent );
1520 }
1521
1522 // XItemListener
1523
1524 void SAL_CALL FormController::itemStateChanged(const ItemEvent& /*rEvent*/) throw( RuntimeException, std::exception )
1525 {
1526 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1527 impl_onModify();
1528 }
1529
1530 // XModificationBroadcaster
1531
1532 void SAL_CALL FormController::addModifyListener(const Reference< XModifyListener > & l) throw( RuntimeException, std::exception )
1533 {
1534 ::osl::MutexGuard aGuard( m_aMutex );
1535 impl_checkDisposed_throw();
1536 m_aModifyListeners.addInterface( l );
1537 }
1538
1539
1540 void FormController::removeModifyListener(const Reference< XModifyListener > & l) throw( RuntimeException, std::exception )
1541 {
1542 ::osl::MutexGuard aGuard( m_aMutex );
1543 impl_checkDisposed_throw();
1544 m_aModifyListeners.removeInterface( l );
1545 }
1546
1547 // XModificationListener
1548
1549 void FormController::modified( const EventObject& _rEvent ) throw( RuntimeException, std::exception )
1550 {
1551 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1552
1553 try
1554 {
1555 if ( _rEvent.Source != m_xActiveControl )
1556 { // let this control grab the focus
1557 // (this case may happen if somebody moves the scroll wheel of the mouse over a control
1558 // which does not have the focus)
1559 // 85511 - 29.05.2001 - frank.schoenheit@germany.sun.com
1560
1561 // also, it happens when an image control gets a new image by double-clicking it
1562 // #i88458# / 2009-01-12 / frank.schoenheit@sun.com
1563 Reference< XWindow > xControlWindow( _rEvent.Source, UNO_QUERY_THROW );
1564 xControlWindow->setFocus();
1565 }
1566 }
1567 catch( const Exception& )
1568 {
1569 DBG_UNHANDLED_EXCEPTION();
1570 }
1571
1572 impl_onModify();
1573 }
1574
1575
1576 void FormController::impl_checkDisposed_throw() const
1577 {
1578 if ( impl_isDisposed_nofail() )
1579 throw DisposedException( OUString(), *const_cast< FormController* >( this ) );
1580 }
1581
1582
1583 void FormController::impl_onModify()
1584 {
1585 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1586
1587 {
1588 ::osl::MutexGuard aGuard( m_aMutex );
1589 if ( !m_bModified )
1590 m_bModified = true;
1591 }
1592
1593 EventObject aEvt(static_cast<cppu::OWeakObject*>(this));
1594 m_aModifyListeners.notifyEach( &XModifyListener::modified, aEvt );
1595 }
1596
1597
1598 void FormController::impl_addFilterRow( const FmFilterRow& _row )
1599 {
1600 m_aFilterRows.push_back( _row );
1601
1602 if ( m_aFilterRows.size() == 1 )
1603 { // that's the first row ever
1604 OSL_ENSURE( m_nCurrentFilterPosition == -1, "FormController::impl_addFilterRow: inconsistency!" );
1605 m_nCurrentFilterPosition = 0;
1606 }
1607 }
1608
1609
1610 void FormController::impl_appendEmptyFilterRow( ::osl::ClearableMutexGuard& _rClearBeforeNotify )
1611 {
1612 // SYNCHRONIZED -->
1613 impl_addFilterRow( FmFilterRow() );
1614
1615 // notify the listeners
1616 FilterEvent aEvent;
1617 aEvent.Source = *this;
1618 aEvent.DisjunctiveTerm = (sal_Int32)m_aFilterRows.size() - 1;
1619 _rClearBeforeNotify.clear();
1620 // <-- SYNCHRONIZED
1621 m_aFilterListeners.notifyEach( &XFilterControllerListener::disjunctiveTermAdded, aEvent );
1622 }
1623
1624
1625 bool FormController::determineLockState() const
1626 {
1627 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1628 // a.) in filter mode we are always locked
1629 // b.) if we have no valid model or our model (a result set) is not alive -> we're locked
1630 // c.) if we are inserting everything is OK and we are not locked
1631 // d.) if are not updatable or on invalid position
1632 Reference< XResultSet > xResultSet(m_xModelAsIndex, UNO_QUERY);
1633 if (m_bFiltering || !xResultSet.is() || !isRowSetAlive(xResultSet))
1634 return true;
1635 else
1636 return (m_bCanInsert && m_bCurrentRecordNew) ? sal_False
1637 : xResultSet->isBeforeFirst() || xResultSet->isAfterLast() || xResultSet->rowDeleted() || !m_bCanUpdate;
1638 }
1639
1640 // FocusListener
1641
1642 void FormController::focusGained(const FocusEvent& e) throw( RuntimeException, std::exception )
1643 {
1644 // SYNCHRONIZED -->
1645 ::osl::ClearableMutexGuard aGuard( m_aMutex );
1646 impl_checkDisposed_throw();
1647
1648 m_pControlBorderManager->focusGained( e.Source );
1649
1650 Reference< XControl > xControl(e.Source, UNO_QUERY);
1651 if (m_bDBConnection)
1652 {
1653 // do we need to keep the locking of the commit
1654 // we hold the lock as long as the control differs from the current
1655 // otherwise we disabled the lock
1656 m_bCommitLock = m_bCommitLock && (XControl*)xControl.get() != (XControl*)m_xCurrentControl.get();
1657 if (m_bCommitLock)
1658 return;
1659
1660 // when do we have to commit a value to form or a filter
1661 // a.) if the current value is modified
1662 // b.) there must be a current control
1663 // c.) and it must be different from the new focus owning control or
1664 // d.) the focus is moving around (so we have only one control)
1665
1666 if ( ( m_bModified || m_bFiltering )
1667 && m_xCurrentControl.is()
1668 && ( ( xControl.get() != m_xCurrentControl.get() )
1669 || ( ( e.FocusFlags & FocusChangeReason::AROUND )
1670 && ( m_bCycle || m_bFiltering )
1671 )
1672 )
1673 )
1674 {
1675 // check the old control if the content is ok
1676 #if OSL_DEBUG_LEVEL > 1
1677 Reference< XBoundControl > xLockingTest(m_xCurrentControl, UNO_QUERY);
1678 sal_Bool bControlIsLocked = xLockingTest.is() && xLockingTest->getLock();
1679 OSL_ENSURE(!bControlIsLocked, "FormController::Gained: I'm modified and the current control is locked ? How this ?");
1680 // normalerweise sollte ein gelocktes Control nicht modified sein, also muss wohl mein bModified aus einem anderen Kontext
1681 // gesetzt worden sein, was ich nicht verstehen wuerde ...
1682 #endif
1683 DBG_ASSERT(m_xCurrentControl.is(), "kein CurrentControl gesetzt");
1684 // zunaechst das Control fragen ob es das IFace unterstuetzt
1685 Reference< XBoundComponent > xBound(m_xCurrentControl, UNO_QUERY);
1686 if (!xBound.is() && m_xCurrentControl.is())
1687 xBound = Reference< XBoundComponent > (m_xCurrentControl->getModel(), UNO_QUERY);
1688
1689 // lock if we lose the focus during commit
1690 m_bCommitLock = true;
1691
1692 // Commit nicht erfolgreich, Focus zuruecksetzen
1693 if (xBound.is() && !xBound->commit())
1694 {
1695 // the commit failed and we don't commit again until the current control
1696 // which couldn't be commit gains the focus again
1697 Reference< XWindow > xWindow(m_xCurrentControl, UNO_QUERY);
1698 if (xWindow.is())
1699 xWindow->setFocus();
1700 return;
1701 }
1702 else
1703 {
1704 m_bModified = false;
1705 m_bCommitLock = false;
1706 }
1707 }
1708
1709 if (!m_bFiltering && m_bCycle && (e.FocusFlags & FocusChangeReason::AROUND) && m_xCurrentControl.is())
1710 {
1711 SQLErrorEvent aErrorEvent;
1712 OSL_ENSURE( m_xFormOperations.is(), "FormController::focusGained: hmm?" );
1713 // should have been created in setModel
1714 try
1715 {
1716 if ( e.FocusFlags & FocusChangeReason::FORWARD )
1717 {
1718 if ( m_xFormOperations.is() && m_xFormOperations->isEnabled( FormFeature::MoveToNext ) )
1719 m_xFormOperations->execute( FormFeature::MoveToNext );
1720 }
1721 else // backward
1722 {
1723 if ( m_xFormOperations.is() && m_xFormOperations->isEnabled( FormFeature::MoveToPrevious ) )
1724 m_xFormOperations->execute( FormFeature::MoveToPrevious );
1725 }
1726 }
1727 catch ( const Exception& )
1728 {
1729 // don't handle this any further. That's an ... admissible error.
1730 DBG_UNHANDLED_EXCEPTION();
1731 }
1732 }
1733 }
1734
1735 // Immer noch ein und dasselbe Control
1736 if ( ( m_xActiveControl == xControl )
1737 && ( xControl == m_xCurrentControl )
1738 )
1739 {
1740 DBG_ASSERT(m_xCurrentControl.is(), "Kein CurrentControl selektiert");
1741 return;
1742 }
1743
1744 bool bActivated = !m_xActiveControl.is() && xControl.is();
1745
1746 m_xActiveControl = xControl;
1747
1748 implSetCurrentControl( xControl );
1749 SAL_WARN_IF( !m_xCurrentControl.is(), "svx.form", "implSetCurrentControl did nonsense!" );
1750
1751 if ( bActivated )
1752 {
1753 // (asynchronously) call activation handlers
1754 m_aActivationEvent.Call();
1755
1756 // call modify listeners
1757 if ( m_bModified )
1758 m_aModifyListeners.notifyEach( &XModifyListener::modified, EventObject( *this ) );
1759 }
1760
1761 // invalidate all features which depend on the currently focused control
1762 if ( m_bDBConnection && !m_bFiltering )
1763 implInvalidateCurrentControlDependentFeatures();
1764
1765 if ( !m_xCurrentControl.is() )
1766 return;
1767
1768 // Control erhaelt Focus, dann eventuell in den sichtbaren Bereich
1769 Reference< XFormControllerContext > xContext( m_xFormControllerContext );
1770 Reference< XControl > xCurrentControl( m_xCurrentControl );
1771 aGuard.clear();
1772 // <-- SYNCHRONIZED
1773
1774 if ( xContext.is() )
1775 xContext->makeVisible( xCurrentControl );
1776 }
1777
1778
1779 IMPL_LINK( FormController, OnActivated, void*, /**/ )
1780 {
1781 EventObject aEvent;
1782 aEvent.Source = *this;
1783 m_aActivateListeners.notifyEach( &XFormControllerListener::formActivated, aEvent );
1784
1785 return 0L;
1786 }
1787
1788
1789 IMPL_LINK( FormController, OnDeactivated, void*, /**/ )
1790 {
1791 EventObject aEvent;
1792 aEvent.Source = *this;
1793 m_aActivateListeners.notifyEach( &XFormControllerListener::formDeactivated, aEvent );
1794
1795 return 0L;
1796 }
1797
1798
1799 void FormController::focusLost(const FocusEvent& e) throw( RuntimeException, std::exception )
1800 {
1801 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1802
1803 m_pControlBorderManager->focusLost( e.Source );
1804
1805 Reference< XControl > xControl(e.Source, UNO_QUERY);
1806 Reference< XWindowPeer > xNext(e.NextFocus, UNO_QUERY);
1807 Reference< XControl > xNextControl = isInList(xNext);
1808 if (!xNextControl.is())
1809 {
1810 m_xActiveControl = NULL;
1811 m_aDeactivationEvent.Call();
1812 }
1813 }
1814
1815
1816 void SAL_CALL FormController::mousePressed( const awt::MouseEvent& /*_rEvent*/ ) throw (RuntimeException, std::exception)
1817 {
1818 // not interested in
1819 }
1820
1821
1822 void SAL_CALL FormController::mouseReleased( const awt::MouseEvent& /*_rEvent*/ ) throw (RuntimeException, std::exception)
1823 {
1824 // not interested in
1825 }
1826
1827
1828 void SAL_CALL FormController::mouseEntered( const awt::MouseEvent& _rEvent ) throw (RuntimeException, std::exception)
1829 {
1830 m_pControlBorderManager->mouseEntered( _rEvent.Source );
1831 }
1832
1833
1834 void SAL_CALL FormController::mouseExited( const awt::MouseEvent& _rEvent ) throw (RuntimeException, std::exception)
1835 {
1836 m_pControlBorderManager->mouseExited( _rEvent.Source );
1837 }
1838
1839
1840 void SAL_CALL FormController::componentValidityChanged( const EventObject& _rSource ) throw (RuntimeException, std::exception)
1841 {
1842 Reference< XControl > xControl( findControl( m_aControls, Reference< XControlModel >( _rSource.Source, UNO_QUERY ), false, false ) );
1843 Reference< XValidatableFormComponent > xValidatable( _rSource.Source, UNO_QUERY );
1844
1845 OSL_ENSURE( xControl.is() && xValidatable.is(), "FormController::componentValidityChanged: huh?" );
1846
1847 if ( xControl.is() && xValidatable.is() )
1848 m_pControlBorderManager->validityChanged( xControl, xValidatable );
1849 }
1850
1851
1852 void FormController::setModel(const Reference< XTabControllerModel > & Model) throw( RuntimeException, std::exception )
1853 {
1854 ::osl::MutexGuard aGuard( m_aMutex );
1855 impl_checkDisposed_throw();
1856
1857 DBG_ASSERT(m_xTabController.is(), "FormController::setModel : invalid aggregate !");
1858
1859 try
1860 {
1861 // disconnect from the old model
1862 if (m_xModelAsIndex.is())
1863 {
1864 if (m_bDBConnection)
1865 {
1866 // we are currently working on the model
1867 EventObject aEvt(m_xModelAsIndex);
1868 unloaded(aEvt);
1869 }
1870
1871 Reference< XLoadable > xForm(m_xModelAsIndex, UNO_QUERY);
1872 if (xForm.is())
1873 xForm->removeLoadListener(this);
1874
1875 Reference< XSQLErrorBroadcaster > xBroadcaster(m_xModelAsIndex, UNO_QUERY);
1876 if (xBroadcaster.is())
1877 xBroadcaster->removeSQLErrorListener(this);
1878
1879 Reference< XDatabaseParameterBroadcaster > xParamBroadcaster(m_xModelAsIndex, UNO_QUERY);
1880 if (xParamBroadcaster.is())
1881 xParamBroadcaster->removeParameterListener(this);
1882
1883 }
1884
1885 disposeAllFeaturesAndDispatchers();
1886
1887 if ( m_xFormOperations.is() )
1888 m_xFormOperations->dispose();
1889 m_xFormOperations.clear();
1890
1891 // set the new model wait for the load event
1892 if (m_xTabController.is())
1893 m_xTabController->setModel(Model);
1894 m_xModelAsIndex = Reference< XIndexAccess > (Model, UNO_QUERY);
1895 m_xModelAsManager = Reference< XEventAttacherManager > (Model, UNO_QUERY);
1896
1897 // only if both ifaces exit, the controller will work successful
1898 if (!m_xModelAsIndex.is() || !m_xModelAsManager.is())
1899 {
1900 m_xModelAsManager = NULL;
1901 m_xModelAsIndex = NULL;
1902 }
1903
1904 if (m_xModelAsIndex.is())
1905 {
1906 // re-create m_xFormOperations
1907 m_xFormOperations = FormOperations::createWithFormController( m_xComponentContext, this );
1908 m_xFormOperations->setFeatureInvalidation( this );
1909
1910 // adding load and ui interaction listeners
1911 Reference< XLoadable > xForm(Model, UNO_QUERY);
1912 if (xForm.is())
1913 xForm->addLoadListener(this);
1914
1915 Reference< XSQLErrorBroadcaster > xBroadcaster(Model, UNO_QUERY);
1916 if (xBroadcaster.is())
1917 xBroadcaster->addSQLErrorListener(this);
1918
1919 Reference< XDatabaseParameterBroadcaster > xParamBroadcaster(Model, UNO_QUERY);
1920 if (xParamBroadcaster.is())
1921 xParamBroadcaster->addParameterListener(this);
1922
1923 // well, is the database already loaded?
1924 // then we have to simulate a load event
1925 Reference< XLoadable > xCursor(m_xModelAsIndex, UNO_QUERY);
1926 if (xCursor.is() && xCursor->isLoaded())
1927 {
1928 EventObject aEvt(xCursor);
1929 loaded(aEvt);
1930 }
1931
1932 Reference< XPropertySet > xModelProps( m_xModelAsIndex, UNO_QUERY );
1933 Reference< XPropertySetInfo > xPropInfo( xModelProps->getPropertySetInfo() );
1934 if ( xPropInfo.is()
1935 && xPropInfo->hasPropertyByName( FM_PROP_DYNAMIC_CONTROL_BORDER )
1936 && xPropInfo->hasPropertyByName( FM_PROP_CONTROL_BORDER_COLOR_FOCUS )
1937 && xPropInfo->hasPropertyByName( FM_PROP_CONTROL_BORDER_COLOR_MOUSE )
1938 && xPropInfo->hasPropertyByName( FM_PROP_CONTROL_BORDER_COLOR_INVALID )
1939 )
1940 {
1941 bool bEnableDynamicControlBorder = lcl_shouldUseDynamicControlBorder(
1942 xModelProps.get(), xModelProps->getPropertyValue( FM_PROP_DYNAMIC_CONTROL_BORDER ) );
1943 if ( bEnableDynamicControlBorder )
1944 m_pControlBorderManager->enableDynamicBorderColor();
1945 else
1946 m_pControlBorderManager->disableDynamicBorderColor();
1947
1948 sal_Int32 nColor = 0;
1949 if ( xModelProps->getPropertyValue( FM_PROP_CONTROL_BORDER_COLOR_FOCUS ) >>= nColor )
1950 m_pControlBorderManager->setStatusColor( CONTROL_STATUS_FOCUSED, nColor );
1951 if ( xModelProps->getPropertyValue( FM_PROP_CONTROL_BORDER_COLOR_MOUSE ) >>= nColor )
1952 m_pControlBorderManager->setStatusColor( CONTROL_STATUS_MOUSE_HOVER, nColor );
1953 if ( xModelProps->getPropertyValue( FM_PROP_CONTROL_BORDER_COLOR_INVALID ) >>= nColor )
1954 m_pControlBorderManager->setStatusColor( CONTROL_STATUS_INVALID, nColor );
1955 }
1956 }
1957 }
1958 catch( const Exception& )
1959 {
1960 DBG_UNHANDLED_EXCEPTION();
1961 }
1962 }
1963
1964
1965 Reference< XTabControllerModel > FormController::getModel() throw( RuntimeException, std::exception )
1966 {
1967 ::osl::MutexGuard aGuard( m_aMutex );
1968 impl_checkDisposed_throw();
1969
1970 DBG_ASSERT(m_xTabController.is(), "FormController::getModel : invalid aggregate !");
1971 if (!m_xTabController.is())
1972 return Reference< XTabControllerModel > ();
1973 return m_xTabController->getModel();
1974 }
1975
1976
1977 void FormController::addToEventAttacher(const Reference< XControl > & xControl)
1978 {
1979 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
1980 OSL_ENSURE( xControl.is(), "FormController::addToEventAttacher: invalid control - how did you reach this?" );
1981 if ( !xControl.is() )
1982 return; /* throw IllegalArgumentException(); */
1983
1984 // anmelden beim Eventattacher
1985 Reference< XFormComponent > xComp(xControl->getModel(), UNO_QUERY);
1986 if (xComp.is() && m_xModelAsIndex.is())
1987 {
1988 // Und die Position des ControlModel darin suchen
1989 sal_uInt32 nPos = m_xModelAsIndex->getCount();
1990 Reference< XFormComponent > xTemp;
1991 for( ; nPos; )
1992 {
1993 m_xModelAsIndex->getByIndex(--nPos) >>= xTemp;
1994 if ((XFormComponent*)xComp.get() == (XFormComponent*)xTemp.get())
1995 {
1996 m_xModelAsManager->attach( nPos, xControl, makeAny(xControl) );
1997 break;
1998 }
1999 }
2000 }
2001 }
2002
2003
2004 void FormController::removeFromEventAttacher(const Reference< XControl > & xControl)
2005 {
2006 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2007 OSL_ENSURE( xControl.is(), "FormController::removeFromEventAttacher: invalid control - how did you reach this?" );
2008 if ( !xControl.is() )
2009 return; /* throw IllegalArgumentException(); */
2010
2011 // abmelden beim Eventattacher
2012 Reference< XFormComponent > xComp(xControl->getModel(), UNO_QUERY);
2013 if ( xComp.is() && m_xModelAsIndex.is() )
2014 {
2015 // Und die Position des ControlModel darin suchen
2016 sal_uInt32 nPos = m_xModelAsIndex->getCount();
2017 Reference< XFormComponent > xTemp;
2018 for( ; nPos; )
2019 {
2020 m_xModelAsIndex->getByIndex(--nPos) >>= xTemp;
2021 if ((XFormComponent*)xComp.get() == (XFormComponent*)xTemp.get())
2022 {
2023 m_xModelAsManager->detach( nPos, xControl );
2024 break;
2025 }
2026 }
2027 }
2028 }
2029
2030
2031 void FormController::setContainer(const Reference< XControlContainer > & xContainer) throw( RuntimeException, std::exception )
2032 {
2033 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2034 Reference< XTabControllerModel > xTabModel(getModel());
2035 DBG_ASSERT(xTabModel.is() || !xContainer.is(), "No Model defined");
2036 // if we have a new container we need a model
2037 DBG_ASSERT(m_xTabController.is(), "FormController::setContainer : invalid aggregate !");
2038
2039 ::osl::MutexGuard aGuard( m_aMutex );
2040 Reference< XContainer > xCurrentContainer;
2041 if (m_xTabController.is())
2042 xCurrentContainer = Reference< XContainer > (m_xTabController->getContainer(), UNO_QUERY);
2043 if (xCurrentContainer.is())
2044 {
2045 xCurrentContainer->removeContainerListener(this);
2046
2047 if ( m_aTabActivationTimer.IsActive() )
2048 m_aTabActivationTimer.Stop();
2049
2050 // clear the filter map
2051 ::std::for_each( m_aFilterComponents.begin(), m_aFilterComponents.end(), RemoveComponentTextListener( this ) );
2052 m_aFilterComponents.clear();
2053
2054 // einsammeln der Controls
2055 const Reference< XControl >* pControls = m_aControls.getConstArray();
2056 const Reference< XControl >* pControlsEnd = pControls + m_aControls.getLength();
2057 while ( pControls != pControlsEnd )
2058 implControlRemoved( *pControls++, true );
2059
2060 // Datenbank spezifische Dinge vornehmen
2061 if (m_bDBConnection && isListeningForChanges())
2062 stopListening();
2063
2064 m_aControls.realloc( 0 );
2065 }
2066
2067 if (m_xTabController.is())
2068 m_xTabController->setContainer(xContainer);
2069
2070 // Welche Controls gehoeren zum Container ?
2071 if (xContainer.is() && xTabModel.is())
2072 {
2073 Sequence< Reference< XControlModel > > aModels = xTabModel->getControlModels();
2074 const Reference< XControlModel > * pModels = aModels.getConstArray();
2075 Sequence< Reference< XControl > > aAllControls = xContainer->getControls();
2076
2077 sal_Int32 nCount = aModels.getLength();
2078 m_aControls = Sequence< Reference< XControl > >( nCount );
2079 Reference< XControl > * pControls = m_aControls.getArray();
2080
2081 // einsammeln der Controls
2082 sal_Int32 i, j;
2083 for (i = 0, j = 0; i < nCount; ++i, ++pModels )
2084 {
2085 Reference< XControl > xControl = findControl( aAllControls, *pModels, false, true );
2086 if ( xControl.is() )
2087 {
2088 pControls[j++] = xControl;
2089 implControlInserted( xControl, true );
2090 }
2091 }
2092
2093 // not every model had an associated control
2094 if (j != i)
2095 m_aControls.realloc(j);
2096
2097 // am Container horchen
2098 Reference< XContainer > xNewContainer(xContainer, UNO_QUERY);
2099 if (xNewContainer.is())
2100 xNewContainer->addContainerListener(this);
2101
2102 // Datenbank spezifische Dinge vornehmen
2103 if (m_bDBConnection)
2104 {
2105 m_bLocked = determineLockState();
2106 setLocks();
2107 if (!isLocked())
2108 startListening();
2109 }
2110 }
2111 // befinden sich die Controls in der richtigen Reihenfolge
2112 m_bControlsSorted = true;
2113 }
2114
2115
2116 Reference< XControlContainer > FormController::getContainer() throw( RuntimeException, std::exception )
2117 {
2118 ::osl::MutexGuard aGuard( m_aMutex );
2119 impl_checkDisposed_throw();
2120
2121 DBG_ASSERT(m_xTabController.is(), "FormController::getContainer : invalid aggregate !");
2122 if (!m_xTabController.is())
2123 return Reference< XControlContainer > ();
2124 return m_xTabController->getContainer();
2125 }
2126
2127
2128 Sequence< Reference< XControl > > FormController::getControls(void) throw( RuntimeException, std::exception )
2129 {
2130 ::osl::MutexGuard aGuard( m_aMutex );
2131 impl_checkDisposed_throw();
2132
2133 if (!m_bControlsSorted)
2134 {
2135 Reference< XTabControllerModel > xModel = getModel();
2136 if (!xModel.is())
2137 return m_aControls;
2138
2139 Sequence< Reference< XControlModel > > aControlModels = xModel->getControlModels();
2140 const Reference< XControlModel > * pModels = aControlModels.getConstArray();
2141 sal_Int32 nModels = aControlModels.getLength();
2142
2143 Sequence< Reference< XControl > > aNewControls(nModels);
2144
2145 Reference< XControl > * pControls = aNewControls.getArray();
2146 Reference< XControl > xControl;
2147
2148 // Umsortieren der Controls entsprechend der TabReihenfolge
2149 sal_Int32 j = 0;
2150 for (sal_Int32 i = 0; i < nModels; ++i, ++pModels )
2151 {
2152 xControl = findControl( m_aControls, *pModels, true, true );
2153 if ( xControl.is() )
2154 pControls[j++] = xControl;
2155 }
2156
2157 // not every model had an associated control
2158 if ( j != nModels )
2159 aNewControls.realloc( j );
2160
2161 m_aControls = aNewControls;
2162 m_bControlsSorted = true;
2163 }
2164 return m_aControls;
2165 }
2166
2167
2168 void FormController::autoTabOrder() throw( RuntimeException, std::exception )
2169 {
2170 ::osl::MutexGuard aGuard( m_aMutex );
2171 impl_checkDisposed_throw();
2172
2173 DBG_ASSERT(m_xTabController.is(), "FormController::autoTabOrder : invalid aggregate !");
2174 if (m_xTabController.is())
2175 m_xTabController->autoTabOrder();
2176 }
2177
2178
2179 void FormController::activateTabOrder() throw( RuntimeException, std::exception )
2180 {
2181 ::osl::MutexGuard aGuard( m_aMutex );
2182 impl_checkDisposed_throw();
2183
2184 DBG_ASSERT(m_xTabController.is(), "FormController::activateTabOrder : invalid aggregate !");
2185 if (m_xTabController.is())
2186 m_xTabController->activateTabOrder();
2187 }
2188
2189
2190 void FormController::setControlLock(const Reference< XControl > & xControl)
2191 {
2192 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2193 bool bLocked = isLocked();
2194
2195 // es wird gelockt
2196 // a.) wenn der ganze Datensatz gesperrt ist
2197 // b.) wenn das zugehoerige Feld gespeert ist
2198 Reference< XBoundControl > xBound(xControl, UNO_QUERY);
2199 if (xBound.is() && (( (bLocked && (bLocked ? 1 : 0) != xBound->getLock()) ||
2200 !bLocked))) // beim entlocken immer einzelne Felder ueberprüfen
2201 {
2202 // gibt es eine Datenquelle
2203 Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY);
2204 if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
2205 {
2206 // wie sieht mit den Properties ReadOnly und Enable aus
2207 bool bTouch = true;
2208 if (::comphelper::hasProperty(FM_PROP_ENABLED, xSet))
2209 bTouch = ::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_ENABLED));
2210 if (::comphelper::hasProperty(FM_PROP_READONLY, xSet))
2211 bTouch = !::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_READONLY));
2212
2213 if (bTouch)
2214 {
2215 Reference< XPropertySet > xField;
2216 xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
2217 if (xField.is())
2218 {
2219 if (bLocked)
2220 xBound->setLock(bLocked);
2221 else
2222 {
2223 try
2224 {
2225 Any aVal = xField->getPropertyValue(FM_PROP_ISREADONLY);
2226 if (aVal.hasValue() && ::comphelper::getBOOL(aVal))
2227 xBound->setLock(sal_True);
2228 else
2229 xBound->setLock(bLocked);
2230 }
2231 catch( const Exception& )
2232 {
2233 DBG_UNHANDLED_EXCEPTION();
2234 }
2235
2236 }
2237 }
2238 }
2239 }
2240 }
2241 }
2242
2243
2244 void FormController::setLocks()
2245 {
2246 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2247 // alle Controls, die mit einer Datenquelle verbunden sind locken/unlocken
2248 const Reference< XControl >* pControls = m_aControls.getConstArray();
2249 const Reference< XControl >* pControlsEnd = pControls + m_aControls.getLength();
2250 while ( pControls != pControlsEnd )
2251 setControlLock( *pControls++ );
2252 }
2253
2254
2255 namespace
2256 {
2257 bool lcl_shouldListenForModifications( const Reference< XControl >& _rxControl, const Reference< XPropertyChangeListener >& _rxBoundFieldListener )
2258 {
2259 bool bShould = false;
2260
2261 Reference< XBoundComponent > xBound( _rxControl, UNO_QUERY );
2262 if ( xBound.is() )
2263 {
2264 bShould = true;
2265 }
2266 else if ( _rxControl.is() )
2267 {
2268 Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY );
2269 if ( xModelProps.is() && ::comphelper::hasProperty( FM_PROP_BOUNDFIELD, xModelProps ) )
2270 {
2271 Reference< XPropertySet > xField;
2272 xModelProps->getPropertyValue( FM_PROP_BOUNDFIELD ) >>= xField;
2273 bShould = xField.is();
2274
2275 if ( !bShould && _rxBoundFieldListener.is() )
2276 xModelProps->addPropertyChangeListener( FM_PROP_BOUNDFIELD, _rxBoundFieldListener );
2277 }
2278 }
2279
2280 return bShould;
2281 }
2282 }
2283
2284
2285 void FormController::startControlModifyListening(const Reference< XControl > & xControl)
2286 {
2287 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2288
2289 bool bModifyListening = lcl_shouldListenForModifications( xControl, this );
2290
2291 // artificial while
2292 while ( bModifyListening )
2293 {
2294 Reference< XModifyBroadcaster > xMod(xControl, UNO_QUERY);
2295 if (xMod.is())
2296 {
2297 xMod->addModifyListener(this);
2298 break;
2299 }
2300
2301 // alle die Text um vorzeitig ein modified zu erkennen
2302 Reference< XTextComponent > xText(xControl, UNO_QUERY);
2303 if (xText.is())
2304 {
2305 xText->addTextListener(this);
2306 break;
2307 }
2308
2309 Reference< XCheckBox > xBox(xControl, UNO_QUERY);
2310 if (xBox.is())
2311 {
2312 xBox->addItemListener(this);
2313 break;
2314 }
2315
2316 Reference< XComboBox > xCbBox(xControl, UNO_QUERY);
2317 if (xCbBox.is())
2318 {
2319 xCbBox->addItemListener(this);
2320 break;
2321 }
2322
2323 Reference< XListBox > xListBox(xControl, UNO_QUERY);
2324 if (xListBox.is())
2325 {
2326 xListBox->addItemListener(this);
2327 break;
2328 }
2329 break;
2330 }
2331 }
2332
2333
2334 void FormController::stopControlModifyListening(const Reference< XControl > & xControl)
2335 {
2336 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2337
2338 bool bModifyListening = lcl_shouldListenForModifications( xControl, NULL );
2339
2340 // kuenstliches while
2341 while (bModifyListening)
2342 {
2343 Reference< XModifyBroadcaster > xMod(xControl, UNO_QUERY);
2344 if (xMod.is())
2345 {
2346 xMod->removeModifyListener(this);
2347 break;
2348 }
2349 // alle die Text um vorzeitig ein modified zu erkennen
2350 Reference< XTextComponent > xText(xControl, UNO_QUERY);
2351 if (xText.is())
2352 {
2353 xText->removeTextListener(this);
2354 break;
2355 }
2356
2357 Reference< XCheckBox > xBox(xControl, UNO_QUERY);
2358 if (xBox.is())
2359 {
2360 xBox->removeItemListener(this);
2361 break;
2362 }
2363
2364 Reference< XComboBox > xCbBox(xControl, UNO_QUERY);
2365 if (xCbBox.is())
2366 {
2367 xCbBox->removeItemListener(this);
2368 break;
2369 }
2370
2371 Reference< XListBox > xListBox(xControl, UNO_QUERY);
2372 if (xListBox.is())
2373 {
2374 xListBox->removeItemListener(this);
2375 break;
2376 }
2377 break;
2378 }
2379 }
2380
2381
2382 void FormController::startListening()
2383 {
2384 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2385 m_bModified = false;
2386
2387 // jetzt anmelden bei gebundenen feldern
2388 const Reference< XControl >* pControls = m_aControls.getConstArray();
2389 const Reference< XControl >* pControlsEnd = pControls + m_aControls.getLength();
2390 while ( pControls != pControlsEnd )
2391 startControlModifyListening( *pControls++ );
2392 }
2393
2394
2395 void FormController::stopListening()
2396 {
2397 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2398 m_bModified = false;
2399
2400 // jetzt anmelden bei gebundenen feldern
2401 const Reference< XControl >* pControls = m_aControls.getConstArray();
2402 const Reference< XControl >* pControlsEnd = pControls + m_aControls.getLength();
2403 while ( pControls != pControlsEnd )
2404 stopControlModifyListening( *pControls++ );
2405 }
2406
2407
2408
2409 Reference< XControl > FormController::findControl(Sequence< Reference< XControl > >& _rControls, const Reference< XControlModel > & xCtrlModel ,bool _bRemove,bool _bOverWrite) const
2410 {
2411 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2412 DBG_ASSERT( xCtrlModel.is(), "findControl - welches ?!" );
2413
2414 Reference< XControl >* pControls = _rControls.getArray();
2415 Reference< XControlModel > xModel;
2416 for ( sal_Int32 i = 0, nCount = _rControls.getLength(); i < nCount; ++i, ++pControls )
2417 {
2418 if ( pControls->is() )
2419 {
2420 xModel = (*pControls)->getModel();
2421 if ( xModel.get() == xCtrlModel.get() )
2422 {
2423 Reference< XControl > xControl( *pControls );
2424 if ( _bRemove )
2425 ::comphelper::removeElementAt( _rControls, i );
2426 else if ( _bOverWrite )
2427 pControls->clear();
2428 return xControl;
2429 }
2430 }
2431 }
2432 return Reference< XControl > ();
2433 }
2434
2435
2436 void FormController::implControlInserted( const Reference< XControl>& _rxControl, bool _bAddToEventAttacher )
2437 {
2438 Reference< XWindow > xWindow( _rxControl, UNO_QUERY );
2439 if ( xWindow.is() )
2440 {
2441 xWindow->addFocusListener( this );
2442 xWindow->addMouseListener( this );
2443
2444 if ( _bAddToEventAttacher )
2445 addToEventAttacher( _rxControl );
2446 }
2447
2448 // add a dispatch interceptor to the control (if supported)
2449 Reference< XDispatchProviderInterception > xInterception( _rxControl, UNO_QUERY );
2450 if ( xInterception.is() )
2451 createInterceptor( xInterception );
2452
2453 if ( _rxControl.is() )
2454 {
2455 Reference< XControlModel > xModel( _rxControl->getModel() );
2456
2457 // we want to know about the reset of the model of our controls
2458 // (for correctly resetting m_bModified)
2459 Reference< XReset > xReset( xModel, UNO_QUERY );
2460 if ( xReset.is() )
2461 xReset->addResetListener( this );
2462
2463 // and we want to know about the validity, to visually indicate it
2464 Reference< XValidatableFormComponent > xValidatable( xModel, UNO_QUERY );
2465 if ( xValidatable.is() )
2466 {
2467 xValidatable->addFormComponentValidityListener( this );
2468 m_pControlBorderManager->validityChanged( _rxControl, xValidatable );
2469 }
2470 }
2471
2472 }
2473
2474
2475 void FormController::implControlRemoved( const Reference< XControl>& _rxControl, bool _bRemoveFromEventAttacher )
2476 {
2477 Reference< XWindow > xWindow( _rxControl, UNO_QUERY );
2478 if ( xWindow.is() )
2479 {
2480 xWindow->removeFocusListener( this );
2481 xWindow->removeMouseListener( this );
2482
2483 if ( _bRemoveFromEventAttacher )
2484 removeFromEventAttacher( _rxControl );
2485 }
2486
2487 Reference< XDispatchProviderInterception > xInterception( _rxControl, UNO_QUERY);
2488 if ( xInterception.is() )
2489 deleteInterceptor( xInterception );
2490
2491 if ( _rxControl.is() )
2492 {
2493 Reference< XControlModel > xModel( _rxControl->getModel() );
2494
2495 Reference< XReset > xReset( xModel, UNO_QUERY );
2496 if ( xReset.is() )
2497 xReset->removeResetListener( this );
2498
2499 Reference< XValidatableFormComponent > xValidatable( xModel, UNO_QUERY );
2500 if ( xValidatable.is() )
2501 xValidatable->removeFormComponentValidityListener( this );
2502 }
2503 }
2504
2505
2506 void FormController::implSetCurrentControl( const Reference< XControl >& _rxControl )
2507 {
2508 if ( m_xCurrentControl.get() == _rxControl.get() )
2509 return;
2510
2511 Reference< XGridControl > xGridControl( m_xCurrentControl, UNO_QUERY );
2512 if ( xGridControl.is() )
2513 xGridControl->removeGridControlListener( this );
2514
2515 m_xCurrentControl = _rxControl;
2516
2517 xGridControl.set( m_xCurrentControl, UNO_QUERY );
2518 if ( xGridControl.is() )
2519 xGridControl->addGridControlListener( this );
2520 }
2521
2522
2523 void FormController::insertControl(const Reference< XControl > & xControl)
2524 {
2525 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2526 m_bControlsSorted = false;
2527 m_aControls.realloc(m_aControls.getLength() + 1);
2528 m_aControls.getArray()[m_aControls.getLength() - 1] = xControl;
2529
2530 if ( m_pColumnInfoCache.get() )
2531 m_pColumnInfoCache->deinitializeControls();
2532
2533 implControlInserted( xControl, m_bAttachEvents );
2534
2535 if (m_bDBConnection && !m_bFiltering)
2536 setControlLock(xControl);
2537
2538 if (isListeningForChanges() && m_bAttachEvents)
2539 startControlModifyListening( xControl );
2540 }
2541
2542
2543 void FormController::removeControl(const Reference< XControl > & xControl)
2544 {
2545 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2546 const Reference< XControl >* pControls = m_aControls.getConstArray();
2547 const Reference< XControl >* pControlsEnd = pControls + m_aControls.getLength();
2548 while ( pControls != pControlsEnd )
2549 {
2550 if ( xControl.get() == (*pControls++).get() )
2551 {
2552 ::comphelper::removeElementAt( m_aControls, pControls - m_aControls.getConstArray() - 1 );
2553 break;
2554 }
2555 }
2556
2557 FilterComponents::iterator componentPos = ::std::find( m_aFilterComponents.begin(), m_aFilterComponents.end(), xControl );
2558 if ( componentPos != m_aFilterComponents.end() )
2559 m_aFilterComponents.erase( componentPos );
2560
2561 implControlRemoved( xControl, m_bDetachEvents );
2562
2563 if ( isListeningForChanges() && m_bDetachEvents )
2564 stopControlModifyListening( xControl );
2565 }
2566
2567 // XLoadListener
2568
2569 void FormController::loaded(const EventObject& rEvent) throw( RuntimeException, std::exception )
2570 {
2571 OSL_ENSURE( rEvent.Source == m_xModelAsIndex, "FormController::loaded: where did this come from?" );
2572
2573 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2574 ::osl::MutexGuard aGuard( m_aMutex );
2575 Reference< XRowSet > xForm(rEvent.Source, UNO_QUERY);
2576 // do we have a connected data source
2577 OStaticDataAccessTools aStaticTools;
2578 if (xForm.is() && aStaticTools.getRowSetConnection(xForm).is())
2579 {
2580 Reference< XPropertySet > xSet(xForm, UNO_QUERY);
2581 if (xSet.is())
2582 {
2583 Any aVal = xSet->getPropertyValue(FM_PROP_CYCLE);
2584 sal_Int32 aVal2 = 0;
2585 ::cppu::enum2int(aVal2,aVal);
2586 m_bCycle = !aVal.hasValue() || aVal2 == TabulatorCycle_RECORDS;
2587 m_bCanUpdate = aStaticTools.canUpdate(xSet);
2588 m_bCanInsert = aStaticTools.canInsert(xSet);
2589 m_bCurrentRecordModified = ::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_ISMODIFIED));
2590 m_bCurrentRecordNew = ::comphelper::getBOOL(xSet->getPropertyValue(FM_PROP_ISNEW));
2591
2592 startFormListening( xSet, false );
2593
2594 // set the locks for the current controls
2595 if (getContainer().is())
2596 {
2597 m_aLoadEvent.Call();
2598 }
2599 }
2600 else
2601 {
2602 m_bCanInsert = m_bCanUpdate = m_bCycle = false;
2603 m_bCurrentRecordModified = false;
2604 m_bCurrentRecordNew = false;
2605 m_bLocked = false;
2606 }
2607 m_bDBConnection = true;
2608 }
2609 else
2610 {
2611 m_bDBConnection = false;
2612 m_bCanInsert = m_bCanUpdate = m_bCycle = false;
2613 m_bCurrentRecordModified = false;
2614 m_bCurrentRecordNew = false;
2615 m_bLocked = false;
2616 }
2617
2618 Reference< XColumnsSupplier > xFormColumns( xForm, UNO_QUERY );
2619 m_pColumnInfoCache.reset( xFormColumns.is() ? new ColumnInfoCache( xFormColumns ) : NULL );
2620
2621 updateAllDispatchers();
2622 }
2623
2624
2625 void FormController::updateAllDispatchers() const
2626 {
2627 ::std::for_each(
2628 m_aFeatureDispatchers.begin(),
2629 m_aFeatureDispatchers.end(),
2630 ::o3tl::compose1(
2631 UpdateAllListeners(),
2632 ::o3tl::select2nd< DispatcherContainer::value_type >()
2633 )
2634 );
2635 }
2636
2637
2638 IMPL_LINK_NOARG(FormController, OnLoad)
2639 {
2640 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2641 m_bLocked = determineLockState();
2642
2643 setLocks();
2644
2645 if (!m_bLocked)
2646 startListening();
2647
2648 // just one exception toggle the auto values
2649 if (m_bCurrentRecordNew)
2650 toggleAutoFields(true);
2651
2652 return 1L;
2653 }
2654
2655
2656 void FormController::unloaded(const EventObject& /*rEvent*/) throw( RuntimeException, std::exception )
2657 {
2658 ::osl::MutexGuard aGuard( m_aMutex );
2659 impl_checkDisposed_throw();
2660
2661 updateAllDispatchers();
2662 }
2663
2664
2665 void FormController::reloading(const EventObject& /*aEvent*/) throw( RuntimeException, std::exception )
2666 {
2667 ::osl::MutexGuard aGuard( m_aMutex );
2668 impl_checkDisposed_throw();
2669
2670 // do the same like in unloading
2671 // just one exception toggle the auto values
2672 m_aToggleEvent.CancelPendingCall();
2673 unload();
2674 }
2675
2676
2677 void FormController::reloaded(const EventObject& aEvent) throw( RuntimeException, std::exception )
2678 {
2679 ::osl::MutexGuard aGuard( m_aMutex );
2680 impl_checkDisposed_throw();
2681
2682 loaded(aEvent);
2683 }
2684
2685
2686 void FormController::unloading(const EventObject& /*aEvent*/) throw( RuntimeException, std::exception )
2687 {
2688 ::osl::MutexGuard aGuard( m_aMutex );
2689 impl_checkDisposed_throw();
2690
2691 unload();
2692 }
2693
2694
2695 void FormController::unload() throw( RuntimeException )
2696 {
2697 ::osl::MutexGuard aGuard( m_aMutex );
2698 impl_checkDisposed_throw();
2699
2700 m_aLoadEvent.CancelPendingCall();
2701
2702 // be sure not to have autofields
2703 if (m_bCurrentRecordNew)
2704 toggleAutoFields(false);
2705
2706 // remove bound field listing again
2707 removeBoundFieldListener();
2708
2709 if (m_bDBConnection && isListeningForChanges())
2710 stopListening();
2711
2712 Reference< XPropertySet > xSet( m_xModelAsIndex, UNO_QUERY );
2713 if ( m_bDBConnection && xSet.is() )
2714 stopFormListening( xSet, false );
2715
2716 m_bDBConnection = false;
2717 m_bCanInsert = m_bCanUpdate = m_bCycle = false;
2718 m_bCurrentRecordModified = m_bCurrentRecordNew = m_bLocked = false;
2719
2720 m_pColumnInfoCache.reset();
2721 }
2722
2723
2724 void FormController::removeBoundFieldListener()
2725 {
2726 const Reference< XControl >* pControls = m_aControls.getConstArray();
2727 const Reference< XControl >* pControlsEnd = pControls + m_aControls.getLength();
2728 while ( pControls != pControlsEnd )
2729 {
2730 Reference< XPropertySet > xProp( *pControls++, UNO_QUERY );
2731 if ( xProp.is() )
2732 xProp->removePropertyChangeListener( FM_PROP_BOUNDFIELD, this );
2733 }
2734 }
2735
2736
2737 void FormController::startFormListening( const Reference< XPropertySet >& _rxForm, bool _bPropertiesOnly )
2738 {
2739 try
2740 {
2741 if ( m_bCanInsert || m_bCanUpdate ) // form can be modified
2742 {
2743 _rxForm->addPropertyChangeListener( FM_PROP_ISNEW, this );
2744 _rxForm->addPropertyChangeListener( FM_PROP_ISMODIFIED, this );
2745
2746 if ( !_bPropertiesOnly )
2747 {
2748 // set the Listener for UI interaction
2749 Reference< XRowSetApproveBroadcaster > xApprove( _rxForm, UNO_QUERY );
2750 if ( xApprove.is() )
2751 xApprove->addRowSetApproveListener( this );
2752
2753 // listener for row set changes
2754 Reference< XRowSet > xRowSet( _rxForm, UNO_QUERY );
2755 if ( xRowSet.is() )
2756 xRowSet->addRowSetListener( this );
2757 }
2758 }
2759
2760 Reference< XPropertySetInfo > xInfo = _rxForm->getPropertySetInfo();
2761 if ( xInfo.is() && xInfo->hasPropertyByName( FM_PROP_DYNAMIC_CONTROL_BORDER ) )
2762 _rxForm->addPropertyChangeListener( FM_PROP_DYNAMIC_CONTROL_BORDER, this );
2763 }
2764 catch( const Exception& )
2765 {
2766 DBG_UNHANDLED_EXCEPTION();
2767 }
2768 }
2769
2770
2771 void FormController::stopFormListening( const Reference< XPropertySet >& _rxForm, bool _bPropertiesOnly )
2772 {
2773 try
2774 {
2775 if ( m_bCanInsert || m_bCanUpdate )
2776 {
2777 _rxForm->removePropertyChangeListener( FM_PROP_ISNEW, this );
2778 _rxForm->removePropertyChangeListener( FM_PROP_ISMODIFIED, this );
2779
2780 if ( !_bPropertiesOnly )
2781 {
2782 Reference< XRowSetApproveBroadcaster > xApprove( _rxForm, UNO_QUERY );
2783 if (xApprove.is())
2784 xApprove->removeRowSetApproveListener(this);
2785
2786 Reference< XRowSet > xRowSet( _rxForm, UNO_QUERY );
2787 if ( xRowSet.is() )
2788 xRowSet->removeRowSetListener( this );
2789 }
2790 }
2791
2792 Reference< XPropertySetInfo > xInfo = _rxForm->getPropertySetInfo();
2793 if ( xInfo.is() && xInfo->hasPropertyByName( FM_PROP_DYNAMIC_CONTROL_BORDER ) )
2794 _rxForm->removePropertyChangeListener( FM_PROP_DYNAMIC_CONTROL_BORDER, this );
2795 }
2796 catch( const Exception& )
2797 {
2798 DBG_UNHANDLED_EXCEPTION();
2799 }
2800 }
2801
2802 // com::sun::star::sdbc::XRowSetListener
2803
2804 void FormController::cursorMoved(const EventObject& /*event*/) throw( RuntimeException, std::exception )
2805 {
2806 ::osl::MutexGuard aGuard( m_aMutex );
2807 impl_checkDisposed_throw();
2808
2809 // toggle the locking ?
2810 if (m_bLocked != determineLockState())
2811 {
2812 m_bLocked = !m_bLocked;
2813 setLocks();
2814 if (isListeningForChanges())
2815 startListening();
2816 else
2817 stopListening();
2818 }
2819
2820 // neither the current control nor the current record are modified anymore
2821 m_bCurrentRecordModified = m_bModified = false;
2822 }
2823
2824
2825 void FormController::rowChanged(const EventObject& /*event*/) throw( RuntimeException, std::exception )
2826 {
2827 // not interested in ...
2828 }
2829
2830 void FormController::rowSetChanged(const EventObject& /*event*/) throw( RuntimeException, std::exception )
2831 {
2832 // not interested in ...
2833 }
2834
2835
2836 // XContainerListener
2837
2838 void SAL_CALL FormController::elementInserted(const ContainerEvent& evt) throw( RuntimeException, std::exception )
2839 {
2840 ::osl::MutexGuard aGuard( m_aMutex );
2841 impl_checkDisposed_throw();
2842
2843 Reference< XControl > xControl( evt.Element, UNO_QUERY );
2844 if ( !xControl.is() )
2845 return;
2846
2847 Reference< XFormComponent > xModel(xControl->getModel(), UNO_QUERY);
2848 if (xModel.is() && m_xModelAsIndex == xModel->getParent())
2849 {
2850 insertControl(xControl);
2851
2852 if ( m_aTabActivationTimer.IsActive() )
2853 m_aTabActivationTimer.Stop();
2854
2855 m_aTabActivationTimer.Start();
2856 }
2857 // are we in filtermode and a XModeSelector has inserted an element
2858 else if (m_bFiltering && Reference< XModeSelector > (evt.Source, UNO_QUERY).is())
2859 {
2860 xModel = Reference< XFormComponent > (evt.Source, UNO_QUERY);
2861 if (xModel.is() && m_xModelAsIndex == xModel->getParent())
2862 {
2863 Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY);
2864 if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
2865 {
2866 // does the model use a bound field ?
2867 Reference< XPropertySet > xField;
2868 xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
2869
2870 Reference< XTextComponent > xText(xControl, UNO_QUERY);
2871 // may we filter the field?
2872 if (xText.is() && xField.is() && ::comphelper::hasProperty(FM_PROP_SEARCHABLE, xField) &&
2873 ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_SEARCHABLE)))
2874 {
2875 m_aFilterComponents.push_back( xText );
2876 xText->addTextListener( this );
2877 }
2878 }
2879 }
2880 }
2881 }
2882
2883
2884 void SAL_CALL FormController::elementReplaced(const ContainerEvent& evt) throw( RuntimeException, std::exception )
2885 {
2886 // simulate an elementRemoved
2887 ContainerEvent aRemoveEvent( evt );
2888 aRemoveEvent.Element = evt.ReplacedElement;
2889 aRemoveEvent.ReplacedElement = Any();
2890 elementRemoved( aRemoveEvent );
2891
2892 // simulate an elementInserted
2893 ContainerEvent aInsertEvent( evt );
2894 aInsertEvent.ReplacedElement = Any();
2895 elementInserted( aInsertEvent );
2896 }
2897
2898
2899 void SAL_CALL FormController::elementRemoved(const ContainerEvent& evt) throw( RuntimeException, std::exception )
2900 {
2901 ::osl::MutexGuard aGuard( m_aMutex );
2902 impl_checkDisposed_throw();
2903
2904 Reference< XControl > xControl;
2905 evt.Element >>= xControl;
2906 if (!xControl.is())
2907 return;
2908
2909 Reference< XFormComponent > xModel(xControl->getModel(), UNO_QUERY);
2910 if (xModel.is() && m_xModelAsIndex == xModel->getParent())
2911 {
2912 removeControl(xControl);
2913 // TabOrder nicht neu berechnen, da das intern schon funktionieren muss!
2914 }
2915 // are we in filtermode and a XModeSelector has inserted an element
2916 else if (m_bFiltering && Reference< XModeSelector > (evt.Source, UNO_QUERY).is())
2917 {
2918 FilterComponents::iterator componentPos = ::std::find(
2919 m_aFilterComponents.begin(), m_aFilterComponents.end(), xControl );
2920 if ( componentPos != m_aFilterComponents.end() )
2921 m_aFilterComponents.erase( componentPos );
2922 }
2923 }
2924
2925
2926 Reference< XControl > FormController::isInList(const Reference< XWindowPeer > & xPeer) const
2927 {
2928 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
2929 const Reference< XControl >* pControls = m_aControls.getConstArray();
2930
2931 sal_uInt32 nCtrls = m_aControls.getLength();
2932 for ( sal_uInt32 n = 0; n < nCtrls && xPeer.is(); ++n, ++pControls )
2933 {
2934 if ( pControls->is() )
2935 {
2936 Reference< XVclWindowPeer > xCtrlPeer( (*pControls)->getPeer(), UNO_QUERY);
2937 if ( ( xCtrlPeer.get() == xPeer.get() ) || xCtrlPeer->isChild( xPeer ) )
2938 return *pControls;
2939 }
2940 }
2941 return Reference< XControl > ();
2942 }
2943
2944
2945 void FormController::activateFirst() throw( RuntimeException, std::exception )
2946 {
2947 ::osl::MutexGuard aGuard( m_aMutex );
2948 impl_checkDisposed_throw();
2949
2950 DBG_ASSERT(m_xTabController.is(), "FormController::activateFirst : invalid aggregate !");
2951 if (m_xTabController.is())
2952 m_xTabController->activateFirst();
2953 }
2954
2955
2956 void FormController::activateLast() throw( RuntimeException, std::exception )
2957 {
2958 ::osl::MutexGuard aGuard( m_aMutex );
2959 impl_checkDisposed_throw();
2960
2961 DBG_ASSERT(m_xTabController.is(), "FormController::activateLast : invalid aggregate !");
2962 if (m_xTabController.is())
2963 m_xTabController->activateLast();
2964 }
2965
2966 // XFormController
2967
2968 Reference< XFormOperations > SAL_CALL FormController::getFormOperations() throw (RuntimeException, std::exception)
2969 {
2970 ::osl::MutexGuard aGuard( m_aMutex );
2971 impl_checkDisposed_throw();
2972
2973 return m_xFormOperations;
2974 }
2975
2976
2977 Reference< XControl> SAL_CALL FormController::getCurrentControl(void) throw( RuntimeException, std::exception )
2978 {
2979 ::osl::MutexGuard aGuard( m_aMutex );
2980 impl_checkDisposed_throw();
2981 return m_xCurrentControl;
2982 }
2983
2984
2985 void SAL_CALL FormController::addActivateListener(const Reference< XFormControllerListener > & l) throw( RuntimeException, std::exception )
2986 {
2987 ::osl::MutexGuard aGuard( m_aMutex );
2988 impl_checkDisposed_throw();
2989 m_aActivateListeners.addInterface(l);
2990 }
2991
2992 void SAL_CALL FormController::removeActivateListener(const Reference< XFormControllerListener > & l) throw( RuntimeException, std::exception )
2993 {
2994 ::osl::MutexGuard aGuard( m_aMutex );
2995 impl_checkDisposed_throw();
2996 m_aActivateListeners.removeInterface(l);
2997 }
2998
2999
3000 void SAL_CALL FormController::addChildController( const Reference< XFormController >& _ChildController ) throw( RuntimeException, IllegalArgumentException, std::exception )
3001 {
3002 ::osl::MutexGuard aGuard( m_aMutex );
3003 impl_checkDisposed_throw();
3004
3005 if ( !_ChildController.is() )
3006 throw IllegalArgumentException( OUString(), *this, 1 );
3007 // TODO: (localized) error message
3008
3009 // the parent of our (to-be-)child must be our own model
3010 Reference< XFormComponent > xFormOfChild( _ChildController->getModel(), UNO_QUERY );
3011 if ( !xFormOfChild.is() )
3012 throw IllegalArgumentException( OUString(), *this, 1 );
3013 // TODO: (localized) error message
3014
3015 if ( xFormOfChild->getParent() != m_xModelAsIndex )
3016 throw IllegalArgumentException( OUString(), *this, 1 );
3017 // TODO: (localized) error message
3018
3019 m_aChildren.push_back( _ChildController );
3020 _ChildController->setParent( *this );
3021
3022 // search the position of the model within the form
3023 sal_uInt32 nPos = m_xModelAsIndex->getCount();
3024 Reference< XFormComponent > xTemp;
3025 for( ; nPos; )
3026 {
3027 m_xModelAsIndex->getByIndex(--nPos) >>= xTemp;
3028 if ( xFormOfChild == xTemp )
3029 {
3030 m_xModelAsManager->attach( nPos, _ChildController, makeAny( _ChildController) );
3031 break;
3032 }
3033 }
3034 }
3035
3036
3037 Reference< XFormControllerContext > SAL_CALL FormController::getContext() throw (RuntimeException, std::exception)
3038 {
3039 ::osl::MutexGuard aGuard( m_aMutex );
3040 impl_checkDisposed_throw();
3041 return m_xFormControllerContext;
3042 }
3043
3044
3045 void SAL_CALL FormController::setContext( const Reference< XFormControllerContext >& _context ) throw (RuntimeException, std::exception)
3046 {
3047 ::osl::MutexGuard aGuard( m_aMutex );
3048 impl_checkDisposed_throw();
3049 m_xFormControllerContext = _context;
3050 }
3051
3052
3053 Reference< XInteractionHandler > SAL_CALL FormController::getInteractionHandler() throw (RuntimeException, std::exception)
3054 {
3055 ::osl::MutexGuard aGuard( m_aMutex );
3056 impl_checkDisposed_throw();
3057 return m_xInteractionHandler;
3058 }
3059
3060
3061 void SAL_CALL FormController::setInteractionHandler( const Reference< XInteractionHandler >& _interactionHandler ) throw (RuntimeException, std::exception)
3062 {
3063 ::osl::MutexGuard aGuard( m_aMutex );
3064 impl_checkDisposed_throw();
3065 m_xInteractionHandler = _interactionHandler;
3066 }
3067
3068
3069 void FormController::setFilter(::std::vector<FmFieldInfo>& rFieldInfos)
3070 {
3071 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
3072 // create the composer
3073 Reference< XRowSet > xForm(m_xModelAsIndex, UNO_QUERY);
3074 Reference< XConnection > xConnection(OStaticDataAccessTools().getRowSetConnection(xForm));
3075 if (xForm.is())
3076 {
3077 try
3078 {
3079 Reference< XMultiServiceFactory > xFactory( xConnection, UNO_QUERY_THROW );
3080 m_xComposer.set(
3081 xFactory->createInstance("com.sun.star.sdb.SingleSelectQueryComposer"),
3082 UNO_QUERY_THROW );
3083
3084 Reference< XPropertySet > xSet( xForm, UNO_QUERY );
3085 OUString sStatement = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_ACTIVECOMMAND ) );
3086 OUString sFilter = ::comphelper::getString( xSet->getPropertyValue( FM_PROP_FILTER ) );
3087 m_xComposer->setElementaryQuery( sStatement );
3088 m_xComposer->setFilter( sFilter );
3089 }
3090 catch( const Exception& )
3091 {
3092 DBG_UNHANDLED_EXCEPTION();
3093 }
3094 }
3095
3096 if (m_xComposer.is())
3097 {
3098 Sequence< Sequence < PropertyValue > > aFilterRows = m_xComposer->getStructuredFilter();
3099
3100 // ok, we receive the list of filters as sequence of fieldnames, value
3101 // now we have to transform the fieldname into UI names, that could be a label of the field or
3102 // a aliasname or the fieldname itself
3103
3104 // first adjust the field names if necessary
3105 Reference< XNameAccess > xQueryColumns =
3106 Reference< XColumnsSupplier >( m_xComposer, UNO_QUERY_THROW )->getColumns();
3107
3108 for (::std::vector<FmFieldInfo>::iterator iter = rFieldInfos.begin();
3109 iter != rFieldInfos.end(); ++iter)
3110 {
3111 if ( xQueryColumns->hasByName((*iter).aFieldName) )
3112 {
3113 if ( (xQueryColumns->getByName((*iter).aFieldName) >>= (*iter).xField) && (*iter).xField.is() )
3114 (*iter).xField->getPropertyValue(FM_PROP_REALNAME) >>= (*iter).aFieldName;
3115 }
3116 }
3117
3118 Reference< XDatabaseMetaData> xMetaData(xConnection->getMetaData());
3119 // now transfer the filters into Value/TextComponent pairs
3120 ::comphelper::UStringMixEqual aCompare(xMetaData->storesMixedCaseQuotedIdentifiers());
3121
3122 // need to parse criteria localized
3123 OStaticDataAccessTools aStaticTools;
3124 Reference< XNumberFormatsSupplier> xFormatSupplier( aStaticTools.getNumberFormats(xConnection, true));
3125 Reference< XNumberFormatter> xFormatter = NumberFormatter::create(m_xComponentContext);
3126 xFormatter->attachNumberFormatsSupplier(xFormatSupplier);
3127 Locale aAppLocale = Application::GetSettings().GetUILanguageTag().getLocale();
3128 const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetUILocaleDataWrapper() );
3129 /* FIXME: casting this to sal_Char is plain wrong and of course only
3130 * works for ASCII separators, but
3131 * xParseNode->parseNodeToPredicateStr() expects a sal_Char. Fix it
3132 * there. */
3133 sal_Char cDecimalSeparator = (sal_Char)rLocaleWrapper.getNumDecimalSep()[0];
3134 SAL_WARN_IF( (sal_Unicode)cDecimalSeparator != rLocaleWrapper.getNumDecimalSep()[0],
3135 "svx.form", "FormController::setFilter: wrong cast of decimal separator to sal_Char!");
3136
3137 // retrieving the filter
3138 const Sequence < PropertyValue >* pRow = aFilterRows.getConstArray();
3139 for (sal_Int32 i = 0, nLen = aFilterRows.getLength(); i < nLen; ++i)
3140 {
3141 FmFilterRow aRow;
3142
3143 // search a field for the given name
3144 const PropertyValue* pRefValues = pRow[i].getConstArray();
3145 for (sal_Int32 j = 0, nLen1 = pRow[i].getLength(); j < nLen1; j++)
3146 {
3147 // look for the text component
3148 Reference< XPropertySet > xField;
3149 try
3150 {
3151 Reference< XPropertySet > xSet;
3152 OUString aRealName;
3153
3154 // first look with the given name
3155 if (xQueryColumns->hasByName(pRefValues[j].Name))
3156 {
3157 xQueryColumns->getByName(pRefValues[j].Name) >>= xSet;
3158
3159 // get the RealName
3160 xSet->getPropertyValue("RealName") >>= aRealName;
3161
3162 // compare the condition field name and the RealName
3163 if (aCompare(aRealName, pRefValues[j].Name))
3164 xField = xSet;
3165 }
3166 if (!xField.is())
3167 {
3168 // no we have to check every column to find the realname
3169 Reference< XIndexAccess > xColumnsByIndex(xQueryColumns, UNO_QUERY);
3170 for (sal_Int32 n = 0, nCount = xColumnsByIndex->getCount(); n < nCount; n++)
3171 {
3172 xColumnsByIndex->getByIndex(n) >>= xSet;
3173 xSet->getPropertyValue("RealName") >>= aRealName;
3174 if (aCompare(aRealName, pRefValues[j].Name))
3175 {
3176 // get the column by its alias
3177 xField = xSet;
3178 break;
3179 }
3180 }
3181 }
3182 if (!xField.is())
3183 continue;
3184 }
3185 catch (const Exception&)
3186 {
3187 continue;
3188 }
3189
3190 // find the text component
3191 for (::std::vector<FmFieldInfo>::iterator iter = rFieldInfos.begin();
3192 iter != rFieldInfos.end(); ++iter)
3193 {
3194 // we found the field so insert a new entry to the filter row
3195 if ((*iter).xField == xField)
3196 {
3197 // do we already have the control ?
3198 if (aRow.find((*iter).xText) != aRow.end())
3199 {
3200 OUString aCompText = aRow[(*iter).xText];
3201 aCompText += " ";
3202 OString aVal = m_xParser->getContext().getIntlKeywordAscii(IParseContext::KEY_AND);
3203 aCompText += OUString(aVal.getStr(),aVal.getLength(),RTL_TEXTENCODING_ASCII_US);
3204 aCompText += " ";
3205 aCompText += ::comphelper::getString(pRefValues[j].Value);
3206 aRow[(*iter).xText] = aCompText;
3207 }
3208 else
3209 {
3210 OUString sPredicate,sErrorMsg;
3211 pRefValues[j].Value >>= sPredicate;
3212 ::rtl::Reference< ISQLParseNode > xParseNode = predicateTree(sErrorMsg, sPredicate, xFormatter, xField);
3213 if ( xParseNode.is() )
3214 {
3215 OUString sCriteria;
3216 xParseNode->parseNodeToPredicateStr( sCriteria
3217 ,xConnection
3218 ,xFormatter
3219 ,xField
3220 ,OUString()
3221 ,aAppLocale
3222 ,cDecimalSeparator
3223 ,getParseContext());
3224 aRow[(*iter).xText] = sCriteria;
3225 }
3226 }
3227 }
3228 }
3229 }
3230
3231 if (aRow.empty())
3232 continue;
3233
3234 impl_addFilterRow( aRow );
3235 }
3236 }
3237
3238 // now set the filter controls
3239 for ( ::std::vector<FmFieldInfo>::iterator field = rFieldInfos.begin();
3240 field != rFieldInfos.end();
3241 ++field
3242 )
3243 {
3244 m_aFilterComponents.push_back( field->xText );
3245 }
3246 }
3247
3248
3249 void FormController::startFiltering()
3250 {
3251 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
3252
3253 OStaticDataAccessTools aStaticTools;
3254 Reference< XConnection > xConnection( aStaticTools.getRowSetConnection( Reference< XRowSet >( m_xModelAsIndex, UNO_QUERY ) ) );
3255 if ( !xConnection.is() )
3256 // nothing to do - can't filter a form which is not connected
3257 return;
3258
3259 // stop listening for controls
3260 if (isListeningForChanges())
3261 stopListening();
3262
3263 m_bFiltering = true;
3264
3265 // as we don't want new controls to be attached to the scripting environment
3266 // we change attach flags
3267 m_bAttachEvents = false;
3268
3269 // Austauschen der Kontrols fuer das aktuelle Formular
3270 Sequence< Reference< XControl > > aControlsCopy( m_aControls );
3271 const Reference< XControl >* pControls = aControlsCopy.getConstArray();
3272 sal_Int32 nControlCount = aControlsCopy.getLength();
3273
3274 // the control we have to activate after replacement
3275 Reference< XDatabaseMetaData > xMetaData(xConnection->getMetaData());
3276 Reference< XNumberFormatsSupplier > xFormatSupplier = aStaticTools.getNumberFormats(xConnection, true);
3277 Reference< XNumberFormatter > xFormatter = NumberFormatter::create(m_xComponentContext);
3278 xFormatter->attachNumberFormatsSupplier(xFormatSupplier);
3279
3280 // structure for storing the field info
3281 ::std::vector<FmFieldInfo> aFieldInfos;
3282
3283 for (sal_Int32 i = nControlCount; i > 0;)
3284 {
3285 Reference< XControl > xControl = pControls[--i];
3286 if (xControl.is())
3287 {
3288 // no events for the control anymore
3289 removeFromEventAttacher(xControl);
3290
3291 // do we have a mode selector
3292 Reference< XModeSelector > xSelector(xControl, UNO_QUERY);
3293 if (xSelector.is())
3294 {
3295 xSelector->setMode( OUString( "FilterMode" ) );
3296
3297 // listening for new controls of the selector
3298 Reference< XContainer > xContainer(xSelector, UNO_QUERY);
3299 if (xContainer.is())
3300 xContainer->addContainerListener(this);
3301
3302 Reference< XEnumerationAccess > xElementAccess(xSelector, UNO_QUERY);
3303 if (xElementAccess.is())
3304 {
3305 Reference< XEnumeration > xEnumeration(xElementAccess->createEnumeration());
3306 Reference< XControl > xSubControl;
3307 while (xEnumeration->hasMoreElements())
3308 {
3309 xEnumeration->nextElement() >>= xSubControl;
3310 if (xSubControl.is())
3311 {
3312 Reference< XPropertySet > xSet(xSubControl->getModel(), UNO_QUERY);
3313 if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
3314 {
3315 // does the model use a bound field ?
3316 Reference< XPropertySet > xField;
3317 xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
3318
3319 Reference< XTextComponent > xText(xSubControl, UNO_QUERY);
3320 // may we filter the field?
3321 if (xText.is() && xField.is() && ::comphelper::hasProperty(FM_PROP_SEARCHABLE, xField) &&
3322 ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_SEARCHABLE)))
3323 {
3324 aFieldInfos.push_back(FmFieldInfo(xField, xText));
3325 xText->addTextListener(this);
3326 }
3327 }
3328 }
3329 }
3330 }
3331 continue;
3332 }
3333
3334 Reference< XPropertySet > xModel( xControl->getModel(), UNO_QUERY );
3335 if (xModel.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xModel))
3336 {
3337 // does the model use a bound field ?
3338 Any aVal = xModel->getPropertyValue(FM_PROP_BOUNDFIELD);
3339 Reference< XPropertySet > xField;
3340 aVal >>= xField;
3341
3342 // may we filter the field?
3343
3344 if ( xField.is()
3345 && ::comphelper::hasProperty( FM_PROP_SEARCHABLE, xField )
3346 && ::comphelper::getBOOL( xField->getPropertyValue( FM_PROP_SEARCHABLE ) )
3347 )
3348 {
3349 // create a filter control
3350 Reference< XControl > xFilterControl = form::control::FilterControl::createWithFormat(
3351 m_xComponentContext,
3352 VCLUnoHelper::GetInterface( getDialogParentWindow() ),
3353 xFormatter,
3354 xModel);
3355
3356 if ( replaceControl( xControl, xFilterControl ) )
3357 {
3358 Reference< XTextComponent > xFilterText( xFilterControl, UNO_QUERY );
3359 aFieldInfos.push_back( FmFieldInfo( xField, xFilterText ) );
3360 xFilterText->addTextListener(this);
3361 }
3362 }
3363 }
3364 else
3365 {
3366 // abmelden vom EventManager
3367 }
3368 }
3369 }
3370
3371 // we have all filter controls now, so the next step is to read the filters from the form
3372 // resolve all aliases and set the current filter to the according structure
3373 setFilter(aFieldInfos);
3374
3375 Reference< XPropertySet > xSet( m_xModelAsIndex, UNO_QUERY );
3376 if ( xSet.is() )
3377 stopFormListening( xSet, true );
3378
3379 impl_setTextOnAllFilter_throw();
3380
3381 // lock all controls which are not used for filtering
3382 m_bLocked = determineLockState();
3383 setLocks();
3384 m_bAttachEvents = true;
3385 }
3386
3387
3388 void FormController::stopFiltering()
3389 {
3390 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
3391 if ( !m_bFiltering ) // #104693# OJ
3392 { // nothing to do
3393 return;
3394 }
3395
3396 m_bFiltering = false;
3397 m_bDetachEvents = false;
3398
3399 ::comphelper::disposeComponent(m_xComposer);
3400
3401 // Austauschen der Kontrols fuer das aktuelle Formular
3402 Sequence< Reference< XControl > > aControlsCopy( m_aControls );
3403 const Reference< XControl > * pControls = aControlsCopy.getConstArray();
3404 sal_Int32 nControlCount = aControlsCopy.getLength();
3405
3406 // clear the filter control map
3407 ::std::for_each( m_aFilterComponents.begin(), m_aFilterComponents.end(), RemoveComponentTextListener( this ) );
3408 m_aFilterComponents.clear();
3409
3410 for ( sal_Int32 i = nControlCount; i > 0; )
3411 {
3412 Reference< XControl > xControl = pControls[--i];
3413 if (xControl.is())
3414 {
3415 // now enable eventhandling again
3416 addToEventAttacher(xControl);
3417
3418 Reference< XModeSelector > xSelector(xControl, UNO_QUERY);
3419 if (xSelector.is())
3420 {
3421 xSelector->setMode( OUString( "DataMode" ) );
3422
3423 // listening for new controls of the selector
3424 Reference< XContainer > xContainer(xSelector, UNO_QUERY);
3425 if (xContainer.is())
3426 xContainer->removeContainerListener(this);
3427 continue;
3428 }
3429
3430 Reference< XPropertySet > xSet(xControl->getModel(), UNO_QUERY);
3431 if (xSet.is() && ::comphelper::hasProperty(FM_PROP_BOUNDFIELD, xSet))
3432 {
3433 // does the model use a bound field ?
3434 Reference< XPropertySet > xField;
3435 xSet->getPropertyValue(FM_PROP_BOUNDFIELD) >>= xField;
3436
3437 // may we filter the field?
3438 if ( xField.is()
3439 && ::comphelper::hasProperty( FM_PROP_SEARCHABLE, xField )
3440 && ::comphelper::getBOOL( xField->getPropertyValue( FM_PROP_SEARCHABLE ) )
3441 )
3442 {
3443 OUString sServiceName;
3444 OSL_VERIFY( xSet->getPropertyValue( FM_PROP_DEFAULTCONTROL ) >>= sServiceName );
3445 Reference< XControl > xNewControl( m_xComponentContext->getServiceManager()->createInstanceWithContext( sServiceName, m_xComponentContext ), UNO_QUERY );
3446 replaceControl( xControl, xNewControl );
3447 }
3448 }
3449 }
3450 }
3451
3452 Reference< XPropertySet > xSet( m_xModelAsIndex, UNO_QUERY );
3453 if ( xSet.is() )
3454 startFormListening( xSet, true );
3455
3456 m_bDetachEvents = true;
3457
3458 m_aFilterRows.clear();
3459 m_nCurrentFilterPosition = -1;
3460
3461 // release the locks if possible
3462 // lock all controls which are not used for filtering
3463 m_bLocked = determineLockState();
3464 setLocks();
3465
3466 // restart listening for control modifications
3467 if (isListeningForChanges())
3468 startListening();
3469 }
3470
3471 // XModeSelector
3472
3473 void FormController::setMode(const OUString& Mode) throw( NoSupportException, RuntimeException, std::exception )
3474 {
3475 ::osl::MutexGuard aGuard( m_aMutex );
3476 impl_checkDisposed_throw();
3477
3478 if (!supportsMode(Mode))
3479 throw NoSupportException();
3480
3481 if (Mode == m_aMode)
3482 return;
3483
3484 m_aMode = Mode;
3485
3486 if ( Mode == "FilterMode" )
3487 startFiltering();
3488 else
3489 stopFiltering();
3490
3491 for (FmFormControllers::const_iterator i = m_aChildren.begin();
3492 i != m_aChildren.end(); ++i)
3493 {
3494 Reference< XModeSelector > xMode(*i, UNO_QUERY);
3495 if ( xMode.is() )
3496 xMode->setMode(Mode);
3497 }
3498 }
3499
3500
3501 OUString SAL_CALL FormController::getMode(void) throw( RuntimeException, std::exception )
3502 {
3503 ::osl::MutexGuard aGuard( m_aMutex );
3504 impl_checkDisposed_throw();
3505
3506 return m_aMode;
3507 }
3508
3509
3510 Sequence< OUString > SAL_CALL FormController::getSupportedModes(void) throw( RuntimeException, std::exception )
3511 {
3512 ::osl::MutexGuard aGuard( m_aMutex );
3513 impl_checkDisposed_throw();
3514
3515 static Sequence< OUString > aModes;
3516 if (!aModes.getLength())
3517 {
3518 aModes.realloc(2);
3519 aModes[0] = "DataMode";
3520 aModes[1] = "FilterMode";
3521 }
3522 return aModes;
3523 }
3524
3525
3526 sal_Bool SAL_CALL FormController::supportsMode(const OUString& Mode) throw( RuntimeException, std::exception )
3527 {
3528 ::osl::MutexGuard aGuard( m_aMutex );
3529 impl_checkDisposed_throw();
3530
3531 Sequence< OUString > aModes(getSupportedModes());
3532 const OUString* pModes = aModes.getConstArray();
3533 for (sal_Int32 i = aModes.getLength(); i > 0; )
3534 {
3535 if (pModes[--i] == Mode)
3536 return sal_True;
3537 }
3538 return sal_False;
3539 }
3540
3541
3542 Window* FormController::getDialogParentWindow()
3543 {
3544 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
3545 Window* pParentWindow = NULL;
3546 try
3547 {
3548 Reference< XControl > xContainerControl( getContainer(), UNO_QUERY_THROW );
3549 Reference< XWindowPeer > xContainerPeer( xContainerControl->getPeer(), UNO_QUERY_THROW );
3550 pParentWindow = VCLUnoHelper::GetWindow( xContainerPeer );
3551 }
3552 catch( const Exception& )
3553 {
3554 DBG_UNHANDLED_EXCEPTION();
3555 }
3556 return pParentWindow;
3557 }
3558
3559 bool FormController::checkFormComponentValidity( OUString& /* [out] */ _rFirstInvalidityExplanation, Reference< XControlModel >& /* [out] */ _rxFirstInvalidModel ) SAL_THROW(())
3560 {
3561 try
3562 {
3563 Reference< XEnumerationAccess > xControlEnumAcc( getModel(), UNO_QUERY );
3564 Reference< XEnumeration > xControlEnumeration;
3565 if ( xControlEnumAcc.is() )
3566 xControlEnumeration = xControlEnumAcc->createEnumeration();
3567 OSL_ENSURE( xControlEnumeration.is(), "FormController::checkFormComponentValidity: cannot enumerate the controls!" );
3568 if ( !xControlEnumeration.is() )
3569 // assume all valid
3570 return true;
3571
3572 Reference< XValidatableFormComponent > xValidatable;
3573 while ( xControlEnumeration->hasMoreElements() )
3574 {
3575 if ( !( xControlEnumeration->nextElement() >>= xValidatable ) )
3576 // control does not support validation
3577 continue;
3578
3579 if ( xValidatable->isValid() )
3580 continue;
3581
3582 Reference< XValidator > xValidator( xValidatable->getValidator() );
3583 OSL_ENSURE( xValidator.is(), "FormController::checkFormComponentValidity: invalid, but no validator?" );
3584 if ( !xValidator.is() )
3585 // this violates the interface definition of css.form.validation.XValidatableFormComponent ...
3586 continue;
3587
3588 _rFirstInvalidityExplanation = xValidator->explainInvalid( xValidatable->getCurrentValue() );
3589 _rxFirstInvalidModel = _rxFirstInvalidModel.query( xValidatable );
3590 return false;
3591 }
3592 }
3593 catch( const Exception& )
3594 {
3595 DBG_UNHANDLED_EXCEPTION();
3596 }
3597 return true;
3598 }
3599
3600
3601 Reference< XControl > FormController::locateControl( const Reference< XControlModel >& _rxModel ) SAL_THROW(())
3602 {
3603 try
3604 {
3605 Sequence< Reference< XControl > > aControls( getControls() );
3606 const Reference< XControl >* pControls = aControls.getConstArray();
3607 const Reference< XControl >* pControlsEnd = aControls.getConstArray() + aControls.getLength();
3608
3609 for ( ; pControls != pControlsEnd; ++pControls )
3610 {
3611 OSL_ENSURE( pControls->is(), "FormController::locateControl: NULL-control?" );
3612 if ( pControls->is() )
3613 {
3614 if ( ( *pControls)->getModel() == _rxModel )
3615 return *pControls;
3616 }
3617 }
3618 OSL_FAIL( "FormController::locateControl: did not find a control for this model!" );
3619 }
3620 catch( const Exception& )
3621 {
3622 DBG_UNHANDLED_EXCEPTION();
3623 }
3624 return NULL;
3625 }
3626
3627
3628 namespace
3629 {
3630 void displayErrorSetFocus( const OUString& _rMessage, const Reference< XControl >& _rxFocusControl, Window* _pDialogParent )
3631 {
3632 SQLContext aError;
3633 aError.Message = SVX_RESSTR(RID_STR_WRITEERROR);
3634 aError.Details = _rMessage;
3635 displayException( aError, _pDialogParent );
3636
3637 if ( _rxFocusControl.is() )
3638 {
3639 Reference< XWindow > xControlWindow( _rxFocusControl, UNO_QUERY );
3640 OSL_ENSURE( xControlWindow.is(), "displayErrorSetFocus: invalid control!" );
3641 if ( xControlWindow.is() )
3642 xControlWindow->setFocus();
3643 }
3644 }
3645
3646 bool lcl_shouldValidateRequiredFields_nothrow( const Reference< XInterface >& _rxForm )
3647 {
3648 try
3649 {
3650 static OUString s_sFormsCheckRequiredFields( "FormsCheckRequiredFields" );
3651
3652 // first, check whether the form has a property telling us the answer
3653 // this allows people to use the XPropertyContainer interface of a form to control
3654 // the behaviour on a per-form basis.
3655 Reference< XPropertySet > xFormProps( _rxForm, UNO_QUERY_THROW );
3656 Reference< XPropertySetInfo > xPSI( xFormProps->getPropertySetInfo() );
3657 if ( xPSI->hasPropertyByName( s_sFormsCheckRequiredFields ) )
3658 {
3659 bool bShouldValidate = true;
3660 OSL_VERIFY( xFormProps->getPropertyValue( s_sFormsCheckRequiredFields ) >>= bShouldValidate );
3661 return bShouldValidate;
3662 }
3663
3664 // next, check the data source which created the connection
3665 Reference< XChild > xConnectionAsChild( xFormProps->getPropertyValue( FM_PROP_ACTIVE_CONNECTION ), UNO_QUERY_THROW );
3666 Reference< XPropertySet > xDataSource( xConnectionAsChild->getParent(), UNO_QUERY );
3667 if ( !xDataSource.is() )
3668 // seldom (but possible): this is not a connection created by a data source
3669 return true;
3670
3671 Reference< XPropertySet > xDataSourceSettings(
3672 xDataSource->getPropertyValue("Settings"),
3673 UNO_QUERY_THROW );
3674
3675 bool bShouldValidate = true;
3676 OSL_VERIFY( xDataSourceSettings->getPropertyValue( s_sFormsCheckRequiredFields ) >>= bShouldValidate );
3677 return bShouldValidate;
3678 }
3679 catch( const Exception& )
3680 {
3681 DBG_UNHANDLED_EXCEPTION();
3682 }
3683
3684 return true;
3685 }
3686 }
3687
3688 // XRowSetApproveListener
3689
3690 sal_Bool SAL_CALL FormController::approveRowChange(const RowChangeEvent& _rEvent) throw( RuntimeException, std::exception )
3691 {
3692 ::osl::ClearableMutexGuard aGuard( m_aMutex );
3693 impl_checkDisposed_throw();
3694
3695 ::cppu::OInterfaceIteratorHelper aIter(m_aRowSetApproveListeners);
3696 bool bValid = true;
3697 if (aIter.hasMoreElements())
3698 {
3699 RowChangeEvent aEvt( _rEvent );
3700 aEvt.Source = *this;
3701 bValid = ((XRowSetApproveListener*)aIter.next())->approveRowChange(aEvt);
3702 }
3703
3704 if ( !bValid )
3705 return bValid;
3706
3707 if ( ( _rEvent.Action != RowChangeAction::INSERT )
3708 && ( _rEvent.Action != RowChangeAction::UPDATE )
3709 )
3710 return bValid;
3711
3712 // if some of the control models are bound to validators, check them
3713 OUString sInvalidityExplanation;
3714 Reference< XControlModel > xInvalidModel;
3715 if ( !checkFormComponentValidity( sInvalidityExplanation, xInvalidModel ) )
3716 {
3717 Reference< XControl > xControl( locateControl( xInvalidModel ) );
3718 aGuard.clear();
3719 displayErrorSetFocus( sInvalidityExplanation, xControl, getDialogParentWindow() );
3720 return false;
3721 }
3722
3723 // check values on NULL and required flag
3724 if ( !lcl_shouldValidateRequiredFields_nothrow( _rEvent.Source ) )
3725 return sal_True;
3726
3727 OSL_ENSURE( m_pColumnInfoCache.get(), "FormController::approveRowChange: no column infos!" );
3728 if ( !m_pColumnInfoCache.get() )
3729 return sal_True;
3730
3731 try
3732 {
3733 if ( !m_pColumnInfoCache->controlsInitialized() )
3734 m_pColumnInfoCache->initializeControls( getControls() );
3735
3736 size_t colCount = m_pColumnInfoCache->getColumnCount();
3737 for ( size_t col = 0; col < colCount; ++col )
3738 {
3739 const ColumnInfo& rColInfo = m_pColumnInfoCache->getColumnInfo( col );
3740 if ( rColInfo.nNullable != ColumnValue::NO_NULLS )
3741 continue;
3742
3743 if ( rColInfo.bAutoIncrement )
3744 continue;
3745
3746 if ( rColInfo.bReadOnly )
3747 continue;
3748
3749 if ( !rColInfo.xFirstControlWithInputRequired.is() && !rColInfo.xFirstGridWithInputRequiredColumn.is() )
3750 continue;
3751
3752 // TODO: in case of binary fields, this "getString" below is extremely expensive
3753 if ( !rColInfo.xColumn->getString().isEmpty() || !rColInfo.xColumn->wasNull() )
3754 continue;
3755
3756 OUString sMessage( SVX_RESSTR( RID_ERR_FIELDREQUIRED ) );
3757 sMessage = sMessage.replaceFirst( "#", rColInfo.sName );
3758
3759 // the control to focus
3760 Reference< XControl > xControl( rColInfo.xFirstControlWithInputRequired );
3761 if ( !xControl.is() )
3762 xControl.set( rColInfo.xFirstGridWithInputRequiredColumn, UNO_QUERY );
3763
3764 aGuard.clear();
3765 displayErrorSetFocus( sMessage, rColInfo.xFirstControlWithInputRequired, getDialogParentWindow() );
3766 return sal_False;
3767 }
3768 }
3769 catch( const Exception& )
3770 {
3771 DBG_UNHANDLED_EXCEPTION();
3772 }
3773
3774 return true;
3775 }
3776
3777
3778 sal_Bool SAL_CALL FormController::approveCursorMove(const EventObject& event) throw( RuntimeException, std::exception )
3779 {
3780 ::osl::MutexGuard aGuard( m_aMutex );
3781 impl_checkDisposed_throw();
3782
3783 ::cppu::OInterfaceIteratorHelper aIter(m_aRowSetApproveListeners);
3784 if (aIter.hasMoreElements())
3785 {
3786 EventObject aEvt(event);
3787 aEvt.Source = *this;
3788 return ((XRowSetApproveListener*)aIter.next())->approveCursorMove(aEvt);
3789 }
3790
3791 return sal_True;
3792 }
3793
3794
3795 sal_Bool SAL_CALL FormController::approveRowSetChange(const EventObject& event) throw( RuntimeException, std::exception )
3796 {
3797 ::osl::MutexGuard aGuard( m_aMutex );
3798 impl_checkDisposed_throw();
3799
3800 ::cppu::OInterfaceIteratorHelper aIter(m_aRowSetApproveListeners);
3801 if (aIter.hasMoreElements())
3802 {
3803 EventObject aEvt(event);
3804 aEvt.Source = *this;
3805 return ((XRowSetApproveListener*)aIter.next())->approveRowSetChange(aEvt);
3806 }
3807
3808 return sal_True;
3809 }
3810
3811 // XRowSetApproveBroadcaster
3812
3813 void SAL_CALL FormController::addRowSetApproveListener(const Reference< XRowSetApproveListener > & _rxListener) throw( RuntimeException, std::exception )
3814 {
3815 ::osl::MutexGuard aGuard( m_aMutex );
3816 impl_checkDisposed_throw();
3817
3818 m_aRowSetApproveListeners.addInterface(_rxListener);
3819 }
3820
3821
3822 void SAL_CALL FormController::removeRowSetApproveListener(const Reference< XRowSetApproveListener > & _rxListener) throw( RuntimeException, std::exception )
3823 {
3824 ::osl::MutexGuard aGuard( m_aMutex );
3825 impl_checkDisposed_throw();
3826
3827 m_aRowSetApproveListeners.removeInterface(_rxListener);
3828 }
3829
3830 // XErrorListener
3831
3832 void SAL_CALL FormController::errorOccured(const SQLErrorEvent& aEvent) throw( RuntimeException, std::exception )
3833 {
3834 ::osl::ClearableMutexGuard aGuard( m_aMutex );
3835 impl_checkDisposed_throw();
3836
3837 ::cppu::OInterfaceIteratorHelper aIter(m_aErrorListeners);
3838 if (aIter.hasMoreElements())
3839 {
3840 SQLErrorEvent aEvt(aEvent);
3841 aEvt.Source = *this;
3842 ((XSQLErrorListener*)aIter.next())->errorOccured(aEvt);
3843 }
3844 else
3845 {
3846 aGuard.clear();
3847 displayException( aEvent );
3848 }
3849 }
3850
3851 // XErrorBroadcaster
3852
3853 void SAL_CALL FormController::addSQLErrorListener(const Reference< XSQLErrorListener > & aListener) throw( RuntimeException, std::exception )
3854 {
3855 ::osl::MutexGuard aGuard( m_aMutex );
3856 impl_checkDisposed_throw();
3857
3858 m_aErrorListeners.addInterface(aListener);
3859 }
3860
3861
3862 void SAL_CALL FormController::removeSQLErrorListener(const Reference< XSQLErrorListener > & aListener) throw( RuntimeException, std::exception )
3863 {
3864 ::osl::MutexGuard aGuard( m_aMutex );
3865 impl_checkDisposed_throw();
3866
3867 m_aErrorListeners.removeInterface(aListener);
3868 }
3869
3870 // XDatabaseParameterBroadcaster2
3871
3872 void SAL_CALL FormController::addDatabaseParameterListener(const Reference< XDatabaseParameterListener > & aListener) throw( RuntimeException, std::exception )
3873 {
3874 ::osl::MutexGuard aGuard( m_aMutex );
3875 impl_checkDisposed_throw();
3876
3877 m_aParameterListeners.addInterface(aListener);
3878 }
3879
3880
3881 void SAL_CALL FormController::removeDatabaseParameterListener(const Reference< XDatabaseParameterListener > & aListener) throw( RuntimeException, std::exception )
3882 {
3883 ::osl::MutexGuard aGuard( m_aMutex );
3884 impl_checkDisposed_throw();
3885
3886 m_aParameterListeners.removeInterface(aListener);
3887 }
3888
3889 // XDatabaseParameterBroadcaster
3890
3891 void SAL_CALL FormController::addParameterListener(const Reference< XDatabaseParameterListener > & aListener) throw( RuntimeException, std::exception )
3892 {
3893 FormController::addDatabaseParameterListener( aListener );
3894 }
3895
3896
3897 void SAL_CALL FormController::removeParameterListener(const Reference< XDatabaseParameterListener > & aListener) throw( RuntimeException, std::exception )
3898 {
3899 FormController::removeDatabaseParameterListener( aListener );
3900 }
3901
3902 // XDatabaseParameterListener
3903
3904 sal_Bool SAL_CALL FormController::approveParameter(const DatabaseParameterEvent& aEvent) throw( RuntimeException, std::exception )
3905 {
3906 SolarMutexGuard aSolarGuard;
3907 ::osl::MutexGuard aGuard( m_aMutex );
3908 impl_checkDisposed_throw();
3909
3910 ::cppu::OInterfaceIteratorHelper aIter(m_aParameterListeners);
3911 if (aIter.hasMoreElements())
3912 {
3913 DatabaseParameterEvent aEvt(aEvent);
3914 aEvt.Source = *this;
3915 return ((XDatabaseParameterListener*)aIter.next())->approveParameter(aEvt);
3916 }
3917 else
3918 {
3919 // default handling: instantiate an interaction handler and let it handle the parameter request
3920 try
3921 {
3922 if ( !ensureInteractionHandler() )
3923 return sal_False;
3924
3925 // two continuations allowed: OK and Cancel
3926 OParameterContinuation* pParamValues = new OParameterContinuation;
3927 OInteractionAbort* pAbort = new OInteractionAbort;
3928 // the request
3929 ParametersRequest aRequest;
3930 aRequest.Parameters = aEvent.Parameters;
3931 aRequest.Connection = OStaticDataAccessTools().getRowSetConnection(Reference< XRowSet >(aEvent.Source, UNO_QUERY));
3932 OInteractionRequest* pParamRequest = new OInteractionRequest(makeAny(aRequest));
3933 Reference< XInteractionRequest > xParamRequest(pParamRequest);
3934 // some knittings
3935 pParamRequest->addContinuation(pParamValues);
3936 pParamRequest->addContinuation(pAbort);
3937
3938 // handle the request
3939 m_xInteractionHandler->handle(xParamRequest);
3940
3941 if (!pParamValues->wasSelected())
3942 // canceled
3943 return sal_False;
3944
3945 // transfer the values into the parameter supplier
3946 Sequence< PropertyValue > aFinalValues = pParamValues->getValues();
3947 if (aFinalValues.getLength() != aRequest.Parameters->getCount())
3948 {
3949 OSL_FAIL("FormController::approveParameter: the InteractionHandler returned nonsense!");
3950 return sal_False;
3951 }
3952 const PropertyValue* pFinalValues = aFinalValues.getConstArray();
3953 for (sal_Int32 i=0; i<aFinalValues.getLength(); ++i, ++pFinalValues)
3954 {
3955 Reference< XPropertySet > xParam(
3956 aRequest.Parameters->getByIndex(i), css::uno::UNO_QUERY);
3957 if (xParam.is())
3958 {
3959 #ifdef DBG_UTIL
3960 OUString sName;
3961 xParam->getPropertyValue(FM_PROP_NAME) >>= sName;
3962 DBG_ASSERT(sName.equals(pFinalValues->Name), "FormController::approveParameter: suspicious value names!");
3963 #endif
3964 try { xParam->setPropertyValue(FM_PROP_VALUE, pFinalValues->Value); }
3965 catch(Exception&)
3966 {
3967 OSL_FAIL("FormController::approveParameter: setting one of the properties failed!");
3968 }
3969 }
3970 }
3971 }
3972 catch(Exception&)
3973 {
3974 DBG_UNHANDLED_EXCEPTION();
3975 }
3976 }
3977 return sal_True;
3978 }
3979
3980 // XConfirmDeleteBroadcaster
3981
3982 void SAL_CALL FormController::addConfirmDeleteListener(const Reference< XConfirmDeleteListener > & aListener) throw( RuntimeException, std::exception )
3983 {
3984 ::osl::MutexGuard aGuard( m_aMutex );
3985 impl_checkDisposed_throw();
3986
3987 m_aDeleteListeners.addInterface(aListener);
3988 }
3989
3990
3991 void SAL_CALL FormController::removeConfirmDeleteListener(const Reference< XConfirmDeleteListener > & aListener) throw( RuntimeException, std::exception )
3992 {
3993 ::osl::MutexGuard aGuard( m_aMutex );
3994 impl_checkDisposed_throw();
3995
3996 m_aDeleteListeners.removeInterface(aListener);
3997 }
3998
3999 // XConfirmDeleteListener
4000
4001 sal_Bool SAL_CALL FormController::confirmDelete(const RowChangeEvent& aEvent) throw( RuntimeException, std::exception )
4002 {
4003 ::osl::MutexGuard aGuard( m_aMutex );
4004 impl_checkDisposed_throw();
4005
4006 ::cppu::OInterfaceIteratorHelper aIter(m_aDeleteListeners);
4007 if (aIter.hasMoreElements())
4008 {
4009 RowChangeEvent aEvt(aEvent);
4010 aEvt.Source = *this;
4011 return ((XConfirmDeleteListener*)aIter.next())->confirmDelete(aEvt);
4012 }
4013 // default handling: instantiate an interaction handler and let it handle the request
4014
4015 OUString sTitle;
4016 sal_Int32 nLength = aEvent.Rows;
4017 if ( nLength > 1 )
4018 {
4019 sTitle = SVX_RESSTR( RID_STR_DELETECONFIRM_RECORDS );
4020 sTitle = sTitle.replaceFirst( "#", OUString::number(nLength) );
4021 }
4022 else
4023 sTitle = SVX_RESSTR( RID_STR_DELETECONFIRM_RECORD );
4024
4025 try
4026 {
4027 if ( !ensureInteractionHandler() )
4028 return sal_False;
4029
4030 // two continuations allowed: Yes and No
4031 OInteractionApprove* pApprove = new OInteractionApprove;
4032 OInteractionDisapprove* pDisapprove = new OInteractionDisapprove;
4033
4034 // the request
4035 SQLWarning aWarning;
4036 aWarning.Message = sTitle;
4037 SQLWarning aDetails;
4038 aDetails.Message = SVX_RESSTR(RID_STR_DELETECONFIRM);
4039 aWarning.NextException <<= aDetails;
4040
4041 OInteractionRequest* pRequest = new OInteractionRequest( makeAny( aWarning ) );
4042 Reference< XInteractionRequest > xRequest( pRequest );
4043
4044 // some knittings
4045 pRequest->addContinuation( pApprove );
4046 pRequest->addContinuation( pDisapprove );
4047
4048 // handle the request
4049 m_xInteractionHandler->handle( xRequest );
4050
4051 if ( pApprove->wasSelected() )
4052 return sal_True;
4053 }
4054 catch( const Exception& )
4055 {
4056 DBG_UNHANDLED_EXCEPTION();
4057 }
4058
4059 return sal_False;
4060 }
4061
4062
4063 void SAL_CALL FormController::invalidateFeatures( const Sequence< ::sal_Int16 >& _Features ) throw (RuntimeException, std::exception)
4064 {
4065 ::osl::MutexGuard aGuard( m_aMutex );
4066 // for now, just copy the ids of the features, because ....
4067 ::std::copy( _Features.getConstArray(), _Features.getConstArray() + _Features.getLength(),
4068 ::std::insert_iterator< ::std::set< sal_Int16 > >( m_aInvalidFeatures, m_aInvalidFeatures.begin() )
4069 );
4070
4071 // ... we will do the real invalidation asynchronously
4072 if ( !m_aFeatureInvalidationTimer.IsActive() )
4073 m_aFeatureInvalidationTimer.Start();
4074 }
4075
4076
4077 void SAL_CALL FormController::invalidateAllFeatures( ) throw (RuntimeException, std::exception)
4078 {
4079 ::osl::ClearableMutexGuard aGuard( m_aMutex );
4080
4081 Sequence< sal_Int16 > aInterceptedFeatures( m_aFeatureDispatchers.size() );
4082 ::std::transform(
4083 m_aFeatureDispatchers.begin(),
4084 m_aFeatureDispatchers.end(),
4085 aInterceptedFeatures.getArray(),
4086 ::o3tl::select1st< DispatcherContainer::value_type >()
4087 );
4088
4089 aGuard.clear();
4090 if ( aInterceptedFeatures.getLength() )
4091 invalidateFeatures( aInterceptedFeatures );
4092 }
4093
4094
4095 Reference< XDispatch >
4096 FormController::interceptedQueryDispatch( const URL& aURL,
4097 const OUString& /*aTargetFrameName*/, sal_Int32 /*nSearchFlags*/)
4098 throw( RuntimeException )
4099 {
4100 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
4101 Reference< XDispatch > xReturn;
4102 // dispatches handled by ourself
4103 if ( ( aURL.Complete == FMURL_CONFIRM_DELETION )
4104 || ( ( aURL.Complete == "private:/InteractionHandler" )
4105 && ensureInteractionHandler()
4106 )
4107 )
4108 xReturn = static_cast< XDispatch* >( this );
4109
4110 // dispatches of FormSlot-URLs we have to translate
4111 if ( !xReturn.is() && m_xFormOperations.is() )
4112 {
4113 // find the slot id which corresponds to the URL
4114 sal_Int32 nFeatureSlotId = ::svx::FeatureSlotTranslation::getControllerFeatureSlotIdForURL( aURL.Main );
4115 sal_Int16 nFormFeature = ( nFeatureSlotId != -1 ) ? ::svx::FeatureSlotTranslation::getFormFeatureForSlotId( nFeatureSlotId ) : -1;
4116 if ( nFormFeature > 0 )
4117 {
4118 // get the dispatcher for this feature, create if necessary
4119 DispatcherContainer::const_iterator aDispatcherPos = m_aFeatureDispatchers.find( nFormFeature );
4120 if ( aDispatcherPos == m_aFeatureDispatchers.end() )
4121 {
4122 aDispatcherPos = m_aFeatureDispatchers.insert(
4123 DispatcherContainer::value_type( nFormFeature, new ::svx::OSingleFeatureDispatcher( aURL, nFormFeature, m_xFormOperations, m_aMutex ) )
4124 ).first;
4125 }
4126
4127 OSL_ENSURE( aDispatcherPos->second.is(), "FormController::interceptedQueryDispatch: should have a dispatcher by now!" );
4128 return aDispatcherPos->second;
4129 }
4130 }
4131
4132 // no more to offer
4133 return xReturn;
4134 }
4135
4136
4137 void SAL_CALL FormController::dispatch( const URL& _rURL, const Sequence< PropertyValue >& _rArgs ) throw (RuntimeException, std::exception)
4138 {
4139 if ( _rArgs.getLength() != 1 )
4140 {
4141 OSL_FAIL( "FormController::dispatch: no arguments -> no dispatch!" );
4142 return;
4143 }
4144
4145 if ( _rURL.Complete == "private:/InteractionHandler" )
4146 {
4147 Reference< XInteractionRequest > xRequest;
4148 OSL_VERIFY( _rArgs[0].Value >>= xRequest );
4149 if ( xRequest.is() )
4150 handle( xRequest );
4151 return;
4152 }
4153
4154 if ( _rURL.Complete == FMURL_CONFIRM_DELETION )
4155 {
4156 OSL_FAIL( "FormController::dispatch: How do you expect me to return something via this call?" );
4157 // confirmDelete has a return value - dispatch hasn't
4158 return;
4159 }
4160
4161 OSL_FAIL( "FormController::dispatch: unknown URL!" );
4162 }
4163
4164
4165 void SAL_CALL FormController::addStatusListener( const Reference< XStatusListener >& _rxListener, const URL& _rURL ) throw (RuntimeException, std::exception)
4166 {
4167 if (_rURL.Complete == FMURL_CONFIRM_DELETION)
4168 {
4169 if (_rxListener.is())
4170 { // send an initial statusChanged event
4171 FeatureStateEvent aEvent;
4172 aEvent.FeatureURL = _rURL;
4173 aEvent.IsEnabled = sal_True;
4174 _rxListener->statusChanged(aEvent);
4175 // and don't add the listener at all (the status will never change)
4176 }
4177 }
4178 else
4179 OSL_FAIL("FormController::addStatusListener: invalid (unsupported) URL!");
4180 }
4181
4182
4183 Reference< XInterface > SAL_CALL FormController::getParent() throw( RuntimeException, std::exception )
4184 {
4185 return m_xParent;
4186 }
4187
4188
4189 void SAL_CALL FormController::setParent( const Reference< XInterface >& Parent) throw( NoSupportException, RuntimeException, std::exception )
4190 {
4191 m_xParent = Parent;
4192 }
4193
4194
4195 void SAL_CALL FormController::removeStatusListener( const Reference< XStatusListener >& /*_rxListener*/, const URL& _rURL ) throw (RuntimeException, std::exception)
4196 {
4197 (void)_rURL;
4198 OSL_ENSURE(_rURL.Complete == FMURL_CONFIRM_DELETION, "FormController::removeStatusListener: invalid (unsupported) URL!");
4199 // we never really added the listener, so we don't need to remove it
4200 }
4201
4202
4203 Reference< XDispatchProviderInterceptor > FormController::createInterceptor(const Reference< XDispatchProviderInterception > & _xInterception)
4204 {
4205 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
4206 #ifdef DBG_UTIL
4207 // check if we already have a interceptor for the given object
4208 for ( Interceptors::const_iterator aIter = m_aControlDispatchInterceptors.begin();
4209 aIter != m_aControlDispatchInterceptors.end();
4210 ++aIter
4211 )
4212 {
4213 if ((*aIter)->getIntercepted() == _xInterception)
4214 OSL_FAIL("FormController::createInterceptor : we already do intercept this objects dispatches !");
4215 }
4216 #endif
4217
4218 DispatchInterceptionMultiplexer* pInterceptor = new DispatchInterceptionMultiplexer( _xInterception, this );
4219 pInterceptor->acquire();
4220 m_aControlDispatchInterceptors.insert( m_aControlDispatchInterceptors.end(), pInterceptor );
4221
4222 return pInterceptor;
4223 }
4224
4225
4226 bool FormController::ensureInteractionHandler()
4227 {
4228 if ( m_xInteractionHandler.is() )
4229 return true;
4230 if ( m_bAttemptedHandlerCreation )
4231 return false;
4232 m_bAttemptedHandlerCreation = true;
4233
4234 m_xInteractionHandler = InteractionHandler::createWithParent(m_xComponentContext, 0);
4235 return m_xInteractionHandler.is();
4236 }
4237
4238
4239 void SAL_CALL FormController::handle( const Reference< XInteractionRequest >& _rRequest ) throw (RuntimeException, std::exception)
4240 {
4241 if ( !ensureInteractionHandler() )
4242 return;
4243 m_xInteractionHandler->handle( _rRequest );
4244 }
4245
4246
4247 void FormController::deleteInterceptor(const Reference< XDispatchProviderInterception > & _xInterception)
4248 {
4249 OSL_ENSURE( !impl_isDisposed_nofail(), "FormController: already disposed!" );
4250 // search the interceptor responsible for the given object
4251 Interceptors::iterator aIter;
4252 for ( aIter = m_aControlDispatchInterceptors.begin();
4253 aIter != m_aControlDispatchInterceptors.end();
4254 ++aIter
4255 )
4256 {
4257 if ((*aIter)->getIntercepted() == _xInterception)
4258 break;
4259 }
4260 if (aIter == m_aControlDispatchInterceptors.end())
4261 {
4262 return;
4263 }
4264
4265 // log off the interception from it's interception object
4266 DispatchInterceptionMultiplexer* pInterceptorImpl = *aIter;
4267 pInterceptorImpl->dispose();
4268 pInterceptorImpl->release();
4269
4270 // remove the interceptor from our array
4271 m_aControlDispatchInterceptors.erase(aIter);
4272 }
4273
4274
4275 void FormController::implInvalidateCurrentControlDependentFeatures()
4276 {
4277 Sequence< sal_Int16 > aCurrentControlDependentFeatures(4);
4278
4279 aCurrentControlDependentFeatures[0] = FormFeature::SortAscending;
4280 aCurrentControlDependentFeatures[1] = FormFeature::SortDescending;
4281 aCurrentControlDependentFeatures[2] = FormFeature::AutoFilter;
4282 aCurrentControlDependentFeatures[3] = FormFeature::RefreshCurrentControl;
4283
4284 invalidateFeatures( aCurrentControlDependentFeatures );
4285 }
4286
4287
4288 void SAL_CALL FormController::columnChanged( const EventObject& /*_event*/ ) throw (RuntimeException, std::exception)
4289 {
4290 implInvalidateCurrentControlDependentFeatures();
4291 }
4292
4293 } // namespace svxform
4294
4295 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE