svx/source/sdr/overlay/overlayanimatedbitmapex.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: overlayanimatedbitmapex.cxx,v $
  10  * $Revision: 1.5 $
  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/overlayanimatedbitmapex.hxx>
  34 #include <vcl/salbtype.hxx>
  35 #include <vcl/outdev.hxx>
  36 #include <svx/sdr/overlay/overlaymanager.hxx>
  37 #include <basegfx/matrix/b2dhommatrix.hxx>
  38 #include <svx/sdr/overlay/overlaytools.hxx>
  39
  40 //////////////////////////////////////////////////////////////////////////////
  41
  42 namespace sdr
  43 {
  44     namespace overlay
  45     {
  46         // #i53216# check blink time value range
  47         void OverlayAnimatedBitmapEx::impCheckBlinkTimeValueRange()
  48         {
  49             if(mnBlinkTime < 25)
  50             {
  51                 mnBlinkTime = 25;
  52             }
  53             else if(mnBlinkTime > 10000)
  54             {
  55                 mnBlinkTime = 10000;
  56             }
  57         }
  58
  59         drawinglayer::primitive2d::Primitive2DSequence OverlayAnimatedBitmapEx::createOverlayObjectPrimitive2DSequence()
  60         {
  61             if(mbOverlayState)
  62             {
  63                 const drawinglayer::primitive2d::Primitive2DReference aPrimitive(
  64                     new drawinglayer::primitive2d::OverlayBitmapExPrimitive(
  65                         getBitmapEx1(),
  66                         getBasePosition(),
  67                         getCenterX1(),
  68                         getCenterY1()));
  69
  70                 return drawinglayer::primitive2d::Primitive2DSequence(&aPrimitive, 1);
  71             }
  72             else
  73             {
  74                 const drawinglayer::primitive2d::Primitive2DReference aPrimitive(
  75                     new drawinglayer::primitive2d::OverlayBitmapExPrimitive(
  76                         getBitmapEx2(),
  77                         getBasePosition(),
  78                         getCenterX2(),
  79                         getCenterY2()));
  80
  81                 return drawinglayer::primitive2d::Primitive2DSequence(&aPrimitive, 1);
  82             }
  83         }
  84
  85         OverlayAnimatedBitmapEx::OverlayAnimatedBitmapEx(
  86             const basegfx::B2DPoint& rBasePos,
  87             const BitmapEx& rBitmapEx1,
  88             const BitmapEx& rBitmapEx2,
  89             sal_uInt32 nBlinkTime,
  90             sal_uInt16 nCenX1,
  91             sal_uInt16 nCenY1,
  92             sal_uInt16 nCenX2,
  93             sal_uInt16 nCenY2)
  94         :       OverlayObjectWithBasePosition(rBasePos, Color(COL_WHITE)),
  95             maBitmapEx1(rBitmapEx1),
  96             maBitmapEx2(rBitmapEx2),
  97             mnCenterX1(nCenX1), mnCenterY1(nCenY1),
  98             mnCenterX2(nCenX2), mnCenterY2(nCenY2),
  99             mnBlinkTime(nBlinkTime),
 100             mbOverlayState(false)
 101         {
 102             // set AllowsAnimation flag to mark this object as animation capable
 103             mbAllowsAnimation = true;
 104
 105             // #i53216# check blink time value range
 106             impCheckBlinkTimeValueRange();
 107         }
 108
 109         OverlayAnimatedBitmapEx::~OverlayAnimatedBitmapEx()
 110         {
 111         }
 112
 113         void OverlayAnimatedBitmapEx::setBitmapEx1(const BitmapEx& rNew)
 114         {
 115             if(rNew != maBitmapEx1)
 116             {
 117                 // remember new Bitmap
 118                 maBitmapEx1 = rNew;
 119
 120                 // register change (after change)
 121                 objectChange();
 122             }
 123         }
 124
 125         void OverlayAnimatedBitmapEx::setBitmapEx2(const BitmapEx& rNew)
 126         {
 127             if(rNew != maBitmapEx2)
 128             {
 129                 // remember new Bitmap
 130                 maBitmapEx2 = rNew;
 131
 132                 // register change (after change)
 133                 objectChange();
 134             }
 135         }
 136
 137         void OverlayAnimatedBitmapEx::setCenterXY1(sal_uInt16 nNewX, sal_uInt16 nNewY)
 138         {
 139             if(nNewX != mnCenterX1 || nNewY != mnCenterY1)
 140             {
 141                 // remember new values
 142                 if(nNewX != mnCenterX1)
 143                 {
 144                     mnCenterX1 = nNewX;
 145                 }
 146
 147                 if(nNewY != mnCenterY1)
 148                 {
 149                     mnCenterY1 = nNewY;
 150                 }
 151
 152                 // register change (after change)
 153                 objectChange();
 154             }
 155         }
 156
 157         void OverlayAnimatedBitmapEx::setCenterXY2(sal_uInt16 nNewX, sal_uInt16 nNewY)
 158         {
 159             if(nNewX != mnCenterX2 || nNewY != mnCenterY2)
 160             {
 161                 // remember new values
 162                 if(nNewX != mnCenterX2)
 163                 {
 164                     mnCenterX2 = nNewX;
 165                 }
 166
 167                 if(nNewY != mnCenterY2)
 168                 {
 169                     mnCenterY2 = nNewY;
 170                 }
 171
 172                 // register change (after change)
 173                 objectChange();
 174             }
 175         }
 176
 177         void OverlayAnimatedBitmapEx::setBlinkTime(sal_uInt32 nNew)
 178         {
 179             if(mnBlinkTime != nNew)
 180             {
 181                 // remember new value
 182                 mnBlinkTime = nNew;
 183
 184                 // #i53216# check blink time value range
 185                 impCheckBlinkTimeValueRange();
 186
 187                 // register change (after change)
 188                 objectChange();
 189             }
 190         }
 191
 192         void OverlayAnimatedBitmapEx::Trigger(sal_uInt32 nTime)
 193         {
 194             if(getOverlayManager())
 195             {
 196                 // #i53216# produce event after nTime + x
 197                 SetTime(nTime + mnBlinkTime);
 198
 199                 // switch state
 200                 if(mbOverlayState)
 201                 {
 202                     mbOverlayState = false;
 203                 }
 204                 else
 205                 {
 206                     mbOverlayState = true;
 207                 }
 208
 209                 // re-insert me as event
 210                 getOverlayManager()->InsertEvent(this);
 211
 212                 // register change (after change)
 213                 objectChange();
 214             }
 215         }
 216     } // end of namespace overlay
 217 } // end of namespace sdr
 218
 219 //////////////////////////////////////////////////////////////////////////////
 220 // eof