haiku/headers/os/interface/Screen.h

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


#include <Accelerant.h>
#include <GraphicsDefs.h>
#include <Rect.h>
#include <OS.h>


class BBitmap;
class BWindow;

namespace BPrivate {
	class BPrivateScreen;
}


class BScreen {
public:  
								BScreen(screen_id id = B_MAIN_SCREEN_ID);
								BScreen(BWindow* window);
								~BScreen();

			bool				IsValid();
			status_t			SetToNext();

			color_space			ColorSpace();
			BRect				Frame();
			screen_id			ID();

			status_t			WaitForRetrace();
			status_t			WaitForRetrace(bigtime_t timeout);

			uint8				IndexForColor(rgb_color color);
			uint8				IndexForColor(uint8 red, uint8 green,
									uint8 blue, uint8 alpha = 255);
			rgb_color			ColorForIndex(uint8 index);
			uint8				InvertIndex(uint8 index);

			const color_map*	ColorMap();

			status_t			GetBitmap(BBitmap** _bitmap,
									bool drawCursor = true,
									BRect* frame = NULL);
			status_t			ReadBitmap(BBitmap* bitmap,
									bool drawCursor = true,
									BRect* frame = NULL);

			rgb_color			DesktopColor();
			rgb_color			DesktopColor(uint32 workspace);
			void				SetDesktopColor(rgb_color color,
									bool stick = true);
			void				SetDesktopColor(rgb_color color,
									uint32 workspace, bool stick = true);

			status_t			ProposeMode(display_mode* target,
									const display_mode* low,
									const display_mode* high);
			status_t			GetModeList(display_mode** _modeList,
									uint32* _count);
			status_t			GetMode(display_mode* mode);
			status_t			GetMode(uint32 workspace,
									display_mode* mode);
			status_t			SetMode(display_mode* mode,
									bool makeDefault = false);
			status_t			SetMode(uint32 workspace,
									display_mode* mode,
									bool makeDefault = false);
			status_t			GetDeviceInfo(accelerant_device_info* info);
			status_t			GetMonitorInfo(monitor_info* info);
			status_t			GetPixelClockLimits(display_mode* mode,
									uint32* _low, uint32* _high);
			status_t			GetTimingConstraints(
									display_timing_constraints*
										timingConstraints);
			status_t			SetDPMS(uint32 state);
			uint32				DPMSState();
			uint32				DPMSCapabilites();

			status_t			GetBrightness(float* brightness);
			status_t			SetBrightness(float brightness);

private:
	// Forbidden and deprecated methods
								BScreen(const BScreen& other);
			BScreen&			operator=(const BScreen& other);

			BPrivate::BPrivateScreen* private_screen();
			status_t			ProposeDisplayMode(display_mode* target,
									const display_mode* low,
									const display_mode* high);
			void*				BaseAddress();
			uint32				BytesPerRow();

private:
			BPrivate::BPrivateScreen* fScreen;
};


inline uint8
BScreen::IndexForColor(rgb_color color)
{
	return IndexForColor(color.red, color.green, color.blue, color.alpha);
}

#endif // _SCREEN_H