/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#ifndef INCLUDED_SLIDESHOW_SHAPE_HXX
#define INCLUDED_SLIDESHOW_SHAPE_HXX

#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/drawing/XDrawPage.hpp>

#include <basegfx/range/b2drectangle.hxx>

#include "viewlayer.hxx"

#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
#include <set>
#include <vector>

namespace basegfx {
    class B2DRange;
}

namespace slideshow
{
    namespace internal
    {
        // forward declaration necessary, because methods use ShapeSharedPtr
        class Shape;

        typedef ::boost::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 : private boost::noncopyable
        {
        public:
            virtual ~Shape() {}

            /** 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 ::com::sun::star::uno::Reference< 
                ::com::sun::star::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 bool 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::B2DRange 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::B2DRange 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::B2DRange 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 returnes 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 secondy 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());
                }

                bool operator()(const Shape* pLHS, const Shape* pRHS) const
                {
                    return compare(pLHS, pRHS);
                }
            };
        };

        typedef ::boost::shared_ptr< Shape > ShapeSharedPtr;

        /** A set which contains all shapes in an ordered fashion.
         */
        typedef ::std::set< ShapeSharedPtr, Shape::lessThanShape > 	ShapeSet;
    }
}

#endif /* INCLUDED_SLIDESHOW_SHAPE_HXX */