chart2/source/controller/main/ChartModelClone.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 "ChartModelClone.hxx"
  21 #include <ChartModel.hxx>
  22 #include <ChartModelHelper.hxx>
  23 #include <ControllerLockGuard.hxx>
  24 #include <DataSource.hxx>
  25 #include <DataSourceHelper.hxx>
  26
  27 #include <com/sun/star/chart2/XAnyDescriptionAccess.hpp>
  28 #include <com/sun/star/chart2/XInternalDataProvider.hpp>
  29 #include <com/sun/star/util/XCloneable.hpp>
  30 #include <com/sun/star/chart2/XChartDocument.hpp>
  31 #include <com/sun/star/view/XSelectionSupplier.hpp>
  32 #include <com/sun/star/chart2/data/XLabeledDataSequence.hpp>
  33
  34 #include <comphelper/property.hxx>
  35 #include <comphelper/diagnose_ex.hxx>
  36
  37 namespace chart
  38 {
  39
  40     using ::com::sun::star::uno::Reference;
  41     using ::com::sun::star::uno::UNO_QUERY;
  42     using ::com::sun::star::uno::UNO_QUERY_THROW;
  43     using ::com::sun::star::uno::Exception;
  44     using ::com::sun::star::uno::Sequence;
  45     using ::com::sun::star::frame::XModel;
  46     using ::com::sun::star::util::XCloneable;
  47     using ::com::sun::star::chart2::XChartDocument;
  48     using ::com::sun::star::chart2::XInternalDataProvider;
  49     using ::com::sun::star::chart2::XAnyDescriptionAccess;
  50     using ::com::sun::star::view::XSelectionSupplier;
  51     using ::com::sun::star::chart2::data::XLabeledDataSequence;
  52
  53     // = helper
  54     namespace
  55     {
  56         rtl::Reference<::chart::ChartModel> lcl_cloneModel( const rtl::Reference<::chart::ChartModel> & xModel )
  57         {
  58             try
  59             {
  60                 return new ChartModel(*xModel);
  61             }
  62             catch( const Exception& )
  63             {
  64                 DBG_UNHANDLED_EXCEPTION("chart2");
  65             }
  66             return nullptr;
  67         }
  68
  69     }
  70
  71     // = ChartModelClone
  72     ChartModelClone::ChartModelClone( const rtl::Reference<::chart::ChartModel>& i_model, const ModelFacet i_facet )
  73     {
  74         m_xModelClone = lcl_cloneModel( i_model );
  75
  76         try
  77         {
  78             if ( i_facet == E_MODEL_WITH_DATA )
  79             {
  80                 ENSURE_OR_THROW( m_xModelClone && m_xModelClone->hasInternalDataProvider(), "invalid chart model" );
  81
  82                 const Reference< XCloneable > xCloneable( m_xModelClone->getDataProvider(), UNO_QUERY_THROW );
  83                 m_xDataClone.set( xCloneable->createClone(), UNO_QUERY_THROW );
  84             }
  85
  86             if ( i_facet == E_MODEL_WITH_SELECTION )
  87             {
  88                 const Reference< XSelectionSupplier > xSelSupp( m_xModelClone->getCurrentController(), UNO_QUERY_THROW );
  89                 m_aSelection = xSelSupp->getSelection();
  90             }
  91         }
  92         catch( const Exception& )
  93         {
  94             DBG_UNHANDLED_EXCEPTION("chart2");
  95         }
  96     }
  97
  98     ChartModelClone::~ChartModelClone()
  99     {
 100         if ( !impl_isDisposed() )
 101             dispose();
 102     }
 103
 104     void ChartModelClone::dispose()
 105     {
 106         if ( impl_isDisposed() )
 107             return;
 108
 109         m_xModelClone.clear();
 110         m_xDataClone.clear();
 111         m_aSelection.clear();
 112     }
 113
 114     ModelFacet ChartModelClone::getFacet() const
 115     {
 116         if ( m_aSelection.hasValue() )
 117             return E_MODEL_WITH_SELECTION;
 118         if ( m_xDataClone.is() )
 119             return E_MODEL_WITH_DATA;
 120         return E_MODEL;
 121     }
 122
 123     void ChartModelClone::applyToModel( const rtl::Reference<::chart::ChartModel>& i_model ) const
 124     {
 125         applyModelContentToModel( i_model, m_xModelClone, m_xDataClone );
 126
 127         if ( m_aSelection.hasValue() )
 128         {
 129             try
 130             {
 131                 Reference< XSelectionSupplier > xCurrentSelectionSuppl( i_model->getCurrentController(), UNO_QUERY_THROW );
 132                 xCurrentSelectionSuppl->select( m_aSelection );
 133             }
 134             catch( const Exception& )
 135             {
 136                 DBG_UNHANDLED_EXCEPTION("chart2");
 137             }
 138         }
 139     }
 140
 141     namespace
 142     {
 143         void ImplApplyDataToModel( const Reference< XModel >& i_model, const Reference< XInternalDataProvider > & i_data )
 144         {
 145             Reference< XChartDocument > xDoc( i_model, UNO_QUERY );
 146             OSL_ASSERT( xDoc.is() && xDoc->hasInternalDataProvider() );
 147
 148             // copy data from stored internal data provider
 149             if( xDoc.is() && xDoc->hasInternalDataProvider())
 150             {
 151                 Reference< XAnyDescriptionAccess > xCurrentData( xDoc->getDataProvider(), UNO_QUERY );
 152                 Reference< XAnyDescriptionAccess > xSavedData( i_data, UNO_QUERY );
 153                 if ( xCurrentData.is() && xSavedData.is() )
 154                 {
 155                     xCurrentData->setData( xSavedData->getData() );
 156                     xCurrentData->setAnyRowDescriptions( xSavedData->getAnyRowDescriptions());
 157                     xCurrentData->setAnyColumnDescriptions( xSavedData->getAnyColumnDescriptions());
 158                 }
 159             }
 160         }
 161     }
 162
 163     void ChartModelClone::applyModelContentToModel( const rtl::Reference<::chart::ChartModel>& i_model,
 164         const rtl::Reference<::chart::ChartModel>& i_modelToCopyFrom,
 165         const Reference< XInternalDataProvider >& i_data )
 166     {
 167         ENSURE_OR_RETURN_VOID( i_model.is(), "ChartModelElement::applyModelContentToModel: invalid source model!" );
 168         ENSURE_OR_RETURN_VOID( i_modelToCopyFrom.is(), "ChartModelElement::applyModelContentToModel: invalid source model!" );
 169         try
 170         {
 171             // locked controllers of destination
 172             ControllerLockGuardUNO aLockedControllers( i_model );
 173
 174             // propagate the correct flag for plotting of hidden values to the data provider and all used sequences
 175             ChartModelHelper::setIncludeHiddenCells(ChartModelHelper::isIncludeHiddenCells( i_modelToCopyFrom ), *i_model);
 176
 177             // diagram
 178             i_model->setFirstDiagram( i_modelToCopyFrom->getFirstDiagram() );
 179
 180             // main title
 181             i_model->setTitleObject( i_modelToCopyFrom->getTitleObject() );
 182
 183             // page background
 184             ::comphelper::copyProperties(
 185                 i_modelToCopyFrom->getPageBackground(),
 186                 i_model->getPageBackground() );
 187
 188             // apply data (not applied in standard Undo)
 189             if ( i_data.is() )
 190                 ImplApplyDataToModel( i_model, i_data );
 191
 192             // register all sequences at the internal data provider to get adapted
 193             // indexes when columns are added/removed
 194             if ( i_model->hasInternalDataProvider() )
 195             {
 196                 Reference< XInternalDataProvider > xNewDataProvider( i_model->getDataProvider(), UNO_QUERY );
 197                 rtl::Reference< DataSource > xUsedData = DataSourceHelper::getUsedData( *i_model );
 198                 if ( xUsedData.is() && xNewDataProvider.is() )
 199                 {
 200                     const Sequence< Reference< XLabeledDataSequence > > aData( xUsedData->getDataSequences() );
 201                     for( Reference< XLabeledDataSequence > const & labeledDataSeq : aData )
 202                     {
 203                         xNewDataProvider->registerDataSequenceForChanges( labeledDataSeq->getValues() );
 204                         xNewDataProvider->registerDataSequenceForChanges( labeledDataSeq->getLabel() );
 205                     }
 206                 }
 207             }
 208
 209             // restore modify status
 210             if ( !i_modelToCopyFrom->isModified() )
 211             {
 212                 i_model->setModified( false );
 213             }
 214             // \-- locked controllers of destination
 215         }
 216         catch( const Exception& )
 217         {
 218             DBG_UNHANDLED_EXCEPTION("chart2");
 219         }
 220     }
 221
 222 } // namespace chart
 223
 224 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */