1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26
27 #include "svx/fmgridif.hxx"
28 #include "fmprop.hrc"
29 #include "fmservs.hxx"
30 #include "svx/fmtools.hxx"
31 #include "fmurl.hxx"
32 #include "formcontrolfactory.hxx"
33 #include "gridcell.hxx"
34 #include "sdbdatacolumn.hxx"
35 #include "svx/fmgridcl.hxx"
36 #include "svx/svxids.hrc"
37 #include <tools/urlobj.hxx>
38
39 /** === begin UNO includes === **/
40 #include <com/sun/star/awt/PosSize.hpp>
41 #include <com/sun/star/beans/PropertyAttribute.hpp>
42 #include <com/sun/star/form/FormComponentType.hpp>
43 #include <com/sun/star/form/XFormComponent.hpp>
44 #include <com/sun/star/form/XLoadable.hpp>
45 #include <com/sun/star/lang/DisposedException.hpp>
46 #include <com/sun/star/sdbc/ResultSetType.hpp>
47 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
48 #include <com/sun/star/util/XURLTransformer.hpp>
49 #include <com/sun/star/view/XSelectionSupplier.hpp>
50 #include <com/sun/star/sdbcx/XRowLocate.hpp>
51 /** === end UNO includes === **/
52
53 #include <comphelper/container.hxx>
54 #include <comphelper/enumhelper.hxx>
55 #include <comphelper/extract.hxx>
56 #include <comphelper/processfactory.hxx>
57 #include <comphelper/property.hxx>
58 #include <comphelper/sequence.hxx>
59 #include <comphelper/types.hxx>
60 #include <cppuhelper/typeprovider.hxx>
61 #include <toolkit/helper/vclunohelper.hxx>
62 #include <tools/diagnose_ex.h>
63
64 using namespace ::svxform;
65 using namespace ::com::sun::star::container;
66 using namespace ::com::sun::star::sdb;
67 using namespace ::com::sun::star::sdbc;
68 using namespace ::com::sun::star::uno;
69 using namespace ::com::sun::star::view;
70 using namespace ::com::sun::star::beans;
71 using namespace ::com::sun::star::lang;
72 using namespace ::com::sun::star::form;
73 using namespace ::com::sun::star::util;
74 using namespace ::com::sun::star;
75
76 using ::com::sun::star::sdbcx::XColumnsSupplier;
77 using ::com::sun::star::frame::XDispatchProviderInterceptor;
78 using ::com::sun::star::frame::XDispatchProvider;
79 using ::com::sun::star::accessibility::XAccessible;
80 using ::com::sun::star::accessibility::XAccessibleContext;
81 using ::com::sun::star::sdb::XRowSetSupplier;
82 using ::com::sun::star::awt::XVclWindowPeer;
83
84
85 //------------------------------------------------------------------
ImplCreateFontDescriptor(const Font & rFont)86 ::com::sun::star::awt::FontDescriptor ImplCreateFontDescriptor( const Font& rFont )
87 {
88 ::com::sun::star::awt::FontDescriptor aFD;
89 aFD.Name = rFont.GetName();
90 aFD.StyleName = rFont.GetStyleName();
91 aFD.Height = (sal_Int16)rFont.GetSize().Height();
92 aFD.Width = (sal_Int16)rFont.GetSize().Width();
93 aFD.Family = (sal_Int16)rFont.GetFamily();
94 aFD.CharSet = rFont.GetCharSet();
95 aFD.Pitch = (sal_Int16)rFont.GetPitch();
96 aFD.CharacterWidth = VCLUnoHelper::ConvertFontWidth( rFont.GetWidthType() );
97 aFD.Weight= VCLUnoHelper::ConvertFontWeight( rFont.GetWeight() );
98 aFD.Slant = (::com::sun::star::awt::FontSlant)rFont.GetItalic();
99 aFD.Underline = (sal_Int16)rFont.GetUnderline();
100 aFD.Strikeout = (sal_Int16)rFont.GetStrikeout();
101 aFD.Orientation = rFont.GetOrientation();
102 aFD.Kerning = rFont.IsKerning();
103 aFD.WordLineMode = rFont.IsWordLineMode();
104 aFD.Type = 0; // ??? => Nur an Metric...
105 return aFD;
106 }
107
108 //------------------------------------------------------------------
ImplCreateFont(const::com::sun::star::awt::FontDescriptor & rDescr)109 Font ImplCreateFont( const ::com::sun::star::awt::FontDescriptor& rDescr )
110 {
111 Font aFont;
112 aFont.SetName( rDescr.Name );
113 aFont.SetStyleName( rDescr.StyleName );
114 aFont.SetSize( ::Size( rDescr.Width, rDescr.Height ) );
115 aFont.SetFamily( (FontFamily)rDescr.Family );
116 aFont.SetCharSet( (CharSet)rDescr.CharSet );
117 aFont.SetPitch( (FontPitch)rDescr.Pitch );
118 aFont.SetWidthType( VCLUnoHelper::ConvertFontWidth( rDescr.CharacterWidth ) );
119 aFont.SetWeight( VCLUnoHelper::ConvertFontWeight( rDescr.Weight ) );
120 aFont.SetItalic( (FontItalic)rDescr.Slant );
121 aFont.SetUnderline( (::FontUnderline)rDescr.Underline );
122 aFont.SetStrikeout( (::FontStrikeout)rDescr.Strikeout );
123 aFont.SetOrientation( (sal_Int16)rDescr.Orientation );
124 aFont.SetKerning( rDescr.Kerning );
125 aFont.SetWordLineMode( rDescr.WordLineMode );
126 return aFont;
127 }
128
129 //==================================================================
130 //= FmXModifyMultiplexer
131 //==================================================================
132 //------------------------------------------------------------------
FmXModifyMultiplexer(::cppu::OWeakObject & rSource,::osl::Mutex & _rMutex)133 FmXModifyMultiplexer::FmXModifyMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
134 :OWeakSubObject( rSource )
135 ,OInterfaceContainerHelper( _rMutex )
136 {
137 }
138
139 //------------------------------------------------------------------
queryInterface(const Type & _rType)140 Any SAL_CALL FmXModifyMultiplexer::queryInterface(const Type& _rType) throw (RuntimeException)
141 {
142 Any aReturn;
143 aReturn = ::cppu::queryInterface(_rType,
144 static_cast< ::com::sun::star::util::XModifyListener*>(this),
145 static_cast< XEventListener*>(this)
146 );
147
148 if (!aReturn.hasValue())
149 aReturn = OWeakSubObject::queryInterface( _rType );
150
151 return aReturn;
152 }
153
154 //------------------------------------------------------------------
disposing(const EventObject &)155 void FmXModifyMultiplexer::disposing(const EventObject& ) throw( RuntimeException )
156 {
157 }
158
159 //------------------------------------------------------------------
modified(const EventObject & e)160 void FmXModifyMultiplexer::modified(const EventObject& e) throw( RuntimeException )
161 {
162 EventObject aMulti( e);
163 aMulti.Source = &m_rParent;
164 notifyEach( &XModifyListener::modified, aMulti );
165 }
166
167 //==================================================================
168 //= FmXUpdateMultiplexer
169 //==================================================================
170 //------------------------------------------------------------------
FmXUpdateMultiplexer(::cppu::OWeakObject & rSource,::osl::Mutex & _rMutex)171 FmXUpdateMultiplexer::FmXUpdateMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
172 :OWeakSubObject( rSource )
173 ,OInterfaceContainerHelper( _rMutex )
174 {
175 }
176
177 //------------------------------------------------------------------
queryInterface(const Type & _rType)178 Any SAL_CALL FmXUpdateMultiplexer::queryInterface(const Type& _rType) throw (RuntimeException)
179 {
180 Any aReturn;
181 aReturn = ::cppu::queryInterface(_rType,
182 static_cast< XUpdateListener*>(this),
183 static_cast< XEventListener*>(this)
184 );
185
186 if (!aReturn.hasValue())
187 aReturn = OWeakSubObject::queryInterface( _rType );
188
189 return aReturn;
190 }
191
192 //------------------------------------------------------------------
disposing(const EventObject &)193 void FmXUpdateMultiplexer::disposing(const EventObject& ) throw( RuntimeException )
194 {
195 }
196
197 //------------------------------------------------------------------
approveUpdate(const EventObject & e)198 sal_Bool FmXUpdateMultiplexer::approveUpdate(const EventObject &e) throw( RuntimeException )
199 {
200 EventObject aMulti( e );
201 aMulti.Source = &m_rParent;
202
203 sal_Bool bResult = sal_True;
204 if (getLength())
205 {
206 ::cppu::OInterfaceIteratorHelper aIter(*this);
207 while ( bResult && aIter.hasMoreElements() )
208 bResult = static_cast< XUpdateListener* >( aIter.next() )->approveUpdate( aMulti );
209 }
210
211 return bResult;
212 }
213
214 //------------------------------------------------------------------
updated(const EventObject & e)215 void FmXUpdateMultiplexer::updated(const EventObject &e) throw( RuntimeException )
216 {
217 EventObject aMulti( e );
218 aMulti.Source = &m_rParent;
219 notifyEach( &XUpdateListener::updated, aMulti );
220 }
221
222
223 //==================================================================
224 //= FmXSelectionMultiplexer
225 //==================================================================
226 //------------------------------------------------------------------
FmXSelectionMultiplexer(::cppu::OWeakObject & rSource,::osl::Mutex & _rMutex)227 FmXSelectionMultiplexer::FmXSelectionMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
228 :OWeakSubObject( rSource )
229 ,OInterfaceContainerHelper( _rMutex )
230 {
231 }
232
233 //------------------------------------------------------------------
queryInterface(const Type & _rType)234 Any SAL_CALL FmXSelectionMultiplexer::queryInterface(const Type& _rType) throw (RuntimeException)
235 {
236 Any aReturn;
237 aReturn = ::cppu::queryInterface(_rType,
238 static_cast< XSelectionChangeListener*>(this),
239 static_cast< XEventListener*>(this)
240 );
241
242 if (!aReturn.hasValue())
243 aReturn = OWeakSubObject::queryInterface( _rType );
244
245 return aReturn;
246 }
247
248 //------------------------------------------------------------------
disposing(const EventObject &)249 void FmXSelectionMultiplexer::disposing(const EventObject& ) throw( RuntimeException )
250 {
251 }
252
253 //------------------------------------------------------------------
selectionChanged(const EventObject & _rEvent)254 void SAL_CALL FmXSelectionMultiplexer::selectionChanged( const EventObject& _rEvent ) throw (RuntimeException)
255 {
256 EventObject aMulti(_rEvent);
257 aMulti.Source = &m_rParent;
258 notifyEach( &XSelectionChangeListener::selectionChanged, aMulti );
259 }
260
261 //==================================================================
262 //= FmXContainerMultiplexer
263 //==================================================================
264 //------------------------------------------------------------------
FmXContainerMultiplexer(::cppu::OWeakObject & rSource,::osl::Mutex & _rMutex)265 FmXContainerMultiplexer::FmXContainerMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
266 :OWeakSubObject( rSource )
267 ,OInterfaceContainerHelper( _rMutex )
268 {
269 }
270
271 //------------------------------------------------------------------
queryInterface(const Type & _rType)272 Any SAL_CALL FmXContainerMultiplexer::queryInterface(const Type& _rType) throw (RuntimeException)
273 {
274 Any aReturn;
275 aReturn = ::cppu::queryInterface(_rType,
276 static_cast< XContainerListener*>(this),
277 static_cast< XEventListener*>(this)
278 );
279
280 if (!aReturn.hasValue())
281 aReturn = OWeakSubObject::queryInterface( _rType );
282
283 return aReturn;
284 }
285
286 //------------------------------------------------------------------
disposing(const EventObject &)287 void FmXContainerMultiplexer::disposing(const EventObject& ) throw( RuntimeException )
288 {
289 }
290 //------------------------------------------------------------------
elementInserted(const ContainerEvent & e)291 void FmXContainerMultiplexer::elementInserted(const ContainerEvent& e) throw( RuntimeException )
292 {
293 ContainerEvent aMulti( e );
294 aMulti.Source = &m_rParent;
295 notifyEach( &XContainerListener::elementInserted, aMulti );
296 }
297
298 //------------------------------------------------------------------
elementRemoved(const ContainerEvent & e)299 void FmXContainerMultiplexer::elementRemoved(const ContainerEvent& e) throw( RuntimeException )
300 {
301 ContainerEvent aMulti( e );
302 aMulti.Source = &m_rParent;
303 notifyEach( &XContainerListener::elementRemoved, aMulti );
304 }
305
306
307 //------------------------------------------------------------------
elementReplaced(const ContainerEvent & e)308 void FmXContainerMultiplexer::elementReplaced(const ContainerEvent& e) throw( RuntimeException )
309 {
310 ContainerEvent aMulti( e );
311 aMulti.Source = &m_rParent;
312 notifyEach( &XContainerListener::elementReplaced, aMulti );
313 }
314
315 //==================================================================
316 //= FmXGridControlMultiplexer
317 //==================================================================
318 //------------------------------------------------------------------
FmXGridControlMultiplexer(::cppu::OWeakObject & rSource,::osl::Mutex & _rMutex)319 FmXGridControlMultiplexer::FmXGridControlMultiplexer( ::cppu::OWeakObject& rSource, ::osl::Mutex& _rMutex )
320 :OWeakSubObject( rSource )
321 ,OInterfaceContainerHelper( _rMutex )
322 {
323 }
324
325 //------------------------------------------------------------------
queryInterface(const Type & _rType)326 Any SAL_CALL FmXGridControlMultiplexer::queryInterface(const Type& _rType) throw (RuntimeException)
327 {
328 Any aReturn;
329 aReturn = ::cppu::queryInterface( _rType,
330 static_cast< XGridControlListener*>(this)
331 );
332
333 if (!aReturn.hasValue())
334 aReturn = OWeakSubObject::queryInterface( _rType );
335
336 return aReturn;
337 }
338
339 //------------------------------------------------------------------
disposing(const EventObject &)340 void FmXGridControlMultiplexer::disposing( const EventObject& ) throw( RuntimeException )
341 {
342 }
343
344 //------------------------------------------------------------------
columnChanged(const EventObject & _event)345 void SAL_CALL FmXGridControlMultiplexer::columnChanged( const EventObject& _event ) throw (RuntimeException)
346 {
347 EventObject aForwardedEvent( _event );
348 aForwardedEvent.Source = &m_rParent;
349 notifyEach( &XGridControlListener::columnChanged, aForwardedEvent );
350 }
351
352 //==================================================================
353 //= FmXGridControl
354 //==================================================================
355
356 //------------------------------------------------------------------
FmXGridControl_NewInstance_Impl(const Reference<XMultiServiceFactory> & _rxFactory)357 Reference< XInterface > SAL_CALL FmXGridControl_NewInstance_Impl(const Reference< XMultiServiceFactory>& _rxFactory)
358 {
359 return *(new FmXGridControl(_rxFactory));
360 }
DBG_NAME(FmXGridControl)361 DBG_NAME(FmXGridControl )
362 //------------------------------------------------------------------------------
363 FmXGridControl::FmXGridControl(const Reference< XMultiServiceFactory >& _rxFactory)
364 :UnoControl( _rxFactory)
365 ,m_aModifyListeners(*this, GetMutex())
366 ,m_aUpdateListeners(*this, GetMutex())
367 ,m_aContainerListeners(*this, GetMutex())
368 ,m_aSelectionListeners(*this, GetMutex())
369 ,m_aGridControlListeners(*this, GetMutex())
370 ,m_nPeerCreationLevel(0)
371 ,m_bInDraw(sal_False)
372 ,m_xServiceFactory(_rxFactory)
373 {
374 DBG_CTOR(FmXGridControl ,NULL);
375 }
376
377 //------------------------------------------------------------------------------
~FmXGridControl()378 FmXGridControl::~FmXGridControl()
379 {
380 DBG_DTOR(FmXGridControl ,NULL);
381 }
382
383 //------------------------------------------------------------------
queryAggregation(const Type & _rType)384 Any SAL_CALL FmXGridControl::queryAggregation(const Type& _rType) throw (RuntimeException)
385 {
386 Any aReturn = FmXGridControl_BASE::queryInterface(_rType);
387
388 if (!aReturn.hasValue())
389 aReturn = UnoControl::queryAggregation( _rType );
390 return aReturn;
391 }
392
393 //------------------------------------------------------------------
getTypes()394 Sequence< Type> SAL_CALL FmXGridControl::getTypes( ) throw(RuntimeException)
395 {
396 return comphelper::concatSequences(UnoControl::getTypes(),FmXGridControl_BASE::getTypes());
397 }
398
399 //------------------------------------------------------------------
getImplementationId()400 Sequence<sal_Int8> SAL_CALL FmXGridControl::getImplementationId( ) throw(RuntimeException)
401 {
402 static ::cppu::OImplementationId* pId = 0;
403 if (! pId)
404 {
405 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
406 if (! pId)
407 {
408 static ::cppu::OImplementationId aId;
409 pId = &aId;
410 }
411 }
412 return pId->getImplementationId();
413 }
414
415 // XServiceInfo
416 //------------------------------------------------------------------------------
supportsService(const::rtl::OUString & ServiceName)417 sal_Bool SAL_CALL FmXGridControl::supportsService(const ::rtl::OUString& ServiceName) throw()
418 {
419 ::comphelper::StringSequence aSupported = getSupportedServiceNames();
420 const ::rtl::OUString * pArray = aSupported.getConstArray();
421 for( sal_Int32 i = 0; i < aSupported.getLength(); i++ )
422 if( pArray[i] == ServiceName )
423 return sal_True;
424 return sal_False;
425 }
426
427 //------------------------------------------------------------------------------
getImplementationName()428 ::rtl::OUString SAL_CALL FmXGridControl::getImplementationName() throw()
429 {
430 return ::rtl::OUString::createFromAscii("com.sun.star.form.FmXGridControl");
431 }
432
433 //------------------------------------------------------------------------------
getSupportedServiceNames()434 ::comphelper::StringSequence SAL_CALL FmXGridControl::getSupportedServiceNames() throw()
435 {
436 Sequence< ::rtl::OUString > aServiceNames(2);
437 aServiceNames[0] = FM_SUN_CONTROL_GRIDCONTROL;
438 aServiceNames[1] = ::rtl::OUString::createFromAscii("com.sun.star.awt.UnoControl");
439 return aServiceNames;
440 }
441
442 //------------------------------------------------------------------------------
dispose()443 void SAL_CALL FmXGridControl::dispose() throw( RuntimeException )
444 {
445 ::vos::OGuard aGuard( Application::GetSolarMutex() );
446
447 EventObject aEvt;
448 aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
449 m_aModifyListeners.disposeAndClear(aEvt);
450 m_aUpdateListeners.disposeAndClear(aEvt);
451 m_aContainerListeners.disposeAndClear(aEvt);
452
453 UnoControl::dispose();
454 }
455
456 //------------------------------------------------------------------------------
GetComponentServiceName()457 ::rtl::OUString FmXGridControl::GetComponentServiceName()
458 {
459 ::rtl::OUString aName = ::rtl::OUString::createFromAscii("DBGrid");
460 return aName;
461 }
462
463 //------------------------------------------------------------------------------
setModel(const Reference<::com::sun::star::awt::XControlModel> & rModel)464 sal_Bool SAL_CALL FmXGridControl::setModel(const Reference< ::com::sun::star::awt::XControlModel >& rModel) throw( RuntimeException )
465 {
466 ::vos::OGuard aGuard( Application::GetSolarMutex() );
467
468 if (!UnoControl::setModel(rModel))
469 return sal_False;
470
471 Reference< XGridPeer > xGridPeer(getPeer(), UNO_QUERY);
472 if (xGridPeer.is())
473 {
474 Reference< XIndexContainer > xCols(mxModel, UNO_QUERY);
475 xGridPeer->setColumns(xCols);
476 }
477 return sal_True;
478 }
479
480 //------------------------------------------------------------------------------
imp_CreatePeer(Window * pParent)481 FmXGridPeer* FmXGridControl::imp_CreatePeer(Window* pParent)
482 {
483 FmXGridPeer* pReturn = new FmXGridPeer(m_xServiceFactory);
484
485 // translate properties into WinBits
486 WinBits nStyle = WB_TABSTOP;
487 Reference< XPropertySet > xModelSet(getModel(), UNO_QUERY);
488 if (xModelSet.is())
489 {
490 try
491 {
492 if (::comphelper::getINT16(xModelSet->getPropertyValue(FM_PROP_BORDER)))
493 nStyle |= WB_BORDER;
494 }
495 catch(const Exception&)
496 {
497 OSL_ASSERT(!"Can not get style");
498 }
499 }
500
501 pReturn->Create(pParent, nStyle);
502 return pReturn;
503 }
504
505 //------------------------------------------------------------------------------
createPeer(const Reference<::com::sun::star::awt::XToolkit> &,const Reference<::com::sun::star::awt::XWindowPeer> & rParentPeer)506 void SAL_CALL FmXGridControl::createPeer(const Reference< ::com::sun::star::awt::XToolkit >& /*rToolkit*/, const Reference< ::com::sun::star::awt::XWindowPeer >& rParentPeer) throw( RuntimeException )
507 {
508 if ( !mxModel.is() )
509 throw DisposedException( ::rtl::OUString(), *this );
510
511 DBG_ASSERT(/*(0 == m_nPeerCreationLevel) && */!mbCreatingPeer, "FmXGridControl::createPeer : recursion!");
512 // I think this should never assert, now that we're using the base class' mbCreatingPeer in addition to
513 // our own m_nPeerCreationLevel
514 // But I'm not sure as I don't _fully_ understand the underlying toolkit implementations ....
515 // (if this asserts, we still need m_nPeerCreationLevel. If not, we could omit it ....)
516 // 14.05.2001 - 86836 - frank.schoenheit@germany.sun.com
517
518 // TODO: why the hell this whole class does not use any mutex?
519
520 if (!getPeer().is())
521 {
522 mbCreatingPeer = sal_True;
523 // mbCreatingPeer is virtually the same as m_nPeerCreationLevel, but it's the base class' method
524 // to prevent recursion.
525
526 Window* pParentWin = NULL;
527 if (rParentPeer.is())
528 {
529 VCLXWindow* pParent = VCLXWindow::GetImplementation(rParentPeer);
530 if (pParent)
531 pParentWin = pParent->GetWindow();
532 }
533
534 FmXGridPeer* pPeer = imp_CreatePeer(pParentWin);
535 DBG_ASSERT(pPeer != NULL, "FmXGridControl::createPeer : imp_CreatePeer didn't return a peer !");
536 setPeer( pPeer );
537
538 // lesen der properties aus dem model
539 // ++m_nPeerCreationLevel;
540 updateFromModel();
541
542 // folgendes unschoene Szenario : updateFromModel fuehrt zu einem propertiesChanged am Control,
543 // das stellt fest, dass sich eine 'kritische' Property geaendert hat (zum Beispiel "Border") und
544 // legt daraufhin eine neue Peer an, was wieder hier im createPeer landet, wir legen also eine
545 // zweite FmXGridPeer an und initialisieren die. Dann kommen wir in der ersten Inkarnation aus
546 // dem updsateFromModel raus und arbeiten dort weiter mit dem pPeer, das jetzt eigentlich schon
547 // veraltet ist (da ja in der zweiten Inkarnation eine andere Peer angelegt wurde).
548 // Deswegen also der Aufwand mit dem PeerCreationLevel, das stellt sicher, dass wir die in dem
549 // tiefsten Level angelegte Peer wirklich verwenden, sie aber erst im top-level
550 // initialisieren.
551 // if (--m_nPeerCreationLevel == 0)
552 {
553 DBG_ASSERT(getPeer().is(), "FmXGridControl::createPeer : something went wrong ... no top level peer !");
554 pPeer = FmXGridPeer::getImplementation(getPeer());
555
556 setPosSize( maComponentInfos.nX, maComponentInfos.nY, maComponentInfos.nWidth, maComponentInfos.nHeight, ::com::sun::star::awt::PosSize::POSSIZE );
557
558 Reference< XIndexContainer > xColumns(getModel(), UNO_QUERY);
559 if (xColumns.is())
560 pPeer->setColumns(xColumns);
561
562 if (maComponentInfos.bVisible)
563 pPeer->setVisible(sal_True);
564
565 if (!maComponentInfos.bEnable)
566 pPeer->setEnable(sal_False);
567
568 if (maWindowListeners.getLength())
569 pPeer->addWindowListener( &maWindowListeners );
570
571 if (maFocusListeners.getLength())
572 pPeer->addFocusListener( &maFocusListeners );
573
574 if (maKeyListeners.getLength())
575 pPeer->addKeyListener( &maKeyListeners );
576
577 if (maMouseListeners.getLength())
578 pPeer->addMouseListener( &maMouseListeners );
579
580 if (maMouseMotionListeners.getLength())
581 pPeer->addMouseMotionListener( &maMouseMotionListeners );
582
583 if (maPaintListeners.getLength())
584 pPeer->addPaintListener( &maPaintListeners );
585
586 if (m_aModifyListeners.getLength())
587 pPeer->addModifyListener( &m_aModifyListeners );
588
589 if (m_aUpdateListeners.getLength())
590 pPeer->addUpdateListener( &m_aUpdateListeners );
591
592 if (m_aContainerListeners.getLength())
593 pPeer->addContainerListener( &m_aContainerListeners );
594
595 // forward the design mode
596 sal_Bool bForceAlivePeer = m_bInDraw && !maComponentInfos.bVisible;
597 // (we force a alive-mode peer if we're in "draw", cause in this case the peer will be used for drawing in
598 // foreign devices. We ensure this with the visibility check as an living peer is assumed to be noncritical
599 // only if invisible)
600 Any aOldCursorBookmark;
601 if (!mbDesignMode || bForceAlivePeer)
602 {
603 Reference< XFormComponent > xComp(getModel(), UNO_QUERY);
604 if (xComp.is())
605 {
606 Reference< XRowSet > xForm(xComp->getParent(), UNO_QUERY);
607 // is the form alive?
608 // we can see that if the form contains columns
609 Reference< ::com::sun::star::sdbcx::XColumnsSupplier > xColumnsSupplier(xForm, UNO_QUERY);
610 if (xColumnsSupplier.is())
611 {
612 if (Reference< XIndexAccess > (xColumnsSupplier->getColumns(),UNO_QUERY)->getCount())
613 {
614 // we get only a new bookmark if the resultset is not forwardonly
615 if (::comphelper::getINT32(Reference< XPropertySet > (xForm, UNO_QUERY)->getPropertyValue(FM_PROP_RESULTSET_TYPE)) != ResultSetType::FORWARD_ONLY)
616 {
617 // as the FmGridControl touches the data source it is connected to we have to remember the current
618 // cursor position (and restore afterwards)
619 // OJ: but only when we stand on a valid row
620 Reference< XResultSet > xResultSet(xForm, UNO_QUERY);
621 if ( !xResultSet->isBeforeFirst() && !xResultSet->isAfterLast() )
622 {
623 try
624 {
625 aOldCursorBookmark = Reference< ::com::sun::star::sdbcx::XRowLocate > (xForm, UNO_QUERY)->getBookmark();
626 }
627 catch( const Exception& e )
628 {
629 DBG_UNHANDLED_EXCEPTION();
630 (void)e;
631 }
632 }
633 }
634 }
635 }
636 pPeer->setRowSet(xForm);
637 }
638 }
639 pPeer->setDesignMode(mbDesignMode && !bForceAlivePeer);
640
641 try
642 {
643 if (aOldCursorBookmark.hasValue())
644 { // we have a valid bookmark, so we have to restore the cursor's position
645 Reference< XFormComponent > xComp(getModel(), UNO_QUERY);
646 Reference< ::com::sun::star::sdbcx::XRowLocate > xLocate(xComp->getParent(), UNO_QUERY);
647 xLocate->moveToBookmark(aOldCursorBookmark);
648 }
649 }
650 catch( const Exception& e )
651 {
652 DBG_UNHANDLED_EXCEPTION();
653 (void)e;
654 }
655
656 Reference< ::com::sun::star::awt::XView > xPeerView(getPeer(), UNO_QUERY);
657 xPeerView->setZoom( maComponentInfos.nZoomX, maComponentInfos.nZoomY );
658 xPeerView->setGraphics( mxGraphics );
659 }
660 mbCreatingPeer = sal_False;
661 }
662 }
663
664 //------------------------------------------------------------------------------
addModifyListener(const Reference<::com::sun::star::util::XModifyListener> & l)665 void FmXGridControl::addModifyListener(const Reference< ::com::sun::star::util::XModifyListener >& l) throw( RuntimeException )
666 {
667 m_aModifyListeners.addInterface( l );
668 if( getPeer().is() && m_aModifyListeners.getLength() == 1 )
669 {
670 Reference< ::com::sun::star::util::XModifyBroadcaster > xGrid(getPeer(), UNO_QUERY);
671 xGrid->addModifyListener( &m_aModifyListeners);
672 }
673 }
674
675 //------------------------------------------------------------------------------
select(const Any & _rSelection)676 sal_Bool SAL_CALL FmXGridControl::select( const Any& _rSelection ) throw (IllegalArgumentException, RuntimeException)
677 {
678 ::vos::OGuard aGuard( Application::GetSolarMutex() );
679 Reference< XSelectionSupplier > xPeer(getPeer(), UNO_QUERY);
680 return xPeer->select(_rSelection);
681 }
682
683 //------------------------------------------------------------------------------
getSelection()684 Any SAL_CALL FmXGridControl::getSelection( ) throw (RuntimeException)
685 {
686 ::vos::OGuard aGuard( Application::GetSolarMutex() );
687 Reference< XSelectionSupplier > xPeer(getPeer(), UNO_QUERY);
688 return xPeer->getSelection();
689 }
690
691 //------------------------------------------------------------------------------
addSelectionChangeListener(const Reference<XSelectionChangeListener> & _rxListener)692 void SAL_CALL FmXGridControl::addSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener ) throw (RuntimeException)
693 {
694 m_aSelectionListeners.addInterface( _rxListener );
695 if( getPeer().is() && 1 == m_aSelectionListeners.getLength() )
696 {
697 Reference< XSelectionSupplier > xGrid(getPeer(), UNO_QUERY);
698 xGrid->addSelectionChangeListener( &m_aSelectionListeners);
699 }
700 }
701
702 //------------------------------------------------------------------------------
removeSelectionChangeListener(const Reference<XSelectionChangeListener> & _rxListener)703 void SAL_CALL FmXGridControl::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener ) throw (RuntimeException)
704 {
705 if( getPeer().is() && 1 == m_aSelectionListeners.getLength() )
706 {
707 Reference< XSelectionSupplier > xGrid(getPeer(), UNO_QUERY);
708 xGrid->removeSelectionChangeListener( &m_aSelectionListeners);
709 }
710 m_aSelectionListeners.removeInterface( _rxListener );
711 }
712
713 //------------------------------------------------------------------------------
queryFieldDataType(const Type & xType)714 Sequence< sal_Bool > SAL_CALL FmXGridControl::queryFieldDataType( const Type& xType ) throw(RuntimeException)
715 {
716 if (getPeer().is())
717 {
718 Reference< XGridFieldDataSupplier > xPeerSupplier(getPeer(), UNO_QUERY);
719 if (xPeerSupplier.is())
720 return xPeerSupplier->queryFieldDataType(xType);
721 }
722
723 return Sequence<sal_Bool>();
724 }
725
726 //------------------------------------------------------------------------------
queryFieldData(sal_Int32 nRow,const Type & xType)727 Sequence< Any > SAL_CALL FmXGridControl::queryFieldData( sal_Int32 nRow, const Type& xType ) throw(RuntimeException)
728 {
729 if (getPeer().is())
730 {
731 Reference< XGridFieldDataSupplier > xPeerSupplier(getPeer(), UNO_QUERY);
732 if (xPeerSupplier.is())
733 return xPeerSupplier->queryFieldData(nRow, xType);
734 }
735
736 return Sequence< Any>();
737 }
738
739 //------------------------------------------------------------------------------
removeModifyListener(const Reference<::com::sun::star::util::XModifyListener> & l)740 void SAL_CALL FmXGridControl::removeModifyListener(const Reference< ::com::sun::star::util::XModifyListener >& l) throw( RuntimeException )
741 {
742 if( getPeer().is() && m_aModifyListeners.getLength() == 1 )
743 {
744 Reference< ::com::sun::star::util::XModifyBroadcaster > xGrid(getPeer(), UNO_QUERY);
745 xGrid->removeModifyListener( &m_aModifyListeners);
746 }
747 m_aModifyListeners.removeInterface( l );
748 }
749
750 //------------------------------------------------------------------------------
draw(sal_Int32 x,sal_Int32 y)751 void SAL_CALL FmXGridControl::draw( sal_Int32 x, sal_Int32 y ) throw( RuntimeException )
752 {
753 ::vos::OGuard aGuard( Application::GetSolarMutex() );
754 m_bInDraw = sal_True;
755 UnoControl::draw(x, y);
756 m_bInDraw = sal_False;
757 }
758
759 //------------------------------------------------------------------------------
setDesignMode(sal_Bool bOn)760 void SAL_CALL FmXGridControl::setDesignMode(sal_Bool bOn) throw( RuntimeException )
761 {
762 ::com::sun::star::util::ModeChangeEvent aModeChangeEvent;
763
764 // --- <mutex_lock> ---
765 {
766 ::vos::OGuard aGuard( Application::GetSolarMutex() );
767
768 Reference< XRowSetSupplier > xGrid(getPeer(), UNO_QUERY);
769
770 if (xGrid.is() && (bOn != mbDesignMode || (!bOn && !xGrid->getRowSet().is())))
771 {
772 if (bOn)
773 {
774 xGrid->setRowSet(Reference< XRowSet > ());
775 }
776 else
777 {
778 Reference< XFormComponent > xComp(getModel(), UNO_QUERY);
779 if (xComp.is())
780 {
781 Reference< XRowSet > xForm(xComp->getParent(), UNO_QUERY);
782 xGrid->setRowSet(xForm);
783 }
784 }
785
786 mbDesignMode = bOn;
787
788 Reference< XVclWindowPeer > xVclWindowPeer( getPeer(), UNO_QUERY );
789 if (xVclWindowPeer.is())
790 xVclWindowPeer->setDesignMode(bOn);
791 }
792 mbDesignMode = bOn;
793
794 // dispose our current AccessibleContext, if we have one
795 // (changing the design mode implies having a new implementation for this context,
796 // so the old one must be declared DEFUNC)
797 disposeAccessibleContext();
798
799 // prepare firing an event
800 aModeChangeEvent.Source = *this;
801 aModeChangeEvent.NewMode = ::rtl::OUString::createFromAscii( mbDesignMode ? "design" : "alive" );
802 }
803
804 // --- </mutex_lock> ---
805 maModeChangeListeners.notifyEach( &XModeChangeListener::modeChanged, aModeChangeEvent );
806 }
807
808 // XBoundComponent
809 //------------------------------------------------------------------------------
addUpdateListener(const Reference<XUpdateListener> & l)810 void SAL_CALL FmXGridControl::addUpdateListener(const Reference< XUpdateListener >& l) throw( RuntimeException )
811 {
812 m_aUpdateListeners.addInterface( l );
813 if( getPeer().is() && m_aUpdateListeners.getLength() == 1 )
814 {
815 Reference< XBoundComponent > xBound(getPeer(), UNO_QUERY);
816 xBound->addUpdateListener( &m_aUpdateListeners);
817 }
818 }
819
820 //------------------------------------------------------------------------------
removeUpdateListener(const Reference<XUpdateListener> & l)821 void SAL_CALL FmXGridControl::removeUpdateListener(const Reference< XUpdateListener >& l) throw( RuntimeException )
822 {
823 if( getPeer().is() && m_aUpdateListeners.getLength() == 1 )
824 {
825 Reference< XBoundComponent > xBound(getPeer(), UNO_QUERY);
826 xBound->removeUpdateListener( &m_aUpdateListeners);
827 }
828 m_aUpdateListeners.removeInterface( l );
829 }
830
831 //------------------------------------------------------------------------------
commit()832 sal_Bool SAL_CALL FmXGridControl::commit() throw( RuntimeException )
833 {
834 Reference< XBoundComponent > xBound(getPeer(), UNO_QUERY);
835 if (xBound.is())
836 return xBound->commit();
837 else
838 return sal_True;
839 }
840
841 // XContainer
842 //------------------------------------------------------------------------------
addContainerListener(const Reference<XContainerListener> & l)843 void SAL_CALL FmXGridControl::addContainerListener(const Reference< XContainerListener >& l) throw( RuntimeException )
844 {
845 m_aContainerListeners.addInterface( l );
846 if( getPeer().is() && m_aContainerListeners.getLength() == 1 )
847 {
848 Reference< XContainer > xContainer(getPeer(), UNO_QUERY);
849 xContainer->addContainerListener( &m_aContainerListeners);
850 }
851 }
852
853 //------------------------------------------------------------------------------
removeContainerListener(const Reference<XContainerListener> & l)854 void SAL_CALL FmXGridControl::removeContainerListener(const Reference< XContainerListener >& l) throw( RuntimeException )
855 {
856 if( getPeer().is() && m_aContainerListeners.getLength() == 1 )
857 {
858 Reference< XContainer > xContainer(getPeer(), UNO_QUERY);
859 xContainer->removeContainerListener( &m_aContainerListeners);
860 }
861 m_aContainerListeners.removeInterface( l );
862 }
863
864 //------------------------------------------------------------------------------
queryDispatch(const::com::sun::star::util::URL & aURL,const::rtl::OUString & aTargetFrameName,sal_Int32 nSearchFlags)865 Reference< ::com::sun::star::frame::XDispatch > SAL_CALL FmXGridControl::queryDispatch(const ::com::sun::star::util::URL& aURL, const ::rtl::OUString& aTargetFrameName, sal_Int32 nSearchFlags) throw( RuntimeException )
866 {
867 Reference< ::com::sun::star::frame::XDispatchProvider > xPeerProvider(getPeer(), UNO_QUERY);
868 if (xPeerProvider.is())
869 return xPeerProvider->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
870 else
871 return Reference< ::com::sun::star::frame::XDispatch > ();
872 }
873
874 //------------------------------------------------------------------------------
queryDispatches(const Sequence<::com::sun::star::frame::DispatchDescriptor> & aDescripts)875 Sequence< Reference< ::com::sun::star::frame::XDispatch > > SAL_CALL FmXGridControl::queryDispatches(const Sequence< ::com::sun::star::frame::DispatchDescriptor>& aDescripts) throw( RuntimeException )
876 {
877 Reference< ::com::sun::star::frame::XDispatchProvider > xPeerProvider(getPeer(), UNO_QUERY);
878 if (xPeerProvider.is())
879 return xPeerProvider->queryDispatches(aDescripts);
880 else
881 return Sequence< Reference< ::com::sun::star::frame::XDispatch > >();
882 }
883
884 //------------------------------------------------------------------------------
registerDispatchProviderInterceptor(const Reference<::com::sun::star::frame::XDispatchProviderInterceptor> & _xInterceptor)885 void SAL_CALL FmXGridControl::registerDispatchProviderInterceptor(const Reference< ::com::sun::star::frame::XDispatchProviderInterceptor >& _xInterceptor) throw( RuntimeException )
886 {
887 Reference< ::com::sun::star::frame::XDispatchProviderInterception > xPeerInterception(getPeer(), UNO_QUERY);
888 if (xPeerInterception.is())
889 xPeerInterception->registerDispatchProviderInterceptor(_xInterceptor);
890 }
891
892 //------------------------------------------------------------------------------
releaseDispatchProviderInterceptor(const Reference<::com::sun::star::frame::XDispatchProviderInterceptor> & _xInterceptor)893 void SAL_CALL FmXGridControl::releaseDispatchProviderInterceptor(const Reference< ::com::sun::star::frame::XDispatchProviderInterceptor >& _xInterceptor) throw( RuntimeException )
894 {
895 Reference< ::com::sun::star::frame::XDispatchProviderInterception > xPeerInterception(getPeer(), UNO_QUERY);
896 if (xPeerInterception.is())
897 xPeerInterception->releaseDispatchProviderInterceptor(_xInterceptor);
898 }
899
900 //------------------------------------------------------------------------------
addGridControlListener(const Reference<XGridControlListener> & _listener)901 void SAL_CALL FmXGridControl::addGridControlListener( const Reference< XGridControlListener >& _listener ) throw( RuntimeException )
902 {
903 ::osl::MutexGuard aGuard( GetMutex() );
904
905 m_aGridControlListeners.addInterface( _listener );
906 if ( getPeer().is() && 1 == m_aGridControlListeners.getLength() )
907 {
908 Reference< XGridControl > xPeerGrid( getPeer(), UNO_QUERY );
909 if ( xPeerGrid.is() )
910 xPeerGrid->addGridControlListener( &m_aGridControlListeners );
911 }
912 }
913
914 //------------------------------------------------------------------------------
removeGridControlListener(const Reference<XGridControlListener> & _listener)915 void SAL_CALL FmXGridControl::removeGridControlListener( const Reference< XGridControlListener >& _listener ) throw( RuntimeException )
916 {
917 ::osl::MutexGuard aGuard( GetMutex() );
918
919 if( getPeer().is() && 1 == m_aGridControlListeners.getLength() )
920 {
921 Reference< XGridControl > xPeerGrid( getPeer(), UNO_QUERY );
922 if ( xPeerGrid.is() )
923 xPeerGrid->removeGridControlListener( &m_aGridControlListeners );
924 }
925
926 m_aGridControlListeners.removeInterface( _listener );
927 }
928
929 //------------------------------------------------------------------------------
getCurrentColumnPosition()930 sal_Int16 SAL_CALL FmXGridControl::getCurrentColumnPosition() throw( RuntimeException )
931 {
932 Reference< XGridControl > xGrid( getPeer(), UNO_QUERY );
933 return xGrid.is() ? xGrid->getCurrentColumnPosition() : -1;
934 }
935
936 //------------------------------------------------------------------------------
setCurrentColumnPosition(sal_Int16 nPos)937 void SAL_CALL FmXGridControl::setCurrentColumnPosition(sal_Int16 nPos) throw( RuntimeException )
938 {
939 Reference< XGridControl > xGrid( getPeer(), UNO_QUERY );
940 if ( xGrid.is() )
941 {
942 ::vos::OGuard aGuard( Application::GetSolarMutex() );
943 xGrid->setCurrentColumnPosition( nPos );
944 }
945 }
946
947 // XElementAccess
948 //------------------------------------------------------------------------------
hasElements()949 sal_Bool SAL_CALL FmXGridControl::hasElements() throw( RuntimeException )
950 {
951 Reference< XElementAccess > xPeer(getPeer(), UNO_QUERY);
952 return xPeer.is() ? xPeer->hasElements() : 0;
953 }
954
955 //------------------------------------------------------------------------------
getElementType()956 Type SAL_CALL FmXGridControl::getElementType( ) throw(RuntimeException)
957 {
958 return ::getCppuType((const Reference< ::com::sun::star::awt::XTextComponent >*)NULL);
959 }
960
961 // XEnumerationAccess
962 //------------------------------------------------------------------------------
createEnumeration()963 Reference< XEnumeration > SAL_CALL FmXGridControl::createEnumeration() throw( RuntimeException )
964 {
965 Reference< XEnumerationAccess > xPeer(getPeer(), UNO_QUERY);
966 if (xPeer.is())
967 return xPeer->createEnumeration();
968 else
969 return new ::comphelper::OEnumerationByIndex(this);
970 }
971
972 // XIndexAccess
973 //------------------------------------------------------------------------------
getCount()974 sal_Int32 SAL_CALL FmXGridControl::getCount() throw( RuntimeException )
975 {
976 Reference< XIndexAccess > xPeer(getPeer(), UNO_QUERY);
977 return xPeer.is() ? xPeer->getCount() : 0;
978 }
979
980 //------------------------------------------------------------------------------
getByIndex(sal_Int32 _nIndex)981 Any SAL_CALL FmXGridControl::getByIndex(sal_Int32 _nIndex) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
982 {
983 Reference< XIndexAccess > xPeer(getPeer(), UNO_QUERY);
984 if (!xPeer.is())
985 throw IndexOutOfBoundsException();
986
987 return xPeer->getByIndex(_nIndex);
988 }
989
990 // ::com::sun::star::util::XModeSelector
991 //------------------------------------------------------------------------------
setMode(const::rtl::OUString & Mode)992 void SAL_CALL FmXGridControl::setMode(const ::rtl::OUString& Mode) throw( NoSupportException, RuntimeException )
993 {
994 Reference< ::com::sun::star::util::XModeSelector > xPeer(getPeer(), UNO_QUERY);
995 if (!xPeer.is())
996 throw NoSupportException();
997
998 xPeer->setMode(Mode);
999 }
1000
1001 //------------------------------------------------------------------------------
getMode()1002 ::rtl::OUString SAL_CALL FmXGridControl::getMode() throw( RuntimeException )
1003 {
1004 Reference< ::com::sun::star::util::XModeSelector > xPeer(getPeer(), UNO_QUERY);
1005 return xPeer.is() ? xPeer->getMode() : ::rtl::OUString();
1006 }
1007
1008 //------------------------------------------------------------------------------
getSupportedModes()1009 ::comphelper::StringSequence SAL_CALL FmXGridControl::getSupportedModes() throw( RuntimeException )
1010 {
1011 Reference< ::com::sun::star::util::XModeSelector > xPeer(getPeer(), UNO_QUERY);
1012 return xPeer.is() ? xPeer->getSupportedModes() : ::comphelper::StringSequence();
1013 }
1014
1015 //------------------------------------------------------------------------------
supportsMode(const::rtl::OUString & Mode)1016 sal_Bool SAL_CALL FmXGridControl::supportsMode(const ::rtl::OUString& Mode) throw( RuntimeException )
1017 {
1018 Reference< ::com::sun::star::util::XModeSelector > xPeer(getPeer(), UNO_QUERY);
1019 return xPeer.is() ? xPeer->supportsMode(Mode) : sal_False;
1020 }
1021
1022 //==============================================================================
1023 //= FmXGridPeer
1024 //==============================================================================
1025 // helper class which prevents that in the peer's header the FmGridListener must be known
1026 class FmXGridPeer::GridListenerDelegator : public FmGridListener
1027 {
1028 protected:
1029 FmXGridPeer* m_pPeer;
1030
1031 public:
1032 GridListenerDelegator( FmXGridPeer* _pPeer );
1033
1034 protected:
1035 virtual void selectionChanged();
1036 virtual void columnChanged();
1037 };
1038
1039 //------------------------------------------------------------------
GridListenerDelegator(FmXGridPeer * _pPeer)1040 FmXGridPeer::GridListenerDelegator::GridListenerDelegator(FmXGridPeer* _pPeer)
1041 :m_pPeer(_pPeer)
1042 {
1043 DBG_ASSERT(m_pPeer, "GridListenerDelegator::GridListenerDelegator");
1044 }
1045
1046 //------------------------------------------------------------------
selectionChanged()1047 void FmXGridPeer::GridListenerDelegator::selectionChanged()
1048 {
1049 m_pPeer->selectionChanged();
1050 }
1051
1052 //------------------------------------------------------------------
columnChanged()1053 void FmXGridPeer::GridListenerDelegator::columnChanged()
1054 {
1055 m_pPeer->columnChanged();
1056 }
1057
1058 //==============================================================================
1059 //------------------------------------------------------------------
FmXGridPeer_CreateInstance(const Reference<XMultiServiceFactory> & _rxFactory)1060 Reference< XInterface > FmXGridPeer_CreateInstance(const Reference< XMultiServiceFactory>& _rxFactory)
1061 {
1062 FmXGridPeer* pNewObject = new FmXGridPeer(_rxFactory);
1063 pNewObject->Create(NULL, WB_TABSTOP);
1064 return *pNewObject;
1065 }
1066
1067 //------------------------------------------------------------------
getTypes()1068 Sequence< Type> SAL_CALL FmXGridPeer::getTypes( ) throw(RuntimeException)
1069 {
1070 return comphelper::concatSequences( VCLXWindow::getTypes(), FmXGridPeer_BASE::getTypes() );
1071 }
1072
1073 //------------------------------------------------------------------
getImplementationId()1074 Sequence<sal_Int8> SAL_CALL FmXGridPeer::getImplementationId( ) throw(RuntimeException)
1075 {
1076 static ::cppu::OImplementationId* pId = 0;
1077 if (! pId)
1078 {
1079 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
1080 if (! pId)
1081 {
1082 static ::cppu::OImplementationId aId;
1083 pId = &aId;
1084 }
1085 }
1086 return pId->getImplementationId();
1087 }
1088
1089 //------------------------------------------------------------------
queryInterface(const Type & _rType)1090 Any SAL_CALL FmXGridPeer::queryInterface(const Type& _rType) throw (RuntimeException)
1091 {
1092 Any aReturn = FmXGridPeer_BASE::queryInterface(_rType);
1093
1094 if (!aReturn.hasValue())
1095 aReturn = VCLXWindow::queryInterface( _rType );
1096
1097 return aReturn;
1098 }
1099
1100 //------------------------------------------------------------------
selectionChanged()1101 void FmXGridPeer::selectionChanged()
1102 {
1103 EventObject aSource;
1104 aSource.Source = static_cast< ::cppu::OWeakObject* >(this);
1105 m_aSelectionListeners.notifyEach( &XSelectionChangeListener::selectionChanged, aSource);
1106 }
1107
1108 //------------------------------------------------------------------
columnChanged()1109 void FmXGridPeer::columnChanged()
1110 {
1111 EventObject aEvent( *this );
1112 m_aGridControlListeners.notifyEach( &XGridControlListener::columnChanged, aEvent );
1113 }
1114
1115 //------------------------------------------------------------------
1116 namespace fmgridif
1117 {
getDataModeIdentifier()1118 const ::rtl::OUString getDataModeIdentifier()
1119 {
1120 static ::rtl::OUString s_sDataModeIdentifier = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DataMode" ) );
1121 return s_sDataModeIdentifier;
1122 }
1123 }
1124 using namespace fmgridif;
1125
1126 //------------------------------------------------------------------
FmXGridPeer(const Reference<XMultiServiceFactory> & _rxFactory)1127 FmXGridPeer::FmXGridPeer(const Reference< XMultiServiceFactory >& _rxFactory)
1128 :m_aModifyListeners(m_aMutex)
1129 ,m_aUpdateListeners(m_aMutex)
1130 ,m_aContainerListeners(m_aMutex)
1131 ,m_aSelectionListeners(m_aMutex)
1132 ,m_aGridControlListeners(m_aMutex)
1133 ,m_aMode( getDataModeIdentifier() )
1134 ,m_nCursorListening(0)
1135 ,m_bInterceptingDispatch(sal_False)
1136 ,m_pStateCache(NULL)
1137 ,m_pDispatchers(NULL)
1138 ,m_pGridListener(NULL)
1139 ,m_xServiceFactory(_rxFactory)
1140 {
1141 // nach diesem Constructor muss Create gerufen werden !
1142 m_pGridListener = new GridListenerDelegator( this );
1143 }
1144
1145 //------------------------------------------------------------------------------
imp_CreateControl(Window * pParent,WinBits nStyle)1146 FmGridControl* FmXGridPeer::imp_CreateControl(Window* pParent, WinBits nStyle)
1147 {
1148 return new FmGridControl(m_xServiceFactory, pParent, this, nStyle);
1149 }
1150
1151 //------------------------------------------------------------------------------
Create(Window * pParent,WinBits nStyle)1152 void FmXGridPeer::Create(Window* pParent, WinBits nStyle)
1153 {
1154 FmGridControl* pWin = imp_CreateControl(pParent, nStyle);
1155 DBG_ASSERT(pWin != NULL, "FmXGridPeer::Create : imp_CreateControl didn't return a control !");
1156
1157 pWin->SetStateProvider(LINK(this, FmXGridPeer, OnQueryGridSlotState));
1158 pWin->SetSlotExecutor(LINK(this, FmXGridPeer, OnExecuteGridSlot));
1159
1160 // want to hear about row selections
1161 pWin->setGridListener( m_pGridListener );
1162
1163 // Init mu� immer aufgerufen werden
1164 pWin->Init();
1165 pWin->SetComponentInterface(this);
1166
1167 getSupportedURLs();
1168 }
1169
1170 //------------------------------------------------------------------------------
~FmXGridPeer()1171 FmXGridPeer::~FmXGridPeer()
1172 {
1173 setRowSet(Reference< XRowSet > ());
1174 setColumns(Reference< XIndexContainer > ());
1175
1176 delete m_pGridListener;
1177 }
1178
1179 //------------------------------------------------------------------------------
getUnoTunnelImplementationId()1180 const Sequence< sal_Int8 >& FmXGridPeer::getUnoTunnelImplementationId() throw()
1181 {
1182 static Sequence< sal_Int8 > * pSeq = 0;
1183 if( !pSeq )
1184 {
1185 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
1186 if( !pSeq )
1187 {
1188 static Sequence< sal_Int8 > aSeq( 16 );
1189 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
1190 pSeq = &aSeq;
1191 }
1192 }
1193 return *pSeq;
1194 }
1195
1196 //------------------------------------------------------------------------------
getImplementation(const Reference<XInterface> & _rxIFace)1197 FmXGridPeer* FmXGridPeer::getImplementation( const Reference< XInterface >& _rxIFace ) throw()
1198 {
1199 FmXGridPeer* pReturn = NULL;
1200 Reference< XUnoTunnel > xTunnel(_rxIFace, UNO_QUERY);
1201 if (xTunnel.is())
1202 pReturn = reinterpret_cast<FmXGridPeer*>(xTunnel->getSomething(getUnoTunnelImplementationId()));
1203
1204 return pReturn;
1205 }
1206
1207 //------------------------------------------------------------------------------
getSomething(const Sequence<sal_Int8> & _rIdentifier)1208 sal_Int64 SAL_CALL FmXGridPeer::getSomething( const Sequence< sal_Int8 >& _rIdentifier ) throw(RuntimeException)
1209 {
1210 sal_Int64 nReturn(0);
1211
1212 if ( (_rIdentifier.getLength() == 16)
1213 && (0 == rtl_compareMemory( getUnoTunnelImplementationId().getConstArray(), _rIdentifier.getConstArray(), 16 ))
1214 )
1215 {
1216 nReturn = reinterpret_cast<sal_Int64>(this);
1217 }
1218 else
1219 nReturn = VCLXWindow::getSomething(_rIdentifier);
1220
1221 return nReturn;
1222 }
1223
1224 // XEventListener
1225 //------------------------------------------------------------------------------
disposing(const EventObject & e)1226 void FmXGridPeer::disposing(const EventObject& e) throw( RuntimeException )
1227 {
1228 using namespace ::com::sun::star::util;
1229 bool bKnownSender = false;
1230
1231 Reference< XIndexContainer > xCols( e.Source, UNO_QUERY );
1232 if ( xCols.is() )
1233 {
1234 setColumns(Reference< XIndexContainer > ());
1235 bKnownSender = true;
1236 }
1237
1238 Reference< XRowSet > xCursor(e.Source, UNO_QUERY);
1239 if (xCursor.is())
1240 {
1241 setRowSet( m_xCursor );
1242 m_xCursor = NULL;
1243 bKnownSender = true;
1244 }
1245
1246
1247 if ( !bKnownSender && m_pDispatchers )
1248 {
1249 const Sequence< URL>& aSupportedURLs = getSupportedURLs();
1250 const URL* pSupportedURLs = aSupportedURLs.getConstArray();
1251 for ( sal_uInt16 i=0; i < ( aSupportedURLs.getLength() ) && !bKnownSender; ++i, ++pSupportedURLs )
1252 {
1253 if ( m_pDispatchers[i] == e.Source )
1254 {
1255 m_pDispatchers[i]->removeStatusListener( static_cast< ::com::sun::star::frame::XStatusListener* >( this ), *pSupportedURLs );
1256 m_pDispatchers[i] = NULL;
1257 m_pStateCache[i] = 0;
1258 bKnownSender = true;
1259 }
1260 }
1261 }
1262
1263 if ( !bKnownSender )
1264 VCLXWindow::disposing(e);
1265 }
1266
1267 //------------------------------------------------------------------------------
addModifyListener(const Reference<::com::sun::star::util::XModifyListener> & l)1268 void FmXGridPeer::addModifyListener(const Reference< ::com::sun::star::util::XModifyListener >& l) throw( RuntimeException )
1269 {
1270 m_aModifyListeners.addInterface( l );
1271 }
1272
1273 //------------------------------------------------------------------------------
removeModifyListener(const Reference<::com::sun::star::util::XModifyListener> & l)1274 void FmXGridPeer::removeModifyListener(const Reference< ::com::sun::star::util::XModifyListener >& l) throw( RuntimeException )
1275 {
1276 m_aModifyListeners.removeInterface( l );
1277 }
1278
1279 //------------------------------------------------------------------------------
1280 #define LAST_KNOWN_TYPE FormComponentType::PATTERNFIELD
queryFieldDataType(const Type & xType)1281 Sequence< sal_Bool > SAL_CALL FmXGridPeer::queryFieldDataType( const Type& xType ) throw(RuntimeException)
1282 {
1283 // eine 'Konvertierungstabelle'
1284 static sal_Bool bCanConvert[LAST_KNOWN_TYPE][4] =
1285 {
1286 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::CONTROL
1287 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::COMMANDBUTTON
1288 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::RADIOBUTTON
1289 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::IMAGEBUTTON
1290 { sal_False, sal_False, sal_False, sal_True }, // FormComponentType::CHECKBOX
1291 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::LISTBOX
1292 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::COMBOBOX
1293 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::GROUPBOX
1294 { sal_True , sal_False, sal_False, sal_False }, // FormComponentType::TEXTFIELD
1295 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::FIXEDTEXT
1296 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::GRIDCONTROL
1297 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::FILECONTROL
1298 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::HIDDENCONTROL
1299 { sal_False, sal_False, sal_False, sal_False }, // FormComponentType::IMAGECONTROL
1300 { sal_True , sal_True , sal_True , sal_False }, // FormComponentType::DATEFIELD
1301 { sal_True , sal_True , sal_False, sal_False }, // FormComponentType::TIMEFIELD
1302 { sal_True , sal_True , sal_False, sal_False }, // FormComponentType::NUMERICFIELD
1303 { sal_True , sal_True , sal_False, sal_False }, // FormComponentType::CURRENCYFIELD
1304 { sal_True , sal_False, sal_False, sal_False } // FormComponentType::PATTERNFIELD
1305 };
1306
1307
1308 sal_Int16 nMapColumn = -1;
1309 switch (xType.getTypeClass())
1310 {
1311 case TypeClass_STRING : nMapColumn = 0; break;
1312 case TypeClass_FLOAT:
1313 case TypeClass_DOUBLE : nMapColumn = 1; break;
1314 case TypeClass_SHORT:
1315 case TypeClass_LONG:
1316 case TypeClass_UNSIGNED_LONG:
1317 case TypeClass_UNSIGNED_SHORT : nMapColumn = 2; break;
1318 case TypeClass_BOOLEAN : nMapColumn = 3; break;
1319 default:
1320 break;
1321 }
1322
1323 Reference< XIndexContainer > xColumns = getColumns();
1324
1325 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1326 sal_Int32 nColumns = pGrid->GetViewColCount();
1327
1328 DbGridColumns aColumns = pGrid->GetColumns();
1329
1330 Sequence<sal_Bool> aReturnSequence(nColumns);
1331 sal_Bool* pReturnArray = aReturnSequence.getArray();
1332
1333 sal_Bool bRequestedAsAny = (xType.getTypeClass() == TypeClass_ANY);
1334
1335 DbGridColumn* pCol;
1336 Reference< ::com::sun::star::sdb::XColumn > xFieldContent;
1337 Reference< XPropertySet > xCurrentColumn;
1338 for (sal_Int32 i=0; i<nColumns; ++i)
1339 {
1340 if (bRequestedAsAny)
1341 {
1342 pReturnArray[i] = sal_True;
1343 continue;
1344 }
1345
1346 pReturnArray[i] = sal_False;
1347
1348 sal_uInt16 nModelPos = pGrid->GetModelColumnPos(pGrid->GetColumnIdFromViewPos((sal_uInt16)i));
1349 DBG_ASSERT(nModelPos != (sal_uInt16)-1, "FmXGridPeer::queryFieldDataType : no model pos !");
1350
1351 pCol = aColumns.GetObject(nModelPos);
1352 const DbGridRowRef xRow = pGrid->GetSeekRow();
1353 xFieldContent = (xRow.Is() && xRow->HasField(pCol->GetFieldPos())) ? xRow->GetField(pCol->GetFieldPos()).getColumn() : Reference< ::com::sun::star::sdb::XColumn > ();
1354 if (!xFieldContent.is())
1355 // can't supply anything without a field content
1356 // FS - 07.12.99 - 54391
1357 continue;
1358
1359 xColumns->getByIndex(nModelPos) >>= xCurrentColumn;
1360 if (!::comphelper::hasProperty(FM_PROP_CLASSID, xCurrentColumn))
1361 continue;
1362
1363 sal_Int16 nClassId = sal_Int16();
1364 xCurrentColumn->getPropertyValue(FM_PROP_CLASSID) >>= nClassId;
1365 if (nClassId>LAST_KNOWN_TYPE)
1366 continue;
1367 DBG_ASSERT(nClassId>0, "FmXGridPeer::queryFieldDataType : somebody changed the definition of the FormComponentType enum !");
1368
1369 if (nMapColumn != -1)
1370 pReturnArray[i] = bCanConvert[nClassId-1][nMapColumn];
1371 }
1372
1373 return aReturnSequence;
1374 }
1375
1376 //------------------------------------------------------------------------------
queryFieldData(sal_Int32 nRow,const Type & xType)1377 Sequence< Any > SAL_CALL FmXGridPeer::queryFieldData( sal_Int32 nRow, const Type& xType ) throw(RuntimeException)
1378 {
1379 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1380 DBG_ASSERT(pGrid && pGrid->IsOpen(), "FmXGridPeer::queryFieldData : have no valid grid window !");
1381 if (!pGrid || !pGrid->IsOpen())
1382 return Sequence< Any>();
1383
1384 // das Control zur angegebenen Row fahren
1385 if (!pGrid->SeekRow(nRow))
1386 {
1387 throw IllegalArgumentException();
1388 }
1389
1390 // don't use GetCurrentRow as this isn't affected by the above SeekRow
1391 // FS - 30.09.99 - 68644
1392 DbGridRowRef xPaintRow = pGrid->GetPaintRow();
1393 ENSURE_OR_THROW( xPaintRow.Is(), "invalid paint row" );
1394
1395 // die Columns des Controls brauche ich fuer GetFieldText
1396 DbGridColumns aColumns = pGrid->GetColumns();
1397
1398 // und durch alle Spalten durch
1399 sal_Int32 nColumnCount = pGrid->GetViewColCount();
1400
1401 Sequence< Any> aReturnSequence(nColumnCount);
1402 Any* pReturnArray = aReturnSequence.getArray();
1403
1404 sal_Bool bRequestedAsAny = (xType.getTypeClass() == TypeClass_ANY);
1405 Reference< ::com::sun::star::sdb::XColumn > xFieldContent;
1406 DbGridColumn* pCol;
1407 for (sal_Int32 i=0; i < nColumnCount; ++i)
1408 {
1409 sal_uInt16 nModelPos = pGrid->GetModelColumnPos(pGrid->GetColumnIdFromViewPos((sal_uInt16)i));
1410 DBG_ASSERT(nModelPos != (sal_uInt16)-1, "FmXGridPeer::queryFieldData : invalid model pos !");
1411
1412 // don't use GetCurrentFieldValue to determine the field content as this isn't affected by the above SeekRow
1413 // FS - 30.09.99 - 68644
1414 pCol = aColumns.GetObject(nModelPos);
1415 xFieldContent = xPaintRow->HasField( pCol->GetFieldPos() )
1416 ? xPaintRow->GetField( pCol->GetFieldPos() ).getColumn()
1417 : Reference< XColumn > ();
1418
1419 if ( !xFieldContent.is() )
1420 continue;
1421
1422 if (bRequestedAsAny)
1423 {
1424 Reference< XPropertySet > xFieldSet(xFieldContent, UNO_QUERY);
1425 pReturnArray[i] = xFieldSet->getPropertyValue(FM_PROP_VALUE);
1426 }
1427 else
1428 {
1429 switch (xType.getTypeClass())
1430 {
1431 // Strings werden direkt ueber das GetFieldText abgehandelt
1432 case TypeClass_STRING :
1433 {
1434 String sText = aColumns.GetObject(nModelPos)->GetCellText( xPaintRow, pGrid->getNumberFormatter() );
1435 pReturnArray[i] <<= ::rtl::OUString(sText);
1436 }
1437 break;
1438 // alles andere wird an der DatabaseVariant erfragt
1439 case TypeClass_FLOAT : pReturnArray[i] <<= xFieldContent->getFloat(); break;
1440 case TypeClass_DOUBLE : pReturnArray[i] <<= xFieldContent->getDouble(); break;
1441 case TypeClass_SHORT : pReturnArray[i] <<= (sal_Int16)xFieldContent->getShort(); break;
1442 case TypeClass_LONG : pReturnArray[i] <<= (sal_Int32)xFieldContent->getLong(); break;
1443 case TypeClass_UNSIGNED_SHORT : pReturnArray[i] <<= (sal_uInt16)xFieldContent->getShort(); break;
1444 case TypeClass_UNSIGNED_LONG : pReturnArray[i] <<= (sal_uInt32)xFieldContent->getLong(); break;
1445 case TypeClass_BOOLEAN : ::comphelper::setBOOL(pReturnArray[i],xFieldContent->getBoolean()); break;
1446 default:
1447 {
1448 throw IllegalArgumentException();
1449 }
1450 }
1451 }
1452 }
1453 return aReturnSequence;
1454 }
1455
1456 //------------------------------------------------------------------------------
CellModified()1457 void FmXGridPeer::CellModified()
1458 {
1459 EventObject aEvt;
1460 aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
1461 m_aModifyListeners.notifyEach( &XModifyListener::modified, aEvt );
1462 }
1463
1464 // XPropertyChangeListener
1465 //------------------------------------------------------------------------------
propertyChange(const PropertyChangeEvent & evt)1466 void FmXGridPeer::propertyChange(const PropertyChangeEvent& evt) throw( RuntimeException )
1467 {
1468 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1469 // want to do a lot of VCL stuff here ...
1470 // this should not be (deadlock) critical, as by definition, every component should release
1471 // any own mutexes before notifying
1472
1473 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1474 if (!pGrid)
1475 return;
1476
1477 // DatenbankEvent
1478 Reference< XRowSet > xCursor(evt.Source, UNO_QUERY);
1479 if (evt.PropertyName == FM_PROP_VALUE || m_xCursor == evt.Source)
1480 pGrid->propertyChange(evt);
1481 else if (pGrid && m_xColumns.is() && m_xColumns->hasElements())
1482 {
1483 // zunaechst raussuchen welche Column sich geaendert hat
1484 ::comphelper::InterfaceRef xCurrent;
1485 sal_Int32 i;
1486
1487 for ( i = 0; i < m_xColumns->getCount(); i++)
1488 {
1489 ::cppu::extractInterface(xCurrent, m_xColumns->getByIndex(i));
1490 if (evt.Source == xCurrent)
1491 break;
1492 }
1493
1494 if (i >= m_xColumns->getCount())
1495 // this is valid because we are listening at the cursor, too (RecordCount, -status, edit mode)
1496 return;
1497
1498 sal_uInt16 nId = pGrid->GetColumnIdFromModelPos((sal_uInt16)i);
1499 sal_Bool bInvalidateColumn = sal_False;
1500
1501 if (evt.PropertyName == FM_PROP_LABEL)
1502 {
1503 String aName = ::comphelper::getString(evt.NewValue);
1504 if (aName != pGrid->GetColumnTitle(nId))
1505 pGrid->SetColumnTitle(nId, aName);
1506 }
1507 else if (evt.PropertyName == FM_PROP_WIDTH)
1508 {
1509 sal_Int32 nWidth = 0;
1510 if (evt.NewValue.getValueType().getTypeClass() == TypeClass_VOID)
1511 nWidth = pGrid->GetDefaultColumnWidth(pGrid->GetColumnTitle(nId));
1512 // GetDefaultColumnWidth already considered the zoom factor
1513 else
1514 {
1515 sal_Int32 nTest = 0;
1516 if (evt.NewValue >>= nTest)
1517 {
1518 nWidth = pGrid->LogicToPixel(Point(nTest,0),MAP_10TH_MM).X();
1519 // take the zoom factor into account
1520 nWidth = pGrid->CalcZoom(nWidth);
1521 }
1522 }
1523 if (nWidth != (sal_Int32(pGrid->GetColumnWidth(nId))))
1524 {
1525 if (pGrid->IsEditing())
1526 {
1527 pGrid->DeactivateCell();
1528 pGrid->ActivateCell();
1529 }
1530 pGrid->SetColumnWidth(nId, nWidth);
1531 }
1532 }
1533 else if (evt.PropertyName == FM_PROP_HIDDEN)
1534 {
1535 DBG_ASSERT(evt.NewValue.getValueType().getTypeClass() == TypeClass_BOOLEAN,
1536 "FmXGridPeer::propertyChange : the property 'hidden' should be of type boolean !");
1537 if (::comphelper::getBOOL(evt.NewValue))
1538 pGrid->HideColumn(nId);
1539 else
1540 pGrid->ShowColumn(nId);
1541 }
1542 else if (evt.PropertyName == FM_PROP_ALIGN)
1543 {
1544 // it design mode it doesn't matter
1545 if (!isDesignMode())
1546 {
1547 DbGridColumn* pCol = pGrid->GetColumns().GetObject(i);
1548
1549 pCol->SetAlignmentFromModel(-1);
1550 bInvalidateColumn = sal_True;
1551 }
1552 }
1553 else if (evt.PropertyName == FM_PROP_FORMATKEY)
1554 {
1555 if (!isDesignMode())
1556 bInvalidateColumn = sal_True;
1557 }
1558
1559 // need to invalidate the affected column ?
1560 if (bInvalidateColumn)
1561 {
1562 sal_Bool bWasEditing = pGrid->IsEditing();
1563 if (bWasEditing)
1564 pGrid->DeactivateCell();
1565
1566 ::Rectangle aColRect = pGrid->GetFieldRect(nId);
1567 aColRect.Top() = 0;
1568 aColRect.Bottom() = pGrid->GetSizePixel().Height();
1569 pGrid->Invalidate(aColRect);
1570
1571 if (bWasEditing)
1572 pGrid->ActivateCell();
1573 }
1574 }
1575 }
1576
1577 // XBoundComponent
1578 //------------------------------------------------------------------------------
addUpdateListener(const Reference<XUpdateListener> & l)1579 void FmXGridPeer::addUpdateListener(const Reference< XUpdateListener >& l) throw( RuntimeException )
1580 {
1581 m_aUpdateListeners.addInterface(l);
1582 }
1583
1584 //------------------------------------------------------------------------------
removeUpdateListener(const Reference<XUpdateListener> & l)1585 void FmXGridPeer::removeUpdateListener(const Reference< XUpdateListener >& l) throw( RuntimeException )
1586 {
1587 m_aUpdateListeners.removeInterface(l);
1588 }
1589
1590 //------------------------------------------------------------------------------
commit()1591 sal_Bool FmXGridPeer::commit() throw( RuntimeException )
1592 {
1593 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1594 if (!m_xCursor.is() || !pGrid)
1595 return sal_True;
1596
1597 EventObject aEvt(static_cast< ::cppu::OWeakObject* >(this));
1598 ::cppu::OInterfaceIteratorHelper aIter(m_aUpdateListeners);
1599 sal_Bool bCancel = sal_False;
1600 while (aIter.hasMoreElements() && !bCancel)
1601 if ( !static_cast< XUpdateListener* >( aIter.next() )->approveUpdate( aEvt ) )
1602 bCancel = sal_True;
1603
1604 if (!bCancel)
1605 bCancel = !pGrid->commit();
1606
1607 if (!bCancel)
1608 m_aUpdateListeners.notifyEach( &XUpdateListener::updated, aEvt );
1609 return !bCancel;
1610 }
1611
1612
1613 //------------------------------------------------------------------------------
cursorMoved(const EventObject & _rEvent)1614 void FmXGridPeer::cursorMoved(const EventObject& _rEvent) throw( RuntimeException )
1615 {
1616 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1617 // we are not interested in move to insert row only in the resetted event
1618 // which is fired after positioning an the insert row
1619 if (pGrid && pGrid->IsOpen() && !::comphelper::getBOOL(Reference< XPropertySet > (_rEvent.Source, UNO_QUERY)->getPropertyValue(FM_PROP_ISNEW)))
1620 pGrid->positioned(_rEvent);
1621 }
1622
1623 //------------------------------------------------------------------------------
rowChanged(const EventObject & _rEvent)1624 void FmXGridPeer::rowChanged(const EventObject& _rEvent) throw( RuntimeException )
1625 {
1626 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1627 if (pGrid && pGrid->IsOpen())
1628 {
1629 if (m_xCursor->rowUpdated() && !pGrid->IsCurrentAppending())
1630 pGrid->RowModified(pGrid->GetCurrentPos());
1631 else if (m_xCursor->rowInserted())
1632 pGrid->inserted(_rEvent);
1633 }
1634 }
1635
1636 //------------------------------------------------------------------------------
rowSetChanged(const EventObject &)1637 void FmXGridPeer::rowSetChanged(const EventObject& /*event*/) throw( RuntimeException )
1638 {
1639 // not interested in ...
1640 // (our parent is a form which means we get a loaded or reloaded after this rowSetChanged)
1641 }
1642
1643 // XLoadListener
1644 //------------------------------------------------------------------------------
loaded(const EventObject &)1645 void FmXGridPeer::loaded(const EventObject& /*rEvent*/) throw( RuntimeException )
1646 {
1647 updateGrid(m_xCursor);
1648 }
1649
1650 //------------------------------------------------------------------------------
unloaded(const EventObject &)1651 void FmXGridPeer::unloaded(const EventObject& /*rEvent*/) throw( RuntimeException )
1652 {
1653 updateGrid( Reference< XRowSet > (NULL) );
1654 }
1655
1656 //------------------------------------------------------------------------------
reloading(const EventObject &)1657 void FmXGridPeer::reloading(const EventObject& /*aEvent*/) throw( RuntimeException )
1658 {
1659 // empty the grid
1660 updateGrid( Reference< XRowSet > (NULL) );
1661 }
1662
1663 //------------------------------------------------------------------------------
unloading(const EventObject &)1664 void FmXGridPeer::unloading(const EventObject& /*aEvent*/) throw( RuntimeException )
1665 {
1666 // empty the grid
1667 updateGrid( Reference< XRowSet > (NULL) );
1668 }
1669
1670 //------------------------------------------------------------------------------
reloaded(const EventObject &)1671 void FmXGridPeer::reloaded(const EventObject& /*aEvent*/) throw( RuntimeException )
1672 {
1673 updateGrid(m_xCursor);
1674 }
1675
1676 // XGridPeer
1677 //------------------------------------------------------------------------------
getColumns()1678 Reference< XIndexContainer > FmXGridPeer::getColumns() throw( RuntimeException )
1679 {
1680 return m_xColumns;
1681 }
1682
1683 //------------------------------------------------------------------------------
addColumnListeners(const Reference<XPropertySet> & xCol)1684 void FmXGridPeer::addColumnListeners(const Reference< XPropertySet >& xCol)
1685 {
1686 static const ::rtl::OUString aPropsListenedTo[] =
1687 {
1688 FM_PROP_LABEL, FM_PROP_WIDTH, FM_PROP_HIDDEN, FM_PROP_ALIGN, FM_PROP_FORMATKEY
1689 };
1690
1691 // as not all properties have to be supported by all columns we have to check this
1692 // before adding a listener
1693 Reference< XPropertySetInfo > xInfo = xCol->getPropertySetInfo();
1694 Property aPropDesc;
1695 const ::rtl::OUString* pProps = aPropsListenedTo;
1696 const ::rtl::OUString* pPropsEnd = pProps + sizeof( aPropsListenedTo ) / sizeof( aPropsListenedTo[ 0 ] );
1697 for (; pProps != pPropsEnd; ++pProps)
1698 {
1699 if ( xInfo->hasPropertyByName( *pProps ) )
1700 {
1701 aPropDesc = xInfo->getPropertyByName( *pProps );
1702 if ( 0 != ( aPropDesc.Attributes & PropertyAttribute::BOUND ) )
1703 xCol->addPropertyChangeListener( *pProps, this );
1704 }
1705 }
1706 }
1707
1708 //------------------------------------------------------------------------------
removeColumnListeners(const Reference<XPropertySet> & xCol)1709 void FmXGridPeer::removeColumnListeners(const Reference< XPropertySet >& xCol)
1710 {
1711 // the same props as in addColumnListeners ... linux has problems with global static UStrings, so
1712 // we have to do it this way ....
1713 static ::rtl::OUString aPropsListenedTo[] =
1714 {
1715 FM_PROP_LABEL, FM_PROP_WIDTH, FM_PROP_HIDDEN, FM_PROP_ALIGN, FM_PROP_FORMATKEY
1716 };
1717
1718 Reference< XPropertySetInfo > xInfo = xCol->getPropertySetInfo();
1719 for (sal_uInt16 i=0; i<sizeof(aPropsListenedTo)/sizeof(aPropsListenedTo[0]); ++i)
1720 if (xInfo->hasPropertyByName(aPropsListenedTo[i]))
1721 xCol->removePropertyChangeListener(aPropsListenedTo[i], this);
1722 }
1723
1724 //------------------------------------------------------------------------------
setColumns(const Reference<XIndexContainer> & Columns)1725 void FmXGridPeer::setColumns(const Reference< XIndexContainer >& Columns) throw( RuntimeException )
1726 {
1727 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1728
1729 FmGridControl* pGrid = static_cast< FmGridControl* >( GetWindow() );
1730
1731 if (m_xColumns.is())
1732 {
1733 Reference< XPropertySet > xCol;
1734 for (sal_Int32 i = 0; i < m_xColumns->getCount(); i++)
1735 {
1736 ::cppu::extractInterface(xCol, m_xColumns->getByIndex(i));
1737 removeColumnListeners(xCol);
1738 }
1739 Reference< XContainer > xContainer(m_xColumns, UNO_QUERY);
1740 xContainer->removeContainerListener(this);
1741
1742 Reference< XSelectionSupplier > xSelSupplier(m_xColumns, UNO_QUERY);
1743 xSelSupplier->removeSelectionChangeListener(this);
1744
1745 Reference< XReset > xColumnReset(m_xColumns, UNO_QUERY);
1746 if (xColumnReset.is())
1747 xColumnReset->removeResetListener((XResetListener*)this);
1748 }
1749 if (Columns.is())
1750 {
1751 Reference< XContainer > xContainer(Columns, UNO_QUERY);
1752 xContainer->addContainerListener(this);
1753
1754 Reference< XSelectionSupplier > xSelSupplier(Columns, UNO_QUERY);
1755 xSelSupplier->addSelectionChangeListener(this);
1756
1757 Reference< XPropertySet > xCol;
1758 for (sal_Int32 i = 0; i < Columns->getCount(); i++)
1759 {
1760 ::cppu::extractInterface(xCol, Columns->getByIndex(i));
1761 addColumnListeners(xCol);
1762 }
1763
1764 Reference< XReset > xColumnReset(Columns, UNO_QUERY);
1765 if (xColumnReset.is())
1766 xColumnReset->addResetListener((XResetListener*)this);
1767 }
1768 m_xColumns = Columns;
1769 if (pGrid)
1770 {
1771 pGrid->InitColumnsByModels(m_xColumns);
1772
1773 if (m_xColumns.is())
1774 {
1775 EventObject aEvt(m_xColumns);
1776 selectionChanged(aEvt);
1777 }
1778 }
1779 }
1780
1781 //------------------------------------------------------------------------------
setDesignMode(sal_Bool bOn)1782 void FmXGridPeer::setDesignMode(sal_Bool bOn) throw( RuntimeException )
1783 {
1784 if (bOn != isDesignMode())
1785 {
1786 Window* pWin = GetWindow();
1787 if (pWin)
1788 ((FmGridControl*) pWin)->SetDesignMode(bOn);
1789 }
1790
1791 if (bOn)
1792 DisConnectFromDispatcher();
1793 else
1794 UpdateDispatches(); // will connect if not already connected and just update else
1795 }
1796
1797 //------------------------------------------------------------------------------
isDesignMode()1798 sal_Bool FmXGridPeer::isDesignMode() throw( RuntimeException )
1799 {
1800 Window* pWin = GetWindow();
1801 if (pWin)
1802 return ((FmGridControl*) pWin)->IsDesignMode();
1803 else
1804 return sal_False;
1805 }
1806
1807 //------------------------------------------------------------------------------
elementInserted(const ContainerEvent & evt)1808 void FmXGridPeer::elementInserted(const ContainerEvent& evt) throw( RuntimeException )
1809 {
1810 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1811
1812 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1813 // Handle Column beruecksichtigen
1814 if (!pGrid || !m_xColumns.is() || pGrid->IsInColumnMove() || m_xColumns->getCount() == ((sal_Int32)pGrid->GetModelColCount()))
1815 return;
1816
1817 Reference< XPropertySet > xSet;
1818 ::cppu::extractInterface(xSet, evt.Element);
1819 addColumnListeners(xSet);
1820
1821 Reference< XPropertySet > xNewColumn(xSet);
1822 String aName = ::comphelper::getString(xNewColumn->getPropertyValue(FM_PROP_LABEL));
1823 Any aWidth = xNewColumn->getPropertyValue(FM_PROP_WIDTH);
1824 sal_Int32 nWidth = 0;
1825 if (aWidth >>= nWidth)
1826 nWidth = pGrid->LogicToPixel(Point(nWidth,0),MAP_10TH_MM).X();
1827
1828 pGrid->AppendColumn(aName, (sal_uInt16)nWidth, (sal_Int16)::comphelper::getINT32(evt.Accessor));
1829
1830 // jetzt die Spalte setzen
1831 DbGridColumn* pCol = pGrid->GetColumns().GetObject(::comphelper::getINT32(evt.Accessor));
1832 pCol->setModel(xNewColumn);
1833
1834 Any aHidden = xNewColumn->getPropertyValue(FM_PROP_HIDDEN);
1835 if (::comphelper::getBOOL(aHidden))
1836 pGrid->HideColumn(pCol->GetId());
1837
1838 FormControlFactory( m_xServiceFactory ).initializeTextFieldLineEnds( xNewColumn );
1839 }
1840
1841 //------------------------------------------------------------------------------
elementReplaced(const ContainerEvent & evt)1842 void FmXGridPeer::elementReplaced(const ContainerEvent& evt) throw( RuntimeException )
1843 {
1844 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1845
1846 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1847
1848 // Handle Column beruecksichtigen
1849 if (!pGrid || !m_xColumns.is() || pGrid->IsInColumnMove())
1850 return;
1851
1852 Reference< XPropertySet > xNewColumn;
1853 Reference< XPropertySet > xOldColumn;
1854 ::cppu::extractInterface(xNewColumn, evt.Element);
1855 ::cppu::extractInterface(xOldColumn, evt.ReplacedElement);
1856
1857 sal_Bool bWasEditing = pGrid->IsEditing();
1858 if (bWasEditing)
1859 pGrid->DeactivateCell();
1860
1861 pGrid->RemoveColumn(pGrid->GetColumnIdFromModelPos((sal_uInt16)::comphelper::getINT32(evt.Accessor)));
1862
1863 removeColumnListeners(xOldColumn);
1864 addColumnListeners(xNewColumn);
1865
1866 String aName = ::comphelper::getString(xNewColumn->getPropertyValue(FM_PROP_LABEL));
1867 Any aWidth = xNewColumn->getPropertyValue(FM_PROP_WIDTH);
1868 sal_Int32 nWidth = 0;
1869 if (aWidth >>= nWidth)
1870 nWidth = pGrid->LogicToPixel(Point(nWidth,0),MAP_10TH_MM).X();
1871 sal_uInt16 nNewId = pGrid->AppendColumn(aName, (sal_uInt16)nWidth, (sal_Int16)::comphelper::getINT32(evt.Accessor));
1872 sal_uInt16 nNewPos = pGrid->GetModelColumnPos(nNewId);
1873
1874 // set the model of the new column
1875 DbGridColumn* pCol = pGrid->GetColumns().GetObject(nNewPos);
1876
1877 // for initializong this grid column, we need the fields of the grid's data source
1878 Reference< XColumnsSupplier > xSuppColumns;
1879 CursorWrapper* pGridDataSource = pGrid->getDataSource();
1880 if ( pGridDataSource )
1881 xSuppColumns = xSuppColumns.query( (Reference< XInterface >)( *pGridDataSource ) );
1882 Reference< XNameAccess > xColumnsByName;
1883 if ( xSuppColumns.is() )
1884 xColumnsByName = xSuppColumns->getColumns();
1885 Reference< XIndexAccess > xColumnsByIndex( xColumnsByName, UNO_QUERY );
1886
1887 if ( xColumnsByIndex.is() )
1888 pGrid->InitColumnByField( pCol, xNewColumn, xColumnsByName, xColumnsByIndex );
1889 else
1890 // the simple version, applies when the grid is not yet connected to a data source
1891 pCol->setModel(xNewColumn);
1892
1893 if (bWasEditing)
1894 pGrid->ActivateCell();
1895 }
1896
1897 //------------------------------------------------------------------------------
elementRemoved(const ContainerEvent & evt)1898 void FmXGridPeer::elementRemoved(const ContainerEvent& evt) throw( RuntimeException )
1899 {
1900 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1901
1902 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1903
1904 // Handle Column beruecksichtigen
1905 if (!pGrid || !m_xColumns.is() || pGrid->IsInColumnMove() || m_xColumns->getCount() == ((sal_Int32)pGrid->GetModelColCount()))
1906 return;
1907
1908 pGrid->RemoveColumn(pGrid->GetColumnIdFromModelPos((sal_uInt16)::comphelper::getINT32(evt.Accessor)));
1909
1910 Reference< XPropertySet > xOldColumn;
1911 ::cppu::extractInterface(xOldColumn, evt.Element);
1912 removeColumnListeners(xOldColumn);
1913 }
1914
1915 //------------------------------------------------------------------------------
setProperty(const::rtl::OUString & PropertyName,const Any & Value)1916 void FmXGridPeer::setProperty( const ::rtl::OUString& PropertyName, const Any& Value) throw( RuntimeException )
1917 {
1918 ::vos::OGuard aGuard( Application::GetSolarMutex() );
1919
1920 FmGridControl* pGrid = (FmGridControl*) GetWindow();
1921
1922 sal_Bool bVoid = !Value.hasValue();
1923
1924 if ( 0 == PropertyName.compareTo( FM_PROP_TEXTLINECOLOR ) )
1925 {
1926 ::Color aTextLineColor( bVoid ? COL_TRANSPARENT : ::comphelper::getINT32( Value ) );
1927 if (bVoid)
1928 {
1929 pGrid->SetTextLineColor();
1930 pGrid->GetDataWindow().SetTextLineColor();
1931 }
1932 else
1933 {
1934 pGrid->SetTextLineColor(aTextLineColor);
1935 pGrid->GetDataWindow().SetTextLineColor(aTextLineColor);
1936 }
1937
1938 // need to forward this to the columns
1939 DbGridColumns& rColumns = const_cast<DbGridColumns&>(pGrid->GetColumns());
1940 DbGridColumn* pLoop = rColumns.First();
1941 while (pLoop)
1942 {
1943 FmXGridCell* pXCell = pLoop->GetCell();
1944 if (pXCell)
1945 {
1946 if (bVoid)
1947 pXCell->SetTextLineColor();
1948 else
1949 pXCell->SetTextLineColor(aTextLineColor);
1950 }
1951
1952 pLoop = rColumns.Next();
1953 }
1954
1955 if (isDesignMode())
1956 pGrid->Invalidate();
1957 }
1958 else if ( 0 == PropertyName.compareTo( FM_PROP_FONTEMPHASISMARK ) )
1959 {
1960 Font aGridFont = pGrid->GetControlFont();
1961 sal_Int16 nValue = ::comphelper::getINT16(Value);
1962 aGridFont.SetEmphasisMark( nValue );
1963 pGrid->SetControlFont( aGridFont );
1964 }
1965 else if ( 0 == PropertyName.compareTo( FM_PROP_FONTRELIEF ) )
1966 {
1967 Font aGridFont = pGrid->GetControlFont();
1968 sal_Int16 nValue = ::comphelper::getINT16(Value);
1969 aGridFont.SetRelief( (FontRelief)nValue );
1970 pGrid->SetControlFont( aGridFont );
1971 }
1972 else if ( 0 == PropertyName.compareTo( FM_PROP_HELPURL ) )
1973 {
1974 ::rtl::OUString sHelpURL;
1975 OSL_VERIFY( Value >>= sHelpURL );
1976 INetURLObject aHID( sHelpURL );
1977 if ( aHID.GetProtocol() == INET_PROT_HID )
1978 sHelpURL = aHID.GetURLPath();
1979 pGrid->SetHelpId( rtl::OUStringToOString( sHelpURL, RTL_TEXTENCODING_UTF8 ) );
1980 }
1981 else if ( 0 == PropertyName.compareTo( FM_PROP_DISPLAYSYNCHRON ) )
1982 {
1983 pGrid->setDisplaySynchron(::comphelper::getBOOL(Value));
1984 }
1985 else if ( 0 == PropertyName.compareTo( FM_PROP_CURSORCOLOR ) )
1986 {
1987 if (bVoid)
1988 pGrid->SetCursorColor(COL_TRANSPARENT);
1989 else
1990 pGrid->SetCursorColor( ::Color(::comphelper::getINT32(Value)));
1991 if (isDesignMode())
1992 pGrid->Invalidate();
1993 }
1994 else if ( 0 == PropertyName.compareTo( FM_PROP_ALWAYSSHOWCURSOR ) )
1995 {
1996 pGrid->EnablePermanentCursor(::comphelper::getBOOL(Value));
1997 if (isDesignMode())
1998 pGrid->Invalidate();
1999 }
2000 else if ( 0 == PropertyName.compareTo( FM_PROP_FONT ) )
2001 {
2002 if ( bVoid )
2003 pGrid->SetControlFont( Font() );
2004 else
2005 {
2006 ::com::sun::star::awt::FontDescriptor aFont;
2007 if (Value >>= aFont)
2008 {
2009 Font aNewVclFont;
2010 if (::comphelper::operator!=(aFont, ::comphelper::getDefaultFont())) // ist das der Default
2011 aNewVclFont = ImplCreateFont( aFont );
2012
2013 // need to add relief and emphasis (they're stored in a VCL-Font, but not in a FontDescriptor
2014 Font aOldVclFont = pGrid->GetControlFont();
2015 aNewVclFont.SetRelief( aOldVclFont.GetRelief() );
2016 aNewVclFont.SetEmphasisMark( aOldVclFont.GetEmphasisMark() );
2017
2018 // now set it ...
2019 pGrid->SetControlFont( aNewVclFont );
2020
2021 // if our row-height property is void (which means "calculate it font-dependent") we have
2022 // to adjust the control's row height
2023 Reference< XPropertySet > xModelSet(getColumns(), UNO_QUERY);
2024 if (xModelSet.is() && ::comphelper::hasProperty(FM_PROP_ROWHEIGHT, xModelSet))
2025 {
2026 Any aHeight = xModelSet->getPropertyValue(FM_PROP_ROWHEIGHT);
2027 if (!aHeight.hasValue())
2028 pGrid->SetDataRowHeight(0);
2029 }
2030
2031 }
2032 }
2033 }
2034 else if ( 0 == PropertyName.compareTo( FM_PROP_BACKGROUNDCOLOR ) )
2035 {
2036 if ( bVoid )
2037 {
2038 pGrid->SetControlBackground();
2039 }
2040 else
2041 {
2042 ::Color aColor( ::comphelper::getINT32(Value) );
2043 pGrid->SetBackground( aColor );
2044 pGrid->SetControlBackground( aColor );
2045 }
2046 }
2047 else if ( 0 == PropertyName.compareTo( FM_PROP_TEXTCOLOR ) )
2048 {
2049 if ( bVoid )
2050 {
2051 pGrid->SetControlForeground();
2052 }
2053 else
2054 {
2055 ::Color aColor( ::comphelper::getINT32(Value) );
2056 pGrid->SetTextColor( aColor );
2057 pGrid->SetControlForeground( aColor );
2058 }
2059 }
2060 else if ( 0 == PropertyName.compareTo( FM_PROP_ROWHEIGHT ) )
2061 {
2062 sal_Int32 nLogHeight(0);
2063 if (Value >>= nLogHeight)
2064 {
2065 sal_Int32 nHeight = pGrid->LogicToPixel(Point(0,nLogHeight),MAP_10TH_MM).Y();
2066 // take the zoom factor into account
2067 nHeight = pGrid->CalcZoom(nHeight);
2068 pGrid->SetDataRowHeight(nHeight);
2069 }
2070 else if (bVoid)
2071 pGrid->SetDataRowHeight(0);
2072 }
2073 else if ( 0 == PropertyName.compareTo( FM_PROP_HASNAVIGATION ) )
2074 {
2075 sal_Bool bValue( sal_True );
2076 OSL_VERIFY( Value >>= bValue );
2077 pGrid->EnableNavigationBar( bValue );
2078 }
2079 else if ( 0 == PropertyName.compareTo( FM_PROP_RECORDMARKER ) )
2080 {
2081 sal_Bool bValue( sal_True );
2082 OSL_VERIFY( Value >>= bValue );
2083 pGrid->EnableHandle( bValue );
2084 }
2085 else if ( 0 == PropertyName.compareTo( FM_PROP_ENABLED ) )
2086 {
2087 sal_Bool bValue( sal_True );
2088 OSL_VERIFY( Value >>= bValue );
2089 pGrid->EnableHandle( bValue );
2090
2091 // Im DesignModus nur das Datenfenster disablen
2092 // Sonst kann das Control nicht mehr konfiguriert werden
2093 if (isDesignMode())
2094 pGrid->GetDataWindow().Enable( bValue );
2095 else
2096 pGrid->Enable( bValue );
2097 }
2098 else
2099 VCLXWindow::setProperty( PropertyName, Value );
2100 }
2101
2102 //------------------------------------------------------------------------------
CreateAccessibleContext()2103 Reference< XAccessibleContext > FmXGridPeer::CreateAccessibleContext()
2104 {
2105 Reference< XAccessibleContext > xContext;
2106
2107 // use the AccessibleContext provided by the VCL window
2108 Window* pGrid = GetWindow();
2109 if ( pGrid )
2110 {
2111 Reference< XAccessible > xAcc( pGrid->GetAccessible( sal_True ) );
2112 if ( xAcc.is() )
2113 xContext = xAcc->getAccessibleContext();
2114 // TODO: this has a slight conceptual problem:
2115 //
2116 // We know that the XAccessible and XAccessibleContext implementation of the browse
2117 // box is the same (the class implements both interfaces), which, speaking strictly,
2118 // is bad here (means when a browse box acts as UnoControl): We (the FmXGridPeer) are
2119 // the XAccessible here, and the browse box should be able to provide us an XAccessibleContext,
2120 // but it should _not_ be the XAccessible itself.
2121 // However, as long as no client implementation uses dirty hacks such as querying an
2122 // XAccessibleContext for XAccessible, this should not be a problem.
2123 }
2124
2125 if ( !xContext.is() )
2126 xContext = VCLXWindow::CreateAccessibleContext( );
2127
2128 return xContext;
2129 }
2130
2131 //------------------------------------------------------------------------------
getProperty(const::rtl::OUString & _rPropertyName)2132 Any FmXGridPeer::getProperty( const ::rtl::OUString& _rPropertyName ) throw( RuntimeException )
2133 {
2134 Any aProp;
2135 if (GetWindow())
2136 {
2137 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2138 Window* pDataWindow = &pGrid->GetDataWindow();
2139
2140 if ( 0 == _rPropertyName.compareTo( FM_PROP_NAME ) )
2141 {
2142 Font aFont = pDataWindow->GetControlFont();
2143 aProp <<= ImplCreateFontDescriptor( aFont );
2144 }
2145 else if ( 0 == _rPropertyName.compareTo( FM_PROP_TEXTCOLOR ) )
2146 {
2147 aProp <<= (sal_Int32)pDataWindow->GetControlForeground().GetColor();
2148 }
2149 else if ( 0 == _rPropertyName.compareTo( FM_PROP_BACKGROUNDCOLOR ) )
2150 {
2151 aProp <<= (sal_Int32)pDataWindow->GetControlBackground().GetColor();
2152 }
2153 else if ( 0 == _rPropertyName.compareTo( FM_PROP_ROWHEIGHT ) )
2154 {
2155 sal_Int32 nPixelHeight = pGrid->GetDataRowHeight();
2156 // take the zoom factor into account
2157 nPixelHeight = pGrid->CalcReverseZoom(nPixelHeight);
2158 aProp <<= (sal_Int32)pGrid->PixelToLogic(Point(0,nPixelHeight),MAP_10TH_MM).Y();
2159 }
2160 else if ( 0 == _rPropertyName.compareTo( FM_PROP_HASNAVIGATION ) )
2161 {
2162 sal_Bool bHasNavBar = pGrid->HasNavigationBar();
2163 aProp <<= (sal_Bool)bHasNavBar;
2164 }
2165 else if ( 0 == _rPropertyName.compareTo( FM_PROP_RECORDMARKER ) )
2166 {
2167 sal_Bool bHasHandle = pGrid->HasHandle();
2168 aProp <<= (sal_Bool)bHasHandle;
2169 }
2170 else if ( 0 == _rPropertyName.compareTo( FM_PROP_ENABLED ) )
2171 {
2172 aProp <<= (sal_Bool)pDataWindow->IsEnabled();
2173 }
2174 else
2175 aProp = VCLXWindow::getProperty( _rPropertyName );
2176 }
2177 return aProp;
2178 }
2179
2180 //------------------------------------------------------------------------------
dispose()2181 void FmXGridPeer::dispose() throw( RuntimeException )
2182 {
2183 EventObject aEvt;
2184 aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
2185 m_aModifyListeners.disposeAndClear(aEvt);
2186 m_aUpdateListeners.disposeAndClear(aEvt);
2187 m_aContainerListeners.disposeAndClear(aEvt);
2188 VCLXWindow::dispose();
2189
2190 // release all interceptors
2191 // discovered during #100312# - 2002-10-23 - fs@openoffice.org
2192 Reference< XDispatchProviderInterceptor > xInterceptor( m_xFirstDispatchInterceptor );
2193 m_xFirstDispatchInterceptor.clear();
2194 while ( xInterceptor.is() )
2195 {
2196 // tell the interceptor it has a new (means no) predecessor
2197 xInterceptor->setMasterDispatchProvider( NULL );
2198
2199 // ask for it's successor
2200 Reference< XDispatchProvider > xSlave = xInterceptor->getSlaveDispatchProvider();
2201 // and give it the new (means no) successoert
2202 xInterceptor->setSlaveDispatchProvider( NULL );
2203
2204 // start over with the next chain element
2205 xInterceptor = xInterceptor.query( xSlave );
2206 }
2207
2208 DisConnectFromDispatcher();
2209 setRowSet(Reference< XRowSet > ());
2210 }
2211
2212 // XContainer
2213 //------------------------------------------------------------------------------
addContainerListener(const Reference<XContainerListener> & l)2214 void FmXGridPeer::addContainerListener(const Reference< XContainerListener >& l) throw( RuntimeException )
2215 {
2216 m_aContainerListeners.addInterface( l );
2217 }
2218 //------------------------------------------------------------------------------
removeContainerListener(const Reference<XContainerListener> & l)2219 void FmXGridPeer::removeContainerListener(const Reference< XContainerListener >& l) throw( RuntimeException )
2220 {
2221 m_aContainerListeners.removeInterface( l );
2222 }
2223
2224 // ::com::sun::star::data::XDatabaseCursorSupplier
2225 //------------------------------------------------------------------------------
startCursorListening()2226 void FmXGridPeer::startCursorListening()
2227 {
2228 if (!m_nCursorListening)
2229 {
2230 Reference< XRowSet > xRowSet(m_xCursor, UNO_QUERY);
2231 if (xRowSet.is())
2232 xRowSet->addRowSetListener(this);
2233
2234 Reference< XReset > xReset(m_xCursor, UNO_QUERY);
2235 if (xReset.is())
2236 xReset->addResetListener(this);
2237
2238 // alle Listener anmelden
2239 Reference< XPropertySet > xSet(m_xCursor, UNO_QUERY);
2240 if (xSet.is())
2241 {
2242 xSet->addPropertyChangeListener(FM_PROP_ISMODIFIED, this);
2243 xSet->addPropertyChangeListener(FM_PROP_ROWCOUNT, this);
2244 }
2245 }
2246 m_nCursorListening++;
2247 }
2248
2249 //------------------------------------------------------------------------------
stopCursorListening()2250 void FmXGridPeer::stopCursorListening()
2251 {
2252 if (!--m_nCursorListening)
2253 {
2254 Reference< XRowSet > xRowSet(m_xCursor, UNO_QUERY);
2255 if (xRowSet.is())
2256 xRowSet->removeRowSetListener(this);
2257
2258 Reference< XReset > xReset(m_xCursor, UNO_QUERY);
2259 if (xReset.is())
2260 xReset->removeResetListener(this);
2261
2262 Reference< XPropertySet > xSet(m_xCursor, UNO_QUERY);
2263 if (xSet.is())
2264 {
2265 xSet->removePropertyChangeListener(FM_PROP_ISMODIFIED, this);
2266 xSet->removePropertyChangeListener(FM_PROP_ROWCOUNT, this);
2267 }
2268 }
2269 }
2270
2271 //------------------------------------------------------------------------------
updateGrid(const Reference<XRowSet> & _rxCursor)2272 void FmXGridPeer::updateGrid(const Reference< XRowSet >& _rxCursor)
2273 {
2274 FmGridControl* pGrid = (FmGridControl*)GetWindow();
2275 if (pGrid)
2276 pGrid->setDataSource(_rxCursor);
2277 }
2278
2279 //------------------------------------------------------------------------------
getRowSet()2280 Reference< XRowSet > FmXGridPeer::getRowSet() throw( RuntimeException )
2281 {
2282 return m_xCursor;
2283 }
2284
2285 //------------------------------------------------------------------------------
setRowSet(const Reference<XRowSet> & _rDatabaseCursor)2286 void FmXGridPeer::setRowSet(const Reference< XRowSet >& _rDatabaseCursor) throw( RuntimeException )
2287 {
2288 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2289 if (!pGrid || !m_xColumns.is() || !m_xColumns->getCount())
2290 return;
2291 // alle Listener abmelden
2292 if (m_xCursor.is())
2293 {
2294 Reference< XLoadable > xLoadable(m_xCursor, UNO_QUERY);
2295 // only if the form is loaded we set the rowset
2296 if (xLoadable.is())
2297 {
2298 stopCursorListening();
2299 xLoadable->removeLoadListener(this);
2300 }
2301 }
2302
2303 m_xCursor = _rDatabaseCursor;
2304
2305 if (pGrid)
2306 {
2307 Reference< XLoadable > xLoadable(m_xCursor, UNO_QUERY);
2308 // only if the form is loaded we set the rowset
2309 if (xLoadable.is() && xLoadable->isLoaded())
2310 pGrid->setDataSource(m_xCursor);
2311 else
2312 pGrid->setDataSource(Reference< XRowSet > ());
2313
2314 if (xLoadable.is())
2315 {
2316 startCursorListening();
2317 xLoadable->addLoadListener(this);
2318 }
2319 }
2320 }
2321
2322 //------------------------------------------------------------------------------
addGridControlListener(const Reference<XGridControlListener> & _listener)2323 void SAL_CALL FmXGridPeer::addGridControlListener( const Reference< XGridControlListener >& _listener ) throw( RuntimeException )
2324 {
2325 m_aGridControlListeners.addInterface( _listener );
2326 }
2327
2328 //------------------------------------------------------------------------------
removeGridControlListener(const Reference<XGridControlListener> & _listener)2329 void SAL_CALL FmXGridPeer::removeGridControlListener( const Reference< XGridControlListener >& _listener ) throw( RuntimeException )
2330 {
2331 m_aGridControlListeners.removeInterface( _listener );
2332 }
2333
2334 //------------------------------------------------------------------------------
getCurrentColumnPosition()2335 sal_Int16 FmXGridPeer::getCurrentColumnPosition() throw( RuntimeException )
2336 {
2337 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2338 return pGrid ? pGrid->GetViewColumnPos(pGrid->GetCurColumnId()) : -1;
2339 }
2340
2341 //------------------------------------------------------------------------------
setCurrentColumnPosition(sal_Int16 nPos)2342 void FmXGridPeer::setCurrentColumnPosition(sal_Int16 nPos) throw( RuntimeException )
2343 {
2344 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2345 if (pGrid)
2346 pGrid->GoToColumnId(pGrid->GetColumnIdFromViewPos(nPos));
2347 }
2348
2349 //------------------------------------------------------------------------------
selectionChanged(const EventObject & evt)2350 void FmXGridPeer::selectionChanged(const EventObject& evt) throw( RuntimeException )
2351 {
2352 ::vos::OGuard aGuard(Application::GetSolarMutex());
2353
2354 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2355 if (pGrid)
2356 {
2357 Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(evt.Source, UNO_QUERY);
2358 Any aSelection = xSelSupplier->getSelection();
2359 DBG_ASSERT(aSelection.getValueType().getTypeClass() == TypeClass_INTERFACE, "FmXGridPeer::selectionChanged : invalid selection !");
2360 Reference< XPropertySet > xSelection;
2361 aSelection >>= xSelection;
2362 if (xSelection.is())
2363 {
2364 Reference< XPropertySet > xCol;
2365 sal_Int32 i = 0;
2366 sal_Int32 nColCount = m_xColumns->getCount();
2367
2368 for (; i < nColCount; ++i)
2369 {
2370 m_xColumns->getByIndex(i) >>= xCol;
2371 if ( xCol == xSelection )
2372 {
2373 pGrid->markColumn(pGrid->GetColumnIdFromModelPos((sal_uInt16)i));
2374 break;
2375 }
2376 }
2377 // fuer das VCL-Control muessen die Columns 1-basiert sein
2378 // die Selektion an das VCL-Control weiterreichen, wenn noetig
2379 if ( i != pGrid->GetSelectedColumn() )
2380 { // (wenn das nicht greift, wurde das selectionChanged implizit von dem Control selber ausgeloest
2381 if ( i < nColCount )
2382 {
2383 pGrid->SelectColumnPos(pGrid->GetViewColumnPos(pGrid->GetColumnIdFromModelPos( (sal_uInt16)i )) + 1, sal_True);
2384 // SelectColumnPos hat wieder zu einem impliziten ActivateCell gefuehrt
2385 if (pGrid->IsEditing())
2386 pGrid->DeactivateCell();
2387 }
2388 else
2389 pGrid->SetNoSelection();
2390 }
2391 }
2392 else
2393 pGrid->markColumn(USHRT_MAX);
2394 }
2395 }
2396
2397 // XElementAccess
2398 //------------------------------------------------------------------------------
hasElements()2399 sal_Bool FmXGridPeer::hasElements() throw( RuntimeException )
2400 {
2401 return getCount() != 0;
2402 }
2403
2404 //------------------------------------------------------------------------------
getElementType()2405 Type SAL_CALL FmXGridPeer::getElementType( ) throw(RuntimeException)
2406 {
2407 return ::getCppuType((Reference< ::com::sun::star::awt::XControl> *)NULL);
2408 }
2409
2410 // XEnumerationAccess
2411 //------------------------------------------------------------------------------
createEnumeration()2412 Reference< XEnumeration > FmXGridPeer::createEnumeration() throw( RuntimeException )
2413 {
2414 return new ::comphelper::OEnumerationByIndex(this);
2415 }
2416
2417 // XIndexAccess
2418 //------------------------------------------------------------------------------
getCount()2419 sal_Int32 FmXGridPeer::getCount() throw( RuntimeException )
2420 {
2421 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2422 if (pGrid)
2423 return pGrid->GetViewColCount();
2424 else
2425 return 0;
2426 }
2427
2428 //------------------------------------------------------------------------------
getByIndex(sal_Int32 _nIndex)2429 Any FmXGridPeer::getByIndex(sal_Int32 _nIndex) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
2430 {
2431 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2432 if (_nIndex < 0 ||
2433 _nIndex >= getCount() || !pGrid)
2434 throw IndexOutOfBoundsException();
2435
2436 Any aElement;
2437 // get the columnid
2438 sal_uInt16 nId = pGrid->GetColumnIdFromViewPos((sal_uInt16)_nIndex);
2439 // get the list position
2440 sal_uInt16 nPos = pGrid->GetModelColumnPos(nId);
2441
2442 DbGridColumn* pCol = pGrid->GetColumns().GetObject(nPos);
2443 // DBG_ASSERT(pCol && pCol->GetCell(), "FmXGridPeer::getByIndex(): Invalid cell");
2444 Reference< ::com::sun::star::awt::XControl > xControl(pCol->GetCell());
2445 aElement <<= xControl;
2446
2447 return aElement;
2448 }
2449
2450 // ::com::sun::star::util::XModeSelector
2451 //------------------------------------------------------------------------------
setMode(const::rtl::OUString & Mode)2452 void FmXGridPeer::setMode(const ::rtl::OUString& Mode) throw( NoSupportException, RuntimeException )
2453 {
2454 if (!supportsMode(Mode))
2455 throw NoSupportException();
2456
2457 if (Mode == m_aMode)
2458 return;
2459
2460 m_aMode = Mode;
2461
2462 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2463 if ( Mode == ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterMode" ) ) )
2464 pGrid->SetFilterMode(sal_True);
2465 else
2466 {
2467 pGrid->SetFilterMode(sal_False);
2468 pGrid->setDataSource(m_xCursor);
2469 }
2470 }
2471
2472 //------------------------------------------------------------------------------
getMode()2473 ::rtl::OUString FmXGridPeer::getMode() throw( RuntimeException )
2474 {
2475 return m_aMode;
2476 }
2477
2478 //------------------------------------------------------------------------------
getSupportedModes()2479 ::comphelper::StringSequence FmXGridPeer::getSupportedModes() throw( RuntimeException )
2480 {
2481 static ::comphelper::StringSequence aModes;
2482 if (!aModes.getLength())
2483 {
2484 aModes.realloc(2);
2485 ::rtl::OUString* pModes = aModes.getArray();
2486 pModes[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DataMode" ) );
2487 pModes[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FilterMode" ) );
2488 }
2489 return aModes;
2490 }
2491
2492 //------------------------------------------------------------------------------
supportsMode(const::rtl::OUString & Mode)2493 sal_Bool FmXGridPeer::supportsMode(const ::rtl::OUString& Mode) throw( RuntimeException )
2494 {
2495 ::comphelper::StringSequence aModes(getSupportedModes());
2496 const ::rtl::OUString* pModes = aModes.getConstArray();
2497 for (sal_Int32 i = aModes.getLength(); i > 0; )
2498 {
2499 if (pModes[--i] == Mode)
2500 return sal_True;
2501 }
2502 return sal_False;
2503 }
2504
2505 //------------------------------------------------------------------------------
columnVisible(DbGridColumn * pColumn)2506 void FmXGridPeer::columnVisible(DbGridColumn* pColumn)
2507 {
2508 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2509
2510 sal_Int32 _nIndex = pGrid->GetModelColumnPos(pColumn->GetId());
2511 Reference< ::com::sun::star::awt::XControl > xControl(pColumn->GetCell());
2512 ContainerEvent aEvt;
2513 aEvt.Source = (XContainer*)this;
2514 aEvt.Accessor <<= _nIndex;
2515 aEvt.Element <<= xControl;
2516
2517 m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvt );
2518 }
2519
2520 //------------------------------------------------------------------------------
columnHidden(DbGridColumn * pColumn)2521 void FmXGridPeer::columnHidden(DbGridColumn* pColumn)
2522 {
2523 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2524
2525 sal_Int32 _nIndex = pGrid->GetModelColumnPos(pColumn->GetId());
2526 Reference< ::com::sun::star::awt::XControl > xControl(pColumn->GetCell());
2527 ContainerEvent aEvt;
2528 aEvt.Source = (XContainer*)this;
2529 aEvt.Accessor <<= _nIndex;
2530 aEvt.Element <<= xControl;
2531
2532 m_aContainerListeners.notifyEach( &XContainerListener::elementRemoved, aEvt );
2533 }
2534
2535 //------------------------------------------------------------------------------
draw(sal_Int32 x,sal_Int32 y)2536 void FmXGridPeer::draw( sal_Int32 x, sal_Int32 y ) throw( RuntimeException )
2537 {
2538 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2539 sal_Int32 nOldFlags = pGrid->GetBrowserFlags();
2540 pGrid->SetBrowserFlags(nOldFlags | EBBF_NOROWPICTURE);
2541
2542 VCLXWindow::draw(x, y);
2543
2544 pGrid->SetBrowserFlags(nOldFlags);
2545 }
2546
2547 //------------------------------------------------------------------------------
queryDispatch(const::com::sun::star::util::URL & aURL,const::rtl::OUString & aTargetFrameName,sal_Int32 nSearchFlags)2548 Reference< ::com::sun::star::frame::XDispatch > FmXGridPeer::queryDispatch(const ::com::sun::star::util::URL& aURL, const ::rtl::OUString& aTargetFrameName, sal_Int32 nSearchFlags) throw( RuntimeException )
2549 {
2550 Reference< ::com::sun::star::frame::XDispatch > xResult;
2551
2552 // first ask our interceptor chain
2553 if (m_xFirstDispatchInterceptor.is() && !m_bInterceptingDispatch)
2554 {
2555 m_bInterceptingDispatch = sal_True;
2556 // safety against recursion : as we are master of the first chain element and slave of the last one we would
2557 // have an infinite loop without this if no dispatcher can fulfill the rewuest)
2558 xResult = m_xFirstDispatchInterceptor->queryDispatch(aURL, aTargetFrameName, nSearchFlags);
2559 m_bInterceptingDispatch = sal_False;
2560 }
2561
2562 // then ask ourself : we don't have any dispatches
2563 return xResult;
2564 }
2565
2566 //------------------------------------------------------------------------------
queryDispatches(const Sequence<::com::sun::star::frame::DispatchDescriptor> & aDescripts)2567 Sequence< Reference< ::com::sun::star::frame::XDispatch > > FmXGridPeer::queryDispatches(const Sequence< ::com::sun::star::frame::DispatchDescriptor>& aDescripts) throw( RuntimeException )
2568 {
2569 if (m_xFirstDispatchInterceptor.is())
2570 return m_xFirstDispatchInterceptor->queryDispatches(aDescripts);
2571
2572 // then ask ourself : we don't have any dispatches
2573 return Sequence< Reference< ::com::sun::star::frame::XDispatch > >();
2574 }
2575
2576 //------------------------------------------------------------------------------
registerDispatchProviderInterceptor(const Reference<::com::sun::star::frame::XDispatchProviderInterceptor> & _xInterceptor)2577 void FmXGridPeer::registerDispatchProviderInterceptor(const Reference< ::com::sun::star::frame::XDispatchProviderInterceptor >& _xInterceptor) throw( RuntimeException )
2578 {
2579 if (_xInterceptor.is())
2580 {
2581 if (m_xFirstDispatchInterceptor.is())
2582 {
2583 Reference< ::com::sun::star::frame::XDispatchProvider > xFirstProvider(m_xFirstDispatchInterceptor, UNO_QUERY);
2584 // there is already an interceptor; the new one will become its master
2585 _xInterceptor->setSlaveDispatchProvider(xFirstProvider);
2586 m_xFirstDispatchInterceptor->setMasterDispatchProvider(xFirstProvider);
2587 }
2588 else
2589 {
2590 // it is the first interceptor; set ourself as slave
2591 _xInterceptor->setSlaveDispatchProvider((::com::sun::star::frame::XDispatchProvider*)this);
2592 }
2593
2594 // we are the master of the chain's first interceptor
2595 m_xFirstDispatchInterceptor = _xInterceptor;
2596 m_xFirstDispatchInterceptor->setMasterDispatchProvider((::com::sun::star::frame::XDispatchProvider*)this);
2597
2598 // we have a new interceptor and we're alive ?
2599 if (!isDesignMode())
2600 // -> check for new dispatchers
2601 UpdateDispatches();
2602 }
2603 }
2604
2605 //------------------------------------------------------------------------------
releaseDispatchProviderInterceptor(const Reference<::com::sun::star::frame::XDispatchProviderInterceptor> & _xInterceptor)2606 void FmXGridPeer::releaseDispatchProviderInterceptor(const Reference< ::com::sun::star::frame::XDispatchProviderInterceptor >& _xInterceptor) throw( RuntimeException )
2607 {
2608 if (!_xInterceptor.is())
2609 return;
2610
2611 Reference< ::com::sun::star::frame::XDispatchProviderInterceptor > xChainWalk(m_xFirstDispatchInterceptor);
2612
2613 if (m_xFirstDispatchInterceptor == _xInterceptor)
2614 { // our chain will have a new first element
2615 Reference< ::com::sun::star::frame::XDispatchProviderInterceptor > xSlave(m_xFirstDispatchInterceptor->getSlaveDispatchProvider(), UNO_QUERY);
2616 m_xFirstDispatchInterceptor = xSlave;
2617 }
2618 // do this before removing the interceptor from the chain as we won't know it's slave afterwards)
2619
2620 while (xChainWalk.is())
2621 {
2622 // walk along the chain of interceptors and look for the interceptor that has to be removed
2623 Reference< ::com::sun::star::frame::XDispatchProviderInterceptor > xSlave(xChainWalk->getSlaveDispatchProvider(), UNO_QUERY);
2624
2625 if (xChainWalk == _xInterceptor)
2626 {
2627 // old master may be an interceptor too
2628 Reference< ::com::sun::star::frame::XDispatchProviderInterceptor > xMaster(xChainWalk->getMasterDispatchProvider(), UNO_QUERY);
2629
2630 // unchain the interceptor that has to be removed
2631 xChainWalk->setSlaveDispatchProvider(Reference< ::com::sun::star::frame::XDispatchProvider > ());
2632 xChainWalk->setMasterDispatchProvider(Reference< ::com::sun::star::frame::XDispatchProvider > ());
2633
2634 // reconnect the chain
2635 if (xMaster.is())
2636 {
2637 if (xSlave.is())
2638 xMaster->setSlaveDispatchProvider(Reference< ::com::sun::star::frame::XDispatchProvider >::query(xSlave));
2639 else
2640 // it's the first interceptor of the chain, set ourself as slave
2641 xMaster->setSlaveDispatchProvider((::com::sun::star::frame::XDispatchProvider*)this);
2642 }
2643 else
2644 {
2645 // the chain's first element was removed, set ourself as new master of the second one
2646 if (xSlave.is())
2647 xSlave->setMasterDispatchProvider((::com::sun::star::frame::XDispatchProvider*)this);
2648 }
2649 }
2650
2651 xChainWalk = xSlave;
2652 }
2653 // our interceptor chain has changed and we're alive ?
2654 if (!isDesignMode())
2655 // -> check the dispatchers
2656 UpdateDispatches();
2657 }
2658
2659 //------------------------------------------------------------------------------
statusChanged(const::com::sun::star::frame::FeatureStateEvent & Event)2660 void FmXGridPeer::statusChanged(const ::com::sun::star::frame::FeatureStateEvent& Event) throw( RuntimeException )
2661 {
2662 DBG_ASSERT(m_pStateCache, "FmXGridPeer::statusChanged : invalid call !");
2663 DBG_ASSERT(m_pDispatchers, "FmXGridPeer::statusChanged : invalid call !");
2664
2665 Sequence< ::com::sun::star::util::URL>& aUrls = getSupportedURLs();
2666 const ::com::sun::star::util::URL* pUrls = aUrls.getConstArray();
2667
2668 Sequence<sal_uInt16> aSlots = getSupportedGridSlots();
2669 const sal_uInt16* pSlots = aSlots.getConstArray();
2670
2671 sal_uInt16 i;
2672 for (i=0; i<aUrls.getLength(); ++i, ++pUrls, ++pSlots)
2673 {
2674 if (pUrls->Main == Event.FeatureURL.Main)
2675 {
2676 DBG_ASSERT(m_pDispatchers[i] == Event.Source, "FmXGridPeer::statusChanged : the event source is a little bit suspect !");
2677 m_pStateCache[i] = Event.IsEnabled;
2678 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2679 if (*pSlots != SID_FM_RECORD_UNDO)
2680 pGrid->GetNavigationBar().InvalidateState(*pSlots);
2681 break;
2682 }
2683 }
2684 DBG_ASSERT(i<aUrls.getLength(), "FmXGridPeer::statusChanged : got a call for an unknown url !");
2685 }
2686
2687 //------------------------------------------------------------------------------
approveReset(const EventObject &)2688 sal_Bool FmXGridPeer::approveReset(const EventObject& /*rEvent*/) throw( RuntimeException )
2689 {
2690 return sal_True;
2691 }
2692
2693 //------------------------------------------------------------------------------
select(const Any & _rSelection)2694 sal_Bool SAL_CALL FmXGridPeer::select( const Any& _rSelection ) throw (IllegalArgumentException, RuntimeException)
2695 {
2696 Sequence< Any > aBookmarks;
2697 if ( !( _rSelection >>= aBookmarks ) )
2698 throw IllegalArgumentException();
2699
2700 FmGridControl* pVclControl = static_cast<FmGridControl*>(GetWindow());
2701 return pVclControl->selectBookmarks(aBookmarks);
2702
2703 // TODO:
2704 // speaking strictly, we would have to adjust our model, as our ColumnSelection may have changed.
2705 // Our model is a XSelectionSupplier, too, it handles the selection of single columns.
2706 // This is somewhat strange, as selection should be a view (not a model) aspect.
2707 // So for a clean solution, we should handle column selection ourself, and the model shouldn't
2708 // deal with selection at all.
2709 }
2710
2711 //------------------------------------------------------------------------------
getSelection()2712 Any SAL_CALL FmXGridPeer::getSelection( ) throw (RuntimeException)
2713 {
2714 FmGridControl* pVclControl = static_cast<FmGridControl*>(GetWindow());
2715 Sequence< Any > aSelectionBookmarks = pVclControl->getSelectionBookmarks();
2716 return makeAny(aSelectionBookmarks);
2717 }
2718
2719 //------------------------------------------------------------------------------
addSelectionChangeListener(const Reference<XSelectionChangeListener> & _rxListener)2720 void SAL_CALL FmXGridPeer::addSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener ) throw (RuntimeException)
2721 {
2722 m_aSelectionListeners.addInterface( _rxListener );
2723 }
2724
2725 //------------------------------------------------------------------------------
removeSelectionChangeListener(const Reference<XSelectionChangeListener> & _rxListener)2726 void SAL_CALL FmXGridPeer::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener ) throw (RuntimeException)
2727 {
2728 m_aSelectionListeners.removeInterface( _rxListener );
2729 }
2730
2731 //------------------------------------------------------------------------------
resetted(const EventObject & rEvent)2732 void FmXGridPeer::resetted(const EventObject& rEvent) throw( RuntimeException )
2733 {
2734 if (m_xColumns == rEvent.Source)
2735 { // my model was reset -> refresh the grid content
2736 FmGridControl* pGrid = (FmGridControl*)GetWindow();
2737 if (!pGrid)
2738 return;
2739 ::vos::OGuard aGuard( Application::GetSolarMutex() );
2740 pGrid->resetCurrentRow();
2741 }
2742 // if the cursor fired a reset event we seem to be on the insert row
2743 else if (m_xCursor == rEvent.Source)
2744 {
2745 ::vos::OGuard aGuard( Application::GetSolarMutex() );
2746 FmGridControl* pGrid = (FmGridControl*) GetWindow();
2747 if (pGrid && pGrid->IsOpen())
2748 pGrid->positioned(rEvent);
2749 }
2750 }
2751
2752 //------------------------------------------------------------------------------
getSupportedGridSlots()2753 Sequence<sal_uInt16>& FmXGridPeer::getSupportedGridSlots()
2754 {
2755 static Sequence<sal_uInt16> aSupported;
2756 if (aSupported.getLength() == 0)
2757 {
2758 sal_uInt16 nSupported[] = {
2759 DbGridControl::NavigationBar::RECORD_FIRST,
2760 DbGridControl::NavigationBar::RECORD_PREV,
2761 DbGridControl::NavigationBar::RECORD_NEXT,
2762 DbGridControl::NavigationBar::RECORD_LAST,
2763 DbGridControl::NavigationBar::RECORD_NEW,
2764 SID_FM_RECORD_UNDO
2765 };
2766 aSupported.realloc(sizeof(nSupported)/sizeof(nSupported[0]));
2767 sal_uInt16* pSupported = aSupported.getArray();
2768 for (sal_uInt16 i=0; i<aSupported.getLength(); ++i, ++pSupported)
2769 *pSupported = nSupported[i];
2770 }
2771 return aSupported;
2772 }
2773
2774 //------------------------------------------------------------------------------
getSupportedURLs()2775 Sequence< ::com::sun::star::util::URL>& FmXGridPeer::getSupportedURLs()
2776 {
2777 static Sequence< ::com::sun::star::util::URL> aSupported;
2778 if (aSupported.getLength() == 0)
2779 {
2780 static ::rtl::OUString sSupported[] = {
2781 FMURL_RECORD_MOVEFIRST,
2782 FMURL_RECORD_MOVEPREV,
2783 FMURL_RECORD_MOVENEXT,
2784 FMURL_RECORD_MOVELAST,
2785 FMURL_RECORD_MOVETONEW,
2786 FMURL_RECORD_UNDO
2787 };
2788 aSupported.realloc(sizeof(sSupported)/sizeof(sSupported[0]));
2789 ::com::sun::star::util::URL* pSupported = aSupported.getArray();
2790 sal_uInt16 i;
2791
2792 for ( i = 0; i < aSupported.getLength(); ++i, ++pSupported)
2793 pSupported->Complete = sSupported[i];
2794
2795 // let an ::com::sun::star::util::URL-transformer normalize the URLs
2796 Reference< ::com::sun::star::util::XURLTransformer > xTransformer(
2797 ::comphelper::getProcessServiceFactory()->createInstance(
2798 ::rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer")),
2799 UNO_QUERY);
2800 pSupported = aSupported.getArray();
2801 if (xTransformer.is())
2802 {
2803 for (i=0; i<aSupported.getLength(); ++i)
2804 xTransformer->parseStrict(pSupported[i]);
2805 }
2806 }
2807
2808 return aSupported;
2809 }
2810
2811 //------------------------------------------------------------------------------
UpdateDispatches()2812 void FmXGridPeer::UpdateDispatches()
2813 {
2814 if (!m_pStateCache)
2815 { // we don't have any dispatchers yet -> do the initial connect
2816 ConnectToDispatcher();
2817 return;
2818 }
2819
2820 sal_uInt16 nDispatchersGot = 0;
2821 const Sequence< ::com::sun::star::util::URL>& aSupportedURLs = getSupportedURLs();
2822 const ::com::sun::star::util::URL* pSupportedURLs = aSupportedURLs.getConstArray();
2823 Reference< ::com::sun::star::frame::XDispatch > xNewDispatch;
2824 for (sal_uInt16 i=0; i<aSupportedURLs.getLength(); ++i, ++pSupportedURLs)
2825 {
2826 xNewDispatch = queryDispatch(*pSupportedURLs, rtl::OUString(), 0);
2827 if (xNewDispatch != m_pDispatchers[i])
2828 {
2829 if (m_pDispatchers[i].is())
2830 m_pDispatchers[i]->removeStatusListener((::com::sun::star::frame::XStatusListener*)this, *pSupportedURLs);
2831 m_pDispatchers[i] = xNewDispatch;
2832 if (m_pDispatchers[i].is())
2833 m_pDispatchers[i]->addStatusListener((::com::sun::star::frame::XStatusListener*)this, *pSupportedURLs);
2834 }
2835 if (m_pDispatchers[i].is())
2836 ++nDispatchersGot;
2837 }
2838
2839 if (!nDispatchersGot)
2840 {
2841 delete[] m_pStateCache;
2842 delete[] m_pDispatchers;
2843 m_pStateCache = NULL;
2844 m_pDispatchers = NULL;
2845 }
2846 }
2847
2848 //------------------------------------------------------------------------------
ConnectToDispatcher()2849 void FmXGridPeer::ConnectToDispatcher()
2850 {
2851 DBG_ASSERT((m_pStateCache != NULL) == (m_pDispatchers != NULL), "FmXGridPeer::ConnectToDispatcher : inconsistent !");
2852 if (m_pStateCache)
2853 { // already connected -> just do an update
2854 UpdateDispatches();
2855 return;
2856 }
2857
2858 const Sequence< ::com::sun::star::util::URL>& aSupportedURLs = getSupportedURLs();
2859
2860 // _before_ adding the status listeners (as the add should result in a statusChanged-call) !
2861 m_pStateCache = new sal_Bool[aSupportedURLs.getLength()];
2862 m_pDispatchers = new Reference< ::com::sun::star::frame::XDispatch > [aSupportedURLs.getLength()];
2863
2864 sal_uInt16 nDispatchersGot = 0;
2865 const ::com::sun::star::util::URL* pSupportedURLs = aSupportedURLs.getConstArray();
2866 for (sal_uInt16 i=0; i<aSupportedURLs.getLength(); ++i, ++pSupportedURLs)
2867 {
2868 m_pStateCache[i] = 0;
2869 m_pDispatchers[i] = queryDispatch(*pSupportedURLs, rtl::OUString(), 0);
2870 if (m_pDispatchers[i].is())
2871 {
2872 m_pDispatchers[i]->addStatusListener((::com::sun::star::frame::XStatusListener*)this, *pSupportedURLs);
2873 ++nDispatchersGot;
2874 }
2875 }
2876
2877 if (!nDispatchersGot)
2878 {
2879 delete[] m_pStateCache;
2880 delete[] m_pDispatchers;
2881 m_pStateCache = NULL;
2882 m_pDispatchers = NULL;
2883 }
2884 }
2885
2886 //------------------------------------------------------------------------------
DisConnectFromDispatcher()2887 void FmXGridPeer::DisConnectFromDispatcher()
2888 {
2889 if (!m_pStateCache || !m_pDispatchers)
2890 return;
2891 // we're not connected
2892
2893 const Sequence< ::com::sun::star::util::URL>& aSupportedURLs = getSupportedURLs();
2894 const ::com::sun::star::util::URL* pSupportedURLs = aSupportedURLs.getConstArray();
2895 for (sal_uInt16 i=0; i<aSupportedURLs.getLength(); ++i, ++pSupportedURLs)
2896 {
2897 if (m_pDispatchers[i].is())
2898 m_pDispatchers[i]->removeStatusListener((::com::sun::star::frame::XStatusListener*)this, *pSupportedURLs);
2899 }
2900
2901 delete[] m_pStateCache;
2902 delete[] m_pDispatchers;
2903 m_pStateCache = NULL;
2904 m_pDispatchers = NULL;
2905 }
2906
2907 //------------------------------------------------------------------------------
IMPL_LINK(FmXGridPeer,OnQueryGridSlotState,void *,pSlot)2908 IMPL_LINK(FmXGridPeer, OnQueryGridSlotState, void*, pSlot)
2909 {
2910 if (!m_pStateCache)
2911 return -1; // unspecified
2912
2913 sal_uInt16 nSlot = (sal_uInt16)(sal_uIntPtr)pSlot;
2914
2915 // search the given slot with our supported sequence
2916 Sequence<sal_uInt16>& aSupported = getSupportedGridSlots();
2917 const sal_uInt16* pSlots = aSupported.getConstArray();
2918 for (sal_uInt16 i=0; i<aSupported.getLength(); ++i)
2919 {
2920 if (pSlots[i] == nSlot)
2921 {
2922 if (!m_pDispatchers[i].is())
2923 return -1; // nothing known about this slot
2924 else
2925 return m_pStateCache[i];
2926 }
2927 }
2928
2929 return -1;
2930 }
2931
2932 //------------------------------------------------------------------------------
IMPL_LINK(FmXGridPeer,OnExecuteGridSlot,void *,pSlot)2933 IMPL_LINK(FmXGridPeer, OnExecuteGridSlot, void*, pSlot)
2934 {
2935 if (!m_pDispatchers)
2936 return 0; // not handled
2937
2938 Sequence< ::com::sun::star::util::URL>& aUrls = getSupportedURLs();
2939 const ::com::sun::star::util::URL* pUrls = aUrls.getConstArray();
2940
2941 Sequence<sal_uInt16> aSlots = getSupportedGridSlots();
2942 const sal_uInt16* pSlots = aSlots.getConstArray();
2943
2944 DBG_ASSERT(aSlots.getLength() == aUrls.getLength(), "FmXGridPeer::OnExecuteGridSlot : inconstent data returned by getSupportedURLs/getSupportedGridSlots !");
2945
2946 sal_uInt16 nSlot = (sal_uInt16)(sal_uIntPtr)pSlot;
2947 for (sal_uInt16 i=0; i<aSlots.getLength(); ++i, ++pUrls, ++pSlots)
2948 {
2949 if (*pSlots == nSlot)
2950 {
2951 if (m_pDispatchers[i].is())
2952 {
2953 // commit any changes done so far, if it's not the undoRecord URL
2954 if ( 0 == pUrls->Complete.compareTo( FMURL_RECORD_UNDO ) || commit() )
2955 m_pDispatchers[i]->dispatch(*pUrls, Sequence< PropertyValue>());
2956
2957 return 1; // handled
2958 }
2959 }
2960 }
2961
2962 return 0; // not handled
2963 }
2964
2965