forms/source/component/GroupManager.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 #include "GroupManager.hxx"
  21 #include <com/sun/star/form/FormComponentType.hpp>
  22 #include <comphelper/property.hxx>
  23 #include <comphelper/types.hxx>
  24 #include <o3tl/safeint.hxx>
  25 #include <osl/diagnose.h>
  26
  27 #include <frm_strings.hxx>
  28
  29 #include <algorithm>
  30
  31 namespace frm
  32 {
  33 using namespace ::com::sun::star::uno;
  34 using namespace ::com::sun::star::beans;
  35 using namespace ::com::sun::star::container;
  36 using namespace ::com::sun::star::form;
  37 using namespace ::com::sun::star::awt;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::comphelper;
  40
  41 namespace
  42 {
  43     bool isRadioButton( const Reference< XPropertySet >& _rxComponent )
  44     {
  45         bool bIs = false;
  46         if ( hasProperty( PROPERTY_CLASSID, _rxComponent ) )
  47         {
  48             sal_Int16 nClassId = FormComponentType::CONTROL;
  49             _rxComponent->getPropertyValue( PROPERTY_CLASSID ) >>= nClassId;
  50             if ( nClassId == FormComponentType::RADIOBUTTON )
  51                 bIs = true;
  52         }
  53         return bIs;
  54     }
  55 }
  56
  57 OGroupCompAcc::OGroupCompAcc(const Reference<XPropertySet>& rxElement, const OGroupComp& _rGroupComp )
  58                :m_xComponent( rxElement )
  59                ,m_aGroupComp( _rGroupComp )
  60 {
  61 }
  62
  63 bool OGroupCompAcc::operator==( const OGroupCompAcc& rCompAcc ) const
  64 {
  65     return m_xComponent == rCompAcc.m_xComponent;
  66 }
  67
  68 class OGroupCompAccLess
  69 {
  70 public:
  71     bool operator() (const OGroupCompAcc& lhs, const OGroupCompAcc& rhs) const
  72     {
  73         return
  74             reinterpret_cast<sal_Int64>(lhs.m_xComponent.get())
  75         <   reinterpret_cast<sal_Int64>(rhs.m_xComponent.get());
  76     }
  77 };
  78
  79 OGroupComp::OGroupComp()
  80     :m_nPos( -1 )
  81     ,m_nTabIndex( 0 )
  82 {
  83 }
  84
  85 OGroupComp::OGroupComp(const Reference<XPropertySet>& rxSet, sal_Int32 nInsertPos )
  86     : m_xComponent( rxSet )
  87     , m_xControlModel(rxSet,UNO_QUERY)
  88     , m_nPos( nInsertPos )
  89     , m_nTabIndex(0)
  90 {
  91     if (m_xComponent.is())
  92     {
  93         if (hasProperty( PROPERTY_TABINDEX, m_xComponent ) )
  94             // Indices smaller than 0 are treated like 0
  95             m_nTabIndex = std::max(getINT16(m_xComponent->getPropertyValue( PROPERTY_TABINDEX )) , sal_Int16(0));
  96     }
  97 }
  98
  99 bool OGroupComp::operator==( const OGroupComp& rComp ) const
 100 {
 101     return m_nTabIndex == rComp.GetTabIndex() && m_nPos == rComp.GetPos();
 102 }
 103
 104 class OGroupCompLess
 105 {
 106 public:
 107     bool operator() (const OGroupComp& lhs, const OGroupComp& rhs) const
 108     {
 109         bool bResult;
 110         // TabIndex of 0 will be added at the end
 111         if (lhs.m_nTabIndex == rhs.GetTabIndex())
 112             bResult = lhs.m_nPos < rhs.GetPos();
 113         else if (lhs.m_nTabIndex && rhs.GetTabIndex())
 114             bResult = lhs.m_nTabIndex < rhs.GetTabIndex();
 115         else
 116             bResult = lhs.m_nTabIndex != 0;
 117         return bResult;
 118     }
 119 };
 120
 121 OGroup::OGroup( const OUString& rGroupName )
 122         :m_aGroupName( rGroupName )
 123         ,m_nInsertPos(0)
 124 {
 125 }
 126
 127 void OGroup::InsertComponent( const Reference<XPropertySet>& xSet )
 128 {
 129     OGroupComp aNewGroupComp( xSet, m_nInsertPos );
 130     sal_Int32 nPosInserted = insert_sorted(m_aCompArray, aNewGroupComp, OGroupCompLess());
 131
 132     OGroupCompAcc aNewGroupCompAcc( xSet, m_aCompArray[nPosInserted] );
 133     insert_sorted(m_aCompAccArray, aNewGroupCompAcc, OGroupCompAccLess());
 134     m_nInsertPos++;
 135 }
 136
 137 void OGroup::RemoveComponent( const Reference<XPropertySet>& rxElement )
 138 {
 139     sal_Int32 nGroupCompAccPos;
 140     OGroupCompAcc aSearchCompAcc( rxElement, OGroupComp() );
 141     if ( seek_entry(m_aCompAccArray, aSearchCompAcc, nGroupCompAccPos, OGroupCompAccLess()) )
 142     {
 143         OGroupCompAcc& aGroupCompAcc = m_aCompAccArray[nGroupCompAccPos];
 144         const OGroupComp& aGroupComp = aGroupCompAcc.GetGroupComponent();
 145
 146         sal_Int32 nGroupCompPos;
 147         if ( seek_entry(m_aCompArray, aGroupComp, nGroupCompPos, OGroupCompLess()) )
 148         {
 149             m_aCompAccArray.erase( m_aCompAccArray.begin() + nGroupCompAccPos );
 150             m_aCompArray.erase( m_aCompArray.begin() + nGroupCompPos );
 151
 152             /*
 153              * By removing the GroupComp the insertion position has become invalid.
 154              * We do not to change it here, however, because it's passed on continuously
 155              * and ascending distinctively.
 156              */
 157         }
 158         else
 159         {
 160             OSL_FAIL( "OGroup::RemoveComponent: Component not in Group" );
 161         }
 162     }
 163     else
 164     {
 165         OSL_FAIL( "OGroup::RemoveComponent: Component not in Group" );
 166     }
 167 }
 168
 169 Sequence< Reference<XControlModel>  > OGroup::GetControlModels() const
 170 {
 171     Sequence<Reference<XControlModel> > aControlModelSeq( m_aCompArray.size() );
 172     Reference<XControlModel>* pModels = aControlModelSeq.getArray();
 173
 174     for (auto const& rGroupComp : m_aCompArray)
 175     {
 176         *pModels++ = rGroupComp.GetControlModel();
 177     }
 178     return aControlModelSeq;
 179 }
 180
 181 OGroupManager::OGroupManager(const Reference< XContainer >& _rxContainer)
 182     :m_pCompGroup( new OGroup( "AllComponentGroup" ) )
 183     ,m_xContainer(_rxContainer)
 184 {
 185     osl_atomic_increment(&m_refCount);
 186     {
 187         _rxContainer->addContainerListener(this);
 188     }
 189     osl_atomic_decrement(&m_refCount);
 190 }
 191
 192 OGroupManager::~OGroupManager()
 193 {
 194 }
 195
 196 // XPropertyChangeListener
 197 void OGroupManager::disposing(const EventObject& evt)
 198 {
 199     Reference<XContainer>  xContainer(evt.Source, UNO_QUERY);
 200     if (xContainer.get() == m_xContainer.get())
 201     {
 202         m_pCompGroup.reset();
 203
 204         // delete group
 205         m_aGroupArr.clear();
 206         m_xContainer.clear();
 207     }
 208 }
 209
 210 void OGroupManager::removeFromGroupMap(const OUString& _sGroupName,const Reference<XPropertySet>& _xSet)
 211 {
 212     // remove Component from CompGroup
 213     m_pCompGroup->RemoveComponent( _xSet );
 214
 215     OGroupArr::iterator aFind = m_aGroupArr.find(_sGroupName);
 216
 217     if ( aFind != m_aGroupArr.end() )
 218     {
 219         // group exists
 220         aFind->second.RemoveComponent( _xSet );
 221
 222         // If the count of Group elements == 1 -> deactivate Group
 223         sal_Int32 nCount = aFind->second.Count();
 224         if ( nCount == 1 || nCount == 0 )
 225         {
 226             OActiveGroups::iterator aActiveFind = ::std::find(
 227                 m_aActiveGroupMap.begin(),
 228                 m_aActiveGroupMap.end(),
 229                 aFind
 230             );
 231             if ( aActiveFind != m_aActiveGroupMap.end() )
 232             {
 233                 // the group is active. Deactivate it if the remaining component
 234                 // is *no* radio button
 235                 if ( nCount == 0 || !isRadioButton( aFind->second.GetObject( 0 ) ) )
 236                     m_aActiveGroupMap.erase( aActiveFind );
 237             }
 238         }
 239     }
 240
 241
 242     // Deregister as PropertyChangeListener at Component
 243     _xSet->removePropertyChangeListener( PROPERTY_NAME, this );
 244     if (hasProperty(PROPERTY_GROUP_NAME, _xSet))
 245         _xSet->removePropertyChangeListener( PROPERTY_GROUP_NAME, this );
 246     if (hasProperty(PROPERTY_TABINDEX, _xSet))
 247         _xSet->removePropertyChangeListener( PROPERTY_TABINDEX, this );
 248 }
 249
 250 void SAL_CALL OGroupManager::propertyChange(const PropertyChangeEvent& evt)
 251 {
 252     Reference<XPropertySet>  xSet(evt.Source, UNO_QUERY);
 253
 254     // remove Component from group
 255     OUString     sGroupName;
 256     if (hasProperty( PROPERTY_GROUP_NAME, xSet ))
 257         xSet->getPropertyValue( PROPERTY_GROUP_NAME ) >>= sGroupName;
 258     if (evt.PropertyName == PROPERTY_NAME) {
 259         if (!sGroupName.isEmpty())
 260             return; // group hasn't changed; ignore this name change.
 261         // no GroupName; use Name as GroupName
 262         evt.OldValue >>= sGroupName;
 263     }
 264     else if (evt.PropertyName == PROPERTY_GROUP_NAME) {
 265         evt.OldValue >>= sGroupName;
 266         if (sGroupName.isEmpty()) {
 267             // No prior GroupName; fallback to Name
 268             xSet->getPropertyValue( PROPERTY_NAME ) >>= sGroupName;
 269         }
 270     }
 271     else
 272         sGroupName = GetGroupName( xSet );
 273
 274     removeFromGroupMap(sGroupName,xSet);
 275
 276     // Re-insert Component
 277     InsertElement( xSet );
 278 }
 279
 280 // XContainerListener
 281 void SAL_CALL OGroupManager::elementInserted(const ContainerEvent& Event)
 282 {
 283     Reference< XPropertySet > xProps;
 284     Event.Element >>= xProps;
 285     if ( xProps.is() )
 286         InsertElement( xProps );
 287 }
 288
 289 void SAL_CALL OGroupManager::elementRemoved(const ContainerEvent& Event)
 290 {
 291     Reference<XPropertySet> xProps;
 292     Event.Element >>= xProps;
 293     if ( xProps.is() )
 294         RemoveElement( xProps );
 295 }
 296
 297 void SAL_CALL OGroupManager::elementReplaced(const ContainerEvent& Event)
 298 {
 299     Reference<XPropertySet> xProps;
 300     Event.ReplacedElement >>= xProps;
 301     if ( xProps.is() )
 302         RemoveElement( xProps );
 303
 304     xProps.clear();
 305     Event.Element >>= xProps;
 306     if ( xProps.is() )
 307         InsertElement( xProps );
 308 }
 309
 310 // Other functions
 311 Sequence<Reference<XControlModel> > OGroupManager::getControlModels() const
 312 {
 313     return m_pCompGroup->GetControlModels();
 314 }
 315
 316 sal_Int32 OGroupManager::getGroupCount() const
 317 {
 318     return m_aActiveGroupMap.size();
 319 }
 320
 321 void OGroupManager::getGroup(sal_Int32 nGroup, Sequence< Reference<XControlModel> >& _rGroup, OUString& _rName)
 322 {
 323     OSL_ENSURE(nGroup >= 0 && o3tl::make_unsigned(nGroup) < m_aActiveGroupMap.size(),"OGroupManager::getGroup: Invalid group index!");
 324     OGroupArr::iterator aGroupPos   = m_aActiveGroupMap[nGroup];
 325     _rName                          = aGroupPos->second.GetGroupName();
 326     _rGroup                         = aGroupPos->second.GetControlModels();
 327 }
 328
 329 void OGroupManager::getGroupByName(const OUString& _rName, Sequence< Reference<XControlModel>  >& _rGroup)
 330 {
 331     OGroupArr::iterator aFind = m_aGroupArr.find(_rName);
 332     if ( aFind != m_aGroupArr.end() )
 333         _rGroup = aFind->second.GetControlModels();
 334 }
 335
 336 void OGroupManager::InsertElement( const Reference<XPropertySet>& xSet )
 337 {
 338     // Only ControlModels
 339     Reference<XControlModel>  xControl(xSet, UNO_QUERY);
 340     if (!xControl.is() )
 341         return;
 342
 343     // Add Component to CompGroup
 344     m_pCompGroup->InsertComponent( xSet );
 345
 346     // Add Component to Group
 347     OUString sGroupName( GetGroupName( xSet ) );
 348
 349     OGroupArr::iterator aFind = m_aGroupArr.find(sGroupName);
 350
 351     if ( aFind == m_aGroupArr.end() )
 352     {
 353         aFind = m_aGroupArr.emplace(sGroupName,OGroup(sGroupName)).first;
 354     }
 355
 356     aFind->second.InsertComponent( xSet );
 357
 358     // if we have at least 2 elements in the group, then this is an "active group"
 359     bool bActivateGroup = aFind->second.Count() == 2;
 360
 361     // Additionally, if the component is a radio button, then it's group becomes active,
 362     // too. With this, we ensure that in a container with n radio buttons which all are
 363     // in different groups the selection still works reliably (means that all radios can be
 364     // clicked independently)
 365     if ( aFind->second.Count() == 1 )
 366     {
 367         if ( isRadioButton( xSet ) )
 368             bActivateGroup = true;
 369     }
 370
 371     if ( bActivateGroup )
 372     {
 373         OActiveGroups::iterator aAlreadyExistent = ::std::find(
 374             m_aActiveGroupMap.begin(),
 375             m_aActiveGroupMap.end(),
 376             aFind
 377         );
 378         if ( aAlreadyExistent == m_aActiveGroupMap.end() )
 379             m_aActiveGroupMap.push_back(  aFind );
 380     }
 381
 382     // Register as PropertyChangeListener at Component
 383     xSet->addPropertyChangeListener( PROPERTY_NAME, this );
 384     if (hasProperty(PROPERTY_GROUP_NAME, xSet))
 385         xSet->addPropertyChangeListener( PROPERTY_GROUP_NAME, this );
 386
 387     // Not everyone needs to support Tabindex
 388     if (hasProperty(PROPERTY_TABINDEX, xSet))
 389         xSet->addPropertyChangeListener( PROPERTY_TABINDEX, this );
 390 }
 391
 392 void OGroupManager::RemoveElement( const Reference<XPropertySet>& xSet )
 393 {
 394     // Only ControlModels
 395     Reference<XControlModel>  xControl(xSet, UNO_QUERY);
 396     if (!xControl.is() )
 397         return;
 398
 399     // Remove Component from Group
 400     OUString     sGroupName( GetGroupName( xSet ) );
 401
 402     removeFromGroupMap(sGroupName,xSet);
 403 }
 404
 405 OUString OGroupManager::GetGroupName( const css::uno::Reference< css::beans::XPropertySet>& xComponent )
 406 {
 407     if (!xComponent.is())
 408         return OUString();
 409     OUString sGroupName;
 410     if (hasProperty( PROPERTY_GROUP_NAME, xComponent )) {
 411         xComponent->getPropertyValue( PROPERTY_GROUP_NAME ) >>= sGroupName;
 412         if (sGroupName.isEmpty())
 413             xComponent->getPropertyValue( PROPERTY_NAME ) >>= sGroupName;
 414     }
 415     else
 416         xComponent->getPropertyValue( PROPERTY_NAME ) >>= sGroupName;
 417     return sGroupName;
 418 }
 419 }   // namespace frm
 420
 421 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */