/*
 * Copyright 2001-2018, Haiku Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Marc Flerackers (mflerackers@androme.be)
 *              Stefano Ceccherini (stefano.ceccherini@gmail.com)
 *              Marcus Overhagen (marcus@overhagen.de)
 *              Stephan Aßmus <superstippi@gmx.de>
 */
#ifndef _PICTURE_PLAYER_H
#define _PICTURE_PLAYER_H

/*!     PicturePlayer is used to play picture data. */


#include <GraphicsDefs.h>
#include <InterfaceDefs.h>
#include <Point.h>
#include <Rect.h>
#include <Region.h>


struct escapement_delta;

class BAffineTransform;
class BGradient;
class BList;
class BPicture;
class BShape;
class Layer;


namespace BPrivate {


struct picture_player_callbacks_compat {
        /*  0 */ void (*nop)(void* user);
        /*  1 */ void (*move_pen_by)(void* user, BPoint delta);
        /*  2 */ void (*stroke_line)(void* user, BPoint start, BPoint end);
        /*  3 */ void (*stroke_rect)(void* user, BRect rect);
        /*  4 */ void (*fill_rect)(void* user, BRect rect);
        /*  5 */ void (*stroke_round_rect)(void* user, BRect rect, BPoint radii);
        /*  6 */ void (*fill_round_rect)(void* user, BRect rect, BPoint radii);
        /*  7 */ void (*stroke_bezier)(void* user, BPoint* control);
        /*  8 */ void (*fill_bezier)(void* user, BPoint* control);
        /*  9 */ void (*stroke_arc)(void* user, BPoint center, BPoint radii, float startTheta,
                float arcTheta);
        /* 10 */ void (*fill_arc)(void* user, BPoint center, BPoint radii, float startTheta,
                float arcTheta);
        /* 11 */ void (*stroke_ellipse)(void* user, BPoint center, BPoint radii);
        /* 12 */ void (*fill_ellipse)(void* user, BPoint center, BPoint radii);
        /* 13 */ void (*stroke_polygon)(void* user, int32 numPoints, const BPoint* points,
                bool isClosed);
        /* 14 */ void (*fill_polygon)(void* user, int32 numPoints, const BPoint* points,
                bool isClosed);
        // Called "Reserved" in BeBook
        /* 15 */ void (*stroke_shape)(void* user, const BShape *shape);
        // Called "Reserved" in BeBook
        /* 16 */ void (*fill_shape)(void* user, const BShape *shape);
        /* 17 */ void (*draw_string)(void* user, const char* string, float deltax, float deltay);
        /* 18 */ void (*draw_pixels)(void* user, BRect src, BRect dest, int32 width, int32 height,
                int32 bytesPerRow, int32 pixelFormat, int32 flags, const void* data);
        // Called "Reserved" in BeBook
        /* 19 */ void (*draw_picture)(void* user, BPoint where, int32 token);
        /* 20 */ void (*set_clipping_rects)(void* user, const BRect* rects, uint32 numRects);
        // Called "Reserved" in BeBook
        /* 21 */ void (*clip_to_picture)(void* user, int32 token, BPoint point,
                bool clip_to_inverse_picture);
        /* 22 */ void (*push_state)(void* user);
        /* 23 */ void (*pop_state)(void* user);
        /* 24 */ void (*enter_state_change)(void* user);
        /* 25 */ void (*exit_state_change)(void* user);
        /* 26 */ void (*enter_font_state)(void* user);
        /* 27 */ void (*exit_font_state)(void* user);
        /* 28 */ void (*set_origin)(void* user, BPoint pt);
        /* 29 */ void (*set_pen_location)(void* user, BPoint pt);
        /* 30 */ void (*set_drawing_mode)(void* user, drawing_mode mode);
        /* 31 */ void (*set_line_mode)(void* user, cap_mode capMode, join_mode joinMode,
                float miterLimit);
        /* 32 */ void (*set_pen_size)(void* user, float size);
        /* 33 */ void (*set_fore_color)(void* user, rgb_color color);
        /* 34 */ void (*set_back_color)(void* user, rgb_color color);
        /* 35 */ void (*set_stipple_pattern)(void* user, pattern p);
        /* 36 */ void (*set_scale)(void* user, float scale);
        /* 37 */ void (*set_font_family)(void* user, const char* family);
        /* 38 */ void (*set_font_style)(void* user, const char* style);
        /* 39 */ void (*set_font_spacing)(void* user, int32 spacing);
        /* 40 */ void (*set_font_size)(void* user, float size);
        /* 41 */ void (*set_font_rotate)(void* user, float rotation);
        /* 42 */ void (*set_font_encoding)(void* user, int32 encoding);
        /* 43 */ void (*set_font_flags)(void* user, int32 flags);
        /* 44 */ void (*set_font_shear)(void* user, float shear);
        // Called "Reserved" in BeBook
        /* 45 */ void (*set_font_bpp)(void* user, int32 bpp);
        /* 46 */ void (*set_font_face)(void* user, int32 flags);

