sc/source/ui/view/drawvie4.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 <svx/svditer.hxx>
  21 #include <svx/svdograf.hxx>
  22 #include <svx/svdogrp.hxx>
  23 #include <svx/svdoole2.hxx>
  24 #include <svx/svdpage.hxx>
  25 #include <svx/svdundo.hxx>
  26 #include <sfx2/docfile.hxx>
  27 #include <tools/urlobj.hxx>
  28 #include <toolkit/helper/vclunohelper.hxx>
  29
  30 #include "drawview.hxx"
  31 #include "global.hxx"
  32 #include "drwlayer.hxx"
  33 #include "viewdata.hxx"
  34 #include "document.hxx"
  35 #include "docsh.hxx"
  36 #include "drwtrans.hxx"
  37 #include "transobj.hxx"
  38 #include "drawutil.hxx"
  39 #include "scmod.hxx"
  40 #include "globstr.hrc"
  41 #include "chartarr.hxx"
  42 #include <gridwin.hxx>
  43
  44 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
  45 #include <com/sun/star/embed/Aspects.hpp>
  46 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  47 #include <com/sun/star/embed/XComponentSupplier.hpp>
  48 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  49 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  50 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  51
  52 using namespace com::sun::star;
  53
  54 Point aDragStartDiff;
  55
  56 void ScDrawView::CheckOle( const SdrMarkList& rMarkList, bool& rAnyOle, bool& rOneOle )
  57 {
  58     rAnyOle = rOneOle = false;
  59     const size_t nCount = rMarkList.GetMarkCount();
  60     for (size_t i=0; i<nCount; ++i)
  61     {
  62         SdrMark* pMark = rMarkList.GetMark(i);
  63         SdrObject* pObj = pMark->GetMarkedSdrObj();
  64         sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
  65         if (nSdrObjKind == OBJ_OLE2)
  66         {
  67             rAnyOle = true;
  68             rOneOle = (nCount == 1);
  69             break;
  70         }
  71         else if ( dynamic_cast<const SdrObjGroup*>( pObj) !=  nullptr )
  72         {
  73             SdrObjListIter aIter( *pObj, IM_DEEPNOGROUPS );
  74             SdrObject* pSubObj = aIter.Next();
  75             while (pSubObj)
  76             {
  77                 if ( pSubObj->GetObjIdentifier() == OBJ_OLE2 )
  78                 {
  79                     rAnyOle = true;
  80                     // rOneOle remains sal_False - a group isn't treated like a single OLE object
  81                     return;
  82                 }
  83                 pSubObj = aIter.Next();
  84             }
  85         }
  86     }
  87 }
  88
  89 void ScDrawView::BeginDrag( vcl::Window* pWindow, const Point& rStartPos )
  90 {
  91     if ( AreObjectsMarked() )
  92     {
  93         BrkAction();
  94
  95         Rectangle aMarkedRect = GetAllMarkedRect();
  96         vcl::Region aRegion( aMarkedRect );
  97
  98         aDragStartDiff = rStartPos - aMarkedRect.TopLeft();
  99
 100         bool bAnyOle, bOneOle;
 101         const SdrMarkList& rMarkList = GetMarkedObjectList();
 102         CheckOle( rMarkList, bAnyOle, bOneOle );
 103
 104         ScDocShellRef aDragShellRef;
 105         if (bAnyOle)
 106         {
 107             aDragShellRef = new ScDocShell;     // DocShell needs a Ref immediately
 108             aDragShellRef->DoInitNew();
 109         }
 110         ScDrawLayer::SetGlobalDrawPersist(aDragShellRef);
 111         SdrModel* pModel = GetMarkedObjModel();
 112         ScDrawLayer::SetGlobalDrawPersist(nullptr);
 113
 114         //  Charts now always copy their data in addition to the source reference, so
 115         //  there's no need to call SchDLL::Update for the charts in the clipboard doc.
 116         //  Update with the data (including NumberFormatter) from the live document would
 117         //  also store the NumberFormatter in the clipboard chart (#88749#)
 118
 119         ScDocShell* pDocSh = pViewData->GetDocShell();
 120
 121         TransferableObjectDescriptor aObjDesc;
 122         pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 123         aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 124         // maSize is set in ScDrawTransferObj ctor
 125
 126         ScDrawTransferObj* pTransferObj = new ScDrawTransferObj( pModel, pDocSh, aObjDesc );
 127         uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
 128
 129         pTransferObj->SetDrawPersist( &aDragShellRef );    // keep persist for ole objects alive
 130         pTransferObj->SetDragSource( this );               // copies selection
 131
 132         SC_MOD()->SetDragObject( nullptr, pTransferObj );     // for internal D&D
 133         pTransferObj->StartDrag( pWindow, DND_ACTION_COPYMOVE | DND_ACTION_LINK );
 134     }
 135 }
 136
 137 namespace {
 138
 139 void getRangeFromDataSource( uno::Reference< chart2::data::XDataSource > xDataSource, std::vector<OUString>& rRangeRep)
 140 {
 141     uno::Sequence<uno::Reference<chart2::data::XLabeledDataSequence> > xSeqs = xDataSource->getDataSequences();
 142     for (sal_Int32 i = 0, n = xSeqs.getLength(); i < n; ++i)
 143     {
 144         uno::Reference<chart2::data::XLabeledDataSequence> xLS = xSeqs[i];
 145         uno::Reference<chart2::data::XDataSequence> xSeq = xLS->getValues();
 146         if (xSeq.is())
 147         {
 148             OUString aRep = xSeq->getSourceRangeRepresentation();
 149             rRangeRep.push_back(aRep);
 150         }
 151         xSeq = xLS->getLabel();
 152         if (xSeq.is())
 153         {
 154             OUString aRep = xSeq->getSourceRangeRepresentation();
 155             rRangeRep.push_back(aRep);
 156         }
 157     }
 158 }
 159
 160 void getRangeFromErrorBar(const uno::Reference< chart2::XChartDocument >& rChartDoc, std::vector<OUString>& rRangeRep)
 161 {
 162     uno::Reference <chart2::XDiagram > xDiagram = rChartDoc->getFirstDiagram();
 163     if(!xDiagram.is())
 164         return;
 165
 166     uno::Reference< chart2::XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY);
 167     if(!xCooSysContainer.is())
 168         return;
 169
 170     uno::Sequence< uno::Reference< chart2::XCoordinateSystem > > xCooSysSequence( xCooSysContainer->getCoordinateSystems());
 171     for(sal_Int32 i = 0; i < xCooSysSequence.getLength(); ++i)
 172     {
 173         uno::Reference< chart2::XChartTypeContainer > xChartTypeContainer( xCooSysSequence[i], uno::UNO_QUERY);
 174         if(!xChartTypeContainer.is())
 175             continue;
 176
 177         uno::Sequence< uno::Reference< chart2::XChartType > > xChartTypeSequence( xChartTypeContainer->getChartTypes() );
 178         for(sal_Int32 nChartType = 0; nChartType < xChartTypeSequence.getLength(); ++nChartType)
 179         {
 180             uno::Reference< chart2::XDataSeriesContainer > xDataSequenceContainer( xChartTypeSequence[nChartType], uno::UNO_QUERY);
 181             if(!xDataSequenceContainer.is())
 182                 continue;
 183
 184             uno::Sequence< uno::Reference< chart2::XDataSeries > > xSeriesSequence( xDataSequenceContainer->getDataSeries() );
 185             for(sal_Int32 nDataSeries = 0; nDataSeries < xSeriesSequence.getLength(); ++nDataSeries)
 186             {
 187                 uno::Reference< chart2::XDataSeries > xSeries = xSeriesSequence[nDataSeries];
 188                 uno::Reference< beans::XPropertySet > xPropSet( xSeries, uno::UNO_QUERY);
 189                 uno::Reference< chart2::data::XDataSource > xErrorBarY;
 190                 xPropSet->getPropertyValue("ErrorBarY") >>= xErrorBarY;
 191                 if(xErrorBarY.is())
 192                     getRangeFromDataSource(xErrorBarY, rRangeRep);
 193                 uno::Reference< chart2::data::XDataSource > xErrorBarX;
 194                 xPropSet->getPropertyValue("ErrorBarX") >>= xErrorBarX;
 195                 if(xErrorBarX.is())
 196                     getRangeFromDataSource(xErrorBarX, rRangeRep);
 197             }
 198         }
 199     }
 200 }
 201
 202 void getRangeFromOle2Object(const SdrOle2Obj& rObj, std::vector<OUString>& rRangeRep)
 203 {
 204     if (!rObj.IsChart())
 205         // not a chart object.
 206         return;
 207
 208     uno::Reference<embed::XEmbeddedObject> xObj = rObj.GetObjRef();
 209     if (!xObj.is())
 210         return;
 211
 212     uno::Reference<embed::XComponentSupplier> xCompSupp(xObj, uno::UNO_QUERY);
 213     if (!xCompSupp.is())
 214         return;
 215
 216     uno::Reference<chart2::XChartDocument> xChartDoc(xCompSupp->getComponent(), uno::UNO_QUERY);
 217     if (!xChartDoc.is())
 218         return;
 219
 220     if(xChartDoc->hasInternalDataProvider())
 221         return;
 222
 223     getRangeFromErrorBar(xChartDoc, rRangeRep);
 224
 225     uno::Reference<chart2::data::XDataSource> xDataSource(xChartDoc, uno::UNO_QUERY);
 226     if (!xDataSource.is())
 227         return;
 228
 229     // Get all data sources used in this chart.
 230     getRangeFromDataSource(xDataSource, rRangeRep);
 231 }
 232
 233 // Get all cell ranges that are referenced by the selected chart objects.
 234 void getChartSourceRanges(ScDocument* pDoc, const SdrMarkList& rObjs, std::vector<ScRange>& rRanges)
 235 {
 236     std::vector<OUString> aRangeReps;
 237     for (size_t i = 0, n = rObjs.GetMarkCount(); i < n; ++i)
 238     {
 239         const SdrMark* pMark = rObjs.GetMark(i);
 240         if (!pMark)
 241             continue;
 242
 243         const SdrObject* pObj = pMark->GetMarkedSdrObj();
 244         if (!pObj)
 245             continue;
 246
 247         switch (pObj->GetObjIdentifier())
 248         {
 249             case OBJ_OLE2:
 250                 getRangeFromOle2Object(static_cast<const SdrOle2Obj&>(*pObj), aRangeReps);
 251             break;
 252             case OBJ_GRUP:
 253             {
 254                 SdrObjListIter aIter(*pObj, IM_DEEPNOGROUPS);
 255                 for (SdrObject* pSubObj = aIter.Next(); pSubObj; pSubObj = aIter.Next())
 256                 {
 257                     if (pSubObj->GetObjIdentifier() != OBJ_OLE2)
 258                         continue;
 259
 260                     getRangeFromOle2Object(static_cast<const SdrOle2Obj&>(*pSubObj), aRangeReps);
 261                 }
 262
 263             }
 264             break;
 265             default:
 266                 ;
 267         }
 268     }
 269
 270     // Compile all range representation strings into ranges.
 271     std::vector<OUString>::const_iterator it = aRangeReps.begin(), itEnd = aRangeReps.end();
 272     for (; it != itEnd; ++it)
 273     {
 274         ScRangeList aRange;
 275         ScAddress aAddr;
 276         if (aRange.Parse(*it, pDoc, ScRefFlags::VALID, pDoc->GetAddressConvention()) & ScRefFlags::VALID)
 277         {
 278             for(size_t i = 0; i < aRange.size(); ++i)
 279                 rRanges.push_back(*aRange[i]);
 280         }
 281         else if (aAddr.Parse(*it, pDoc, pDoc->GetAddressConvention()) & ScRefFlags::VALID)
 282             rRanges.push_back(aAddr);
 283     }
 284 }
 285
 286 class InsertTabIndex : public std::unary_function<ScRange, void>
 287 {
 288     std::vector<SCTAB>& mrTabs;
 289 public:
 290     explicit InsertTabIndex(std::vector<SCTAB>& rTabs) : mrTabs(rTabs) {}
 291     void operator() (const ScRange& rRange)
 292     {
 293         mrTabs.push_back(rRange.aStart.Tab());
 294     }
 295 };
 296
 297 class CopyRangeData : public std::unary_function<ScRange, void>
 298 {
 299     ScDocument* mpSrc;
 300     ScDocument* mpDest;
 301 public:
 302     CopyRangeData(ScDocument* pSrc, ScDocument* pDest) : mpSrc(pSrc), mpDest(pDest) {}
 303
 304     void operator() (const ScRange& rRange)
 305     {
 306         OUString aTabName;
 307         mpSrc->GetName(rRange.aStart.Tab(), aTabName);
 308
 309         SCTAB nTab;
 310         if (!mpDest->GetTable(aTabName, nTab))
 311             // Sheet by this name doesn't exist.
 312             return;
 313
 314         mpSrc->CopyStaticToDocument(rRange, nTab, mpDest);
 315     }
 316 };
 317
 318 void copyChartRefDataToClipDoc(ScDocument* pSrcDoc, ScDocument* pClipDoc, const std::vector<ScRange>& rRanges)
 319 {
 320     // Get a list of referenced table indices.
 321     std::vector<SCTAB> aTabs;
 322     std::for_each(rRanges.begin(), rRanges.end(), InsertTabIndex(aTabs));
 323     std::sort(aTabs.begin(), aTabs.end());
 324     aTabs.erase(std::unique(aTabs.begin(), aTabs.end()), aTabs.end());
 325
 326     // Get table names.
 327     if (aTabs.empty())
 328         return;
 329
 330     // Create sheets only for referenced source sheets.
 331     OUString aName;
 332     std::vector<SCTAB>::const_iterator it = aTabs.begin(), itEnd = aTabs.end();
 333     if (!pSrcDoc->GetName(*it, aName))
 334         return;
 335
 336     pClipDoc->SetTabNameOnLoad(0, aName); // document initially has one sheet.
 337
 338     for (++it; it != itEnd; ++it)
 339     {
 340         if (!pSrcDoc->GetName(*it, aName))
 341             return;
 342
 343         pClipDoc->AppendTabOnLoad(aName);
 344     }
 345
 346     std::for_each(rRanges.begin(), rRanges.end(), CopyRangeData(pSrcDoc, pClipDoc));
 347 }
 348
 349 }
 350
 351 void ScDrawView::DoCopy()
 352 {
 353     const SdrMarkList& rMarkList = GetMarkedObjectList();
 354     std::vector<ScRange> aRanges;
 355     getChartSourceRanges(pDoc, rMarkList, aRanges);
 356
 357     // update ScGlobal::xDrawClipDocShellRef
 358     ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc(!aRanges.empty()) );
 359     if (ScGlobal::xDrawClipDocShellRef.Is())
 360     {
 361         // Copy data referenced by the chart objects to the draw clip
 362         // document. We need to do this before GetMarkedObjModel() below.
 363         ScDocShellRef xDocSh = ScGlobal::xDrawClipDocShellRef;
 364         ScDocument& rClipDoc = xDocSh->GetDocument();
 365         copyChartRefDataToClipDoc(pDoc, &rClipDoc, aRanges);
 366     }
 367     SdrModel* pModel = GetMarkedObjModel();
 368     ScDrawLayer::SetGlobalDrawPersist(nullptr);
 369
 370     //  Charts now always copy their data in addition to the source reference, so
 371     //  there's no need to call SchDLL::Update for the charts in the clipboard doc.
 372     //  Update with the data (including NumberFormatter) from the live document would
 373     //  also store the NumberFormatter in the clipboard chart (#88749#)
 374
 375     ScDocShell* pDocSh = pViewData->GetDocShell();
 376
 377     TransferableObjectDescriptor aObjDesc;
 378     pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 379     aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 380     // maSize is set in ScDrawTransferObj ctor
 381
 382     ScDrawTransferObj* pTransferObj = new ScDrawTransferObj( pModel, pDocSh, aObjDesc );
 383     uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
 384
 385     if ( ScGlobal::xDrawClipDocShellRef.Is() )
 386     {
 387         pTransferObj->SetDrawPersist( ScGlobal::xDrawClipDocShellRef.get() );    // keep persist for ole objects alive
 388     }
 389
 390     pTransferObj->CopyToClipboard( pViewData->GetActiveWin() );     // system clipboard
 391     SC_MOD()->SetClipObject( nullptr, pTransferObj );                  // internal clipboard
 392 }
 393
 394 uno::Reference<datatransfer::XTransferable> ScDrawView::CopyToTransferable()
 395 {
 396     bool bAnyOle, bOneOle;
 397     const SdrMarkList& rMarkList = GetMarkedObjectList();
 398     CheckOle( rMarkList, bAnyOle, bOneOle );
 399
 400     // update ScGlobal::xDrawClipDocShellRef
 401     ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) );
 402     SdrModel* pModel = GetMarkedObjModel();
 403     ScDrawLayer::SetGlobalDrawPersist(nullptr);
 404
 405     //  Charts now always copy their data in addition to the source reference, so
 406     //  there's no need to call SchDLL::Update for the charts in the clipboard doc.
 407     //  Update with the data (including NumberFormatter) from the live document would
 408     //  also store the NumberFormatter in the clipboard chart (#88749#)
 409     // lcl_RefreshChartData( pModel, pViewData->GetDocument() );
 410
 411     ScDocShell* pDocSh = pViewData->GetDocShell();
 412
 413     TransferableObjectDescriptor aObjDesc;
 414     pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 415     aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 416     // maSize is set in ScDrawTransferObj ctor
 417
 418     ScDrawTransferObj* pTransferObj = new ScDrawTransferObj( pModel, pDocSh, aObjDesc );
 419     uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
 420
 421     if ( ScGlobal::xDrawClipDocShellRef.Is() )
 422     {
 423         pTransferObj->SetDrawPersist( ScGlobal::xDrawClipDocShellRef.get() );    // keep persist for ole objects alive
 424     }
 425
 426     return xTransferable;
 427 }
 428
 429 // Calculate correction for 100%, regardless of current settings
 430
 431 void ScDrawView::CalcNormScale( Fraction& rFractX, Fraction& rFractY ) const
 432 {
 433     double nPPTX = ScGlobal::nScreenPPTX;
 434     double nPPTY = ScGlobal::nScreenPPTY;
 435
 436     if (pViewData)
 437         nPPTX /= pViewData->GetDocShell()->GetOutputFactor();
 438
 439     SCCOL nEndCol = 0;
 440     SCROW nEndRow = 0;
 441     pDoc->GetTableArea( nTab, nEndCol, nEndRow );
 442     if (nEndCol<20)
 443         nEndCol = 20;
 444     if (nEndRow<20)
 445         nEndRow = 1000;
 446
 447     Fraction aZoom(1,1);
 448     ScDrawUtil::CalcScale( pDoc, nTab, 0,0, nEndCol,nEndRow, pDev, aZoom,aZoom,
 449                             nPPTX, nPPTY, rFractX,rFractY );
 450 }
 451
 452 void ScDrawView::SetMarkedOriginalSize()
 453 {
 454     SdrUndoGroup* pUndoGroup = new SdrUndoGroup(*GetModel());
 455
 456     const SdrMarkList& rMarkList = GetMarkedObjectList();
 457     long nDone = 0;
 458     const size_t nCount = rMarkList.GetMarkCount();
 459     for (size_t i=0; i<nCount; ++i)
 460     {
 461         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 462         sal_uInt16 nIdent = pObj->GetObjIdentifier();
 463         bool bDo = false;
 464         Size aOriginalSize;
 465         if (nIdent == OBJ_OLE2)
 466         {
 467             // TODO/LEAN: working with visual area can switch object to running state
 468              uno::Reference < embed::XEmbeddedObject > xObj( static_cast<SdrOle2Obj*>(pObj)->GetObjRef(), uno::UNO_QUERY );
 469             if ( xObj.is() )    // NULL for an invalid object that couldn't be loaded
 470             {
 471                 sal_Int64 nAspect = static_cast<SdrOle2Obj*>(pObj)->GetAspect();
 472
 473                 if ( nAspect == embed::Aspects::MSOLE_ICON )
 474                 {
 475                     MapMode aMapMode( MAP_100TH_MM );
 476                     aOriginalSize = static_cast<SdrOle2Obj*>(pObj)->GetOrigObjSize( &aMapMode );
 477                     bDo = true;
 478                 }
 479                 else
 480                 {
 481                     MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( static_cast<SdrOle2Obj*>(pObj)->GetAspect() ) );
 482                     awt::Size aSz;
 483                     try
 484                     {
 485                         aSz = xObj->getVisualAreaSize( static_cast<SdrOle2Obj*>(pObj)->GetAspect() );
 486                         aOriginalSize = OutputDevice::LogicToLogic(
 487                                             Size( aSz.Width, aSz.Height ),
 488                                             aUnit, MAP_100TH_MM );
 489                         bDo = true;
 490                     } catch( embed::NoVisualAreaSizeException& )
 491                     {
 492                         OSL_ENSURE( false, "Can't get the original size of the object!" );
 493                     }
 494                 }
 495             }
 496         }
 497         else if (nIdent == OBJ_GRAF)
 498         {
 499             const Graphic& rGraphic = static_cast<SdrGrafObj*>(pObj)->GetGraphic();
 500
 501             MapMode aSourceMap = rGraphic.GetPrefMapMode();
 502             MapMode aDestMap( MAP_100TH_MM );
 503             if (aSourceMap.GetMapUnit() == MAP_PIXEL)
 504             {
 505                 // consider pixel correction, so that the bitmap is correct on the screen
 506                 Fraction aNormScaleX, aNormScaleY;
 507                 CalcNormScale( aNormScaleX, aNormScaleY );
 508                 aDestMap.SetScaleX(aNormScaleX);
 509                 aDestMap.SetScaleY(aNormScaleY);
 510             }
 511             if (pViewData)
 512             {
 513                 vcl::Window* pActWin = pViewData->GetActiveWin();
 514                 if (pActWin)
 515                 {
 516                     aOriginalSize = pActWin->LogicToLogic(
 517                                     rGraphic.GetPrefSize(), &aSourceMap, &aDestMap );
 518                     bDo = true;
 519                 }
 520             }
 521         }
 522
 523         if ( bDo )
 524         {
 525             Rectangle aDrawRect = pObj->GetLogicRect();
 526
 527             pUndoGroup->AddAction( new SdrUndoGeoObj( *pObj ) );
 528             pObj->Resize( aDrawRect.TopLeft(), Fraction( aOriginalSize.Width(), aDrawRect.GetWidth() ),
 529                                                  Fraction( aOriginalSize.Height(), aDrawRect.GetHeight() ) );
 530             ++nDone;
 531         }
 532     }
 533
 534     if (nDone && pViewData)
 535     {
 536         pUndoGroup->SetComment(ScGlobal::GetRscString( STR_UNDO_ORIGINALSIZE ));
 537         ScDocShell* pDocSh = pViewData->GetDocShell();
 538         pDocSh->GetUndoManager()->AddUndoAction(pUndoGroup);
 539         pDocSh->SetDrawModified();
 540     }
 541     else
 542         delete pUndoGroup;
 543 }
 544
 545 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */