framebuffer.h

Go to the documentation of this file.

/*
 * File: framebuffer.h - Bitmap memory representation
 * Project: GED - bitmap editor (ICP)
 * Author: Kamil Dudka, xdudka00
 * Team: xdudka00, xfilak01, xhefka00, xhradi08
 * Created: 2006-03-10
 */

#ifndef FRAMEBUFFER_H
#define FRAMEBUFFER_H

struct Pixel {
        unsigned char red;
        unsigned char green;
        unsigned char blue;
        unsigned char alpha;    
};

struct BoxSize {
        int width;              
        int height;             

        BoxSize (): width(0), height(0) { }

        BoxSize (int x, int y): width(x), height(y) { }

        int nPixels () const { return width*height; }

        bool operator== (const BoxSize &b) const
        {
                return
                        width == b.width &&
                        height == b.height;
        }
        bool operator!= (const BoxSize &b) const { return !operator==(b); }
};

struct Point {
        int x;          
        int y;          

        Point (): x(0), y(0) { }

        Point (int ix, int iy): x(ix), y(iy) { }

        bool operator== (const Point &p) const { return x==p.x && y==p.y; }

        bool operator!= (const Point &p) const { return x!=p.x || y!=p.y; }

        Point &operator+= (const Point &p)
        {
                x += p.x;
                y += p.y;
                return  *this;
        }

        Point &operator-= (const Point &p)
        {
                x -= p.x;
                y -= p.y;
                return *this;
        }
};

inline Point operator+ (const Point &a, const Point &b) {
        Point tmp (a);
        return tmp+=b;
}

inline Point operator- (const Point &a, const Point &b) {
        Point tmp (a);
        return tmp-=b;
}

struct Rect {
        Point at;               
        BoxSize size;           

        Rect () { }

        Rect (Point p, BoxSize s): at(p), size(s) { }

        bool operator== (const Rect &r) const
        {
                return
                        at == r.at &&
                        size == r.size;
        }
        bool operator!= (const Rect &r) const { return !operator==(r); }
};

class FrameBuffer {
public:
        FrameBuffer (): _pBuff(0) { }

        FrameBuffer (const BoxSize &fbSize): _pBuff(0) { size (fbSize); }

        FrameBuffer (const FrameBuffer &fb);

        FrameBuffer &operator= (const FrameBuffer &fb);

        ~FrameBuffer () { delete[] _pBuff; }

        Pixel *pBuff ();

        void setPixel (Point pos, Pixel color);

        Pixel *operator[] (int y)
        {
                return pBuff() + y*_size.width;
        }

        const BoxSize &size () const { return _size; }

        void resize (const BoxSize &newSize);

        void size (const BoxSize &fbSize);

        const Rect &select () const { return _select; }

        void select (const Rect &selectRect);

        void unSelect ();

        class ErrUnalloc { };

        friend class SharedObject;              
        friend class SharedFrameBuffer;         

protected:
        Pixel *_pBuff;                          

private:
        BoxSize _size;
        Rect _select;
};

#endif

---