ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/AmigaOS/video_amiga.cpp

Comparing BasiliskII/src/AmigaOS/video_amiga.cpp (file contents):
Revision 1.4 by cebix, 2000-07-06T16:04:25Z vs.
Revision 1.24 by jlachmann, 2002-06-23T08:27:05Z

#	Line 1 | Line 1
1		/*
2		*  video_amiga.cpp - Video/graphics emulation, AmigaOS specific stuff
3		*
4	<	*  Basilisk II (C) 1997-2000 Christian Bauer
4	>	*  Basilisk II (C) 1997-2002 Christian Bauer
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 22 | Line 22
22		#include <intuition/intuition.h>
23		#include <graphics/rastport.h>
24		#include <graphics/gfx.h>
25	<	#include <cybergraphx/cybergraphics.h>
25	>	#include <cybergraphics/cybergraphics.h>
26		#include <dos/dostags.h>
27		#include <devices/timer.h>
28	+	#define __USE_SYSBASE
29		#include <proto/exec.h>
30		#include <proto/dos.h>
31		#include <proto/intuition.h>
32		#include <proto/graphics.h>
33		#include <proto/Picasso96.h>
34		#include <proto/cybergraphics.h>
35	+	#include <inline/exec.h>
36	+	#include <inline/dos.h>
37	+	#include <inline/intuition.h>
38	+	#include <inline/Picasso96.h>
39	+	#include <inline/cybergraphics.h>
40
41		#include "sysdeps.h"
42	+	#include "cpu_emulation.h"
43		#include "main.h"
44		#include "adb.h"
45		#include "prefs.h"
#	Line 43 | Line 50
50		#include "debug.h"
51
52
53	+	// Supported video modes
54	+	static vector<video_mode> VideoModes;
55	+
56		// Display types
57		enum {
58		DISPLAY_WINDOW,
59		DISPLAY_PIP,
60	<	DISPLAY_SCREEN
60	>	DISPLAY_SCREEN_P96,
61	>	DISPLAY_SCREEN_CGFX
62		};
63
64		// Global variables
65		static int32 frame_skip;
66	<	static int display_type = DISPLAY_WINDOW;               // See enum above
67	<	static struct Screen *the_screen = NULL;
68	<	static struct Window *the_win = NULL;
58	<	static struct BitMap *the_bitmap = NULL;
59	<	static LONG black_pen = -1, white_pen = -1;
60	<	static struct Process *periodic_proc = NULL;    // Periodic process
61	<	static bool is_cgfx = false;                                    // Flag: screen mode is a CyberGfx mode
62	<	static bool is_p96 = false;                                             // Flag: screen mode is a Picasso96 mode
66	>	static UWORD *null_pointer = NULL;                      // Blank mouse pointer data
67	>	static UWORD *current_pointer = (UWORD *)-1;            // Currently visible mouse pointer data
68	>	static struct Process *periodic_proc = NULL;            // Periodic process
69
70	<	extern struct Task *MainTask;                                   // Pointer to main task (from main_amiga.cpp)
70	>	extern struct Task *MainTask;                           // Pointer to main task (from main_amiga.cpp)
71
72
73		// Amiga -> Mac raw keycode translation table
#	Line 85 | Line 91 | static const uint8 keycode2mac[0x80] = {
91		};
92
93
94	<	// Prototypes
95	<	static void periodic_func(void);
94	>	class Amiga_monitor_desc : public monitor_desc {
95	>	public:
96	>	Amiga_monitor_desc(const vector<video_mode> &available_modes, video_depth default_depth, uint32 default_id, int default_display_type)
97	>	:  monitor_desc(available_modes, default_depth, default_id), display_type(default_display_type) {};
98	>	~Amiga_monitor_desc() {};
99	>
100	>	virtual void switch_to_current_mode(void);
101	>	virtual void set_palette(uint8 *pal, int num);
102	>
103	>	bool video_open(void);
104	>	void video_close(void);
105	>	public:
106	>	int display_type;               // See enum above
107	>	};
108
109
110		/*
111	<	*  Initialization
111	>	*  Display "driver" classes
112		*/
113
114	<	// Open window
115	<	static bool init_window(int width, int height)
116	<	{
117	<	// Set absolute mouse mode
118	<	ADBSetRelMouseMode(false);
114	>	class driver_base {
115	>	public:
116	>	driver_base(Amiga_monitor_desc &m);
117	>	virtual ~driver_base();
118	>
119	>	virtual void set_palette(uint8 *pal, int num) {};
120	>	virtual struct BitMap *get_bitmap() { return NULL; };
121	>	public:
122	>	Amiga_monitor_desc &monitor;    // Associated video monitor
123	>	const video_mode &mode;         // Video mode handled by the driver
124	>	BOOL init_ok;                   // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer)
125	>	struct Window *the_win;
126	>	};
127
102	–	// Open window
103	–	the_win = OpenWindowTags(NULL,
104	–	WA_Left, 0, WA_Top, 0,
105	–	WA_InnerWidth, width, WA_InnerHeight, height,
106	–	WA_SimpleRefresh, TRUE,
107	–	WA_NoCareRefresh, TRUE,
108	–	WA_Activate, TRUE,
109	–	WA_RMBTrap, TRUE,
110	–	WA_ReportMouse, TRUE,
111	–	WA_DragBar, TRUE,
112	–	WA_DepthGadget, TRUE,
113	–	WA_SizeGadget, FALSE,
114	–	WA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
115	–	TAG_END
116	–	);
117	–	if (the_win == NULL) {
118	–	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
119	–	return false;
120	–	}
128
129	<	// Create bitmap ("height + 2" for safety)
130	<	the_bitmap = AllocBitMap(width, height + 2, 1, BMF_CLEAR, NULL);
131	<	if (the_bitmap == NULL) {
132	<	ErrorAlert(GetString(STR_NO_MEM_ERR));
133	<	return false;
134	<	}
129	>	class driver_window : public driver_base {
130	>	public:
131	>	driver_window(Amiga_monitor_desc &m, int width, int height);
132	>	~driver_window();
133	>
134	>	struct BitMap *get_bitmap() { return the_bitmap; };
135	>
136	>	private:
137	>	LONG black_pen, white_pen;
138	>	struct BitMap *the_bitmap;
139	>	};
140
141	<	// Set VideoMonitor
142	<	VideoMonitor.mac_frame_base = (uint32)the_bitmap->Planes[0];
143	<	VideoMonitor.bytes_per_row = the_bitmap->BytesPerRow;
144	<	VideoMonitor.x = width;
133	<	VideoMonitor.y = height;
134	<	VideoMonitor.mode = VMODE_1BIT;
141	>	class driver_pip : public driver_base {
142	>	public:
143	>	driver_pip(Amiga_monitor_desc &m, int width, int height);
144	>	~driver_pip();
145
146	<	// Set FgPen and BgPen
137	<	black_pen = ObtainBestPenA(the_win->WScreen->ViewPort.ColorMap, 0, 0, 0, NULL);
138	<	white_pen = ObtainBestPenA(the_win->WScreen->ViewPort.ColorMap, 0xffffffff, 0xffffffff, 0xffffffff, NULL);
139	<	SetAPen(the_win->RPort, black_pen);
140	<	SetBPen(the_win->RPort, white_pen);
141	<	SetDrMd(the_win->RPort, JAM2);
142	<	return true;
143	<	}
146	>	struct BitMap *get_bitmap() { return the_bitmap; };
147
148	<	// Open PIP (requires Picasso96)
149	<	static bool init_pip(int width, int height)
150	<	{
148	<	// Set absolute mouse mode
149	<	ADBSetRelMouseMode(false);
148	>	private:
149	>	struct BitMap *the_bitmap;
150	>	};
151
152	<	// Open window
153	<	ULONG error = 0;
154	<	the_win = p96PIP_OpenTags(
155	<	P96PIP_SourceFormat, RGBFB_R5G5B5,
155	<	P96PIP_SourceWidth, width,
156	<	P96PIP_SourceHeight, height,
157	<	P96PIP_ErrorCode, (ULONG)&error,
158	<	WA_Left, 0, WA_Top, 0,
159	<	WA_InnerWidth, width, WA_InnerHeight, height,
160	<	WA_SimpleRefresh, TRUE,
161	<	WA_NoCareRefresh, TRUE,
162	<	WA_Activate, TRUE,
163	<	WA_RMBTrap, TRUE,
164	<	WA_ReportMouse, TRUE,
165	<	WA_DragBar, TRUE,
166	<	WA_DepthGadget, TRUE,
167	<	WA_SizeGadget, FALSE,
168	<	WA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
169	<	WA_PubScreenName, (ULONG)"Workbench",
170	<	TAG_END
171	<	);
172	<	if (the_win == NULL || error) {
173	<	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
174	<	return false;
175	<	}
152	>	class driver_screen_p96 : public driver_base {
153	>	public:
154	>	driver_screen_p96(Amiga_monitor_desc &m, ULONG mode_id);
155	>	~driver_screen_p96();
156
157	<	// Find bitmap
178	<	p96PIP_GetTags(the_win, P96PIP_SourceBitMap, (ULONG)&the_bitmap, TAG_END);
157	>	void set_palette(uint8 *pal, int num);
158
159	<	// Set VideoMonitor
160	<	VideoMonitor.mac_frame_base = p96GetBitMapAttr(the_bitmap, P96BMA_MEMORY);
161	<	VideoMonitor.bytes_per_row = p96GetBitMapAttr(the_bitmap, P96BMA_BYTESPERROW);
183	<	VideoMonitor.x = width;
184	<	VideoMonitor.y = height;
185	<	VideoMonitor.mode = VMODE_16BIT;
186	<	return true;
187	<	}
159	>	private:
160	>	struct Screen *the_screen;
161	>	};
162
163	<	// Open screen (requires Picasso96/CyberGfx as we need chunky modes)
164	<	static bool init_screen(ULONG mode_id)
165	<	{
166	<	// Set relative mouse mode
193	<	ADBSetRelMouseMode(true);
163	>	class driver_screen_cgfx : public driver_base {
164	>	public:
165	>	driver_screen_cgfx(Amiga_monitor_desc &m, ULONG mode_id);
166	>	~driver_screen_cgfx();
167
168	<	// Check whether the mode is a Picasso96 mode or a CyberGfx mode
196	<	if (CyberGfxBase && IsCyberModeID(mode_id))
197	<	is_cgfx = true;
198	<	else if (P96Base && p96GetModeIDAttr(mode_id, P96IDA_ISP96))
199	<	is_p96 = true;
200	<	else {
201	<	ErrorAlert(GetString(STR_NO_P96_MODE_ERR));
202	<	return false;
203	<	}
168	>	void set_palette(uint8 *pal, int num);
169
170	<	uint32 depth;
171	<	uint32 format;
170	>	private:
171	>	struct Screen *the_screen;
172	>	};
173
208	–	// Check if the mode is one we can handle
209	–	if (is_p96) {
210	–	depth = p96GetModeIDAttr(mode_id, P96IDA_DEPTH);
211	–	format = p96GetModeIDAttr(mode_id, P96IDA_RGBFORMAT);
212	–	} else {
213	–	depth = GetCyberIDAttr(CYBRIDATTR_DEPTH, mode_id);
214	–	format = GetCyberIDAttr(CYBRIDATTR_PIXFMT, mode_id);
215	–	}
174
175	<	switch (depth) {
218	<	case 8:
219	<	VideoMonitor.mode = VMODE_8BIT;
220	<	break;
221	<	case 15:
222	<	case 16:
223	<	if (format != RGBFB_R5G5B5 && format != PIXFMT_RGB16) {
224	<	ErrorAlert(GetString(STR_WRONG_SCREEN_FORMAT_ERR));
225	<	return false;
226	<	}
227	<	VideoMonitor.mode = VMODE_16BIT;
228	<	break;
229	<	case 24:
230	<	case 32:
231	<	if (format != RGBFB_A8R8G8B8 && format != PIXFMT_ARGB32) {
232	<	ErrorAlert(GetString(STR_WRONG_SCREEN_FORMAT_ERR));
233	<	return false;
234	<	}
235	<	VideoMonitor.mode = VMODE_32BIT;
236	<	break;
237	<	default:
238	<	ErrorAlert(GetString(STR_WRONG_SCREEN_DEPTH_ERR));
239	<	return false;
240	<	}
175	>	static driver_base *drv = NULL; // Pointer to currently used driver object
176
242	–	// Yes, get width and height
243	–	uint32 width;
244	–	uint32 height;
177
246	–	if (is_p96) {
247	–	width = p96GetModeIDAttr(mode_id, P96IDA_WIDTH);
248	–	height = p96GetModeIDAttr(mode_id, P96IDA_HEIGHT);
249	–	} else {
250	–	width = GetCyberIDAttr(CYBRIDATTR_WIDTH, mode_id);
251	–	height = GetCyberIDAttr(CYBRIDATTR_HEIGHT, mode_id);
252	–	}
253	–	VideoMonitor.x = width;
254	–	VideoMonitor.y = height;
178
179	<	// Open screen
180	<	if (is_p96) {
181	<	the_screen = p96OpenScreenTags(
182	<	P96SA_DisplayID, mode_id,
183	<	P96SA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
184	<	P96SA_Quiet, TRUE,
185	<	P96SA_NoMemory, TRUE,
186	<	P96SA_NoSprite, TRUE,
187	<	P96SA_Exclusive, TRUE,
265	<	TAG_END
266	<	);
267	<	} else {
268	<	the_screen = OpenScreenTags(NULL,
269	<	SA_DisplayID, mode_id,
270	<	SA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
271	<	SA_Quiet, TRUE,
272	<	SA_Exclusive, TRUE,
273	<	TAG_END
274	<	);
275	<	}
179	>	// Prototypes
180	>	static void periodic_func(void);
181	>	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth);
182	>	static void add_modes(uint32 width, uint32 height, video_depth depth);
183	>	static ULONG find_mode_for_depth(uint32 width, uint32 height, uint32 depth);
184	>	static ULONG bits_from_depth(video_depth depth);
185	>	static bool is_valid_modeid(int display_type, ULONG mode_id);
186	>	static bool check_modeid_p96(ULONG mode_id);
187	>	static bool check_modeid_cgfx(ULONG mode_id);
188
277	–	if (the_screen == NULL) {
278	–	ErrorAlert(GetString(STR_OPEN_SCREEN_ERR));
279	–	return false;
280	–	}
189
190	<	// Open window
191	<	the_win = OpenWindowTags(NULL,
192	<	WA_Left, 0, WA_Top, 0,
285	<	WA_Width, width, WA_Height, height,
286	<	WA_NoCareRefresh, TRUE,
287	<	WA_Borderless, TRUE,
288	<	WA_Activate, TRUE,
289	<	WA_RMBTrap, TRUE,
290	<	WA_ReportMouse, TRUE,
291	<	WA_CustomScreen, (ULONG)the_screen,
292	<	TAG_END
293	<	);
294	<	if (the_win == NULL) {
295	<	ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
296	<	return false;
297	<	}
190	>	/*
191	>	*  Initialization
192	>	*/
193
299	–	// Set VideoMonitor
300	–	ScreenToFront(the_screen);
301	–	if (is_p96) {
302	–	VideoMonitor.mac_frame_base = p96GetBitMapAttr(the_screen->RastPort.BitMap, P96BMA_MEMORY);
303	–	VideoMonitor.bytes_per_row = p96GetBitMapAttr(the_screen->RastPort.BitMap, P96BMA_BYTESPERROW);
304	–	} else {
305	–	static UWORD ptr[] = { 0, 0, 0, 0 };
306	–	SetPointer(the_win, ptr, 0, 0, 0, 0);   // Hide Pointer
307	–
308	–	APTR handle = LockBitMapTags(the_screen->RastPort.BitMap,
309	–	LBMI_BASEADDRESS, (ULONG)&VideoMonitor.mac_frame_base,
310	–	TAG_END);
311	–	UnLockBitMap(handle);
312	–	VideoMonitor.bytes_per_row = GetCyberMapAttr(the_screen->RastPort.BitMap, CYBRMATTR_XMOD);
313	–	}
314	–	return true;
315	–	}
194
195		bool VideoInit(bool classic)
196		{
197	+	video_depth default_depth = VDEPTH_1BIT;
198	+	int default_width, default_height;
199	+	int default_display_type = DISPLAY_WINDOW;
200	+	int window_width, window_height;                        // width and height for window display
201	+	ULONG screen_mode_id;                           // mode ID for screen display
202	+
203	+	// Allocate blank mouse pointer data
204	+	null_pointer = (UWORD *)AllocMem(12, MEMF_PUBLIC | MEMF_CHIP | MEMF_CLEAR);
205	+	if (null_pointer == NULL) {
206	+	ErrorAlert(STR_NO_MEM_ERR);
207	+	return false;
208	+	}
209	+
210		// Read frame skip prefs
211		frame_skip = PrefsFindInt32("frameskip");
212		if (frame_skip == 0)
#	Line 328 | Line 219 | bool VideoInit(bool classic)
219		else
220		mode_str = PrefsFindString("screen");
221
222	<	// Determine type and mode
223	<	display_type = DISPLAY_WINDOW;
224	<	int width = 512, height = 384;
334	<	ULONG mode_id = 0;
222	>	default_width = window_width = 512;
223	>	default_height = window_height = 384;
224	>
225		if (mode_str) {
226	<	if (sscanf(mode_str, "win/%d/%d", &width, &height) == 2)
227	<	display_type = DISPLAY_WINDOW;
228	<	else if (sscanf(mode_str, "pip/%d/%d", &width, &height) == 2 && P96Base)
229	<	display_type = DISPLAY_PIP;
230	<	else if (sscanf(mode_str, "scr/%08lx", &mode_id) == 1 && (CyberGfxBase || P96Base))
231	<	display_type = DISPLAY_SCREEN;
226	>	if (sscanf(mode_str, "win/%d/%d", &window_width, &window_height) == 2)
227	>	default_display_type = DISPLAY_WINDOW;
228	>	else if (sscanf(mode_str, "pip/%d/%d", &window_width, &window_height) == 2 && P96Base)
229	>	default_display_type = DISPLAY_PIP;
230	>	else if (sscanf(mode_str, "scr/%08lx", &screen_mode_id) == 1 && (CyberGfxBase || P96Base)) {
231	>	if (P96Base && p96GetModeIDAttr(screen_mode_id, P96IDA_ISP96))
232	>	default_display_type = DISPLAY_SCREEN_P96;
233	>	else if (CyberGfxBase && IsCyberModeID(screen_mode_id))
234	>	default_display_type = DISPLAY_SCREEN_CGFX;
235	>	else {
236	>	ErrorAlert(STR_NO_P96_MODE_ERR);
237	>	return false;
238	>	}
239	>	}
240	>	}
241	>
242	>	D(bug("default_display_type %d, window_width %d, window_height %d\n", default_display_type, window_width, window_height));
243	>
244	>	// Construct list of supported modes
245	>	switch (default_display_type) {
246	>	case DISPLAY_WINDOW:
247	>	default_width = window_width;
248	>	default_height = window_height;
249	>	default_depth = VDEPTH_1BIT;
250	>	add_modes(window_width, window_height, VDEPTH_1BIT);
251	>	break;
252	>
253	>	case DISPLAY_PIP:
254	>	default_depth = VDEPTH_16BIT;
255	>	default_width = window_width;
256	>	default_height = window_height;
257	>	add_modes(window_width, window_height, VDEPTH_16BIT);
258	>	break;
259	>
260	>	case DISPLAY_SCREEN_P96:
261	>	case DISPLAY_SCREEN_CGFX:
262	>	struct DimensionInfo dimInfo;
263	>	DisplayInfoHandle handle = FindDisplayInfo(screen_mode_id);
264	>
265	>	if (handle == NULL)
266	>	return false;
267	>
268	>	if (GetDisplayInfoData(handle, (UBYTE *) &dimInfo, sizeof(dimInfo), DTAG_DIMS, 0) <= 0)
269	>	return false;
270	>
271	>	default_width = 1 + dimInfo.Nominal.MaxX - dimInfo.Nominal.MinX;
272	>	default_height = 1 + dimInfo.Nominal.MaxY - dimInfo.Nominal.MinY;
273	>
274	>	switch (dimInfo.MaxDepth)
275	>	{
276	>	case 1:
277	>	default_depth = VDEPTH_1BIT;
278	>	break;
279	>	case 8:
280	>	default_depth = VDEPTH_8BIT;
281	>	break;
282	>	case 15:
283	>	case 16:
284	>	default_depth = VDEPTH_16BIT;
285	>	break;
286	>	case 24:
287	>	case 32:
288	>	default_depth = VDEPTH_32BIT;
289	>	break;
290	>	}
291	>
292	>	for (unsigned d=VDEPTH_8BIT; d<=VDEPTH_32BIT; d++) {
293	>	ULONG mode_id = find_mode_for_depth(default_width, default_height, bits_from_depth(video_depth(d)));
294	>
295	>	if (is_valid_modeid(default_display_type, mode_id))
296	>	add_modes(default_width, default_height, video_depth(d));
297	>	}
298	>	break;
299	>	}
300	>
301	>	//      video_init_depth_list();
302	>
303	>	#if DEBUG
304	>	bug("Available video modes:\n");
305	>	vector<video_mode>::const_iterator i = VideoModes.begin(), end = VideoModes.end();
306	>	while (i != end) {
307	>	bug(" %ld x %ld (ID %02lx), %ld colors\n", i->x, i->y, i->resolution_id, 1 << bits_from_depth(i->depth));
308	>	++i;
309	>	}
310	>	#endif
311	>
312	>	D(bug("VideoInit/%ld: def_width=%ld  def_height=%ld  def_depth=%ld\n", \
313	>	__LINE__, default_width, default_height, default_depth));
314	>
315	>	// Find requested default mode and open display
316	>	if (VideoModes.size() == 1)
317	>	{
318	>	uint32 default_id ;
319	>
320	>	// Create Amiga_monitor_desc for this (the only) display
321	>	default_id = VideoModes[0].resolution_id;
322	>	D(bug("VideoInit/%ld: default_id=%ld\n", __LINE__, default_id));
323	>	Amiga_monitor_desc *monitor = new Amiga_monitor_desc(VideoModes, default_depth, default_id, default_display_type);
324	>	VideoMonitors.push_back(monitor);
325	>
326	>	// Open display
327	>	return monitor->video_open();
328	>	}
329	>	else {
330	>	// Find mode with specified dimensions
331	>	std::vector<video_mode>::const_iterator i, end = VideoModes.end();
332	>	for (i = VideoModes.begin(); i != end; ++i) {
333	>	D(bug("VideoInit/%ld: w=%ld  h=%ld  d=%ld\n", __LINE__, i->x, i->y, bits_from_depth(i->depth)));
334	>	if (i->x == default_width && i->y == default_height && i->depth == default_depth)
335	>	{
336	>	// Create Amiga_monitor_desc for this (the only) display
337	>	uint32 default_id = i->resolution_id;
338	>	D(bug("VideoInit/%ld: default_id=%ld\n", __LINE__, default_id));
339	>	Amiga_monitor_desc *monitor = new Amiga_monitor_desc(VideoModes, default_depth, default_id, default_display_type);
340	>	VideoMonitors.push_back(monitor);
341	>
342	>	// Open display
343	>	return monitor->video_open();
344	>	}
345	>	}
346	>
347	>	// Create Amiga_monitor_desc for this (the only) display
348	>	uint32 default_id = VideoModes[0].resolution_id;
349	>	D(bug("VideoInit/%ld: default_id=%ld\n", __LINE__, default_id));
350	>	Amiga_monitor_desc *monitor = new Amiga_monitor_desc(VideoModes, default_depth, default_id, default_display_type);
351	>	VideoMonitors.push_back(monitor);
352	>
353	>	// Open display
354	>	return monitor->video_open();
355		}
356
357	+	return true;
358	+	}
359	+
360	+
361	+	bool Amiga_monitor_desc::video_open()
362	+	{
363	+	const video_mode &mode = get_current_mode();
364	+	ULONG depth_bits = bits_from_depth(mode.depth);
365	+	ULONG ID = find_mode_for_depth(mode.x, mode.y, depth_bits);
366	+
367	+	D(bug("video_open/%ld: width=%ld  height=%ld  depth=%ld  ID=%08lx\n", __LINE__, mode.x, mode.y, depth_bits, ID));
368	+
369	+	if (ID == INVALID_ID) {
370	+	ErrorAlert(STR_NO_VIDEO_MODE_ERR);
371	+	return false;
372	+	}
373	+
374	+	//      VideoMonitor.mode = mode;
375	+
376	+	D(bug("video_open/%ld: display_type=%ld\n", __LINE__, display_type));
377	+
378		// Open display
379		switch (display_type) {
380		case DISPLAY_WINDOW:
381	<	if (!init_window(width, height))
348	<	return false;
381	>	drv = new driver_window(*this, mode.x, mode.y);
382		break;
383
384		case DISPLAY_PIP:
385	<	if (!init_pip(width, height))
353	<	return false;
385	>	drv = new driver_pip(*this, mode.x, mode.y);
386		break;
387
388	<	case DISPLAY_SCREEN:
389	<	if (!init_screen(mode_id))
390	<	return false;
388	>	case DISPLAY_SCREEN_P96:
389	>	drv = new driver_screen_p96(*this, ID);
390	>	break;
391	>
392	>	case DISPLAY_SCREEN_CGFX:
393	>	drv = new driver_screen_cgfx(*this, ID);
394		break;
395		}
396
397	+	D(bug("video_open/%ld: drv=%08lx\n", __LINE__, drv));
398	+
399	+	if (drv == NULL)
400	+	return false;
401	+
402	+	D(bug("video_open/%ld: init_ok=%ld\n", __LINE__, drv->init_ok));
403	+	if (!drv->init_ok) {
404	+	delete drv;
405	+	drv = NULL;
406	+	return false;
407	+	}
408	+
409		// Start periodic process
410		periodic_proc = CreateNewProcTags(
411		NP_Entry, (ULONG)periodic_func,
#	Line 366 | Line 413 | bool VideoInit(bool classic)
413		NP_Priority, 0,
414		TAG_END
415		);
416	+
417	+	D(bug("video_open/%ld: periodic_proc=%08lx\n", __LINE__, periodic_proc));
418	+
419		if (periodic_proc == NULL) {
420	<	ErrorAlert(GetString(STR_NO_MEM_ERR));
420	>	ErrorAlert(STR_NO_MEM_ERR);
421		return false;
422		}
423	+
424		return true;
425		}
426
427
428	<	/*
378	<	*  Deinitialization
379	<	*/
380	<
381	<	void VideoExit(void)
428	>	void Amiga_monitor_desc::video_close()
429		{
430		// Stop periodic process
431		if (periodic_proc) {
#	Line 387 | Line 434 | void VideoExit(void)
434		Wait(SIGF_SINGLE);
435		}
436
437	<	switch (display_type) {
437	>	delete drv;
438
439	<	case DISPLAY_WINDOW:
439	>	// Free mouse pointer
440	>	if (null_pointer) {
441	>	FreeMem(null_pointer, 12);
442	>	null_pointer = NULL;
443	>	}
444	>	}
445
394	–	// Window mode, free bitmap
395	–	if (the_bitmap) {
396	–	WaitBlit();
397	–	FreeBitMap(the_bitmap);
398	–	}
446
447	<	// Free pens and close window
448	<	if (the_win) {
449	<	ReleasePen(the_win->WScreen->ViewPort.ColorMap, black_pen);
403	<	ReleasePen(the_win->WScreen->ViewPort.ColorMap, white_pen);
447	>	/*
448	>	*  Deinitialization
449	>	*/
450
451	<	CloseWindow(the_win);
452	<	}
453	<	break;
451	>	void VideoExit(void)
452	>	{
453	>	// Close displays
454	>	vector<monitor_desc *>::iterator i, end = VideoMonitors.end();
455	>	for (i = VideoMonitors.begin(); i != end; ++i)
456	>	dynamic_cast<Amiga_monitor_desc *>(*i)->video_close();
457	>	}
458
409	–	case DISPLAY_PIP:
459
460	<	// Close PIP
461	<	if (the_win)
462	<	p96PIP_Close(the_win);
414	<	break;
460	>	/*
461	>	*  Set palette
462	>	*/
463
464	<	case DISPLAY_SCREEN:
464	>	void Amiga_monitor_desc::set_palette(uint8 *pal, int num)
465	>	{
466	>	drv->set_palette(pal, num);
467	>	}
468
418	–	// Close window
419	–	if (the_win)
420	–	CloseWindow(the_win);
469
470	<	// Close screen
471	<	if (the_screen) {
472	<	if (is_p96)
425	<	p96CloseScreen(the_screen);
426	<	else
427	<	CloseScreen(the_screen);
470	>	/*
471	>	*  Switch video mode
472	>	*/
473
474	<	the_screen = NULL;
475	<	}
476	<	break;
474	>	void Amiga_monitor_desc::switch_to_current_mode()
475	>	{
476	>	// Close and reopen display
477	>	video_close();
478	>	if (!video_open()) {
479	>	ErrorAlert(STR_OPEN_WINDOW_ERR);
480	>	QuitEmulator();
481		}
482		}
483
484
485		/*
486	<	*  Set palette
486	>	*  Close down full-screen mode (if bringing up error alerts is unsafe while in full-screen mode)
487		*/
488
489	<	void video_set_palette(uint8 *pal)
489	>	void VideoQuitFullScreen(void)
490		{
442	–	if (display_type == DISPLAY_SCREEN) {
443	–
444	–	// Convert palette to 32 bits
445	–	ULONG table[2 + 256 * 3];
446	–	table[0] = 256 << 16;
447	–	table[256 * 3 + 1] = 0;
448	–	for (int i=0; i<256; i++) {
449	–	table[i*3+1] = pal[i*3] * 0x01010101;
450	–	table[i*3+2] = pal[i*3+1] * 0x01010101;
451	–	table[i*3+3] = pal[i*3+2] * 0x01010101;
452	–	}
453	–
454	–	// And load it
455	–	LoadRGB32(&the_screen->ViewPort, table);
456	–	}
491		}
492
493
#	Line 477 | Line 511 | static __saveds void periodic_func(void)
511		struct IntuiMessage *msg;
512		ULONG win_mask = 0, timer_mask = 0;
513
514	+	D(bug("periodic_func/%ld: \n", __LINE__));
515	+
516		// Create message port for window and attach it
517		struct MsgPort *win_port = CreateMsgPort();
518		if (win_port) {
519		win_mask = 1 << win_port->mp_SigBit;
520	<	the_win->UserPort = win_port;
521	<	ModifyIDCMP(the_win, IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_RAWKEY | (display_type == DISPLAY_SCREEN ? IDCMP_DELTAMOVE : 0));
520	>	drv->the_win->UserPort = win_port;
521	>	ModifyIDCMP(drv->the_win, IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_RAWKEY |
522	>	((drv->monitor.display_type == DISPLAY_SCREEN_P96 || drv->monitor.display_type == DISPLAY_SCREEN_CGFX) ? IDCMP_DELTAMOVE : 0));
523		}
524
525	+	D(bug("periodic_func/%ld: \n", __LINE__));
526	+
527		// Start 60Hz timer for window refresh
528	<	if (display_type == DISPLAY_WINDOW) {
528	>	if (drv->monitor.display_type == DISPLAY_WINDOW) {
529		timer_port = CreateMsgPort();
530		if (timer_port) {
531		timer_io = (struct timerequest *)CreateIORequest(timer_port, sizeof(struct timerequest));
532		if (timer_io) {
533	<	if (!OpenDevice((UBYTE *)TIMERNAME, UNIT_MICROHZ, (struct IORequest *)timer_io, 0)) {
533	>	if (!OpenDevice((UBYTE *) TIMERNAME, UNIT_MICROHZ, (struct IORequest *)timer_io, 0)) {
534		timer_mask = 1 << timer_port->mp_SigBit;
535		timer_io->tr_node.io_Command = TR_ADDREQUEST;
536		timer_io->tr_time.tv_secs = 0;
#	Line 502 | Line 541 | static __saveds void periodic_func(void)
541		}
542		}
543
544	+	D(bug("periodic_func/%ld: \n", __LINE__));
545	+
546		// Main loop
547		for (;;) {
548	+	const video_mode &mode = drv->monitor.get_current_mode();
549
550		// Wait for timer and/or window (CTRL_C is used for quitting the task)
551		ULONG sig = Wait(win_mask | timer_mask | SIGBREAKF_CTRL_C);
#	Line 511 | Line 553 | static __saveds void periodic_func(void)
553		if (sig & SIGBREAKF_CTRL_C)
554		break;
555
556	<	if (sig & timer_mask) {
556	>	//              D(bug("periodic_func/%ld: display_type=%ld  the_win=%08lx\n", __LINE__, drv->monitor.display_type, drv->the_win));
557
558	<	// Timer tick, update display
559	<	BltTemplate(the_bitmap->Planes[0], 0, the_bitmap->BytesPerRow, the_win->RPort,
560	<	the_win->BorderLeft, the_win->BorderTop, VideoMonitor.x, VideoMonitor.y);
558	>	if (sig & timer_mask) {
559	>	if (drv->get_bitmap())
560	>	{
561	>	// Timer tick, update display
562	>	BltTemplate(drv->get_bitmap()->Planes[0], 0,
563	>	drv->get_bitmap()->BytesPerRow, drv->the_win->RPort,
564	>	drv->the_win->BorderLeft, drv->the_win->BorderTop,
565	>	mode.x, mode.y);
566	>	}
567
568		// Restart timer
569		timer_io->tr_node.io_Command = TR_ADDREQUEST;
#	Line 540 | Line 588 | static __saveds void periodic_func(void)
588		// Handle message according to class
589		switch (cl) {
590		case IDCMP_MOUSEMOVE:
591	<	if (display_type == DISPLAY_SCREEN)
591	>	switch (drv->monitor.display_type)
592	>	{
593	>	case DISPLAY_SCREEN_P96:
594	>	case DISPLAY_SCREEN_CGFX:
595	>	//                                                      D(bug("periodic_func/%ld: IDCMP_MOUSEMOVE mx=%ld  my=%ld\n", __LINE__, mx, my));
596		ADBMouseMoved(mx, my);
597	<	else
598	<	ADBMouseMoved(mx - the_win->BorderLeft, my - the_win->BorderTop);
597	>	break;
598	>	default:
599	>	//                                                      D(bug("periodic_func/%ld: IDCMP_MOUSEMOVE mx=%ld  my=%ld\n", __LINE__, mx - drv->the_win->BorderLeft, my - drv->the_win->BorderTop));
600	>	ADBMouseMoved(mx - drv->the_win->BorderLeft, my - drv->the_win->BorderTop);
601	>	if (mx < drv->the_win->BorderLeft
602	>	|| my < drv->the_win->BorderTop
603	>	|| mx >= drv->the_win->BorderLeft + mode.x
604	>	|| my >= drv->the_win->BorderTop + mode.y) {
605	>	if (current_pointer) {
606	>	ClearPointer(drv->the_win);
607	>	current_pointer = NULL;
608	>	}
609	>	} else {
610	>	if (current_pointer != null_pointer) {
611	>	// Hide mouse pointer inside window
612	>	SetPointer(drv->the_win, null_pointer, 1, 16, 0, 0);
613	>	current_pointer = null_pointer;
614	>	}
615	>	}
616	>	break;
617	>	}
618		break;
619
620		case IDCMP_MOUSEBUTTONS:
#	Line 564 | Line 635 | static __saveds void periodic_func(void)
635		case IDCMP_RAWKEY:
636		if (qualifier & IEQUALIFIER_REPEAT)     // Keyboard repeat is done by MacOS
637		break;
638	+	if ((qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_LSHIFT | IEQUALIFIER_CONTROL)) ==
639	+	(IEQUALIFIER_LALT | IEQUALIFIER_LSHIFT | IEQUALIFIER_CONTROL) && code == 0x5f) {
640	+	SetInterruptFlag(INTFLAG_NMI);
641	+	TriggerInterrupt();
642	+	break;
643	+	}
644	+
645		if (code & IECODE_UP_PREFIX)
646		ADBKeyUp(keycode2mac[code & 0x7f]);
647		else
#	Line 574 | Line 652 | static __saveds void periodic_func(void)
652		}
653		}
654
655	+	D(bug("periodic_func/%ld: \n", __LINE__));
656	+
657		// Stop timer
658		if (timer_io) {
659		if (!CheckIO((struct IORequest *)timer_io))
#	Line 590 | Line 670 | static __saveds void periodic_func(void)
670		msg = (struct IntuiMessage *)win_port->mp_MsgList.lh_Head;
671		struct Node *succ;
672		while (succ = msg->ExecMessage.mn_Node.ln_Succ) {
673	<	if (msg->IDCMPWindow == the_win) {
673	>	if (msg->IDCMPWindow == drv->the_win) {
674		Remove((struct Node *)msg);
675		ReplyMsg((struct Message *)msg);
676		}
677		msg = (struct IntuiMessage *)succ;
678		}
679	<	the_win->UserPort = NULL;
680	<	ModifyIDCMP(the_win, 0);
679	>	drv->the_win->UserPort = NULL;
680	>	ModifyIDCMP(drv->the_win, 0);
681		Permit();
682		DeleteMsgPort(win_port);
683
#	Line 605 | Line 685 | static __saveds void periodic_func(void)
685		Forbid();
686		Signal(MainTask, SIGF_SINGLE);
687		}
688	+
689	+
690	+	// Add mode to list of supported modes
691	+	static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth)
692	+	{
693	+	video_mode mode;
694	+	mode.x = width;
695	+	mode.y = height;
696	+	mode.resolution_id = resolution_id;
697	+	mode.bytes_per_row = bytes_per_row;
698	+	mode.depth = depth;
699	+
700	+	D(bug("Added video mode: w=%ld  h=%ld  d=%ld\n", width, height, depth));
701	+
702	+	VideoModes.push_back(mode);
703	+	}
704	+
705	+	// Add standard list of modes for given color depth
706	+	static void add_modes(uint32 width, uint32 height, video_depth depth)
707	+	{
708	+	D(bug("add_modes: w=%ld  h=%ld  d=%ld\n", width, height, depth));
709	+
710	+	if (width >= 512 && height >= 384)
711	+	add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth), depth);
712	+	if (width >= 640 && height >= 480)
713	+	add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth), depth);
714	+	if (width >= 800 && height >= 600)
715	+	add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth), depth);
716	+	if (width >= 1024 && height >= 768)
717	+	add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth), depth);
718	+	if (width >= 1152 && height >= 870)
719	+	add_mode(1152, 870, 0x84, TrivialBytesPerRow(1152, depth), depth);
720	+	if (width >= 1280 && height >= 1024)
721	+	add_mode(1280, 1024, 0x85, TrivialBytesPerRow(1280, depth), depth);
722	+	if (width >= 1600 && height >= 1200)
723	+	add_mode(1600, 1200, 0x86, TrivialBytesPerRow(1600, depth), depth);
724	+	}
725	+
726	+
727	+	static ULONG find_mode_for_depth(uint32 width, uint32 height, uint32 depth)
728	+	{
729	+	ULONG ID = BestModeID(BIDTAG_NominalWidth, width,
730	+	BIDTAG_NominalHeight, height,
731	+	BIDTAG_Depth, depth,
732	+	BIDTAG_DIPFMustNotHave, DIPF_IS_ECS | DIPF_IS_HAM | DIPF_IS_AA,
733	+	TAG_END);
734	+
735	+	return ID;
736	+	}
737	+
738	+
739	+	static ULONG bits_from_depth(video_depth depth)
740	+	{
741	+	int bits = 1 << depth;
742	+	if (bits == 16)
743	+	bits = 15;
744	+	else if (bits == 32)
745	+	bits = 24;
746	+
747	+	return bits;
748	+	}
749	+
750	+
751	+	static bool is_valid_modeid(int display_type, ULONG mode_id)
752	+	{
753	+	if (INVALID_ID == mode_id)
754	+	return false;
755	+
756	+	switch (display_type) {
757	+	case DISPLAY_SCREEN_P96:
758	+	return check_modeid_p96(mode_id);
759	+	break;
760	+	case DISPLAY_SCREEN_CGFX:
761	+	return check_modeid_cgfx(mode_id);
762	+	break;
763	+	default:
764	+	return false;
765	+	break;
766	+	}
767	+	}
768	+
769	+
770	+	static bool check_modeid_p96(ULONG mode_id)
771	+	{
772	+	// Check if the mode is one we can handle
773	+	uint32 depth = p96GetModeIDAttr(mode_id, P96IDA_DEPTH);
774	+	uint32 format = p96GetModeIDAttr(mode_id, P96IDA_RGBFORMAT);
775	+
776	+	D(bug("check_modeid_p96: mode_id=%08lx  depth=%ld  format=%ld\n", mode_id, depth, format));
777	+
778	+	if (!p96GetModeIDAttr(mode_id, P96IDA_ISP96))
779	+	return false;
780	+
781	+	switch (depth) {
782	+	case 8:
783	+	break;
784	+	case 15:
785	+	case 16:
786	+	if (format != RGBFB_R5G5B5)
787	+	return false;
788	+	break;
789	+	case 24:
790	+	case 32:
791	+	if (format != RGBFB_A8R8G8B8)
792	+	return false;
793	+	break;
794	+	default:
795	+	return false;
796	+	}
797	+
798	+	return true;
799	+	}
800	+
801	+
802	+	static bool check_modeid_cgfx(ULONG mode_id)
803	+	{
804	+	uint32 depth = GetCyberIDAttr(CYBRIDATTR_DEPTH, mode_id);
805	+	uint32 format = GetCyberIDAttr(CYBRIDATTR_PIXFMT, mode_id);
806	+
807	+	D(bug("check_modeid_cgfx: mode_id=%08lx  depth=%ld  format=%ld\n", mode_id, depth, format));
808	+
809	+	if (!IsCyberModeID(mode_id))
810	+	return false;
811	+
812	+	switch (depth) {
813	+	case 8:
814	+	break;
815	+	case 15:
816	+	case 16:
817	+	if (format != PIXFMT_RGB15)
818	+	return false;
819	+	break;
820	+	case 24:
821	+	case 32:
822	+	if (format != PIXFMT_ARGB32)
823	+	return false;
824	+	break;
825	+	default:
826	+	return false;
827	+	}
828	+
829	+	return true;
830	+	}
831	+
832	+
833	+	driver_base::driver_base(Amiga_monitor_desc &m)
834	+	: monitor(m), mode(m.get_current_mode()), init_ok(false)
835	+	{
836	+	}
837	+
838	+	driver_base::~driver_base()
839	+	{
840	+	}
841	+
842	+
843	+	// Open window
844	+	driver_window::driver_window(Amiga_monitor_desc &m, int width, int height)
845	+	: black_pen(-1), white_pen(-1), driver_base(m)
846	+	{
847	+	// Set relative mouse mode
848	+	ADBSetRelMouseMode(false);
849	+
850	+	// Open window
851	+	the_win = OpenWindowTags(NULL,
852	+	WA_Left, 0, WA_Top, 0,
853	+	WA_InnerWidth, width, WA_InnerHeight, height,
854	+	WA_SimpleRefresh, true,
855	+	WA_NoCareRefresh, true,
856	+	WA_Activate, true,
857	+	WA_RMBTrap, true,
858	+	WA_ReportMouse, true,
859	+	WA_DragBar, true,
860	+	WA_DepthGadget, true,
861	+	WA_SizeGadget, false,
862	+	WA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
863	+	TAG_END
864	+	);
865	+	if (the_win == NULL) {
866	+	init_ok = false;
867	+	ErrorAlert(STR_OPEN_WINDOW_ERR);
868	+	return;
869	+	}
870	+
871	+	// Create bitmap ("height + 2" for safety)
872	+	the_bitmap = AllocBitMap(width, height + 2, 1, BMF_CLEAR, NULL);
873	+	if (the_bitmap == NULL) {
874	+	init_ok = false;
875	+	ErrorAlert(STR_NO_MEM_ERR);
876	+	return;
877	+	}
878	+
879	+	// Add resolution and set VideoMonitor
880	+	monitor.set_mac_frame_base((uint32)the_bitmap->Planes[0]);
881	+
882	+	// Set FgPen and BgPen
883	+	black_pen = ObtainBestPenA(the_win->WScreen->ViewPort.ColorMap, 0, 0, 0, NULL);
884	+	white_pen = ObtainBestPenA(the_win->WScreen->ViewPort.ColorMap, 0xffffffff, 0xffffffff, 0xffffffff, NULL);
885	+	SetAPen(the_win->RPort, black_pen);
886	+	SetBPen(the_win->RPort, white_pen);
887	+	SetDrMd(the_win->RPort, JAM2);
888	+
889	+	init_ok = true;
890	+	}
891	+
892	+
893	+	driver_window::~driver_window()
894	+	{
895	+	// Window mode, free bitmap
896	+	if (the_bitmap) {
897	+	WaitBlit();
898	+	FreeBitMap(the_bitmap);
899	+	}
900	+
901	+	// Free pens and close window
902	+	if (the_win) {
903	+	ReleasePen(the_win->WScreen->ViewPort.ColorMap, black_pen);
904	+	ReleasePen(the_win->WScreen->ViewPort.ColorMap, white_pen);
905	+
906	+	CloseWindow(the_win);
907	+	the_win = NULL;
908	+	}
909	+	}
910	+
911	+
912	+	// Open PIP (requires Picasso96)
913	+	driver_pip::driver_pip(Amiga_monitor_desc &m, int width, int height)
914	+	: driver_base(m)
915	+	{
916	+	// Set relative mouse mode
917	+	ADBSetRelMouseMode(false);
918	+
919	+	// Open window
920	+	ULONG error = 0;
921	+	the_win = p96PIP_OpenTags(
922	+	P96PIP_SourceFormat, RGBFB_R5G5B5,
923	+	P96PIP_SourceWidth, width,
924	+	P96PIP_SourceHeight, height,
925	+	P96PIP_ErrorCode, (ULONG)&error,
926	+	WA_Left, 0, WA_Top, 0,
927	+	WA_InnerWidth, width, WA_InnerHeight, height,
928	+	WA_SimpleRefresh, true,
929	+	WA_NoCareRefresh, true,
930	+	WA_Activate, true,
931	+	WA_RMBTrap, true,
932	+	WA_ReportMouse, true,
933	+	WA_DragBar, true,
934	+	WA_DepthGadget, true,
935	+	WA_SizeGadget, false,
936	+	WA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
937	+	WA_PubScreenName, (ULONG)"Workbench",
938	+	TAG_END
939	+	);
940	+	if (the_win == NULL || error) {
941	+	init_ok = false;
942	+	ErrorAlert(STR_OPEN_WINDOW_ERR);
943	+	return;
944	+	}
945	+
946	+	// Find bitmap
947	+	p96PIP_GetTags(the_win, P96PIP_SourceBitMap, (ULONG)&the_bitmap, TAG_END);
948	+
949	+	// Add resolution and set VideoMonitor
950	+	monitor.set_mac_frame_base(p96GetBitMapAttr(the_bitmap, P96BMA_MEMORY));
951	+
952	+	init_ok = true;
953	+	}
954	+
955	+	driver_pip::~driver_pip()
956	+	{
957	+	// Close PIP
958	+	if (the_win)
959	+	p96PIP_Close(the_win);
960	+	}
961	+
962	+
963	+	// Open Picasso96 screen
964	+	driver_screen_p96::driver_screen_p96(Amiga_monitor_desc &m, ULONG mode_id)
965	+	: driver_base(m)
966	+	{
967	+	// Set absolute mouse mode
968	+	ADBSetRelMouseMode(true);
969	+
970	+	// Check if the mode is one we can handle
971	+	if (!check_modeid_p96(mode_id))
972	+	{
973	+	init_ok = false;
974	+	ErrorAlert(STR_WRONG_SCREEN_FORMAT_ERR);
975	+	return;
976	+	}
977	+
978	+	// Yes, get width and height
979	+	uint32 depth = p96GetModeIDAttr(mode_id, P96IDA_DEPTH);
980	+	uint32 width = p96GetModeIDAttr(mode_id, P96IDA_WIDTH);
981	+	uint32 height = p96GetModeIDAttr(mode_id, P96IDA_HEIGHT);
982	+
983	+	// Open screen
984	+	the_screen = p96OpenScreenTags(
985	+	P96SA_DisplayID, mode_id,
986	+	P96SA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
987	+	P96SA_Quiet, true,
988	+	P96SA_NoMemory, true,
989	+	P96SA_NoSprite, true,
990	+	P96SA_Exclusive, true,
991	+	TAG_END
992	+	);
993	+	if (the_screen == NULL) {
994	+	ErrorAlert(STR_OPEN_SCREEN_ERR);
995	+	init_ok = false;
996	+	return;
997	+	}
998	+
999	+	// Open window
1000	+	the_win = OpenWindowTags(NULL,
1001	+	WA_Left, 0, WA_Top, 0,
1002	+	WA_Width, width, WA_Height, height,
1003	+	WA_SimpleRefresh, true,
1004	+	WA_NoCareRefresh, true,
1005	+	WA_Borderless, true,
1006	+	WA_Activate, true,
1007	+	WA_RMBTrap, true,
1008	+	WA_ReportMouse, true,
1009	+	WA_CustomScreen, (ULONG)the_screen,
1010	+	TAG_END
1011	+	);
1012	+	if (the_win == NULL) {
1013	+	ErrorAlert(STR_OPEN_WINDOW_ERR);
1014	+	init_ok = false;
1015	+	return;
1016	+	}
1017	+
1018	+	ScreenToFront(the_screen);
1019	+
1020	+	// Add resolution and set VideoMonitor
1021	+	monitor.set_mac_frame_base(p96GetBitMapAttr(the_screen->RastPort.BitMap, P96BMA_MEMORY));
1022	+
1023	+	init_ok = true;
1024	+	}
1025	+
1026	+
1027	+	driver_screen_p96::~driver_screen_p96()
1028	+	{
1029	+	// Close window
1030	+	if (the_win)
1031	+	{
1032	+	CloseWindow(the_win);
1033	+	the_win = NULL;
1034	+	}
1035	+
1036	+	// Close screen
1037	+	if (the_screen) {
1038	+	p96CloseScreen(the_screen);
1039	+	the_screen = NULL;
1040	+	}
1041	+	}
1042	+
1043	+
1044	+	void driver_screen_p96::set_palette(uint8 *pal, int num)
1045	+	{
1046	+	// Convert palette to 32 bits
1047	+	ULONG table[2 + 256 * 3];
1048	+	table[0] = num << 16;
1049	+	table[num * 3 + 1] = 0;
1050	+	for (int i=0; i<num; i++) {
1051	+	table[i*3+1] = pal[i*3] * 0x01010101;
1052	+	table[i*3+2] = pal[i*3+1] * 0x01010101;
1053	+	table[i*3+3] = pal[i*3+2] * 0x01010101;
1054	+	}
1055	+
1056	+	// And load it
1057	+	LoadRGB32(&the_screen->ViewPort, table);
1058	+	}
1059	+
1060	+
1061	+	// Open CyberGraphX screen
1062	+	driver_screen_cgfx::driver_screen_cgfx(Amiga_monitor_desc &m, ULONG mode_id)
1063	+	: driver_base(m)
1064	+	{
1065	+	D(bug("driver_screen_cgfx/%ld: mode_id=%08lx\n", __LINE__, mode_id));
1066	+
1067	+	// Set absolute mouse mode
1068	+	ADBSetRelMouseMode(true);
1069	+
1070	+	// Check if the mode is one we can handle
1071	+	if (!check_modeid_cgfx(mode_id))
1072	+	{
1073	+	ErrorAlert(STR_WRONG_SCREEN_FORMAT_ERR);
1074	+	init_ok = false;
1075	+	return;
1076	+	}
1077	+
1078	+	// Yes, get width and height
1079	+	uint32 depth = GetCyberIDAttr(CYBRIDATTR_DEPTH, mode_id);
1080	+	uint32 width = GetCyberIDAttr(CYBRIDATTR_WIDTH, mode_id);
1081	+	uint32 height = GetCyberIDAttr(CYBRIDATTR_HEIGHT, mode_id);
1082	+
1083	+	// Open screen
1084	+	the_screen = OpenScreenTags(NULL,
1085	+	SA_DisplayID, mode_id,
1086	+	SA_Title, (ULONG)GetString(STR_WINDOW_TITLE),
1087	+	SA_Quiet, true,
1088	+	SA_Exclusive, true,
1089	+	TAG_END
1090	+	);
1091	+	if (the_screen == NULL) {
1092	+	ErrorAlert(STR_OPEN_SCREEN_ERR);
1093	+	init_ok = false;
1094	+	return;
1095	+	}
1096	+
1097	+	// Open window
1098	+	the_win = OpenWindowTags(NULL,
1099	+	WA_Left, 0, WA_Top, 0,
1100	+	WA_Width, width, WA_Height, height,
1101	+	WA_SimpleRefresh, true,
1102	+	WA_NoCareRefresh, true,
1103	+	WA_Borderless, true,
1104	+	WA_Activate, true,
1105	+	WA_RMBTrap, true,
1106	+	WA_ReportMouse, true,
1107	+	WA_CustomScreen, (ULONG)the_screen,
1108	+	TAG_END
1109	+	);
1110	+	if (the_win == NULL) {
1111	+	ErrorAlert(STR_OPEN_WINDOW_ERR);
1112	+	init_ok = false;
1113	+	return;
1114	+	}
1115	+
1116	+	ScreenToFront(the_screen);
1117	+	static UWORD ptr[] = { 0, 0, 0, 0 };
1118	+	SetPointer(the_win, ptr, 0, 0, 0, 0);   // Hide mouse pointer
1119	+
1120	+	// Set VideoMonitor
1121	+	ULONG frame_base;
1122	+	APTR handle = LockBitMapTags(the_screen->RastPort.BitMap,
1123	+	LBMI_BASEADDRESS, (ULONG)&frame_base,
1124	+	TAG_END
1125	+	);
1126	+	UnLockBitMap(handle);
1127	+
1128	+	D(bug("driver_screen_cgfx/%ld: frame_base=%08lx\n", __LINE__, frame_base));
1129	+
1130	+	monitor.set_mac_frame_base(frame_base);
1131	+
1132	+	init_ok = true;
1133	+	}
1134	+
1135	+
1136	+	driver_screen_cgfx::~driver_screen_cgfx()
1137	+	{
1138	+	D(bug("~driver_screen_cgfx/%ld: \n", __LINE__));
1139	+
1140	+	// Close window
1141	+	if (the_win)
1142	+	{
1143	+	CloseWindow(the_win);
1144	+	the_win = NULL;
1145	+	}
1146	+
1147	+	// Close screen
1148	+	if (the_screen) {
1149	+	CloseScreen(the_screen);
1150	+	the_screen = NULL;
1151	+	}
1152	+	}
1153	+
1154	+
1155	+	void driver_screen_cgfx::set_palette(uint8 *pal, int num)
1156	+	{
1157	+	// Convert palette to 32 bits
1158	+	ULONG table[2 + 256 * 3];
1159	+	table[0] = num << 16;
1160	+	table[num * 3 + 1] = 0;
1161	+	for (int i=0; i<num; i++) {
1162	+	table[i*3+1] = pal[i*3] * 0x01010101;
1163	+	table[i*3+2] = pal[i*3+1] * 0x01010101;
1164	+	table[i*3+3] = pal[i*3+2] * 0x01010101;
1165	+	}
1166	+
1167	+	// And load it
1168	+	LoadRGB32(&the_screen->ViewPort, table);
1169	+	}
1170	+

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines