/*
 * Copyright 2009, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Michael Lotz <mmlr@mlotz.ch>
 */
#ifndef REMOTE_DRAWING_ENGINE_H
#define REMOTE_DRAWING_ENGINE_H

#include "DrawingEngine.h"
#include "DrawState.h"
#include "RemoteHWInterface.h"
#include "ServerFont.h"

#include <AutoDeleter.h>

class BPoint;
class BRect;
class BRegion;

class BitmapDrawingEngine;
class ServerBitmap;

class RemoteDrawingEngine : public DrawingEngine {
public:
                                                                RemoteDrawingEngine(
                                                                        RemoteHWInterface* interface);
        virtual                                         ~RemoteDrawingEngine();

        // HWInterfaceListener interface
        virtual void                            FrameBufferChanged();

        virtual void                            SetCopyToFrontEnabled(bool enabled);

        // for screen shots
        virtual status_t                        ReadBitmap(ServerBitmap* bitmap,
                                                                        bool drawCursor, BRect bounds);

        // clipping for all drawing functions, passing a NULL region
        // will remove any clipping (drawing allowed everywhere)
        virtual void                            ConstrainClippingRegion(const BRegion* region);

        virtual void                            SetDrawState(const DrawState* state,
                                                                        int32 xOffset = 0, int32 yOffset = 0);

        virtual void                            SetHighColor(const rgb_color& color);
        virtual void                            SetLowColor(const rgb_color& color);
        virtual void                            SetPenSize(float size);
        virtual void                            SetStrokeMode(cap_mode lineCap,
                                                                        join_mode joinMode, float miterLimit);
        virtual void                            SetPattern(const struct pattern& pattern);
        virtual void                            SetDrawingMode(drawing_mode mode);
        virtual void                            SetDrawingMode(drawing_mode mode,
                                                                        drawing_mode& oldMode);
        virtual void                            SetBlendingMode(source_alpha srcAlpha,
                                                                        alpha_function alphaFunc);
        virtual void                            SetFont(const ServerFont& font);
        virtual void                            SetFont(const DrawState* state);
        virtual void                            SetTransform(const BAffineTransform& transform,
                                                                        int32 xOffset, int32 yOffset);

        // drawing functions
        virtual void                            InvertRect(BRect rect);

        virtual void                            DrawBitmap(ServerBitmap* bitmap,
                                                                        const BRect& bitmapRect,
                                                                        const BRect& viewRect, uint32 options = 0);

        // drawing primitives
        virtual void                            DrawArc(BRect rect, const float& angle,
                                                                        const float& span, bool filled);
        virtual void                            DrawArc(BRect rect, const float& angle,
                                                                        const float& span, bool filled, const BGradient& gradient);

        virtual void                            DrawBezier(BPoint* points, bool filled);
        virtual void                            DrawBezier(BPoint* points, bool filled, const BGradient& gradient);

        virtual void                            DrawEllipse(BRect rect, bool filled);
        virtual void                            DrawEllipse(BRect rect, bool filled, const BGradient& gradient);

        virtual void                            DrawPolygon(BPoint* pointList, int32 numPoints,
                                                                        BRect bounds, bool filled, bool closed);
        virtual void                            DrawPolygon(BPoint* pointList, int32 numPoints,
                                                                        BRect bounds, bool filled, bool closed,
                                                                        const BGradient& gradient);

        // these rgb_color versions are used internally by the server
        virtual void                            StrokePoint(const BPoint& point,
                                                                        const rgb_color& color);
        virtual void                            StrokeRect(BRect rect, const rgb_color &color);
        virtual void                            FillRect(BRect rect, const rgb_color &color);
        virtual void                            FillRegion(BRegion& region,
                                                                        const rgb_color& color);

        virtual void                            StrokeRect(BRect rect);
        virtual void                            StrokeRect(BRect rect, const BGradient& gradient);
        virtual void                            FillRect(BRect rect);
        virtual void                            FillRect(BRect rect, const BGradient& gradient);

        virtual void                            FillRegion(BRegion& region);
        virtual void                            FillRegion(BRegion& region,
                                                                        const BGradient& gradient);

        virtual void                            DrawRoundRect(BRect rect, float xRadius,
                                                                        float yRadius, bool filled);
        virtual void                            DrawRoundRect(BRect rect, float xRadius,
                                                                        float yRadius, bool filled, const BGradient& gradient);

        virtual void                            DrawShape(const BRect& bounds,
                                                                        int32 opCount, const uint32* opList,
                                                                        int32 pointCount, const BPoint* pointList,
                                                                        bool filled,
                                                                        const BPoint& viewToScreenOffset,
                                                                        float viewScale);
        virtual void                            DrawShape(const BRect& bounds,
                                                                        int32 opCount, const uint32* opList,
                                                                        int32 pointCount, const BPoint* pointList,
                                                                        bool filled, const BGradient& gradient,
                                                                        const BPoint& viewToScreenOffset,
                                                                        float viewScale);

        virtual void                            DrawTriangle(BPoint* points,
                                                                        const BRect& bounds, bool filled);
        virtual void                            DrawTriangle(BPoint* points, const BRect& bounds,
                                                                        bool filled, const BGradient& gradient);

        // these versions are used by the Decorator
        virtual void                            StrokeLine(const BPoint& start,
                                                                        const BPoint& end, const rgb_color& color);
        virtual void                            StrokeLine(const BPoint& start,
                                                                        const BPoint& end);
        virtual void                            StrokeLine(const BPoint& start,
                                                                        const BPoint& end, const BGradient& gradient);
        virtual void                            StrokeLineArray(int32 numlines,
                                                                        const ViewLineArrayInfo* data);

        // returns the pen position behind the (virtually) drawn string
        virtual BPoint                          DrawString(const char* string, int32 length,
                                                                        const BPoint& point,
                                                                        escapement_delta* delta = NULL);
        virtual BPoint                          DrawString(const char* string, int32 length,
                                                                        const BPoint* offsets);

        virtual float                           StringWidth(const char* string, int32 length,
                                                                        escapement_delta* delta = NULL);

        // software rendering backend invoked by CopyRegion() for the sorted
        // individual rects
        virtual BRect                           CopyRect(BRect rect, int32 xOffset,
                                                                        int32 yOffset) const;

private:
                        status_t                        _AddCallback();

        static  bool                            _DrawingEngineResult(void* cookie,
                                                                        RemoteMessage& message);

                        BRect                           _BuildBounds(BPoint* points, int32 pointCount);
                        status_t                        _ExtractBitmapRegions(ServerBitmap& bitmap,
                                                                        uint32 options, const BRect& bitmapRect,
                                                                        const BRect& viewRect, double xScale,
                                                                        double yScale, BRegion& region,
                                                                        UtilityBitmap**& bitmaps);

                        RemoteHWInterface*      fHWInterface;
                        int32                           fToken;

                        DrawState                       fState;
                        BRegion                         fClippingRegion;
                        float                           fExtendWidth;

                        bool                            fCallbackAdded;
                        sem_id                          fResultNotify;
                        BPoint                          fDrawStringResult;
                        float                           fStringWidthResult;
                        BBitmap*                        fReadBitmapResult;

                        ObjectDeleter<BitmapDrawingEngine>
                                                                fBitmapDrawingEngine;
};

#endif // REMOTE_DRAWING_ENGINE_H