svx/source/fmcomp/fmgridif.cxx

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