summaryrefslogtreecommitdiffstats
path: root/slideshow/source/inc/shape.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /slideshow/source/inc/shape.hxx
parentInitial commit. (diff)
downloadlibreoffice-upstream/1%7.0.4.tar.xz
libreoffice-upstream/1%7.0.4.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--slideshow/source/inc/shape.hxx260
1 files changed, 260 insertions, 0 deletions
diff --git a/slideshow/source/inc/shape.hxx b/slideshow/source/inc/shape.hxx
new file mode 100644
index 000000000..9b6099462
--- /dev/null
+++ b/slideshow/source/inc/shape.hxx
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_SHAPE_HXX
+#define INCLUDED_SLIDESHOW_SOURCE_INC_SHAPE_HXX
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/drawing/XShape.hpp>
+
+#include <basegfx/range/b2drectangle.hxx>
+
+#include "viewlayer.hxx"
+
+#include <memory>
+#include <set>
+
+namespace basegfx {
+ class B2DRange;
+}
+
+namespace slideshow
+{
+ namespace internal
+ {
+ // forward declaration necessary, because methods use ShapeSharedPtr
+ class Shape;
+
+ typedef ::std::shared_ptr< Shape > ShapeSharedPtr;
+
+ /** Represents a slide's shape object.
+
+ This interface represents the view-independent aspects of a
+ slide's shape, providing bound rect, underlying XShape and
+ basic paint methods.
+ */
+ class Shape
+ {
+ public:
+ Shape() = default;
+ virtual ~Shape() {}
+ Shape(const Shape&) = delete;
+ Shape& operator=(const Shape&) = delete;
+
+ /** Get the associated XShape of this shape.
+
+ @return the associated XShape. If this method returns
+ an empty reference, this object might be one of the
+ special-purpose shapes of a slide, which have no
+ direct corresponding XShape (the background comes to
+ mind here).
+ */
+ virtual css::uno::Reference< css::drawing::XShape > getXShape() const = 0;
+
+
+ // View layer methods
+
+
+ /** Add a new view layer.
+
+ This method adds a new view layer, this shape shall
+ show itself on.
+
+ @param rNewLayer
+ New layer to show on
+
+ @param bRedrawLayer
+ Redraw shape on given layer
+ */
+ virtual void addViewLayer( const ViewLayerSharedPtr& rNewLayer,
+ bool bRedrawLayer ) = 0;
+
+ /** Withdraw the shape from a view layer
+
+ This method removes the shape from the given view
+ layer.
+
+ @return true, if the shape was successfully removed
+ */
+ virtual bool removeViewLayer( const ViewLayerSharedPtr& rNewLayer ) = 0;
+
+ /** Withdraw all view layers at once
+
+ This method will be faster than repeated
+ removeViewLayer() calls.
+ */
+ virtual void clearAllViewLayers() = 0;
+
+ // render methods
+
+
+ /** Update the shape
+
+ This method updates the Shape on all registered view
+ layers, but only if shape content has actually
+ changed.
+
+ @return whether the update finished successfully.
+ */
+ virtual bool update() const = 0;
+
+ /** Render the shape.
+
+ This method renders the shape on all registered view
+ layers, regardless of whether shape content has
+ changed or not.
+
+ @return whether the rendering finished successfully.
+ */
+ virtual bool render() const = 0;
+
+ /** Query whether shape content changed
+
+ This method returns true, if shape content changed
+ since the last rendering (i.e. the shape needs an
+ update to reflect that changed content on the views).
+ */
+ virtual bool isContentChanged() const = 0;
+
+
+ // Shape attributes
+
+
+ /** Get the current shape position and size.
+
+ This method yields the currently effective shape
+ bounds (which might change over time, for animated
+ shapes). Please note that possibly shape rotations
+ from its original document state must not be taken
+ into account here: if you need the screen bounding
+ box, use getUpdateArea() instead. Note further that
+ shape rotations, which are already contained in the
+ shape as displayed in the original document
+ <em>are</em> included herein (we currently take the
+ shape as-is from the document, assuming a rotation
+ angle of 0).
+ */
+ virtual ::basegfx::B2DRectangle getBounds() const = 0;
+
+ /** Get the DOM position and size of the shape.
+
+ This method yields the underlying DOM shape bounds,
+ i.e. the original shape bounds from the document
+ model. This value is <em>always</em> unaffected by any
+ animation activity. Note that shape rotations, which
+ are already contained in the shape as displayed in the
+ original document are already included herein (we
+ currently take the shape as-is from the document,
+ assuming a rotation angle of 0).
+ */
+ virtual ::basegfx::B2DRectangle getDomBounds() const = 0;
+
+ /** Get the current shape update area.
+
+ This method yields the currently effective update area
+ for the shape, i.e. the area that needs to be updated,
+ should the shape be painted. Normally, this will be
+ the (possibly rotated and sheared) area returned by
+ getBounds().
+ */
+ virtual ::basegfx::B2DRectangle getUpdateArea() const = 0;
+
+ /** Query whether the shape is visible at all.
+
+ @return true, if this shape is visible, false
+ otherwise.
+ */
+ virtual bool isVisible() const = 0;
+
+ /** Get the shape priority.
+
+ The shape priority defines the relative order of the
+ shapes on the slide.
+
+ @return the priority. Will be in the [0,+infty) range.
+ */
+ virtual double getPriority() const = 0;
+
+ /** Query whether the Shape is currently detached from the
+ background.
+
+ This method checks whether the Shape is currently
+ detached from the slide background, i.e. whether shape
+ updates affect the underlying slide background or
+ not. A shape that returns true here must not alter
+ slide content in any way when called render() or
+ update() (this is normally achieved by making this
+ shape a sprite).
+ */
+ virtual bool isBackgroundDetached() const = 0;
+
+ // Misc
+
+
+ /** Functor struct, for shape ordering
+
+ This defines a strict weak ordering of shapes, primary
+ sort key is the shape priority, and secondary sort key
+ the object ptr value. Most typical use is for
+ associative containers holding shapes (and which also
+ have to maintain something like a paint order).
+ */
+ struct lessThanShape
+ {
+ // make functor adaptable (to boost::bind)
+ typedef bool result_type;
+
+ // since the ZOrder property on the XShape has somewhat
+ // peculiar attributes (it's basically the index of the shapes
+ // in the drawing layer's SdrObjList - which means, it starts
+ // from 0 for children of group objects), we cannot use it to determine
+ // drawing order. Thus, we rely on importer-provided order values here,
+ // which is basically a running counter during shape import (i.e. denotes
+ // the order of shape import). This is the correct order, at least for the
+ // current drawing core.
+
+ // If, someday, the above proposition is no longer true, one directly use
+ // the shape's ZOrder property
+
+ static bool compare(const Shape* pLHS, const Shape* pRHS)
+ {
+ const double nPrioL( pLHS->getPriority() );
+ const double nPrioR( pRHS->getPriority() );
+
+ // if prios are equal, tie-break on ptr value
+ return nPrioL == nPrioR ? pLHS < pRHS : nPrioL < nPrioR;
+ }
+
+ bool operator()(const ShapeSharedPtr& rLHS, const ShapeSharedPtr& rRHS) const
+ {
+ return compare(rLHS.get(),rRHS.get());
+ }
+
+ };
+ };
+
+ /** A set which contains all shapes in an ordered fashion.
+ */
+ typedef ::std::set< ShapeSharedPtr, Shape::lessThanShape > ShapeSet;
+ }
+}
+
+#endif // INCLUDED_SLIDESHOW_SOURCE_INC_SHAPE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */