#ifndef _RASTERIZER_H
#define _RASTERIZER_H


#include <Bitmap.h>

#include "Halftone.h"
#include "ValidRect.h"


class Rasterizer {
public:
                                                Rasterizer(Halftone* halftone);
        virtual                         ~Rasterizer();

        /**
         *  Sets the bitmap to be rasterized
         *  Either the iterator methods HasNextLine() and RasterizeNextLine()
         *  can be used to rasterize the bitmap line per line or the method
         *      RasterizeBitamp()
         *  can be used to rasterize the entire bitmap at once.
         *  @param x the x position of the image on the page.
         *  @param y the y position of the image on the page.
         *  @param bitmap the bitamp to be rasterized.
         *  @param height the page height.
         *  @return true if the bitmap is not empty and false if the bitmap is
         *              empty.
         */
                        bool            SetBitmap(int x, int y, BBitmap* bitmap,
                                                        int pageHeight);

        // Is there a next line?
                        bool            HasNextLine();
        // Rasterizes the next line and returns the line.
                        const void*     RasterizeNextLine();
        
        // Iterates over all lines.
                        void            RasterizeBitmap();

        // Returns the Halftone object specified in the constructor
                        Halftone*       GetHalftone()
                                                {
                                                        return fHalftone;
                                                }
        // The bounds of the bitmap to be rasterized
                        RECT            GetBounds()
                                                {
                                                        return fBounds;
                                                }
        // The width (in pixels) of the bounds passed to Rasterized()
                        int                     GetWidth()
                                                {
                                                        return fWidth;
                                                }
        // The height (in pixels) of the bounds passed to Rasterize()
                        int                     GetHeight()
                                                {
                                                        return fHeight;
                                                }
        // Returns the current x position
                        int                     GetX()
                                                {
                                                        return fX;
                                                }
        // Returns the current y position
                        int                     GetY()
                                                {
                                                        return fY;
                                                }
        
        // The method is called for each line in the bitmap.
        virtual const void*     RasterizeLine(int x, int y,
                                                        const ColorRGB32Little* source) = 0;

        // Returns the number of bytes to store widthInPixels pixels with
        // BPP = bitsPerPixel and padBytes number of pad bytes.
        static  int                     RowBufferSize(int widthInPixels, int bitsPerPixel,
                                                        int padBytes = 1)
                                                {
                                                        int sizeInBytes = (widthInPixels * bitsPerPixel + 7)
                                                                / 8;
                                                        return padBytes * ((sizeInBytes + padBytes - 1)
                                                                / padBytes);
                                                }

private:
                        Halftone*       fHalftone;

                        RECT            fBounds;
                        int                     fWidth;
                        int                     fHeight;
                        int                     fX;
                        int                     fY;

                        const uchar* fBits;
                        int                     fBPR;
                        int                     fIndex;
};

#endif // _RASTERIZER_H