slideshow/source/inc/shape.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #ifndef INCLUDED_SLIDESHOW_SHAPE_HXX
  30 #define INCLUDED_SLIDESHOW_SHAPE_HXX
  31
  32 #include <com/sun/star/uno/Reference.hxx>
  33 #include <com/sun/star/drawing/XShape.hpp>
  34 #include <com/sun/star/drawing/XDrawPage.hpp>
  35
  36 #include <basegfx/range/b2drectangle.hxx>
  37
  38 #include "viewlayer.hxx"
  39
  40 #include <boost/shared_ptr.hpp>
  41 #include <boost/noncopyable.hpp>
  42 #include <set>
  43 #include <vector>
  44
  45 namespace basegfx {
  46     class B2DRange;
  47 }
  48
  49 namespace slideshow
  50 {
  51     namespace internal
  52     {
  53         // forward declaration necessary, because methods use ShapeSharedPtr
  54         class Shape;
  55
  56         typedef ::boost::shared_ptr< Shape > ShapeSharedPtr;
  57
  58         /** Represents a slide's shape object.
  59
  60             This interface represents the view-independent aspects of a
  61             slide's shape, providing bound rect, underlying XShape and
  62             basic paint methods.
  63          */
  64         class Shape : private boost::noncopyable
  65         {
  66         public:
  67             virtual ~Shape() {}
  68
  69             /** Get the associated XShape of this shape.
  70
  71                 @return the associated XShape. If this method returns
  72                 an empty reference, this object might be one of the
  73                 special-purpose shapes of a slide, which have no
  74                 direct corresponding XShape (the background comes to
  75                 mind here).
  76              */
  77             virtual ::com::sun::star::uno::Reference<
  78                 ::com::sun::star::drawing::XShape > getXShape() const = 0;
  79
  80
  81             // View layer methods
  82             //------------------------------------------------------------------
  83
  84             /** Add a new view layer.
  85
  86                 This method adds a new view layer, this shape shall
  87                 show itself on.
  88
  89                 @param rNewLayer
  90                 New layer to show on
  91
  92                 @param bRedrawLayer
  93                 Redraw shape on given layer
  94              */
  95             virtual void addViewLayer( const ViewLayerSharedPtr&    rNewLayer,
  96                                        bool                         bRedrawLayer ) = 0;
  97
  98             /** Withdraw the shape from a view layer
  99
 100                 This method removes the shape from the given view
 101                 layer.
 102
 103                 @return true, if the shape was successfully removed
 104              */
 105             virtual bool removeViewLayer( const ViewLayerSharedPtr& rNewLayer ) = 0;
 106
 107             /** Withdraw all view layers at once
 108
 109                 This method will be faster than repeated
 110                 removeViewLayer() calls.
 111              */
 112             virtual bool clearAllViewLayers() = 0;
 113
 114             // render methods
 115             //------------------------------------------------------------------
 116
 117             /** Update the shape
 118
 119                 This method updates the Shape on all registered view
 120                 layers, but only if shape content has actually
 121                 changed.
 122
 123                 @return whether the update finished successfully.
 124             */
 125             virtual bool update() const = 0;
 126
 127             /** Render the shape.
 128
 129                 This method renders the shape on all registered view
 130                 layers, regardless of whether shape content has
 131                 changed or not.
 132
 133                 @return whether the rendering finished successfully.
 134             */
 135             virtual bool render() const = 0;
 136
 137             /** Query whether shape content changed
 138
 139                 This method returns true, if shape content changed
 140                 since the last rendering (i.e. the shape needs an
 141                 update to reflect that changed content on the views).
 142              */
 143             virtual bool isContentChanged() const = 0;
 144
 145
 146             // Shape attributes
 147             //------------------------------------------------------------------
 148
 149             /** Get the current shape position and size.
 150
 151                 This method yields the currently effective shape
 152                 bounds (which might change over time, for animated
 153                 shapes). Please note that possibly shape rotations
 154                 from its original document state must not be taken
 155                 into account here: if you need the screen bounding
 156                 box, use getUpdateArea() instead. Note further that
 157                 shape rotations, which are already contained in the
 158                 shape as displayed in the original document
 159                 <em>are</em> included herein (we currently take the
 160                 shape as-is from the document, assuming a rotation
 161                 angle of 0).
 162              */
 163             virtual ::basegfx::B2DRange getBounds() const = 0;
 164
 165             /** Get the DOM position and size of the shape.
 166
 167                 This method yields the underlying DOM shape bounds,
 168                 i.e. the original shape bounds from the document
 169                 model. This value is <em>always</em> unaffected by any
 170                 animation activity. Note that shape rotations, which
 171                 are already contained in the shape as displayed in the
 172                 original document are already included herein (we
 173                 currently take the shape as-is from the document,
 174                 assuming a rotation angle of 0).
 175              */
 176             virtual ::basegfx::B2DRange getDomBounds() const = 0;
 177
 178             /** Get the current shape update area.
 179
 180                 This method yields the currently effective update area
 181                 for the shape, i.e. the area that needs to be updated,
 182                 should the shape be painted. Normally, this will be
 183                 the (possibly rotated and sheared) area returned by
 184                 getBounds().
 185              */
 186             virtual ::basegfx::B2DRange getUpdateArea() const = 0;
 187
 188             /** Query whether the shape is visible at all.
 189
 190                 @return true, if this shape is visible, false
 191                 otherwise.
 192              */
 193             virtual bool isVisible() const = 0;
 194
 195             /** Get the shape priority.
 196
 197                 The shape priority defines the relative order of the
 198                 shapes on the slide.
 199
 200                 @return the priority. Will be in the [0,+infty) range.
 201              */
 202             virtual double getPriority() const = 0;
 203
 204             /** Query whether the Shape is currently detached from the
 205                 background.
 206
 207                 This method checks whether the Shape is currently
 208                 detached from the slide background, i.e. whether shape
 209                 updates affect the underlying slide background or
 210                 not. A shape that returnes true here must not alter
 211                 slide content in any way when called render() or
 212                 update() (this is normally achieved by making this
 213                 shape a sprite).
 214              */
 215             virtual bool isBackgroundDetached() const = 0;
 216
 217             // Misc
 218             //------------------------------------------------------------------
 219
 220             /** Functor struct, for shape ordering
 221
 222                 This defines a strict weak ordering of shapes, primary
 223                 sort key is the shape priority, and secondy sort key
 224                 the object ptr value. Most typical use is for
 225                 associative containers holding shapes (and which also
 226                 have to maintain something like a paint order).
 227              */
 228             struct lessThanShape
 229             {
 230                 // make functor adaptable (to boost::bind)
 231                 typedef bool result_type;
 232
 233                 // since the ZOrder property on the XShape has somewhat
 234                 // peculiar attributes (it's basically the index of the shapes
 235                 // in the drawing layer's SdrObjList - which means, it starts
 236                 // from 0 for children of group objects), we cannot use it to determine
 237                 // drawing order. Thus, we rely on importer-provided order values here,
 238                 // which is basically a running counter during shape import (i.e. denotes
 239                 // the order of shape import). This is the correct order, at least for the
 240                 // current drawing core.
 241                 //
 242                 // If, someday, the above proposition is no longer true, one directly use
 243                 // the shape's ZOrder property
 244                 //
 245                 static bool compare(const Shape* pLHS, const Shape* pRHS)
 246                 {
 247                     const double nPrioL( pLHS->getPriority() );
 248                     const double nPrioR( pRHS->getPriority() );
 249
 250                     // if prios are equal, tie-break on ptr value
 251                     return nPrioL == nPrioR ? pLHS < pRHS : nPrioL < nPrioR;
 252                 }
 253
 254                 bool operator()(const ShapeSharedPtr& rLHS, const ShapeSharedPtr& rRHS) const
 255                 {
 256                     return compare(rLHS.get(),rRHS.get());
 257                 }
 258
 259                 bool operator()(const Shape* pLHS, const Shape* pRHS) const
 260                 {
 261                     return compare(pLHS, pRHS);
 262                 }
 263             };
 264         };
 265
 266         typedef ::boost::shared_ptr< Shape > ShapeSharedPtr;
 267
 268         /** A set which contains all shapes in an ordered fashion.
 269          */
 270         typedef ::std::set< ShapeSharedPtr, Shape::lessThanShape >  ShapeSet;
 271     }
 272 }
 273
 274 #endif /* INCLUDED_SLIDESHOW_SHAPE_HXX */
 275
 276 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */