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