forms/source/component/GroupManager.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: GroupManager.cxx,v $
  10  * $Revision: 1.18 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_forms.hxx"
  33 #include "GroupManager.hxx"
  34 #include <com/sun/star/beans/XFastPropertySet.hpp>
  35 #include <com/sun/star/form/FormComponentType.hpp>
  36 #include <comphelper/property.hxx>
  37 #include <comphelper/uno3.hxx>
  38 #include <tools/solar.h>
  39 #include <tools/debug.hxx>
  40
  41 #include "property.hrc"
  42
  43 #include <algorithm>
  44
  45 //.........................................................................
  46 namespace frm
  47 {
  48 //.........................................................................
  49
  50 using namespace ::com::sun::star::uno;
  51 using namespace ::com::sun::star::sdbc;
  52 using namespace ::com::sun::star::beans;
  53 using namespace ::com::sun::star::container;
  54 using namespace ::com::sun::star::form;
  55 using namespace ::com::sun::star::awt;
  56 using namespace ::com::sun::star::lang;
  57 using namespace ::com::sun::star::form;
  58
  59 namespace
  60 {
  61     bool isRadioButton( const Reference< XPropertySet >& _rxComponent )
  62     {
  63         bool bIs = false;
  64         if ( hasProperty( PROPERTY_CLASSID, _rxComponent ) )
  65         {
  66             sal_Int16 nClassId = FormComponentType::CONTROL;
  67             _rxComponent->getPropertyValue( PROPERTY_CLASSID ) >>= nClassId;
  68             if ( nClassId == FormComponentType::RADIOBUTTON )
  69                 bIs = true;
  70         }
  71         return bIs;
  72     }
  73 }
  74
  75 //========================================================================
  76 // class OGroupCompAcc
  77 //========================================================================
  78 //------------------------------------------------------------------
  79 OGroupCompAcc::OGroupCompAcc(const Reference<XPropertySet>& rxElement, const OGroupComp& _rGroupComp )
  80                :m_xComponent( rxElement )
  81                ,m_aGroupComp( _rGroupComp )
  82 {
  83 }
  84
  85 //------------------------------------------------------------------
  86 sal_Bool OGroupCompAcc::operator==( const OGroupCompAcc& rCompAcc ) const
  87 {
  88     return (m_xComponent == rCompAcc.GetComponent());
  89 }
  90
  91 //------------------------------------------------------------------
  92 class OGroupCompAccLess : public ::std::binary_function<OGroupCompAcc, OGroupCompAcc, sal_Bool>
  93 {
  94 public:
  95     sal_Bool operator() (const OGroupCompAcc& lhs, const OGroupCompAcc& rhs) const
  96     {
  97         return
  98             reinterpret_cast<sal_Int64>(lhs.m_xComponent.get())
  99         <       reinterpret_cast<sal_Int64>(rhs.m_xComponent.get());
 100     }
 101 };
 102
 103 //========================================================================
 104 // class OGroupComp
 105 //========================================================================
 106
 107 //------------------------------------------------------------------
 108 OGroupComp::OGroupComp()
 109     :m_nPos( -1 )
 110     ,m_nTabIndex( 0 )
 111 {
 112 }
 113
 114 //------------------------------------------------------------------
 115 OGroupComp::OGroupComp(const OGroupComp& _rSource)
 116     :m_aName( _rSource.m_aName )
 117     ,m_xComponent( _rSource.m_xComponent )
 118     ,m_xControlModel(_rSource.m_xControlModel)
 119     ,m_nPos( _rSource.m_nPos )
 120     ,m_nTabIndex( _rSource.m_nTabIndex )
 121 {
 122 }
 123
 124 //------------------------------------------------------------------
 125 OGroupComp::OGroupComp(const Reference<XPropertySet>& rxSet, sal_Int32 nInsertPos )
 126     :m_xComponent( rxSet )
 127     ,m_xControlModel(rxSet,UNO_QUERY)
 128     ,m_nPos( nInsertPos )
 129     ,m_nTabIndex(0)
 130     ,m_aName( OGroupManager::GetGroupName( rxSet ) )
 131 {
 132     if (m_xComponent.is())
 133     {
 134         if (hasProperty( PROPERTY_TABINDEX, m_xComponent ) )
 135             // Indices kleiner 0 werden wie 0 behandelt
 136             m_nTabIndex = Max(getINT16(m_xComponent->getPropertyValue( PROPERTY_TABINDEX )) , sal_Int16(0));
 137     }
 138 }
 139
 140 //------------------------------------------------------------------
 141 sal_Bool OGroupComp::operator==( const OGroupComp& rComp ) const
 142 {
 143     return m_nTabIndex == rComp.GetTabIndex() && m_nPos == rComp.GetPos();
 144 }
 145
 146 //------------------------------------------------------------------
 147 class OGroupCompLess : public ::std::binary_function<OGroupComp, OGroupComp, sal_Bool>
 148 {
 149 public:
 150     sal_Bool operator() (const OGroupComp& lhs, const OGroupComp& rhs) const
 151     {
 152         sal_Bool bResult;
 153         // TabIndex von 0 wird hinten einsortiert
 154         if (lhs.m_nTabIndex == rhs.GetTabIndex())
 155             bResult = lhs.m_nPos < rhs.GetPos();
 156         else if (lhs.m_nTabIndex && rhs.GetTabIndex())
 157             bResult = lhs.m_nTabIndex < rhs.GetTabIndex();
 158         else
 159             bResult = lhs.m_nTabIndex != 0;
 160         return bResult;
 161     }
 162 };
 163
 164 //========================================================================
 165 // class OGroup
 166 //========================================================================
 167
 168 DBG_NAME(OGroup)
 169 //------------------------------------------------------------------
 170 OGroup::OGroup( const ::rtl::OUString& rGroupName )
 171         :m_aGroupName( rGroupName )
 172         ,m_nInsertPos(0)
 173 {
 174     DBG_CTOR(OGroup,NULL);
 175 }
 176
 177 #ifdef DBG_UTIL
 178 //------------------------------------------------------------------
 179 OGroup::OGroup( const OGroup& _rSource )
 180 :m_aCompArray(_rSource.m_aCompArray)
 181     ,m_aCompAccArray(_rSource.m_aCompAccArray)
 182     ,m_aGroupName(_rSource.m_aGroupName)
 183     ,m_nInsertPos(_rSource.m_nInsertPos)
 184 {
 185     DBG_CTOR(OGroup,NULL);
 186 }
 187 #endif
 188
 189 //------------------------------------------------------------------
 190 OGroup::~OGroup()
 191 {
 192     DBG_DTOR(OGroup,NULL);
 193 }
 194
 195 //------------------------------------------------------------------
 196 void OGroup::InsertComponent( const Reference<XPropertySet>& xSet )
 197 {
 198     OGroupComp aNewGroupComp( xSet, m_nInsertPos );
 199     sal_Int32 nPosInserted = insert_sorted(m_aCompArray, aNewGroupComp, OGroupCompLess());
 200
 201     OGroupCompAcc aNewGroupCompAcc( xSet, m_aCompArray[nPosInserted] );
 202     insert_sorted(m_aCompAccArray, aNewGroupCompAcc, OGroupCompAccLess());
 203     m_nInsertPos++;
 204 }
 205
 206 //------------------------------------------------------------------
 207 void OGroup::RemoveComponent( const Reference<XPropertySet>& rxElement )
 208 {
 209     sal_Int32 nGroupCompAccPos;
 210     OGroupCompAcc aSearchCompAcc( rxElement, OGroupComp() );
 211     if ( seek_entry(m_aCompAccArray, aSearchCompAcc, nGroupCompAccPos, OGroupCompAccLess()) )
 212     {
 213         OGroupCompAcc& aGroupCompAcc = m_aCompAccArray[nGroupCompAccPos];
 214         const OGroupComp& aGroupComp = aGroupCompAcc.GetGroupComponent();
 215
 216         sal_Int32 nGroupCompPos;
 217         if ( seek_entry(m_aCompArray, aGroupComp, nGroupCompPos, OGroupCompLess()) )
 218         {
 219             m_aCompAccArray.erase( m_aCompAccArray.begin() + nGroupCompAccPos );
 220             m_aCompArray.erase( m_aCompArray.begin() + nGroupCompPos );
 221
 222             /*============================================================
 223             Durch das Entfernen der GroupComp ist die Einfuegeposition
 224             ungueltig geworden. Sie braucht hier aber nicht angepasst werden,
 225             da sie fortlaufend vergeben wird und damit immer
 226             aufsteigend eindeutig ist.
 227             ============================================================*/
 228         }
 229         else
 230         {
 231             DBG_ERROR( "OGroup::RemoveComponent: Component nicht in Gruppe" );
 232         }
 233     }
 234     else
 235     {
 236         DBG_ERROR( "OGroup::RemoveComponent: Component nicht in Gruppe" );
 237     }
 238 }
 239
 240 //------------------------------------------------------------------
 241 sal_Bool OGroup::operator==( const OGroup& rGroup ) const
 242 {
 243     return m_aGroupName.equals(rGroup.GetGroupName());
 244 }
 245
 246 //------------------------------------------------------------------
 247 class OGroupLess : public ::std::binary_function<OGroup, OGroup, sal_Bool>
 248 {
 249 public:
 250     sal_Bool operator() (const OGroup& lhs, const OGroup& rhs) const
 251     {
 252         return lhs.m_aGroupName < rhs.m_aGroupName;
 253     }
 254 };
 255
 256 //------------------------------------------------------------------
 257 Sequence< Reference<XControlModel>  > OGroup::GetControlModels() const
 258 {
 259     sal_Int32 nLen = m_aCompArray.size();
 260     Sequence<Reference<XControlModel> > aControlModelSeq( nLen );
 261     Reference<XControlModel>* pModels = aControlModelSeq.getArray();
 262
 263     ConstOGroupCompArrIterator aGroupComps = m_aCompArray.begin();
 264     for (sal_Int32 i = 0; i < nLen; ++i, ++pModels, ++aGroupComps)
 265     {
 266         *pModels = aGroupComps->GetControlModel();
 267     }
 268     return aControlModelSeq;
 269 }
 270
 271 DBG_NAME(OGroupManager);
 272 //------------------------------------------------------------------
 273 OGroupManager::OGroupManager(const Reference< XContainer >& _rxContainer)
 274     :m_pCompGroup( new OGroup( ::rtl::OUString::createFromAscii( "AllComponentGroup" ) ) )
 275     ,m_xContainer(_rxContainer)
 276 {
 277     DBG_CTOR(OGroupManager,NULL);
 278
 279     increment(m_refCount);
 280     {
 281         _rxContainer->addContainerListener(this);
 282     }
 283     decrement(m_refCount);
 284 }
 285
 286 //------------------------------------------------------------------
 287 OGroupManager::~OGroupManager()
 288 {
 289     DBG_DTOR(OGroupManager,NULL);
 290     // Alle Components und CompGroup loeschen
 291     delete m_pCompGroup;
 292 }
 293
 294 // XPropertyChangeListener
 295 //------------------------------------------------------------------
 296 void OGroupManager::disposing(const EventObject& evt) throw( RuntimeException )
 297 {
 298     Reference<XContainer>  xContainer(evt.Source, UNO_QUERY);
 299     if (xContainer.get() == m_xContainer.get())
 300     {
 301         DELETEZ(m_pCompGroup);
 302
 303         ////////////////////////////////////////////////////////////////
 304         // Gruppen loeschen
 305         m_aGroupArr.clear();
 306         m_xContainer.clear();
 307     }
 308 }
 309 // -----------------------------------------------------------------------------
 310 void OGroupManager::removeFromGroupMap(const ::rtl::OUString& _sGroupName,const Reference<XPropertySet>& _xSet)
 311 {
 312     // Component aus CompGroup entfernen
 313     m_pCompGroup->RemoveComponent( _xSet );
 314
 315     OGroupArr::iterator aFind = m_aGroupArr.find(_sGroupName);
 316
 317     if ( aFind != m_aGroupArr.end() )
 318     {
 319         // Gruppe vorhanden
 320         aFind->second.RemoveComponent( _xSet );
 321
 322         // Wenn Anzahl der Gruppenelemente == 1 ist, Gruppe deaktivieren
 323                 sal_Int32 nCount = aFind->second.Count();
 324                 if ( nCount == 1 || nCount == 0 )
 325         {
 326             OActiveGroups::iterator aActiveFind = ::std::find(
 327                 m_aActiveGroupMap.begin(),
 328                 m_aActiveGroupMap.end(),
 329                 aFind
 330             );
 331             if ( aActiveFind != m_aActiveGroupMap.end() )
 332             {
 333                 // the group is active. Deactivate it if the remaining component
 334                 // is *no* radio button
 335                 if ( nCount == 0 || !isRadioButton( aFind->second.GetObject( 0 ) ) )
 336                     m_aActiveGroupMap.erase( aActiveFind );
 337             }
 338         }
 339     }
 340
 341
 342     // Bei Component als PropertyChangeListener abmelden
 343     _xSet->removePropertyChangeListener( PROPERTY_NAME, this );
 344         if (hasProperty(PROPERTY_GROUP_NAME, _xSet))
 345                 _xSet->removePropertyChangeListener( PROPERTY_GROUP_NAME, this );
 346     if (hasProperty(PROPERTY_TABINDEX, _xSet))
 347         _xSet->removePropertyChangeListener( PROPERTY_TABINDEX, this );
 348 }
 349 //------------------------------------------------------------------
 350 void SAL_CALL OGroupManager::propertyChange(const PropertyChangeEvent& evt) throw ( ::com::sun::star::uno::RuntimeException)
 351 {
 352     Reference<XPropertySet>  xSet(evt.Source, UNO_QUERY);
 353
 354     // Component aus Gruppe entfernen
 355     ::rtl::OUString             sGroupName;
 356         if (hasProperty( PROPERTY_GROUP_NAME, xSet ))
 357                 xSet->getPropertyValue( PROPERTY_GROUP_NAME ) >>= sGroupName;
 358         if (evt.PropertyName == PROPERTY_NAME) {
 359                 if (sGroupName.getLength() > 0)
 360                         return; // group hasn't changed; ignore this name change.
 361                 // no GroupName; use Name as GroupNme
 362         evt.OldValue >>= sGroupName;
 363         }
 364         else if (evt.PropertyName == PROPERTY_GROUP_NAME) {
 365                 evt.OldValue >>= sGroupName;
 366                 if (sGroupName.getLength() == 0) {
 367                         // No prior GroupName; fallback to Nme
 368                         xSet->getPropertyValue( PROPERTY_NAME ) >>= sGroupName;
 369                 }
 370         }
 371     else
 372                 sGroupName = GetGroupName( xSet );
 373
 374     removeFromGroupMap(sGroupName,xSet);
 375
 376     // Component neu einordnen
 377     InsertElement( xSet );
 378 }
 379
 380 // XContainerListener
 381 //------------------------------------------------------------------
 382 void SAL_CALL OGroupManager::elementInserted(const ContainerEvent& Event) throw ( ::com::sun::star::uno::RuntimeException)
 383 {
 384     Reference< XPropertySet > xProps;
 385     Event.Element >>= xProps;
 386     if ( xProps.is() )
 387         InsertElement( xProps );
 388 }
 389
 390 //------------------------------------------------------------------
 391 void SAL_CALL OGroupManager::elementRemoved(const ContainerEvent& Event) throw ( ::com::sun::star::uno::RuntimeException)
 392 {
 393     Reference<XPropertySet> xProps;
 394     Event.Element >>= xProps;
 395     if ( xProps.is() )
 396         RemoveElement( xProps );
 397 }
 398
 399 //------------------------------------------------------------------
 400 void SAL_CALL OGroupManager::elementReplaced(const ContainerEvent& Event) throw ( ::com::sun::star::uno::RuntimeException)
 401 {
 402     Reference<XPropertySet> xProps;
 403     Event.ReplacedElement >>= xProps;
 404     if ( xProps.is() )
 405         RemoveElement( xProps );
 406
 407     xProps.clear();
 408     Event.Element >>= xProps;
 409     if ( xProps.is() )
 410         InsertElement( xProps );
 411 }
 412
 413 // Other functions
 414 //------------------------------------------------------------------
 415 Sequence<Reference<XControlModel> > OGroupManager::getControlModels()
 416 {
 417     return m_pCompGroup->GetControlModels();
 418 }
 419
 420 //------------------------------------------------------------------
 421 sal_Int32 OGroupManager::getGroupCount()
 422 {
 423     return m_aActiveGroupMap.size();
 424 }
 425
 426 //------------------------------------------------------------------
 427 void OGroupManager::getGroup(sal_Int32 nGroup, Sequence< Reference<XControlModel> >& _rGroup, ::rtl::OUString& _rName)
 428 {
 429     OSL_ENSURE(nGroup >= 0 && (size_t)nGroup < m_aActiveGroupMap.size(),"OGroupManager::getGroup: Invalid group index!");
 430     OGroupArr::iterator aGroupPos       = m_aActiveGroupMap[nGroup];
 431     _rName                                                      = aGroupPos->second.GetGroupName();
 432     _rGroup                                                     = aGroupPos->second.GetControlModels();
 433 }
 434
 435 //------------------------------------------------------------------
 436 void OGroupManager::getGroupByName(const ::rtl::OUString& _rName, Sequence< Reference<XControlModel>  >& _rGroup)
 437 {
 438     OGroupArr::iterator aFind = m_aGroupArr.find(_rName);
 439     if ( aFind != m_aGroupArr.end() )
 440         _rGroup = aFind->second.GetControlModels();
 441 }
 442
 443 //------------------------------------------------------------------
 444 void OGroupManager::InsertElement( const Reference<XPropertySet>& xSet )
 445 {
 446     // Nur ControlModels
 447     Reference<XControlModel>  xControl(xSet, UNO_QUERY);
 448     if (!xControl.is() )
 449         return;
 450
 451     // Component in CompGroup aufnehmen
 452     m_pCompGroup->InsertComponent( xSet );
 453
 454     // Component in Gruppe aufnehmen
 455         ::rtl::OUString sGroupName( GetGroupName( xSet ) );
 456
 457     OGroupArr::iterator aFind = m_aGroupArr.find(sGroupName);
 458
 459     if ( aFind == m_aGroupArr.end() )
 460     {
 461         aFind = m_aGroupArr.insert(OGroupArr::value_type(sGroupName,OGroup(sGroupName))).first;
 462     }
 463
 464     aFind->second.InsertComponent( xSet );
 465
 466     // if we have at least 2 elements in the group, then this is an "active group"
 467     bool bActivateGroup = aFind->second.Count() == 2;
 468
 469     // Additionally, if the component is a radio button, then it's group becomes active,
 470     // too. With this, we ensure that in a container with n radio buttons which all are
 471     // in different groups the selection still works reliably (means that all radios can be
 472     // clicked independently)
 473     if ( aFind->second.Count() == 1 )
 474     {
 475         if ( isRadioButton( xSet ) )
 476             bActivateGroup = true;
 477     }
 478
 479     if ( bActivateGroup )
 480     {
 481         OActiveGroups::iterator aAlreadyExistent = ::std::find(
 482             m_aActiveGroupMap.begin(),
 483             m_aActiveGroupMap.end(),
 484             aFind
 485         );
 486         if ( aAlreadyExistent == m_aActiveGroupMap.end() )
 487             m_aActiveGroupMap.push_back(  aFind );
 488     }
 489
 490
 491     // Bei Component als PropertyChangeListener anmelden
 492     xSet->addPropertyChangeListener( PROPERTY_NAME, this );
 493         if (hasProperty(PROPERTY_GROUP_NAME, xSet))
 494                 xSet->addPropertyChangeListener( PROPERTY_GROUP_NAME, this );
 495
 496     // Tabindex muss nicht jeder unterstuetzen
 497     if (hasProperty(PROPERTY_TABINDEX, xSet))
 498         xSet->addPropertyChangeListener( PROPERTY_TABINDEX, this );
 499
 500 }
 501
 502 //------------------------------------------------------------------
 503 void OGroupManager::RemoveElement( const Reference<XPropertySet>& xSet )
 504 {
 505     // Nur ControlModels
 506     Reference<XControlModel>  xControl(xSet, UNO_QUERY);
 507     if (!xControl.is() )
 508         return;
 509
 510     // Component aus Gruppe entfernen
 511         ::rtl::OUString         sGroupName( GetGroupName( xSet ) );
 512
 513     removeFromGroupMap(sGroupName,xSet);
 514 }
 515
 516 ::rtl::OUString OGroupManager::GetGroupName( ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet> xComponent )
 517 {
 518     if (!xComponent.is())
 519         return ::rtl::OUString();
 520     ::rtl::OUString sGroupName;
 521     if (hasProperty( PROPERTY_GROUP_NAME, xComponent )) {
 522         xComponent->getPropertyValue( PROPERTY_GROUP_NAME ) >>= sGroupName;
 523         if (sGroupName.getLength() == 0)
 524             xComponent->getPropertyValue( PROPERTY_NAME ) >>= sGroupName;
 525     }
 526     else
 527         xComponent->getPropertyValue( PROPERTY_NAME ) >>= sGroupName;
 528     return sGroupName;
 529 }
 530
 531 //.........................................................................
 532 }       // namespace frm
 533 //.........................................................................
 534