chart2/source/controller/dialogs/DialogModel.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 "DialogModel.hxx"
  21 #include <RangeSelectionHelper.hxx>
  22 #include <DataInterpreter.hxx>
  23 #include <DataSeries.hxx>
  24 #include <DataSeriesHelper.hxx>
  25 #include <DataSourceHelper.hxx>
  26 #include <Diagram.hxx>
  27 #include <strings.hrc>
  28 #include <ResId.hxx>
  29 #include <ControllerLockGuard.hxx>
  30 #include <ChartType.hxx>
  31 #include <ChartTypeHelper.hxx>
  32 #include <ChartTypeTemplate.hxx>
  33 #include <ThreeDHelper.hxx>
  34 #include <ChartModel.hxx>
  35 #include <BaseCoordinateSystem.hxx>
  36 #include <LabeledDataSequence.hxx>
  37
  38 #include <com/sun/star/chart2/AxisType.hpp>
  39 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  40 #include <comphelper/diagnose_ex.hxx>
  41
  42 #include <rtl/ustring.hxx>
  43
  44 #include <utility>
  45 #include <algorithm>
  46 #include <cstddef>
  47 #include <iterator>
  48 #include <numeric>
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::chart2;
  52
  53 using ::com::sun::star::uno::Reference;
  54 using ::com::sun::star::uno::Sequence;
  55
  56 namespace
  57 {
  58 constexpr OUString lcl_aLabelRole( u"label"_ustr );
  59
  60
  61 OUString lcl_ConvertRole( const OUString & rRoleString )
  62 {
  63     OUString aResult( rRoleString );
  64
  65     typedef std::map< OUString, OUString > tTranslationMap;
  66     static const tTranslationMap aTranslationMap =
  67     {
  68         { "categories", ::chart::SchResId( STR_DATA_ROLE_CATEGORIES ) },
  69         { "error-bars-x", ::chart::SchResId( STR_DATA_ROLE_X_ERROR ) },
  70         { "error-bars-x-positive", ::chart::SchResId( STR_DATA_ROLE_X_ERROR_POSITIVE ) },
  71         { "error-bars-x-negative", ::chart::SchResId( STR_DATA_ROLE_X_ERROR_NEGATIVE ) },
  72         { "error-bars-y", ::chart::SchResId( STR_DATA_ROLE_Y_ERROR ) },
  73         { "error-bars-y-positive", ::chart::SchResId( STR_DATA_ROLE_Y_ERROR_POSITIVE ) },
  74         { "error-bars-y-negative", ::chart::SchResId( STR_DATA_ROLE_Y_ERROR_NEGATIVE ) },
  75         { "label",        ::chart::SchResId( STR_DATA_ROLE_LABEL ) },
  76         { "values-first", ::chart::SchResId( STR_DATA_ROLE_FIRST ) },
  77         { "values-last",  ::chart::SchResId( STR_DATA_ROLE_LAST ) },
  78         { "values-max",   ::chart::SchResId( STR_DATA_ROLE_MAX ) },
  79         { "values-min",   ::chart::SchResId( STR_DATA_ROLE_MIN ) },
  80         { "values-x",     ::chart::SchResId( STR_DATA_ROLE_X ) },
  81         { "values-y",     ::chart::SchResId( STR_DATA_ROLE_Y ) },
  82         { "values-size",  ::chart::SchResId( STR_DATA_ROLE_SIZE ) },
  83         { "FillColor",    ::chart::SchResId( STR_PROPERTY_ROLE_FILLCOLOR ) },
  84         { "BorderColor",  ::chart::SchResId( STR_PROPERTY_ROLE_BORDERCOLOR ) },
  85     };
  86
  87     tTranslationMap::const_iterator aIt( aTranslationMap.find( rRoleString ));
  88     if( aIt != aTranslationMap.end())
  89     {
  90         aResult = (*aIt).second;
  91     }
  92     return aResult;
  93 }
  94
  95 typedef std::map< OUString, sal_Int32 > lcl_tRoleIndexMap;
  96
  97 lcl_tRoleIndexMap lcl_createRoleIndexMap()
  98 {
  99     lcl_tRoleIndexMap aMap;
 100     sal_Int32 nIndex = 0;
 101
 102     aMap[ u"label"_ustr ] =                 ++nIndex;
 103     aMap[ u"categories"_ustr ] =            ++nIndex;
 104     aMap[ u"values-x"_ustr ] =              ++nIndex;
 105     aMap[ u"values-y"_ustr ] =              ++nIndex;
 106     aMap[ u"error-bars-x"_ustr ] =          ++nIndex;
 107     aMap[ u"error-bars-x-positive"_ustr ] = ++nIndex;
 108     aMap[ u"error-bars-x-negative"_ustr ] = ++nIndex;
 109     aMap[ u"error-bars-y"_ustr ] =          ++nIndex;
 110     aMap[ u"error-bars-y-positive"_ustr ] = ++nIndex;
 111     aMap[ u"error-bars-y-negative"_ustr ] = ++nIndex;
 112     aMap[ u"values-first"_ustr ] =          ++nIndex;
 113     aMap[ u"values-min"_ustr ] =            ++nIndex;
 114     aMap[ u"values-max"_ustr ] =            ++nIndex;
 115     aMap[ u"values-last"_ustr ] =           ++nIndex;
 116     aMap[ u"values-size"_ustr ] =           ++nIndex;
 117
 118     return aMap;
 119 }
 120
 121
 122 struct lcl_RolesWithRangeAppend
 123 {
 124     typedef Reference< data::XLabeledDataSequence > value_type;
 125     typedef ::chart::DialogModel::tRolesWithRanges tContainerType;
 126
 127     explicit lcl_RolesWithRangeAppend( tContainerType * rCnt,
 128                                        OUString aLabelRole )
 129             : m_rDestCnt( rCnt ),
 130               m_aRoleForLabelSeq(std::move( aLabelRole ))
 131     {}
 132
 133     lcl_RolesWithRangeAppend & operator= ( const value_type & xVal )
 134     {
 135         try
 136         {
 137             if( xVal.is())
 138             {
 139                 // data sequence
 140                 Reference< data::XDataSequence > xSeq( xVal->getValues());
 141                 if( xSeq.is())
 142                 {
 143                     OUString aRole;
 144                     Reference< beans::XPropertySet > xProp( xSeq, uno::UNO_QUERY_THROW );
 145                     if( xProp->getPropertyValue( u"Role"_ustr ) >>= aRole )
 146                     {
 147                         m_rDestCnt->emplace(aRole, xSeq->getSourceRangeRepresentation());
 148                         // label
 149                         if( aRole == m_aRoleForLabelSeq )
 150                         {
 151                             Reference< data::XDataSequence > xLabelSeq( xVal->getLabel());
 152                             if( xLabelSeq.is())
 153                             {
 154                                 m_rDestCnt->emplace(
 155                                         lcl_aLabelRole, xLabelSeq->getSourceRangeRepresentation());
 156                             }
 157                         }
 158                     }
 159                 }
 160             }
 161         }
 162         catch( const uno::Exception & )
 163         {
 164             DBG_UNHANDLED_EXCEPTION("chart2");
 165         }
 166         return *this;
 167     }
 168
 169     // Implement output operator requirements as required by std::copy (and
 170     // implement prefix increment in terms of postfix increment to avoid unused
 171     // member function warnings for the latter in the common case where
 172     // std::copy would not actually need it):
 173     lcl_RolesWithRangeAppend & operator* ()     { return *this; }
 174     lcl_RolesWithRangeAppend & operator++ ()    { return operator++(0); }
 175     lcl_RolesWithRangeAppend & operator++ (int) { return *this; }
 176
 177 private:
 178     tContainerType * m_rDestCnt;
 179     OUString m_aRoleForLabelSeq;
 180 };
 181
 182 }
 183
 184 namespace std
 185 {
 186     template<> struct iterator_traits<lcl_RolesWithRangeAppend>
 187     {
 188         typedef std::output_iterator_tag iterator_category;
 189         typedef Reference< data::XLabeledDataSequence > value_type;
 190         typedef value_type& reference;
 191     };
 192 }
 193
 194 namespace {
 195
 196 void lcl_SetSequenceRole(
 197     const Reference< data::XDataSequence > & xSeq,
 198     const OUString & rRole )
 199 {
 200     Reference< beans::XPropertySet > xProp( xSeq, uno::UNO_QUERY );
 201     if( xProp.is())
 202         xProp->setPropertyValue( u"Role"_ustr , uno::Any( rRole ));
 203 }
 204
 205 Sequence< OUString > lcl_CopyExcludingValuesFirst(
 206     Sequence< OUString > const & i_aInput )
 207 {
 208     Sequence< OUString > aOutput( i_aInput.getLength());
 209     auto pOutput = aOutput.getArray();
 210     int nSourceIndex, nDestIndex;
 211     for( nSourceIndex = nDestIndex = 0; nSourceIndex < i_aInput.getLength(); nSourceIndex++ )
 212     {
 213         if( i_aInput[nSourceIndex] == "values-first" )
 214         {
 215             aOutput.realloc( aOutput.getLength() - 1 );
 216             pOutput = aOutput.getArray();
 217         }
 218         else
 219         {
 220             pOutput[nDestIndex] = i_aInput[nSourceIndex];
 221             nDestIndex++;
 222         }
 223     }
 224     return aOutput;
 225 }
 226
 227 rtl::Reference< ::chart::DataSeries > lcl_CreateNewSeries(
 228     const rtl::Reference< ::chart::ChartType > & xChartType,
 229     sal_Int32 nNewSeriesIndex,
 230     sal_Int32 nTotalNumberOfSeriesInCTGroup,
 231     const rtl::Reference< ::chart::Diagram > & xDiagram,
 232     const rtl::Reference< ::chart::ChartTypeTemplate > & xTemplate,
 233     bool bCreateDataCachedSequences )
 234 {
 235     // create plain series
 236     rtl::Reference< ::chart::DataSeries > xResult = new ::chart::DataSeries();
 237     if( xTemplate.is())
 238     {
 239         // @deprecated: correct default color should be found by view
 240         // without setting it as hard attribute
 241         Reference< XColorScheme > xColorScheme( xDiagram->getDefaultColorScheme());
 242         if( xColorScheme.is())
 243             xResult->setPropertyValue( u"Color"_ustr , uno::Any( xColorScheme->getColorByIndex( nNewSeriesIndex )));
 244         std::size_t nGroupIndex=0;
 245         if( xChartType.is())
 246         {
 247             std::vector< rtl::Reference< ::chart::ChartType > > aCTs =
 248                 xDiagram->getChartTypes();
 249             for( ; nGroupIndex < aCTs.size(); ++nGroupIndex)
 250                 if( aCTs[nGroupIndex] == xChartType )
 251                     break;
 252             if( nGroupIndex == aCTs.size())
 253                 nGroupIndex = 0;
 254         }
 255         xTemplate->applyStyle2( xResult, nGroupIndex, nNewSeriesIndex, nTotalNumberOfSeriesInCTGroup );
 256     }
 257
 258     if( bCreateDataCachedSequences )
 259     {
 260         // set chart type specific roles
 261         if( xChartType.is() )
 262         {
 263             std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > aNewSequences;
 264             const OUString aRoleOfSeqForSeriesLabel = xChartType->getRoleOfSequenceForSeriesLabel();
 265             const OUString aLabel(::chart::SchResId(STR_DATA_UNNAMED_SERIES));
 266             Sequence< OUString > aPossibleRoles( xChartType->getSupportedMandatoryRoles());
 267             Sequence< OUString > aPossibleOptRoles( xChartType->getSupportedOptionalRoles());
 268
 269             //special handling for candlestick type
 270             if( xTemplate.is())
 271             {
 272                 rtl::Reference< ::chart::DataInterpreter > xInterpreter( xTemplate->getDataInterpreter2());
 273                 if( xInterpreter.is())
 274                 {
 275                     sal_Int32 nStockVariant;
 276                     if( xInterpreter->getChartTypeSpecificData(u"stock variant"_ustr) >>= nStockVariant )
 277                     {
 278                         if( nStockVariant == 0 || nStockVariant == 2) {
 279                             //delete "values-first" role
 280                             aPossibleRoles = lcl_CopyExcludingValuesFirst(aPossibleRoles);
 281                             aPossibleOptRoles = lcl_CopyExcludingValuesFirst(aPossibleOptRoles);
 282                         }
 283                     }
 284                 }
 285             }
 286
 287             const Sequence< OUString > aRoles( aPossibleRoles );
 288             const Sequence< OUString > aOptRoles( aPossibleOptRoles );
 289
 290             for(OUString const & role : aRoles)
 291             {
 292                 if( role == lcl_aLabelRole )
 293                     continue;
 294                 Reference< data::XDataSequence > xSeq( ::chart::DataSourceHelper::createCachedDataSequence() );
 295                 lcl_SetSequenceRole( xSeq, role );
 296                 // assert that aRoleOfSeqForSeriesLabel is part of the mandatory roles
 297                 if( role == aRoleOfSeqForSeriesLabel )
 298                 {
 299                     Reference< data::XDataSequence > xLabel( ::chart::DataSourceHelper::createCachedDataSequence( aLabel ));
 300                     lcl_SetSequenceRole( xLabel, lcl_aLabelRole );
 301                     aNewSequences.push_back( ::chart::DataSourceHelper::createLabeledDataSequence( xSeq, xLabel ));
 302                 }
 303                 else
 304                     aNewSequences.push_back( ::chart::DataSourceHelper::createLabeledDataSequence( xSeq ));
 305             }
 306
 307             for(OUString const & role : aOptRoles)
 308             {
 309                 if( role == lcl_aLabelRole )
 310                     continue;
 311                 Reference< data::XDataSequence > xSeq( ::chart::DataSourceHelper::createCachedDataSequence());
 312                 lcl_SetSequenceRole( xSeq, role );
 313                 aNewSequences.push_back( ::chart::DataSourceHelper::createLabeledDataSequence( xSeq ));
 314             }
 315
 316             xResult->setData( aNewSequences );
 317         }
 318     }
 319
 320     return xResult;
 321 }
 322
 323 struct lcl_addSeriesNumber
 324 {
 325     sal_Int32 operator() ( sal_Int32 nCurrentNumber, const Reference< XDataSeriesContainer > & xCnt ) const
 326     {
 327         if( xCnt.is())
 328             return nCurrentNumber + (xCnt->getDataSeries().getLength());
 329         return nCurrentNumber;
 330     }
 331 };
 332
 333 } // anonymous namespace
 334
 335 namespace chart
 336 {
 337
 338 DialogModelTimeBasedInfo::DialogModelTimeBasedInfo():
 339     bTimeBased(false),
 340     nStart(0),
 341     nEnd(0)
 342 {
 343 }
 344
 345 DialogModel::DialogModel(
 346     rtl::Reference<::chart::ChartModel> xChartDocument ) :
 347         m_xChartDocument(std::move( xChartDocument )),
 348         m_aTimerTriggeredControllerLock( m_xChartDocument )
 349 {
 350 }
 351
 352 DialogModel::~DialogModel()
 353 {
 354     if(maTimeBasedInfo.bTimeBased)
 355     {
 356         getModel().setTimeBasedRange(maTimeBasedInfo.nStart, maTimeBasedInfo.nEnd);
 357     }
 358 }
 359
 360 void DialogModel::setTemplate(
 361     const rtl::Reference< ChartTypeTemplate > & xTemplate )
 362 {
 363     m_xTemplate = xTemplate;
 364 }
 365
 366 std::shared_ptr< RangeSelectionHelper > const &
 367     DialogModel::getRangeSelectionHelper() const
 368 {
 369     if( ! m_spRangeSelectionHelper)
 370         m_spRangeSelectionHelper =
 371             std::make_shared<RangeSelectionHelper>( m_xChartDocument );
 372
 373     return m_spRangeSelectionHelper;
 374 }
 375
 376 const rtl::Reference<::chart::ChartModel> & DialogModel::getChartModel() const
 377 {
 378     return m_xChartDocument;
 379 }
 380
 381 Reference< data::XDataProvider > DialogModel::getDataProvider() const
 382 {
 383     Reference< data::XDataProvider > xResult;
 384     if( m_xChartDocument.is())
 385         xResult.set( m_xChartDocument->getDataProvider());
 386     return xResult;
 387 }
 388
 389 std::vector< rtl::Reference< ChartType > >
 390     DialogModel::getAllDataSeriesContainers() const
 391 {
 392     std::vector< rtl::Reference< ChartType > > aResult;
 393
 394     try
 395     {
 396         if( !m_xChartDocument )
 397             return {};
 398         rtl::Reference< Diagram > xDiagram = m_xChartDocument->getFirstChartDiagram();
 399         if( xDiagram.is())
 400         {
 401             const std::vector< rtl::Reference< BaseCoordinateSystem > > & aCooSysSeq(
 402                 xDiagram->getBaseCoordinateSystems());
 403             for( rtl::Reference< BaseCoordinateSystem > const & coords : aCooSysSeq )
 404             {
 405
 406                 for (const auto & rxChartType : coords->getChartTypes2())
 407                     aResult.push_back(rxChartType);
 408             }
 409         }
 410     }
 411     catch( const uno::Exception & )
 412     {
 413         DBG_UNHANDLED_EXCEPTION("chart2");
 414     }
 415
 416     return aResult;
 417 }
 418
 419 std::vector< DialogModel::tSeriesWithChartTypeByName >
 420     DialogModel::getAllDataSeriesWithLabel() const
 421 {
 422     std::vector< tSeriesWithChartTypeByName > aResult;
 423     std::vector< rtl::Reference< ChartType > > aContainers(
 424         getAllDataSeriesContainers());
 425
 426     for (const auto & rxChartType : aContainers )
 427     {
 428         try
 429         {
 430             const std::vector< rtl::Reference< DataSeries > > & aSeq = rxChartType->getDataSeries2();
 431             OUString aRole = rxChartType->getRoleOfSequenceForSeriesLabel();
 432             for( rtl::Reference< DataSeries > const & dataSeries : aSeq )
 433             {
 434                 aResult.push_back(
 435                     ::chart::DialogModel::tSeriesWithChartTypeByName(
 436                         dataSeries->getLabelForRole( aRole ),
 437                         std::make_pair( dataSeries, rxChartType )));
 438             }
 439         }
 440         catch( const uno::Exception & )
 441         {
 442             DBG_UNHANDLED_EXCEPTION("chart2");
 443         }
 444     }
 445
 446     return aResult;
 447 }
 448
 449 namespace {
 450
 451 void addMissingRoles(DialogModel::tRolesWithRanges& rResult, const uno::Sequence<OUString>& rRoles)
 452 {
 453     for(OUString const & role : rRoles)
 454     {
 455         if(rResult.find(role) == rResult.end())
 456             rResult.emplace(role, OUString());
 457     }
 458 }
 459
 460 /**
 461  * Insert a new data series to chart type at position after specified series
 462  * position.
 463  *
 464  * @param xChartType chart type that contains data series.
 465  * @param xSeries insertion position.  The new series will be inserted after
 466  *                this one.
 467  * @param xNewSeries new data series to insert.
 468  */
 469 void addNewSeriesToContainer(
 470     const rtl::Reference<ChartType>& xChartType,
 471     const rtl::Reference<DataSeries>& xSeries,
 472     const rtl::Reference<DataSeries>& xNewSeries )
 473 {
 474     auto aSeries = xChartType->getDataSeries2();
 475
 476     auto aIt = std::find( aSeries.begin(), aSeries.end(), xSeries);
 477
 478     if( aIt == aSeries.end())
 479         // if we have no series we insert at the first position.
 480         aIt = aSeries.begin();
 481     else
 482         // vector::insert inserts before, so we have to advance
 483         ++aIt;
 484
 485     aSeries.insert(aIt, xNewSeries);
 486     xChartType->setDataSeries(aSeries);
 487 }
 488
 489 }
 490
 491 DialogModel::tRolesWithRanges DialogModel::getRolesWithRanges(
 492     const Reference< XDataSeries > & xSeries,
 493     const OUString & aRoleOfSequenceForLabel,
 494     const rtl::Reference< ::chart::ChartType > & xChartType )
 495 {
 496     DialogModel::tRolesWithRanges aResult;
 497     try
 498     {
 499         Reference< data::XDataSource > xSource( xSeries, uno::UNO_QUERY_THROW );
 500         const Sequence< Reference< data::XLabeledDataSequence > > aSeq( xSource->getDataSequences());
 501         std::copy( aSeq.begin(), aSeq.end(),
 502                      lcl_RolesWithRangeAppend( &aResult, aRoleOfSequenceForLabel ));
 503         if( xChartType.is())
 504         {
 505             // add missing mandatory roles
 506             Sequence< OUString > aRoles( xChartType->getSupportedMandatoryRoles());
 507             addMissingRoles(aResult, aRoles);
 508
 509             // add missing optional roles
 510             aRoles = xChartType->getSupportedOptionalRoles();
 511             addMissingRoles(aResult, aRoles);
 512
 513             // add missing property roles
 514             aRoles = xChartType->getSupportedPropertyRoles();
 515             addMissingRoles(aResult, aRoles);
 516         }
 517     }
 518     catch( const uno::Exception & )
 519     {
 520         DBG_UNHANDLED_EXCEPTION("chart2");
 521     }
 522     return aResult;
 523 }
 524
 525 void DialogModel::moveSeries(
 526     const rtl::Reference< DataSeries > & xSeries,
 527     MoveDirection eDirection )
 528 {
 529     m_aTimerTriggeredControllerLock.startTimer();
 530     ControllerLockGuardUNO aLockedControllers( m_xChartDocument );
 531
 532     rtl::Reference< Diagram > xDiagram( m_xChartDocument->getFirstChartDiagram());
 533     xDiagram->moveSeries( xSeries, eDirection==MoveDirection::Down );
 534 }
 535
 536 rtl::Reference< ::chart::DataSeries > DialogModel::insertSeriesAfter(
 537     const Reference< XDataSeries > & xUnoSeries,
 538     const rtl::Reference< ::chart::ChartType > & xChartType,
 539     bool bCreateDataCachedSequences /* = false */ )
 540 {
 541     m_aTimerTriggeredControllerLock.startTimer();
 542     ControllerLockGuardUNO aLockedControllers( m_xChartDocument );
 543     rtl::Reference< ::chart::DataSeries > xNewSeries;
 544     rtl::Reference<DataSeries> xSeries = dynamic_cast<DataSeries*>(xUnoSeries.get());
 545     assert(xSeries || !xUnoSeries);
 546
 547     try
 548     {
 549         rtl::Reference< Diagram > xDiagram( m_xChartDocument->getFirstChartDiagram() );
 550         ThreeDLookScheme e3DScheme = xDiagram->detectScheme();
 551
 552         sal_Int32 nSeriesInChartType = 0;
 553         const sal_Int32 nTotalSeries = countSeries();
 554         if( xChartType.is())
 555         {
 556             nSeriesInChartType = xChartType->getDataSeries().getLength();
 557         }
 558
 559         // create new series
 560         xNewSeries =
 561             lcl_CreateNewSeries(
 562                 xChartType,
 563                 nTotalSeries, // new series' index
 564                 nSeriesInChartType,
 565                 xDiagram,
 566                 m_xTemplate,
 567                 bCreateDataCachedSequences );
 568
 569         // add new series to container
 570         if( xNewSeries.is())
 571             addNewSeriesToContainer(xChartType, xSeries, xNewSeries);
 572
 573         xDiagram->setScheme( e3DScheme );
 574     }
 575     catch( const uno::Exception & )
 576     {
 577         DBG_UNHANDLED_EXCEPTION("chart2");
 578     }
 579     return xNewSeries;
 580 }
 581
 582 void DialogModel::deleteSeries(
 583     const rtl::Reference< DataSeries > & xSeries,
 584     const rtl::Reference< ChartType > & xChartType )
 585 {
 586     m_aTimerTriggeredControllerLock.startTimer();
 587     ControllerLockGuardUNO aLockedControllers( m_xChartDocument );
 588
 589     DataSeriesHelper::deleteSeries( xSeries, xChartType );
 590 }
 591
 592 uno::Reference< chart2::data::XLabeledDataSequence > DialogModel::getCategories() const
 593 {
 594     uno::Reference< chart2::data::XLabeledDataSequence > xResult;
 595     try
 596     {
 597         if( m_xChartDocument.is())
 598         {
 599             rtl::Reference< Diagram > xDiagram( m_xChartDocument->getFirstChartDiagram());
 600             if (xDiagram.is())
 601                 xResult = xDiagram->getCategories();
 602         }
 603     }
 604     catch( const uno::Exception & )
 605     {
 606         DBG_UNHANDLED_EXCEPTION("chart2");
 607     }
 608     return xResult;
 609 }
 610
 611 void DialogModel::setCategories( const Reference< chart2::data::XLabeledDataSequence > & xCategories )
 612 {
 613     if( !m_xChartDocument.is())
 614         return;
 615
 616     rtl::Reference< Diagram > xDiagram( m_xChartDocument->getFirstChartDiagram());
 617     if( !xDiagram.is())
 618         return;
 619
 620     // categories
 621     bool bSupportsCategories = true;
 622
 623     rtl::Reference< ChartType > xFirstChartType( xDiagram->getChartTypeByIndex( 0 ) );
 624     if( xFirstChartType.is() )
 625     {
 626         sal_Int32 nAxisType = ChartTypeHelper::getAxisType( xFirstChartType, 0 ); // x-axis
 627         bSupportsCategories = (nAxisType == AxisType::CATEGORY);
 628     }
 629     xDiagram->setCategories( xCategories, true, bSupportsCategories );
 630 }
 631
 632 OUString DialogModel::getCategoriesRange() const
 633 {
 634     OUString aRange;
 635     try
 636     {
 637         uno::Reference< chart2::data::XLabeledDataSequence > xLSeq( getCategories());
 638         if( xLSeq.is())
 639         {
 640             Reference< data::XDataSequence > xSeq( xLSeq->getValues());
 641             if( xSeq.is())
 642                 aRange = xSeq->getSourceRangeRepresentation();
 643         }
 644     }
 645     catch (const lang::DisposedException&)
 646     {
 647         TOOLS_WARN_EXCEPTION( "chart2", "unexpected exception caught" );
 648     }
 649     return aRange;
 650 }
 651
 652 bool DialogModel::isCategoryDiagram() const
 653 {
 654     bool bRet = false;
 655     if( m_xChartDocument.is() && m_xChartDocument->getFirstChartDiagram())
 656         bRet = m_xChartDocument->getFirstChartDiagram()->isCategory();
 657     return bRet;
 658 }
 659
 660 void DialogModel::detectArguments(
 661     OUString & rOutRangeString,
 662     bool & rOutUseColumns,
 663     bool & rOutFirstCellAsLabel,
 664     bool & rOutHasCategories ) const
 665 {
 666     try
 667     {
 668         uno::Sequence< sal_Int32 > aSequenceMapping;//todo YYYX
 669
 670         // Note: unused data is currently not supported in being passed to detectRangeSegmentation
 671         if( m_xChartDocument.is())
 672         {
 673             (void)DataSourceHelper::detectRangeSegmentation(
 674                 m_xChartDocument,
 675                 rOutRangeString, aSequenceMapping, rOutUseColumns, rOutFirstCellAsLabel, rOutHasCategories );
 676         }
 677     }
 678     catch( const uno::Exception & )
 679     {
 680         DBG_UNHANDLED_EXCEPTION("chart2");
 681     }
 682 }
 683
 684 bool DialogModel::allArgumentsForRectRangeDetected() const
 685 {
 686     return DataSourceHelper::allArgumentsForRectRangeDetected( m_xChartDocument );
 687 }
 688
 689 void DialogModel::startControllerLockTimer()
 690 {
 691     m_aTimerTriggeredControllerLock.startTimer();
 692 }
 693
 694 void DialogModel::setData(
 695     const Sequence< beans::PropertyValue > & rArguments )
 696 {
 697     m_aTimerTriggeredControllerLock.startTimer();
 698     ControllerLockGuardUNO aLockedControllers( m_xChartDocument );
 699
 700     Reference< data::XDataProvider > xDataProvider( getDataProvider());
 701     if( ! xDataProvider.is() ||
 702         ! m_xTemplate.is() )
 703     {
 704         OSL_FAIL( "Model objects missing" );
 705         return;
 706     }
 707
 708     try
 709     {
 710         Reference< chart2::data::XDataSource > xDataSource(
 711             xDataProvider->createDataSource( rArguments ) );
 712
 713         rtl::Reference< ::chart::DataInterpreter > xInterpreter(
 714             m_xTemplate->getDataInterpreter2());
 715         if( xInterpreter.is())
 716         {
 717             rtl::Reference< Diagram > xDiagram( m_xChartDocument->getFirstChartDiagram() );
 718             ThreeDLookScheme e3DScheme = xDiagram->detectScheme();
 719
 720             std::vector< rtl::Reference< DataSeries > > aSeriesToReUse =
 721                 xDiagram->getDataSeries();
 722             applyInterpretedData(
 723                 xInterpreter->interpretDataSource(
 724                     xDataSource, rArguments,
 725                     aSeriesToReUse ),
 726                 aSeriesToReUse);
 727
 728             xDiagram->setScheme( e3DScheme );
 729         }
 730     }
 731     catch( const uno::Exception & )
 732     {
 733         DBG_UNHANDLED_EXCEPTION("chart2");
 734     }
 735 }
 736
 737 void DialogModel::setTimeBasedRange( bool bTimeBased, sal_Int32 nStart, sal_Int32 nEnd) const
 738 {
 739     maTimeBasedInfo.nStart = nStart;
 740     maTimeBasedInfo.nEnd = nEnd;
 741     maTimeBasedInfo.bTimeBased = bTimeBased;
 742 }
 743
 744 OUString DialogModel::ConvertRoleFromInternalToUI( const OUString & rRoleString )
 745 {
 746     return lcl_ConvertRole( rRoleString );
 747 }
 748
 749 OUString DialogModel::GetRoleDataLabel()
 750 {
 751     return ::chart::SchResId(STR_OBJECT_DATALABELS);
 752 }
 753
 754 sal_Int32 DialogModel::GetRoleIndexForSorting( const OUString & rInternalRoleString )
 755 {
 756     static lcl_tRoleIndexMap aRoleIndexMap = lcl_createRoleIndexMap();
 757
 758     lcl_tRoleIndexMap::const_iterator aIt( aRoleIndexMap.find( rInternalRoleString ));
 759     if( aIt != aRoleIndexMap.end())
 760         return aIt->second;
 761
 762     return 0;
 763 }
 764
 765 // private methods
 766
 767 void DialogModel::applyInterpretedData(
 768     const InterpretedData & rNewData,
 769     const std::vector< rtl::Reference< DataSeries > > & rSeriesToReUse )
 770 {
 771     if( ! m_xChartDocument.is())
 772         return;
 773
 774     m_aTimerTriggeredControllerLock.startTimer();
 775     rtl::Reference< Diagram > xDiagram( m_xChartDocument->getFirstChartDiagram());
 776     if( !xDiagram.is())
 777         return;
 778
 779     // styles
 780     if( m_xTemplate.is() )
 781     {
 782         sal_Int32 nGroup = 0;
 783         sal_Int32 nSeriesCounter = 0;
 784         sal_Int32 nNewSeriesIndex = static_cast< sal_Int32 >( rSeriesToReUse.size());
 785         const sal_Int32 nOuterSize=rNewData.Series.size();
 786
 787         for(; nGroup < nOuterSize; ++nGroup)
 788         {
 789             const std::vector< rtl::Reference< DataSeries > > & aSeries( rNewData.Series[ nGroup ] );
 790             const sal_Int32 nSeriesInGroup = aSeries.size();
 791             for( sal_Int32 nSeries=0; nSeries<nSeriesInGroup; ++nSeries, ++nSeriesCounter )
 792             {
 793                 if( std::find( rSeriesToReUse.begin(), rSeriesToReUse.end(), aSeries[nSeries] )
 794                     == rSeriesToReUse.end())
 795                 {
 796                     if( aSeries[nSeries].is())
 797                     {
 798                         // @deprecated: correct default color should be found by view
 799                         // without setting it as hard attribute
 800                         Reference< XColorScheme > xColorScheme( xDiagram->getDefaultColorScheme());
 801                         if( xColorScheme.is())
 802                             aSeries[nSeries]->setPropertyValue( u"Color"_ustr ,
 803                                 uno::Any( xColorScheme->getColorByIndex( nSeriesCounter )));
 804                     }
 805                     m_xTemplate->applyStyle2( aSeries[nSeries], nGroup, nNewSeriesIndex++, nSeriesInGroup );
 806                 }
 807             }
 808         }
 809     }
 810
 811     // data series
 812     std::vector< rtl::Reference< ChartType > > aSeriesCnt = getAllDataSeriesContainers();
 813
 814     OSL_ASSERT( aSeriesCnt.size() == rNewData.Series.size());
 815
 816     auto aSrcIt = rNewData.Series.begin();
 817     auto aDestIt = aSeriesCnt.begin();
 818     for(; aSrcIt != rNewData.Series.end() && aDestIt != aSeriesCnt.end();
 819         ++aSrcIt, ++aDestIt )
 820     {
 821         try
 822         {
 823             OSL_ASSERT( (*aDestIt).is());
 824             (*aDestIt)->setDataSeries( *aSrcIt );
 825         }
 826         catch( const uno::Exception & )
 827         {
 828             DBG_UNHANDLED_EXCEPTION("chart2");
 829         }
 830     }
 831
 832     DialogModel::setCategories(rNewData.Categories);
 833 }
 834
 835 sal_Int32 DialogModel::countSeries() const
 836 {
 837     std::vector< rtl::Reference< ChartType > > aCnt( getAllDataSeriesContainers());
 838     return std::accumulate( aCnt.begin(), aCnt.end(), 0, lcl_addSeriesNumber());
 839 }
 840
 841 ChartModel& DialogModel::getModel() const
 842 {
 843     return *m_xChartDocument;
 844 }
 845
 846 } //  namespace chart
 847
 848 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */