svx/source/fmcomp/fmgridif.cxx

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