        // New in Haiku
        /* 47 */ void (*set_blending_mode)(void* user, source_alpha alphaSrcMode,
                alpha_function alphaFncMode);
        /* 48 */ void (*set_transform)(void* user, const BAffineTransform& transform);
        /* 49 */ void (*translate_by)(void* user, double x, double y);
        /* 50 */ void (*scale_by)(void* user, double x, double y);
        /* 51 */ void (*rotate_by)(void* user, double angleRadians);
        // Broken when saved to file
        /* 52 */ void (*blend_layer)(void* user, class Layer* layer);
        /* 53 */ void (*clip_to_rect)(void* user, const BRect& rect, bool inverse);
        // Why not BShape?
        /* 54 */ void (*clip_to_shape)(void* user, int32 opCount, const uint32 opList[], int32 ptCount,
                const BPoint ptList[], bool inverse);
        /* 55 */ void (*draw_string_locations)(void* user, const char* string, const BPoint* locations,
                size_t locationCount);

        /* 56 */ void (*fill_rect_gradient)(void* user, BRect rect, const BGradient& gradient);
        /* 57 */ void (*stroke_rect_gradient)(void* user, BRect rect, const BGradient& gradient);
        /* 58 */ void (*fill_round_rect_gradient)(void* user, BRect rect, BPoint radii,
                const BGradient& gradient);
        /* 59 */ void (*stroke_round_rect_gradient)(void* user, BRect rect, BPoint radii,
                const BGradient& gradient);
        /* 60 */ void (*fill_bezier_gradient)(void* user, const BPoint* points,
                const BGradient& gradient);
        /* 61 */ void (*stroke_bezier_gradient)(void* user, const BPoint* points,
                const BGradient& gradient);
        /* 62 */ void (*fill_arc_gradient)(void* user, BPoint center, BPoint radii, float startTheta,
                float arcTheta, const BGradient& gradient);
        /* 63 */ void (*stroke_arc_gradient)(void* user, BPoint center, BPoint radii, float startTheta,
                float arcTheta, const BGradient& gradient);
        /* 64 */ void (*fill_ellipse_gradient)(void* user, BPoint center, BPoint radii,
                const BGradient& gradient);
        /* 65 */ void (*stroke_ellipse_gradient)(void* user, BPoint center, BPoint radii,
                const BGradient& gradient);
        /* 66 */ void (*fill_polygon_gradient)(void* user, int32 numPoints, const BPoint* points,
                bool isClosed, const BGradient& gradient);
        /* 67 */ void (*stroke_polygon_gradient)(void* user, int32 numPoints, const BPoint* points,
                bool isClosed, const BGradient& gradient);
        /* 68 */ void (*fill_shape_gradient)(void* user, BShape shape, const BGradient& gradient);
        /* 69 */ void (*stroke_shape_gradient)(void* user, BShape shape, const BGradient& gradient);

        /* 70 */ void (*set_fill_rule)(void* user, int32 fillRule);

