chart2/source/tools/RangeHighlighter.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 <RangeHighlighter.hxx>
  21 #include <WeakListenerAdapter.hxx>
  22 #include <ChartModel.hxx>
  23 #include <ChartModelHelper.hxx>
  24 #include <DataSourceHelper.hxx>
  25 #include <ObjectIdentifier.hxx>
  26 #include <DataSeries.hxx>
  27 #include <DataSeriesHelper.hxx>
  28 #include <Diagram.hxx>
  29
  30 #include <com/sun/star/chart2/ScaleData.hpp>
  31 #include <com/sun/star/chart2/XAxis.hpp>
  32 #include <com/sun/star/chart2/XDataSeries.hpp>
  33 #include <com/sun/star/chart/ErrorBarStyle.hpp>
  34 #include <com/sun/star/drawing/XShape.hpp>
  35 #include <com/sun/star/view/XSelectionSupplier.hpp>
  36 #include <comphelper/sequence.hxx>
  37 #include <comphelper/diagnose_ex.hxx>
  38 #include <tools/color.hxx>
  39
  40 using namespace ::com::sun::star;
  41
  42 using ::com::sun::star::uno::Reference;
  43 using ::com::sun::star::uno::Sequence;
  44
  45 namespace
  46 {
  47
  48 const Color defaultPreferredColor = COL_LIGHTBLUE;
  49
  50 void lcl_fillRanges(
  51     Sequence< chart2::data::HighlightedRange > & rOutRanges,
  52     const Sequence< OUString >& aRangeStrings,
  53     Color nPreferredColor,
  54     sal_Int32 nIndex = -1 )
  55 {
  56     rOutRanges.realloc( aRangeStrings.getLength());
  57     auto pOutRanges = rOutRanges.getArray();
  58     for( sal_Int32 i=0; i<aRangeStrings.getLength(); ++i )
  59     {
  60         pOutRanges[i].RangeRepresentation = aRangeStrings[i];
  61         pOutRanges[i].PreferredColor = sal_Int32(nPreferredColor);
  62         pOutRanges[i].AllowMerginigWithOtherRanges = false;
  63         pOutRanges[i].Index = nIndex;
  64     }
  65 }
  66
  67 } // anonymous namespace
  68
  69 namespace chart
  70 {
  71
  72 RangeHighlighter::RangeHighlighter(
  73     const rtl::Reference< ChartModel > & xChartModel ) :
  74         m_xSelectionSupplier(xChartModel->getCurrentController(), uno::UNO_QUERY),
  75         m_xChartModel( xChartModel ),
  76         m_nAddedListenerCount( 0 ),
  77         m_bIncludeHiddenCells(true)
  78 {
  79 }
  80
  81 RangeHighlighter::~RangeHighlighter()
  82 {}
  83
  84 // ____ XRangeHighlighter ____
  85 Sequence< chart2::data::HighlightedRange > SAL_CALL RangeHighlighter::getSelectedRanges()
  86 {
  87     return m_aSelectedRanges;
  88 }
  89
  90 void RangeHighlighter::determineRanges()
  91 {
  92     m_aSelectedRanges.realloc( 0 );
  93     if( !m_xChartModel.is())
  94         return;
  95     if( !m_xSelectionSupplier.is())
  96         return;
  97
  98     try
  99     {
 100         m_bIncludeHiddenCells = ChartModelHelper::isIncludeHiddenCells( m_xChartModel );
 101
 102         uno::Any aSelection( m_xSelectionSupplier->getSelection());
 103
 104         if (aSelection.getValueType() == cppu::UnoType<OUString>::get())
 105         {
 106             // @todo??: maybe getSelection() should return a model object rather than a CID
 107
 108             OUString aCID;
 109             aSelection >>= aCID;
 110             if ( !aCID.isEmpty() )
 111             {
 112                 ObjectType eObjectType = ObjectIdentifier::getObjectType( aCID );
 113                 sal_Int32 nIndex = ObjectIdentifier::getIndexFromParticleOrCID( aCID );
 114                 rtl::Reference< DataSeries > xDataSeries( ObjectIdentifier::getDataSeriesForCID( aCID, m_xChartModel ) );
 115                 if( eObjectType == OBJECTTYPE_LEGEND_ENTRY )
 116                 {
 117                     OUString aParentParticel( ObjectIdentifier::getFullParentParticle( aCID ) );
 118                     ObjectType eParentObjectType = ObjectIdentifier::getObjectType( aParentParticel );
 119                     eObjectType = eParentObjectType;
 120                     if( eObjectType == OBJECTTYPE_DATA_POINT )
 121                         nIndex = ObjectIdentifier::getIndexFromParticleOrCID( aParentParticel );
 122                 }
 123
 124                 if( eObjectType == OBJECTTYPE_DATA_POINT || eObjectType == OBJECTTYPE_DATA_LABEL )
 125                 {
 126                     // Data Point
 127                     fillRangesForDataPoint( xDataSeries, nIndex );
 128                     return;
 129                 }
 130                 else if( eObjectType == OBJECTTYPE_DATA_ERRORS_X ||
 131                          eObjectType == OBJECTTYPE_DATA_ERRORS_Y ||
 132                          eObjectType == OBJECTTYPE_DATA_ERRORS_Z )
 133                 {
 134                     // select error bar ranges, or data series, if the style is
 135                     // not set to FROM_DATA
 136                     fillRangesForErrorBars( ObjectIdentifier::getObjectPropertySet( aCID, m_xChartModel ), xDataSeries );
 137                     return;
 138                 }
 139                 else if( xDataSeries.is() )
 140                 {
 141                     // Data Series
 142                     fillRangesForDataSeries( xDataSeries );
 143                     return;
 144                 }
 145                 else if( eObjectType == OBJECTTYPE_AXIS )
 146                 {
 147                     // Axis (Categories)
 148                     Reference< chart2::XAxis > xAxis( ObjectIdentifier::getObjectPropertySet( aCID, m_xChartModel ), uno::UNO_QUERY );
 149                     if( xAxis.is())
 150                     {
 151                         fillRangesForCategories( xAxis );
 152                         return;
 153                     }
 154                 }
 155                 else if( eObjectType == OBJECTTYPE_PAGE
 156                          || eObjectType == OBJECTTYPE_DIAGRAM
 157                          || eObjectType == OBJECTTYPE_DIAGRAM_WALL
 158                          || eObjectType == OBJECTTYPE_DIAGRAM_FLOOR
 159                     )
 160                 {
 161                     // Diagram
 162                     rtl::Reference< ::chart::Diagram > xDia( ObjectIdentifier::getDiagramForCID( aCID, m_xChartModel ) );
 163                     if( xDia.is())
 164                     {
 165                         fillRangesForDiagram( xDia );
 166                         return;
 167                     }
 168                 }
 169             }
 170         }
 171         else if (Reference<drawing::XShape> xShape; aSelection >>= xShape)
 172         {
 173             // #i12587# support for shapes in chart
 174             if ( xShape.is() )
 175             {
 176                 return;
 177             }
 178         }
 179         else
 180         {
 181             //if nothing is selected select all ranges
 182             fillRangesForDiagram( m_xChartModel->getFirstChartDiagram() );
 183             return;
 184         }
 185     }
 186     catch( const uno::Exception & )
 187     {
 188         DBG_UNHANDLED_EXCEPTION("chart2");
 189     }
 190 }
 191
 192 void RangeHighlighter::fillRangesForDiagram( const rtl::Reference< Diagram > & xDiagram )
 193 {
 194     Sequence< OUString > aSelectedRanges( DataSourceHelper::getUsedDataRanges( xDiagram ));
 195     m_aSelectedRanges.realloc( aSelectedRanges.getLength());
 196     auto pSelectedRanges = m_aSelectedRanges.getArray();
 197     // @todo: merge ranges
 198     for( sal_Int32 i=0; i<aSelectedRanges.getLength(); ++i )
 199     {
 200         pSelectedRanges[i].RangeRepresentation = aSelectedRanges[i];
 201         pSelectedRanges[i].Index = -1;
 202         pSelectedRanges[i].PreferredColor = sal_Int32(defaultPreferredColor);
 203         pSelectedRanges[i].AllowMerginigWithOtherRanges = true;
 204     }
 205 }
 206
 207 void RangeHighlighter::fillRangesForDataSeries( const uno::Reference< chart2::XDataSeries > & xSeries )
 208 {
 209     Reference< chart2::data::XDataSource > xSource( xSeries, uno::UNO_QUERY );
 210     if( xSource.is())
 211     {
 212         lcl_fillRanges( m_aSelectedRanges,
 213                         ::chart::DataSourceHelper::getRangesFromDataSource( xSource ),
 214                         defaultPreferredColor );
 215     }
 216 }
 217
 218 void RangeHighlighter::fillRangesForErrorBars(
 219     const uno::Reference< beans::XPropertySet > & xErrorBar,
 220     const uno::Reference< chart2::XDataSeries > & xSeries )
 221 {
 222     // only show error bar ranges, if the style is set to FROM_DATA
 223     bool bUsesRangesAsErrorBars = false;
 224     try
 225     {
 226         sal_Int32 nStyle = css::chart::ErrorBarStyle::NONE;
 227         bUsesRangesAsErrorBars =
 228             ( xErrorBar.is() &&
 229               (xErrorBar->getPropertyValue( u"ErrorBarStyle"_ustr) >>= nStyle) &&
 230               nStyle == css::chart::ErrorBarStyle::FROM_DATA );
 231     }
 232     catch( const uno::Exception & )
 233     {
 234         DBG_UNHANDLED_EXCEPTION("chart2");
 235     }
 236
 237     if( bUsesRangesAsErrorBars )
 238     {
 239         Reference< chart2::data::XDataSource > xSource( xErrorBar, uno::UNO_QUERY );
 240         if( xSource.is())
 241         {
 242             lcl_fillRanges( m_aSelectedRanges,
 243                             ::chart::DataSourceHelper::getRangesFromDataSource( xSource ),
 244                             defaultPreferredColor );
 245         }
 246     }
 247     else
 248     {
 249         fillRangesForDataSeries( xSeries );
 250     }
 251 }
 252
 253 void RangeHighlighter::fillRangesForCategories( const Reference< chart2::XAxis > & xAxis )
 254 {
 255     if( ! xAxis.is())
 256         return;
 257     chart2::ScaleData aData( xAxis->getScaleData());
 258     lcl_fillRanges( m_aSelectedRanges,
 259                     DataSourceHelper::getRangesFromLabeledDataSequence( aData.Categories ),
 260                     defaultPreferredColor );
 261 }
 262
 263 void RangeHighlighter::fillRangesForDataPoint( const rtl::Reference< DataSeries > & xDataSeries, sal_Int32 nIndex )
 264 {
 265     if( !xDataSeries.is())
 266         return;
 267
 268     Color nPreferredColor = defaultPreferredColor;
 269     std::vector< chart2::data::HighlightedRange > aHilightedRanges;
 270     const std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > & aLSeqSeq( xDataSeries->getDataSequences2());
 271     for( uno::Reference< chart2::data::XLabeledDataSequence > const & labelDataSeq : aLSeqSeq )
 272     {
 273         Reference< chart2::data::XDataSequence > xLabel( labelDataSeq->getLabel());
 274         Reference< chart2::data::XDataSequence > xValues( labelDataSeq->getValues());
 275
 276         if( xLabel.is())
 277             aHilightedRanges.emplace_back(
 278                     xLabel->getSourceRangeRepresentation(),
 279                     -1,
 280                     sal_Int32(nPreferredColor),
 281                     false );
 282
 283         sal_Int32 nUnhiddenIndex = DataSeriesHelper::translateIndexFromHiddenToFullSequence( nIndex, xValues, !m_bIncludeHiddenCells );
 284         if( xValues.is())
 285             aHilightedRanges.emplace_back(
 286                     xValues->getSourceRangeRepresentation(),
 287                     nUnhiddenIndex,
 288                     sal_Int32(nPreferredColor),
 289                     false );
 290     }
 291     m_aSelectedRanges = comphelper::containerToSequence( aHilightedRanges );
 292 }
 293
 294 void SAL_CALL RangeHighlighter::addSelectionChangeListener( const Reference< view::XSelectionChangeListener >& xListener )
 295 {
 296     if(!xListener.is())
 297         return;
 298
 299     if( m_nAddedListenerCount == 0 )
 300         startListening();
 301     std::unique_lock g(m_aMutex);
 302     maSelectionChangeListeners.addInterface( g, xListener);
 303     ++m_nAddedListenerCount;
 304
 305     //bring the new listener up to the current state
 306     lang::EventObject aEvent( static_cast< lang::XComponent* >( this ) );
 307     xListener->selectionChanged( aEvent );
 308 }
 309
 310 void SAL_CALL RangeHighlighter::removeSelectionChangeListener( const Reference< view::XSelectionChangeListener >& xListener )
 311 {
 312     std::unique_lock g(m_aMutex);
 313     maSelectionChangeListeners.removeInterface( g, xListener );
 314     --m_nAddedListenerCount;
 315     if( m_nAddedListenerCount == 0 )
 316         stopListening();
 317 }
 318
 319 // ____ XSelectionChangeListener ____
 320 void SAL_CALL RangeHighlighter::selectionChanged( const lang::EventObject& /*aEvent*/ )
 321 {
 322     determineRanges();
 323
 324     // determine ranges of selected view objects
 325     // if changed, fire an event
 326     fireSelectionEvent();
 327 }
 328
 329 void RangeHighlighter::fireSelectionEvent()
 330 {
 331     std::unique_lock g(m_aMutex);
 332     if( maSelectionChangeListeners.getLength(g) )
 333     {
 334         lang::EventObject aEvent( static_cast< lang::XComponent* >( this ) );
 335         maSelectionChangeListeners.forEach(g,
 336             [&aEvent](const css::uno::Reference<view::XSelectionChangeListener>& xListener)
 337             {
 338                 xListener->selectionChanged(aEvent);
 339             }
 340         );
 341     }
 342 }
 343
 344 void SAL_CALL RangeHighlighter::disposing( const lang::EventObject& Source )
 345 {
 346     if( Source.Source == m_xSelectionSupplier )
 347     {
 348         m_xSelectionSupplier.clear();
 349         m_aSelectedRanges.realloc( 0 );
 350         fireSelectionEvent();
 351     }
 352 }
 353
 354 void RangeHighlighter::startListening()
 355 {
 356     if( m_xSelectionSupplier.is())
 357     {
 358         if( ! m_xListener.is())
 359         {
 360             m_xListener.set( new WeakSelectionChangeListenerAdapter( this ));
 361             determineRanges();
 362         }
 363         m_xSelectionSupplier->addSelectionChangeListener( m_xListener );
 364     }
 365 }
 366
 367 void RangeHighlighter::stopListening()
 368 {
 369     if( m_xSelectionSupplier.is() && m_xListener.is())
 370     {
 371         m_xSelectionSupplier->removeSelectionChangeListener( m_xListener );
 372         m_xListener.clear();
 373     }
 374 }
 375
 376 // ____ WeakComponentImplHelperBase ____
 377 // is called when dispose() is called at this component
 378 void RangeHighlighter::disposing(std::unique_lock<std::mutex>&)
 379 {
 380     // @todo: remove listener. Currently the controller shows an assertion
 381     // because it is already disposed
 382 //     stopListening();
 383     m_xListener.clear();
 384     m_xSelectionSupplier.clear();
 385     m_nAddedListenerCount =  0;
 386     m_aSelectedRanges.realloc( 0 );
 387 }
 388
 389 } //  namespace chart
 390
 391 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */