chart2/source/tools/ImplUndoManager.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: ImplUndoManager.cxx,v $
  10  * $Revision: 1.7.16.1 $
  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_chart2.hxx"
  33
  34 #include "ImplUndoManager.hxx"
  35 #include "DisposeHelper.hxx"
  36 #include "CommonFunctors.hxx"
  37 #include "ControllerLockGuard.hxx"
  38 #include "PropertyHelper.hxx"
  39 #include "DataSourceHelper.hxx"
  40 #include "ChartModelHelper.hxx"
  41
  42 #include <com/sun/star/chart/XChartDataArray.hpp>
  43 #include <com/sun/star/chart2/XChartDocument.hpp>
  44 #include <com/sun/star/chart2/XInternalDataProvider.hpp>
  45 #include <com/sun/star/chart2/XTitled.hpp>
  46 #include <com/sun/star/util/XCloneable.hpp>
  47 #include <com/sun/star/util/XModifiable.hpp>
  48 #include <com/sun/star/view/XSelectionSupplier.hpp>
  49
  50 #include <boost/bind.hpp>
  51 #include <algorithm>
  52
  53 using namespace ::com::sun::star;
  54
  55 using ::com::sun::star::uno::Reference;
  56 using ::com::sun::star::uno::Sequence;
  57 using ::rtl::OUString;
  58 using ::com::sun::star::chart::XChartDataArray;
  59
  60 namespace chart
  61 {
  62 namespace impl
  63 {
  64
  65 void ImplApplyDataToModel(
  66     Reference< frame::XModel > & xInOutModelToChange,
  67     const Reference< chart2::XInternalDataProvider > & xData )
  68 {
  69     Reference< chart2::XChartDocument > xDoc( xInOutModelToChange, uno::UNO_QUERY );
  70     OSL_ASSERT( xDoc.is() && xDoc->hasInternalDataProvider());
  71
  72     // copy data from stored internal data provider
  73     if( xDoc.is() && xDoc->hasInternalDataProvider())
  74     {
  75         Reference< XChartDataArray > xCurrentData( xDoc->getDataProvider(), uno::UNO_QUERY );
  76         Reference< XChartDataArray > xSavedData( xData, uno::UNO_QUERY );
  77         if( xCurrentData.is() && xSavedData.is())
  78         {
  79             xCurrentData->setData( xSavedData->getData());
  80             xCurrentData->setRowDescriptions( xSavedData->getRowDescriptions());
  81             xCurrentData->setColumnDescriptions( xSavedData->getColumnDescriptions());
  82         }
  83     }
  84 }
  85
  86 // ----------------------------------------
  87
  88 UndoElement::UndoElement(
  89     const OUString & rActionString,
  90     const Reference< frame::XModel > & xModel ) :
  91         m_aActionString( rActionString )
  92 {
  93     initialize( xModel );
  94 }
  95
  96 UndoElement::UndoElement(
  97     const Reference< frame::XModel > & xModel )
  98 {
  99     initialize( xModel );
 100 }
 101
 102 UndoElement::UndoElement( const UndoElement & rOther ) :
 103         m_aActionString( rOther.m_aActionString )
 104 {
 105     initialize( rOther.m_xModel );
 106 }
 107
 108 UndoElement::~UndoElement()
 109 {}
 110
 111 void UndoElement::initialize( const Reference< frame::XModel > & xModel )
 112 {
 113     m_xModel.set( UndoElement::cloneModel( xModel ));
 114 }
 115
 116 void UndoElement::dispose()
 117 {
 118     Reference< lang::XComponent > xComp( m_xModel, uno::UNO_QUERY );
 119     if( xComp.is())
 120         xComp->dispose();
 121     m_xModel.set( 0 );
 122 }
 123
 124 void UndoElement::applyToModel(
 125     Reference< frame::XModel > & xInOutModelToChange )
 126 {
 127     UndoElement::applyModelContentToModel( xInOutModelToChange, m_xModel );
 128 }
 129
 130 UndoElement * UndoElement::createFromModel(
 131     const Reference< frame::XModel > & xModel )
 132 {
 133     return new UndoElement( getActionString(), xModel );
 134 }
 135
 136 void UndoElement::setActionString( const ::rtl::OUString & rActionString )
 137 {
 138     m_aActionString = rActionString;
 139 }
 140
 141 OUString UndoElement::getActionString() const
 142 {
 143     return m_aActionString;
 144 }
 145
 146 // static
 147 Reference< frame::XModel > UndoElement::cloneModel( const Reference< frame::XModel > & xModel )
 148 {
 149     Reference< frame::XModel > xResult;
 150     uno::Reference< util::XCloneable > xCloneable( xModel, uno::UNO_QUERY );
 151     OSL_ENSURE( xCloneable.is(), "Cannot clone model" );
 152     if( xCloneable.is())
 153         xResult.set( xCloneable->createClone(), uno::UNO_QUERY );
 154
 155     return xResult;
 156 }
 157
 158 // static
 159 void UndoElement::applyModelContentToModel(
 160     Reference< frame::XModel > & xInOutModelToChange,
 161     const Reference< frame::XModel > & xModelToCopyFrom,
 162     const Reference< chart2::XInternalDataProvider > & xData /* = 0 */ )
 163 {
 164
 165     if( xModelToCopyFrom.is() && xInOutModelToChange.is())
 166     {
 167         try
 168         {
 169             // /-- loccked controllers of destination
 170             ControllerLockGuard aLockedControllers( xInOutModelToChange );
 171             Reference< chart2::XChartDocument > xSource( xModelToCopyFrom, uno::UNO_QUERY_THROW );
 172             Reference< chart2::XChartDocument > xDestination( xInOutModelToChange, uno::UNO_QUERY_THROW );
 173
 174             // propagate the correct flag for plotting of hidden values to the data provider and all used sequences
 175             ChartModelHelper::setIncludeHiddenCells( ChartModelHelper::isIncludeHiddenCells( xModelToCopyFrom ) , xInOutModelToChange );
 176
 177             // diagram
 178             xDestination->setFirstDiagram( xSource->getFirstDiagram());
 179
 180             // main title
 181             Reference< chart2::XTitled > xDestinationTitled( xDestination, uno::UNO_QUERY_THROW );
 182             Reference< chart2::XTitled > xSourceTitled( xSource, uno::UNO_QUERY_THROW );
 183             xDestinationTitled->setTitleObject( xSourceTitled->getTitleObject());
 184
 185             // page background
 186             comphelper::copyProperties(
 187                 xSource->getPageBackground(),
 188                 xDestination->getPageBackground() );
 189
 190             // apply data (not applied in standard Undo)
 191             if( xData.is())
 192                 ImplApplyDataToModel( xInOutModelToChange, xData );
 193
 194             // register all sequences at the internal data provider to get adapted
 195             // indexes when columns are added/removed
 196             if( xDestination->hasInternalDataProvider())
 197             {
 198                 Reference< chart2::XInternalDataProvider > xNewDataProvider( xDestination->getDataProvider(), uno::UNO_QUERY );
 199                 Reference< chart2::data::XDataSource > xUsedData( DataSourceHelper::getUsedData( xInOutModelToChange ));
 200                 if( xUsedData.is() && xNewDataProvider.is())
 201                 {
 202                     Sequence< Reference< chart2::data::XLabeledDataSequence > > aData( xUsedData->getDataSequences());
 203                     for( sal_Int32 i=0; i<aData.getLength(); ++i )
 204                     {
 205                         xNewDataProvider->registerDataSequenceForChanges( aData[i]->getValues());
 206                         xNewDataProvider->registerDataSequenceForChanges( aData[i]->getLabel());
 207                     }
 208                 }
 209             }
 210
 211             // restore modify status
 212             Reference< util::XModifiable > xSourceMod( xSource, uno::UNO_QUERY );
 213             Reference< util::XModifiable > xDestMod( xDestination, uno::UNO_QUERY );
 214             if( xSourceMod.is() && xDestMod.is() &&
 215                 ! xSourceMod->isModified() )
 216             {
 217                 xDestMod->setModified( sal_False );
 218             }
 219             // \-- loccked controllers of destination
 220         }
 221         catch( uno::Exception & )
 222         {
 223         }
 224     }
 225 }
 226
 227 // ----------------------------------------
 228
 229 UndoElementWithData::UndoElementWithData(
 230     const OUString & rActionString,
 231     const Reference< frame::XModel > & xModel ) :
 232         UndoElement( rActionString, xModel )
 233 {
 234     initializeData();
 235 }
 236
 237 UndoElementWithData::UndoElementWithData(
 238     const Reference< frame::XModel > & xModel ) :
 239         UndoElement( xModel )
 240 {
 241     initializeData();
 242 }
 243
 244
 245 UndoElementWithData::UndoElementWithData(
 246     const UndoElementWithData & rOther ) :
 247         UndoElement( rOther )
 248 {
 249     initializeData();
 250 }
 251
 252 UndoElementWithData::~UndoElementWithData()
 253 {}
 254
 255 void UndoElementWithData::initializeData()
 256 {
 257     try
 258     {
 259         Reference< chart2::XChartDocument > xChartDoc( m_xModel, uno::UNO_QUERY_THROW );
 260         OSL_ASSERT( xChartDoc->hasInternalDataProvider());
 261         if( xChartDoc->hasInternalDataProvider())
 262         {
 263             Reference< util::XCloneable > xCloneable( xChartDoc->getDataProvider(), uno::UNO_QUERY );
 264             OSL_ENSURE( xCloneable.is(), "Cannot clone data" );
 265             if( xCloneable.is())
 266                 m_xData.set( xCloneable->createClone(), uno::UNO_QUERY );
 267         }
 268     }
 269     catch( uno::Exception & )
 270     {
 271     }
 272 }
 273
 274 void UndoElementWithData::dispose()
 275 {
 276     UndoElement::dispose();
 277     m_xData.set( 0 );
 278 }
 279
 280 void UndoElementWithData::applyToModel(
 281     Reference< frame::XModel > & xInOutModelToChange )
 282 {
 283     UndoElement::applyModelContentToModel( xInOutModelToChange, m_xModel, m_xData );
 284 }
 285
 286 UndoElement * UndoElementWithData::createFromModel(
 287     const Reference< frame::XModel > & xModel )
 288 {
 289     return new UndoElementWithData( getActionString(), xModel );
 290 }
 291
 292 // ========================================
 293
 294 // ----------------------------------------
 295
 296 UndoElementWithSelection::UndoElementWithSelection(
 297     const OUString & rActionString,
 298     const Reference< frame::XModel > & xModel ) :
 299         UndoElement( rActionString, xModel )
 300 {
 301     initialize( xModel );
 302 }
 303
 304 UndoElementWithSelection::UndoElementWithSelection(
 305     const Reference< frame::XModel > & xModel ) :
 306         UndoElement( xModel )
 307 {
 308     initialize( xModel );
 309 }
 310
 311 UndoElementWithSelection::UndoElementWithSelection(
 312     const UndoElementWithSelection & rOther ) :
 313         UndoElement( rOther )
 314 {
 315     initialize( rOther.m_xModel );
 316 }
 317
 318 UndoElementWithSelection::~UndoElementWithSelection()
 319 {}
 320
 321 void UndoElementWithSelection::initialize( const Reference< frame::XModel > & xModel )
 322 {
 323     try
 324     {
 325         uno::Reference< view::XSelectionSupplier > xSelSupp( xModel->getCurrentController(), uno::UNO_QUERY );
 326         OSL_ASSERT( xSelSupp.is() );
 327
 328         if( xSelSupp.is() )
 329             m_aSelection = xSelSupp->getSelection();
 330     }
 331     catch( const uno::Exception & )
 332     {
 333     }
 334 }
 335
 336 void UndoElementWithSelection::dispose()
 337 {
 338     UndoElement::dispose();
 339     m_aSelection.clear();
 340 }
 341
 342 void UndoElementWithSelection::applyToModel(
 343     Reference< frame::XModel > & xInOutModelToChange )
 344 {
 345     UndoElement::applyModelContentToModel( xInOutModelToChange, m_xModel );
 346     Reference< view::XSelectionSupplier > xCurrentSelectionSuppl( xInOutModelToChange->getCurrentController(), uno::UNO_QUERY );
 347     OSL_ASSERT( xCurrentSelectionSuppl.is() );
 348
 349     if( xCurrentSelectionSuppl.is())
 350         xCurrentSelectionSuppl->select( m_aSelection );
 351 }
 352
 353 UndoElement * UndoElementWithSelection::createFromModel(
 354         const Reference< frame::XModel > & xModel )
 355 {
 356     return new UndoElementWithSelection( getActionString(), xModel );
 357 }
 358
 359 // ========================================
 360
 361 UndoStack::UndoStack() :
 362         m_nSizeLimit( 1000 )
 363 {
 364 }
 365
 366 UndoStack::~UndoStack()
 367 {
 368     disposeAndClear();
 369 }
 370
 371 void UndoStack::pop()
 372 {
 373     if( ! empty())
 374     {
 375         top()->dispose();
 376         delete top();
 377         m_aStack.pop_back();
 378     }
 379 }
 380
 381 void UndoStack::push( UndoElement * pElement )
 382 {
 383     m_aStack.push_back( pElement );
 384     applyLimitation();
 385 }
 386
 387 UndoElement * UndoStack::top() const
 388 {
 389     return m_aStack.back();
 390 }
 391
 392 OUString UndoStack::topUndoString() const
 393 {
 394     if( ! empty())
 395         return top()->getActionString();
 396     return OUString();
 397 }
 398
 399 Sequence< OUString > UndoStack::getUndoStrings() const
 400 {
 401     sal_Int32 nSize( static_cast< sal_Int32 >( m_aStack.size()));
 402     Sequence< OUString > aResult( nSize );
 403     for( sal_Int32 i=0; i<nSize; ++i )
 404         aResult[i] = m_aStack[i]->getActionString();
 405     return aResult;
 406 }
 407
 408 bool UndoStack::empty() const
 409 {
 410     return m_aStack.empty();
 411 }
 412
 413 void UndoStack::disposeAndClear()
 414 {
 415     ::std::for_each( m_aStack.begin(), m_aStack.end(), ::boost::mem_fn( & UndoElement::dispose ));
 416     ::std::for_each( m_aStack.begin(), m_aStack.end(), CommonFunctors::DeletePtr< UndoElement >() );
 417     m_aStack.clear();
 418 }
 419
 420 void UndoStack::limitSize( sal_Int32 nMaxSize )
 421 {
 422     m_nSizeLimit = nMaxSize;
 423     applyLimitation();
 424 }
 425
 426 void UndoStack::applyLimitation()
 427 {
 428     if( m_aStack.size() > static_cast< sal_uInt32 >( m_nSizeLimit ))
 429     {
 430         tUndoStackType::iterator aBegin( m_aStack.begin());
 431         tUndoStackType::iterator aEnd( aBegin + (m_aStack.size() - m_nSizeLimit));
 432         // dispose and remove all undo elements that are over the limit
 433         ::std::for_each( aBegin, aEnd, ::boost::mem_fn( & UndoElement::dispose ));
 434         ::std::for_each( aBegin, aEnd, CommonFunctors::DeletePtr< UndoElement >() );
 435         m_aStack.erase( aBegin, aEnd );
 436     }
 437 }
 438
 439 // ================================================================================
 440
 441 namespace
 442 {
 443 static const OUString aUndoStepsPropName( RTL_CONSTASCII_USTRINGPARAM("Steps"));
 444 } // anonymous namespace
 445
 446 UndoStepsConfigItem::UndoStepsConfigItem( ConfigItemListener & rListener ) :
 447         ::utl::ConfigItem( OUString(RTL_CONSTASCII_USTRINGPARAM("Office.Common/Undo"))),
 448     m_rListener( rListener )
 449 {
 450     EnableNotification( Sequence< OUString >( & aUndoStepsPropName, 1 ));
 451 }
 452
 453 UndoStepsConfigItem::~UndoStepsConfigItem()
 454 {
 455 }
 456
 457 void UndoStepsConfigItem::Notify( const Sequence< OUString > & aPropertyNames )
 458 {
 459     for( sal_Int32 nIdx=0; nIdx<aPropertyNames.getLength(); ++nIdx )
 460     {
 461         if( aPropertyNames[nIdx].equals( aUndoStepsPropName ))
 462             m_rListener.notify( aPropertyNames[nIdx] );
 463     }
 464 }
 465
 466 // mtehod is not const, because GetProperties is not const
 467 sal_Int32 UndoStepsConfigItem::getUndoSteps()
 468 {
 469     sal_Int32 nSteps = -1;
 470     Sequence< uno::Any > aValues(
 471         GetProperties( Sequence< OUString >( & aUndoStepsPropName, 1 )));
 472     if( aValues.getLength())
 473         aValues[0] >>= nSteps;
 474     return nSteps;
 475 }
 476
 477 } // namespace impl
 478 } //  namespace chart