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