haiku.git

/*
 * Copyright 2001-2007, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef	_BITMAP_H
#define	_BITMAP_H


#include <Archivable.h>
#include <InterfaceDefs.h>
#include <Rect.h>


enum {
	B_BITMAP_CLEAR_TO_WHITE				= 0x00000001,
	B_BITMAP_ACCEPTS_VIEWS				= 0x00000002,
	B_BITMAP_IS_AREA					= 0x00000004,
	B_BITMAP_IS_LOCKED					= 0x00000008 | B_BITMAP_IS_AREA,
	B_BITMAP_IS_CONTIGUOUS				= 0x00000010 | B_BITMAP_IS_LOCKED,
	B_BITMAP_IS_OFFSCREEN				= 0x00000020,
		// Offscreen but non-overlay bitmaps are not supported on Haiku,
		// but appearantly never were on BeOS either! The accelerant API
		// would need to be extended to so that the app_server can ask
		// the graphics driver to reserve memory for a bitmap and for this
		// to make any sense, an accelerated blit from this memory into
		// the framebuffer needs to be added to the API as well.
	B_BITMAP_WILL_OVERLAY				= 0x00000040 | B_BITMAP_IS_OFFSCREEN,
	B_BITMAP_RESERVE_OVERLAY_CHANNEL	= 0x00000080,

	// Haiku extensions:
	B_BITMAP_NO_SERVER_LINK				= 0x00000100,
		// Cheap to create, object will manage memory itself,
		// no BApplication needs to run, but one can't draw such
		// a BBitmap.
};

#define B_ANY_BYTES_PER_ROW	-1


class BBitmap : public BArchivable {
public:
								BBitmap(BRect bounds, uint32 flags,
									color_space colorSpace,
									int32 bytesPerRow = B_ANY_BYTES_PER_ROW,
									screen_id screenID = B_MAIN_SCREEN_ID);
								BBitmap(BRect bounds, color_space colorSpace,
									bool acceptsViews = false,
									bool needsContiguous = false);
								BBitmap(const BBitmap& source, uint32 flags);
								BBitmap(const BBitmap& source);
								BBitmap(const BBitmap* source,
									bool acceptsViews = false,
									bool needsContiguous = false);
	virtual						~BBitmap();

	// Archiving
								BBitmap(BMessage* data);
	static	BArchivable*		Instantiate(BMessage* data);
	virtual	status_t			Archive(BMessage* data, bool deep = true) const;

			status_t			InitCheck() const;
			bool				IsValid() const;

			status_t			LockBits(uint32* state = NULL);
			void				UnlockBits();

			void*				Bits() const;
			int32				BitsLength() const;
			int32				BytesPerRow() const;
			color_space			ColorSpace() const;
			BRect				Bounds() const;

			status_t			SetDrawingFlags(uint32 flags);
			uint32				Flags() const;

			status_t			ImportBits(const void* data, int32 length,
									int32 bpr, int32 offset,
									color_space colorSpace);
			status_t			ImportBits(const void* data, int32 length,
									int32 bpr, color_space colorSpace,
									BPoint from, BPoint to, BSize size);
			status_t			ImportBits(const BBitmap* bitmap);
			status_t			ImportBits(const BBitmap* bitmap, BPoint from,
									BPoint to, BSize size);

			status_t			GetOverlayRestrictions(
									overlay_restrictions* restrictions) const;

			bool				Lock();
			void				Unlock();
			bool				IsLocked() const;

			BBitmap&			operator=(const BBitmap& source);

	class Private;

public:
	// deprecated
			void				SetBits(const void* data, int32 length,
									int32 offset, color_space colorSpace);

private:
			status_t			ImportBits(const void* data, int32 length,
									int32 bpr, color_space colorSpace,
									BPoint from, BPoint to, int32 width, int32 height);
			status_t			ImportBits(const BBitmap* bitmap, BPoint from,
									BPoint to, int32 width, int32 height);

private:
	friend class Private;

	virtual	status_t			Perform(perform_code d, void* arg);
	virtual	void				_ReservedBitmap1();
	virtual	void				_ReservedBitmap2();
	virtual	void				_ReservedBitmap3();

			int32				_ServerToken() const;
			void				_InitObject(BRect bounds,
									color_space colorSpace, uint32 flags,
									int32 bytesPerRow, screen_id screenID);
			void				_CleanUp();
			void				_AssertPointer();

private:
			uint8*				fBasePointer;
			int32				fSize;
			color_space			fColorSpace;
			BRect				fBounds;
			int32				fBytesPerRow;
			int32				fServerToken;
			uint8				unused;
			uint32				fFlags;
			status_t			fInitError;
};

#endif	// _BITMAP_H