        /* 71 */ void (*stroke_line_gradient)(void* user, BPoint start, BPoint end,
                const BGradient& gradient);
};


class PicturePlayerCallbacks {
public:
        virtual void MovePenBy(const BPoint& where) {}
        virtual void StrokeLine(const BPoint& start, const BPoint& end) {}
        virtual void DrawRect(const BRect& rect, bool fill) {}
        virtual void DrawRoundRect(const BRect& rect, const BPoint& radii, bool fill) {}
        virtual void DrawBezier(const BPoint controlPoints[4], bool fill) {}
        virtual void DrawArc(const BPoint& center, const BPoint& radii, float startTheta,
                float arcTheta, bool fill) {}
        virtual void DrawEllipse(const BRect& rect, bool fill) {}
        virtual void DrawPolygon(size_t numPoints, const BPoint points[], bool isClosed, bool fill) {}
        virtual void DrawShape(const BShape& shape, bool fill) {}
        virtual void DrawString(const char* string, size_t length, const escapement_delta& delta) {}
        virtual void DrawPixels(const BRect& source, const BRect& destination, uint32 width,
                uint32 height, size_t bytesPerRow, color_space pixelFormat, uint32 flags, const void* data,
                size_t length) {}
        virtual void DrawPicture(const BPoint& where, int32 token) {}
        virtual void SetClippingRects(size_t numRects, const clipping_rect rects[]) {}
        virtual void ClipToPicture(int32 token, const BPoint& where, bool clipToInverse) {}
        virtual void PushState() {}
        virtual void PopState() {}
        virtual void EnterStateChange() {}
        virtual void ExitStateChange() {}
        virtual void EnterFontState() {}
        virtual void ExitFontState() {}
        virtual void SetOrigin(const BPoint& origin) {}
        virtual void SetPenLocation(const BPoint& location) {}
        virtual void SetDrawingMode(drawing_mode mode) {}
        virtual void SetLineMode(cap_mode capMode, join_mode joinMode, float miterLimit) {}
        virtual void SetPenSize(float size) {}
        virtual void SetForeColor(const rgb_color& color) {}
        virtual void SetBackColor(const rgb_color& color) {}
        virtual void SetStipplePattern(const pattern& patter) {}
        virtual void SetScale(float scale) {}
        virtual void SetFontFamily(const char* familyName, size_t length) {}
        virtual void SetFontStyle(const char* styleName, size_t length) {}
        virtual void SetFontSpacing(uint8 spacing) {}
        virtual void SetFontSize(float size) {}
        virtual void SetFontRotation(float rotation) {}
        virtual void SetFontEncoding(uint8 encoding) {}
        virtual void SetFontFlags(uint32 flags) {}
        virtual void SetFontShear(float shear) {}
        virtual void SetFontFace(uint16 face) {}
        virtual void SetBlendingMode(source_alpha alphaSourceMode, alpha_function alphaFunctionMode) {}
        virtual void SetTransform(const BAffineTransform& transform) {}
        virtual void TranslateBy(double x, double y) {}
        virtual void ScaleBy(double x, double y) {}
        virtual void RotateBy(double angleRadians) {}
        virtual void BlendLayer(Layer* layer) {}
        virtual void ClipToRect(const BRect& rect, bool inverse) {}
        virtual void ClipToShape(int32 opCount, const uint32 opList[], int32 ptCount,
                const BPoint ptList[], bool inverse) {}
        virtual void DrawStringLocations(const char* string, size_t length, const BPoint locations[],
                size_t locationCount) {}
        virtual void DrawRectGradient(const BRect& rect, BGradient& gradient, bool fill) {}
        virtual void DrawRoundRectGradient(const BRect& rect, const BPoint& radii, BGradient& gradient,
                bool fill) {}
        virtual void DrawBezierGradient(const BPoint controlPoints[4], BGradient& gradient, bool fill)
                {}
        virtual void DrawArcGradient(const BPoint& center, const BPoint& radii, float startTheta,
                float arcTheta, BGradient& gradient, bool fill) {}
        virtual void DrawEllipseGradient(const BRect& rect, BGradient& gradient, bool fill) {}
        virtual void DrawPolygonGradient(size_t numPoints, const BPoint points[], bool isClosed,
                BGradient& gradient, bool fill) {}
        virtual void DrawShapeGradient(const BShape& shape, BGradient& gradient, bool fill) {}
        virtual void SetFillRule(int32 fillRule) {}
        virtual void StrokeLineGradient(const BPoint& start, const BPoint& end, BGradient& gradient) {}
};


class PicturePlayer {
public:
        PicturePlayer();
        PicturePlayer(const void* data, size_t size, BList* pictures);
        virtual ~PicturePlayer();

        status_t        Play(void** callbacks, int32 tableEntries,
                                        void* userData);
        status_t        Play(PicturePlayerCallbacks& callbacks);

private:
        status_t        _Play(PicturePlayerCallbacks& callbacks,
                                        const void* data, size_t length, uint16 parentOp);

        const void*     fData;
        size_t          fSize;
        BList*          fPictures;
};

} // namespace BPrivate

#endif // _PICTURE_PLAYER_H