sw/source/uibase/docvw/ShadowOverlayObject.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 "ShadowOverlayObject.hxx"
  21
  22 #include <view.hxx>
  23 #include <svx/sdrpaintwindow.hxx>
  24 #include <svx/svdview.hxx>
  25 #include <svx/sdr/overlay/overlaymanager.hxx>
  26
  27 #include <sw_primitivetypes2d.hxx>
  28 #include <drawinglayer/primitive2d/primitivetools2d.hxx>
  29 #include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>
  30 #include <basegfx/utils/gradienttools.hxx>
  31
  32 namespace sw::sidebarwindows {
  33
  34 // helper SwPostItShadowPrimitive
  35
  36 namespace {
  37
  38 // Used to allow view-dependent primitive definition. For that purpose, the
  39 // initially created primitive (this one) always has to be view-independent,
  40 // but the decomposition is made view-dependent. Very simple primitive which
  41 // just remembers the discrete data and applies it at decomposition time.
  42 class ShadowPrimitive : public drawinglayer::primitive2d::DiscreteMetricDependentPrimitive2D
  43 {
  44 private:
  45     basegfx::B2DPoint           maBasePosition;
  46     basegfx::B2DPoint           maSecondPosition;
  47     ShadowState                 maShadowState;
  48
  49 protected:
  50     virtual void create2DDecomposition(
  51         drawinglayer::primitive2d::Primitive2DContainer& rContainer,
  52         const drawinglayer::geometry::ViewInformation2D& rViewInformation) const override;
  53
  54 public:
  55     ShadowPrimitive(
  56         const basegfx::B2DPoint& rBasePosition,
  57         const basegfx::B2DPoint& rSecondPosition,
  58         ShadowState aShadowState)
  59     :   maBasePosition(rBasePosition),
  60         maSecondPosition(rSecondPosition),
  61         maShadowState(aShadowState)
  62     {}
  63
  64     // data access
  65     const basegfx::B2DPoint& getSecondPosition() const { return maSecondPosition; }
  66
  67     virtual bool operator==( const drawinglayer::primitive2d::BasePrimitive2D& rPrimitive ) const override;
  68
  69     virtual sal_uInt32 getPrimitive2DID() const override;
  70 };
  71
  72 }
  73
  74 void ShadowPrimitive::create2DDecomposition(
  75     drawinglayer::primitive2d::Primitive2DContainer& rContainer,
  76     const drawinglayer::geometry::ViewInformation2D& /*rViewInformation*/) const
  77 {
  78     // get logic sizes in object coordinate system
  79     basegfx::B2DRange aRange(maBasePosition);
  80
  81     switch(maShadowState)
  82     {
  83         case SS_NORMAL:
  84         {
  85             aRange.expand(basegfx::B2DTuple(getSecondPosition().getX(), getSecondPosition().getY() + (2.0 * getDiscreteUnit())));
  86
  87             ::drawinglayer::attribute::FillGradientAttribute aFillGradientAttribute(
  88                 css::awt::GradientStyle_LINEAR,
  89                 0.0,
  90                 0.5,
  91                 0.5,
  92                 M_PI,
  93                 basegfx::BColorStops(
  94                     basegfx::BColor(230.0/255.0,230.0/255.0,230.0/255.0),
  95                     basegfx::BColor(180.0/255.0,180.0/255.0,180.0/255.0)));
  96
  97             rContainer.push_back(
  98                 new drawinglayer::primitive2d::FillGradientPrimitive2D(
  99                     aRange,
 100                     std::move(aFillGradientAttribute)));
 101             break;
 102         }
 103         case SS_VIEW:
 104         {
 105             aRange.expand(basegfx::B2DTuple(getSecondPosition().getX(), getSecondPosition().getY() + (4.0 * getDiscreteUnit())));
 106             drawinglayer::attribute::FillGradientAttribute aFillGradientAttribute(
 107                 css::awt::GradientStyle_LINEAR,
 108                 0.0,
 109                 0.5,
 110                 0.5,
 111                 M_PI,
 112                 basegfx::BColorStops(
 113                     basegfx::BColor(230.0/255.0,230.0/255.0,230.0/255.0),
 114                     basegfx::BColor(180.0/255.0,180.0/255.0,180.0/255.0)));
 115
 116             rContainer.push_back(
 117                 new drawinglayer::primitive2d::FillGradientPrimitive2D(
 118                     aRange,
 119                     std::move(aFillGradientAttribute)));
 120             break;
 121         }
 122         case SS_EDIT:
 123         {
 124             aRange.expand(basegfx::B2DTuple(getSecondPosition().getX(), getSecondPosition().getY() + (4.0 * getDiscreteUnit())));
 125             drawinglayer::attribute::FillGradientAttribute aFillGradientAttribute(
 126                 css::awt::GradientStyle_LINEAR,
 127                 0.0,
 128                 0.5,
 129                 0.5,
 130                 M_PI,
 131                 basegfx::BColorStops(
 132                     basegfx::BColor(230.0/255.0,230.0/255.0,230.0/255.0),
 133                     basegfx::BColor(83.0/255.0,83.0/255.0,83.0/255.0)));
 134
 135             rContainer.push_back(
 136                 new drawinglayer::primitive2d::FillGradientPrimitive2D(
 137                     aRange,
 138                     std::move(aFillGradientAttribute)));
 139             break;
 140         }
 141         default:
 142         {
 143             break;
 144         }
 145     }
 146 }
 147
 148 bool ShadowPrimitive::operator==( const drawinglayer::primitive2d::BasePrimitive2D& rPrimitive ) const
 149 {
 150     if(drawinglayer::primitive2d::DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
 151     {
 152         const ShadowPrimitive& rCompare = static_cast< const ShadowPrimitive& >(rPrimitive);
 153
 154         return (maBasePosition == rCompare.maBasePosition
 155             && getSecondPosition() == rCompare.getSecondPosition()
 156             && maShadowState == rCompare.maShadowState);
 157     }
 158
 159     return false;
 160 }
 161
 162 sal_uInt32 ShadowPrimitive::getPrimitive2DID() const
 163 {
 164     return PRIMITIVE2D_ID_SWSIDEBARSHADOWPRIMITIVE;
 165 }
 166
 167 /* static */ std::unique_ptr<ShadowOverlayObject> ShadowOverlayObject::CreateShadowOverlayObject( SwView const & rDocView )
 168 {
 169     std::unique_ptr<ShadowOverlayObject> pShadowOverlayObject;
 170
 171     if ( rDocView.GetDrawView() )
 172     {
 173         SdrPaintWindow* pPaintWindow = rDocView.GetDrawView()->GetPaintWindow(0);
 174         if( pPaintWindow )
 175         {
 176             const rtl::Reference< sdr::overlay::OverlayManager >& xOverlayManager = pPaintWindow->GetOverlayManager();
 177
 178             if ( xOverlayManager.is() )
 179             {
 180                 pShadowOverlayObject.reset( new ShadowOverlayObject( basegfx::B2DPoint(0,0),
 181                                                                 basegfx::B2DPoint(0,0),
 182                                                                 Color(0,0,0) ) );
 183                 xOverlayManager->add(*pShadowOverlayObject);
 184             }
 185         }
 186     }
 187
 188     return pShadowOverlayObject;
 189 }
 190
 191 ShadowOverlayObject::ShadowOverlayObject( const basegfx::B2DPoint& rBasePos,
 192                                           const basegfx::B2DPoint& rSecondPosition,
 193                                           Color aBaseColor )
 194     : OverlayObjectWithBasePosition(rBasePos, aBaseColor)
 195     , maSecondPosition(rSecondPosition)
 196     , mShadowState(SS_NORMAL)
 197 {
 198 }
 199
 200 ShadowOverlayObject::~ShadowOverlayObject()
 201 {
 202     if ( getOverlayManager() )
 203     {
 204         getOverlayManager()->remove(*this);
 205     }
 206 }
 207
 208 drawinglayer::primitive2d::Primitive2DContainer ShadowOverlayObject::createOverlayObjectPrimitive2DSequence()
 209 {
 210     const drawinglayer::primitive2d::Primitive2DReference aReference(
 211         new ShadowPrimitive( getBasePosition(),
 212                              maSecondPosition,
 213                              GetShadowState() ) );
 214     return drawinglayer::primitive2d::Primitive2DContainer { aReference };
 215 }
 216
 217 void ShadowOverlayObject::SetShadowState(ShadowState aState)
 218 {
 219     if (mShadowState != aState)
 220     {
 221         mShadowState = aState;
 222
 223         objectChange();
 224     }
 225 }
 226
 227 void ShadowOverlayObject::SetPosition( const basegfx::B2DPoint& rPoint1,
 228                                        const basegfx::B2DPoint& rPoint2)
 229 {
 230     if(!rPoint1.equal(getBasePosition()) || !rPoint2.equal(maSecondPosition))
 231     {
 232         maBasePosition = rPoint1;
 233         maSecondPosition = rPoint2;
 234
 235         objectChange();
 236     }
 237 }
 238
 239 } // end of namespace sw::sidebarwindows
 240
 241 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */