svx/source/sdr/overlay/overlaymanager.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/sdr/overlay/overlaymanager.hxx>
  21 #include <basegfx/point/b2dpoint.hxx>
  22 #include <basegfx/range/b2drange.hxx>
  23 #include <tools/gen.hxx>
  24 #include <vcl/outdev.hxx>
  25 #include <vcl/window.hxx>
  26 #include <svx/sdr/overlay/overlayobject.hxx>
  27 #include <basegfx/matrix/b2dhommatrix.hxx>
  28 #include <drawinglayer/processor2d/processor2dtools.hxx>
  29 #include <boost/scoped_ptr.hpp>
  30
  31
  32 using namespace com::sun::star;
  33
  34
  35
  36 namespace sdr
  37 {
  38     namespace overlay
  39     {
  40         void OverlayManager::ImpDrawMembers(const basegfx::B2DRange& rRange, OutputDevice& rDestinationDevice) const
  41         {
  42             const sal_uInt32 nSize(maOverlayObjects.size());
  43
  44             if(nSize)
  45             {
  46                 const AntialiasingFlags nOriginalAA(rDestinationDevice.GetAntialiasing());
  47                 const bool bIsAntiAliasing(getDrawinglayerOpt().IsAntiAliasing());
  48
  49                 // create processor
  50                 boost::scoped_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(drawinglayer::processor2d::createProcessor2DFromOutputDevice(
  51                     rDestinationDevice,
  52                     getCurrentViewInformation2D()));
  53
  54                 if(pProcessor)
  55                 {
  56                     for(OverlayObjectVector::const_iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); ++aIter)
  57                     {
  58                         OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
  59                         const OverlayObject& rCandidate = **aIter;
  60
  61                         if(rCandidate.isVisible())
  62                         {
  63                             const drawinglayer::primitive2d::Primitive2DSequence& rSequence = rCandidate.getOverlayObjectPrimitive2DSequence();
  64
  65                             if(rSequence.hasElements())
  66                             {
  67                                 if(rRange.overlaps(rCandidate.getBaseRange()))
  68                                 {
  69                                     if(bIsAntiAliasing && rCandidate.allowsAntiAliase())
  70                                     {
  71                                         rDestinationDevice.SetAntialiasing(nOriginalAA | AntialiasingFlags::EnableB2dDraw);
  72                                     }
  73                                     else
  74                                     {
  75                                         rDestinationDevice.SetAntialiasing(nOriginalAA & ~AntialiasingFlags::EnableB2dDraw);
  76                                     }
  77
  78                                     pProcessor->process(rSequence);
  79                                 }
  80                             }
  81                         }
  82                     }
  83
  84                     pProcessor.reset();
  85                 }
  86
  87                 // restore AA settings
  88                 rDestinationDevice.SetAntialiasing(nOriginalAA);
  89             }
  90         }
  91
  92         void OverlayManager::ImpStripeDefinitionChanged()
  93         {
  94             const sal_uInt32 nSize(maOverlayObjects.size());
  95
  96             if(nSize)
  97             {
  98                 for(OverlayObjectVector::iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); ++aIter)
  99                 {
 100                     OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
 101                     OverlayObject& rCandidate = **aIter;
 102                     rCandidate.stripeDefinitionHasChanged();
 103                 }
 104             }
 105         }
 106
 107         double OverlayManager::getDiscreteOne() const
 108         {
 109             if(basegfx::fTools::equalZero(mfDiscreteOne))
 110             {
 111                 const basegfx::B2DVector aDiscreteInLogic(getOutputDevice().GetInverseViewTransformation() * basegfx::B2DVector(1.0, 0.0));
 112                 const_cast< OverlayManager* >(this)->mfDiscreteOne = aDiscreteInLogic.getLength();
 113             }
 114
 115             return mfDiscreteOne;
 116         }
 117
 118         OverlayManager::OverlayManager(OutputDevice& rOutputDevice, const SdrModel* pModel)
 119         :   Scheduler(),
 120             mrOutputDevice(rOutputDevice),
 121             mpModel(pModel),
 122             maOverlayObjects(),
 123             maStripeColorA(Color(COL_BLACK)),
 124             maStripeColorB(Color(COL_WHITE)),
 125             mnStripeLengthPixel(5),
 126             maDrawinglayerOpt(),
 127             maViewTransformation(),
 128             maViewInformation2D(),
 129             mfDiscreteOne(0.0)
 130         {
 131             // set Property 'ReducedDisplayQuality' to true to allow simpler interaction
 132             // visualisations
 133             static bool bUseReducedDisplayQualityForDrag(true);
 134
 135             if(bUseReducedDisplayQualityForDrag)
 136             {
 137                 uno::Sequence< beans::PropertyValue > xProperties(1);
 138                 xProperties[0].Name = "ReducedDisplayQuality";
 139                 xProperties[0].Value <<= true;
 140                 maViewInformation2D = drawinglayer::geometry::ViewInformation2D(xProperties);
 141             }
 142         }
 143
 144         rtl::Reference<OverlayManager> OverlayManager::create(OutputDevice& rOutputDevice, const SdrModel* pModel)
 145         {
 146             return rtl::Reference<OverlayManager>(new OverlayManager(rOutputDevice, pModel));
 147         }
 148
 149         const drawinglayer::geometry::ViewInformation2D OverlayManager::getCurrentViewInformation2D() const
 150         {
 151             if(getOutputDevice().GetViewTransformation() != maViewTransformation)
 152             {
 153                 basegfx::B2DRange aViewRange(maViewInformation2D.getViewport());
 154
 155                 if(OUTDEV_WINDOW == getOutputDevice().GetOutDevType())
 156                 {
 157                     const Size aOutputSizePixel(getOutputDevice().GetOutputSizePixel());
 158
 159                     // only set when we *have* a output size, else let aViewRange
 160                     // stay on empty
 161                     if(aOutputSizePixel.Width() && aOutputSizePixel.Height())
 162                     {
 163                         aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight());
 164                         aViewRange.transform(getOutputDevice().GetInverseViewTransformation());
 165                     }
 166                 }
 167
 168                 OverlayManager* pThis = const_cast< OverlayManager* >(this);
 169
 170                 pThis->maViewTransformation = getOutputDevice().GetViewTransformation();
 171                 pThis->maViewInformation2D = drawinglayer::geometry::ViewInformation2D(
 172                     maViewInformation2D.getObjectTransformation(),
 173                     maViewTransformation,
 174                     aViewRange,
 175                     maViewInformation2D.getVisualizedPage(),
 176                     maViewInformation2D.getViewTime(),
 177                     maViewInformation2D.getExtendedInformationSequence());
 178                 pThis->mfDiscreteOne = 0.0;
 179             }
 180
 181             return maViewInformation2D;
 182         }
 183
 184         void OverlayManager::impApplyRemoveActions(OverlayObject& rTarget)
 185         {
 186             // handle evtl. animation
 187             if(rTarget.allowsAnimation())
 188             {
 189                 // remove from event chain
 190                 RemoveEvent(&rTarget);
 191             }
 192
 193             // make invisible
 194             invalidateRange(rTarget.getBaseRange());
 195
 196             // clear manager
 197             rTarget.mpOverlayManager = 0;
 198         }
 199
 200         void OverlayManager::impApplyAddActions(OverlayObject& rTarget)
 201         {
 202             // set manager
 203             rTarget.mpOverlayManager = this;
 204
 205             // make visible
 206             invalidateRange(rTarget.getBaseRange());
 207
 208             // handle evtl. animation
 209             if(rTarget.allowsAnimation())
 210             {
 211                 // Trigger at current time to get alive. This will do the
 212                 // object-specific next time calculation and hand over adding
 213                 // again to the scheduler to the animated object, too. This works for
 214                 // a paused or non-paused animator.
 215                 rTarget.Trigger(GetTime());
 216             }
 217         }
 218
 219         OverlayManager::~OverlayManager()
 220         {
 221             // The OverlayManager is not the owner of the OverlayObjects
 222             // and thus will not delete them, but remove them. Profit here
 223             // from knowing that all will be removed
 224             const sal_uInt32 nSize(maOverlayObjects.size());
 225
 226             if(nSize)
 227             {
 228                 for(OverlayObjectVector::iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); ++aIter)
 229                 {
 230                     OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
 231                     OverlayObject& rCandidate = **aIter;
 232                     impApplyRemoveActions(rCandidate);
 233                 }
 234
 235                 // erase vector
 236                 maOverlayObjects.clear();
 237             }
 238         }
 239
 240         void OverlayManager::completeRedraw(const vcl::Region& rRegion, OutputDevice* pPreRenderDevice) const
 241         {
 242             if(!rRegion.IsEmpty() && maOverlayObjects.size())
 243             {
 244                 // check for changed MapModes. That may influence the
 245                 // logical size of pixel based OverlayObjects (like BitmapHandles)
 246                 //ImpCheckMapModeChange();
 247
 248                 // paint members
 249                 const Rectangle aRegionBoundRect(rRegion.GetBoundRect());
 250                 const basegfx::B2DRange aRegionRange(
 251                     aRegionBoundRect.Left(), aRegionBoundRect.Top(),
 252                     aRegionBoundRect.Right(), aRegionBoundRect.Bottom());
 253
 254                 OutputDevice& rTarget = (pPreRenderDevice) ? *pPreRenderDevice : getOutputDevice();
 255                 ImpDrawMembers(aRegionRange, rTarget);
 256             }
 257         }
 258
 259         void OverlayManager::flush()
 260         {
 261             // default has nothing to do
 262         }
 263
 264         // #i68597# part of content gets copied, react on it
 265         void OverlayManager::copyArea(const Point& /*rDestPt*/, const Point& /*rSrcPt*/, const Size& /*rSrcSize*/)
 266         {
 267             // unbuffered versions do nothing here
 268         }
 269
 270         void OverlayManager::restoreBackground(const vcl::Region& /*rRegion*/) const
 271         {
 272             // unbuffered versions do nothing here
 273         }
 274
 275         void OverlayManager::add(OverlayObject& rOverlayObject)
 276         {
 277             OSL_ENSURE(0 == rOverlayObject.mpOverlayManager, "OverlayObject is added twice to an OverlayManager (!)");
 278
 279             // add to the end of chain to preserve display order in paint
 280             maOverlayObjects.push_back(&rOverlayObject);
 281
 282             // execute add actions
 283             impApplyAddActions(rOverlayObject);
 284         }
 285
 286         void OverlayManager::remove(OverlayObject& rOverlayObject)
 287         {
 288             OSL_ENSURE(rOverlayObject.mpOverlayManager == this, "OverlayObject is removed from wrong OverlayManager (!)");
 289
 290             // execute remove actions
 291             impApplyRemoveActions(rOverlayObject);
 292
 293             // remove from vector
 294             const OverlayObjectVector::iterator aFindResult = ::std::find(maOverlayObjects.begin(), maOverlayObjects.end(), &rOverlayObject);
 295             const bool bFound(aFindResult != maOverlayObjects.end());
 296             OSL_ENSURE(bFound, "OverlayObject NOT found at OverlayManager (!)");
 297
 298             if(bFound)
 299             {
 300                 maOverlayObjects.erase(aFindResult);
 301             }
 302         }
 303
 304         void OverlayManager::invalidateRange(const basegfx::B2DRange& rRange)
 305         {
 306             if(OUTDEV_WINDOW == getOutputDevice().GetOutDevType())
 307             {
 308                 if(getDrawinglayerOpt().IsAntiAliasing())
 309                 {
 310                     // assume AA needs one pixel more and invalidate one pixel more
 311                     const double fDiscreteOne(getDiscreteOne());
 312                     const Rectangle aInvalidateRectangle(
 313                         (sal_Int32)floor(rRange.getMinX() - fDiscreteOne),
 314                         (sal_Int32)floor(rRange.getMinY() - fDiscreteOne),
 315                         (sal_Int32)ceil(rRange.getMaxX() + fDiscreteOne),
 316                         (sal_Int32)ceil(rRange.getMaxY() + fDiscreteOne));
 317
 318                     // simply invalidate
 319                     static_cast<vcl::Window&>(getOutputDevice()).Invalidate(aInvalidateRectangle, INVALIDATE_NOERASE);
 320                 }
 321                 else
 322                 {
 323                     // #i77674# transform to rectangle. Use floor/ceil to get all covered
 324                     // discrete pixels, see #i75163# and OverlayManagerBuffered::invalidateRange
 325                     const Rectangle aInvalidateRectangle(
 326                         (sal_Int32)floor(rRange.getMinX()), (sal_Int32)floor(rRange.getMinY()),
 327                         (sal_Int32)ceil(rRange.getMaxX()), (sal_Int32)ceil(rRange.getMaxY()));
 328
 329                     // simply invalidate
 330                     static_cast<vcl::Window&>(getOutputDevice()).Invalidate(aInvalidateRectangle, INVALIDATE_NOERASE);
 331                 }
 332             }
 333         }
 334
 335         // stripe support ColA
 336         void OverlayManager::setStripeColorA(Color aNew)
 337         {
 338             if(aNew != maStripeColorA)
 339             {
 340                 maStripeColorA = aNew;
 341                 ImpStripeDefinitionChanged();
 342             }
 343         }
 344
 345         // stripe support ColB
 346         void OverlayManager::setStripeColorB(Color aNew)
 347         {
 348             if(aNew != maStripeColorB)
 349             {
 350                 maStripeColorB = aNew;
 351                 ImpStripeDefinitionChanged();
 352             }
 353         }
 354
 355         // stripe support StripeLengthPixel
 356         void OverlayManager::setStripeLengthPixel(sal_uInt32 nNew)
 357         {
 358             if(nNew != mnStripeLengthPixel)
 359             {
 360                 mnStripeLengthPixel = nNew;
 361                 ImpStripeDefinitionChanged();
 362             }
 363         }
 364
 365     } // end of namespace overlay
 366 } // end of namespace sdr
 367
 368 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */