ViewVC Help

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

root/cebix/BasiliskII/src/SDL/video_sdl.cpp

Comparing BasiliskII/src/SDL/video_sdl.cpp (file contents):
Revision 1.35 by asvitkine, 2008-06-20T00:45:27Z vs.
Revision 1.40 by asvitkine, 2011-12-28T21:35:42Z

#	Line 625 | Line 625 | public:
625		class driver_window;
626		static void update_display_window_vosf(driver_window *drv);
627		static void update_display_dynamic(int ticker, driver_window *drv);
628	<	static void update_display_static(driver_window *drv);
628	>	static void update_display_static(driver_base *drv);
629
630		class driver_window : public driver_base {
631		friend void update_display_window_vosf(driver_window *drv);
632		friend void update_display_dynamic(int ticker, driver_window *drv);
633	<	friend void update_display_static(driver_window *drv);
633	>	friend void update_display_static(driver_base *drv);
634
635		public:
636		driver_window(SDL_monitor_desc &monitor);
#	Line 1238 | Line 1238 | bool VideoInit(bool classic)
1238		continue;
1239		if (w == 512 && h == 384)
1240		continue;
1241	–	#ifdef ENABLE_VOSF
1241		for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1242		add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1244	–	#else
1245	–	add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)default_depth), default_depth);
1246	–	#endif
1243		}
1244		}
1245
#	Line 1543 | Line 1539 | void SDL_monitor_desc::switch_to_current
1539		#ifdef SHEEPSHAVER
1540		bool video_can_change_cursor(void)
1541		{
1542	<	return (display_type == DISPLAY_WINDOW);
1542	>	static char driver[] = "Quartz?";
1543	>	static int quartzok = -1;
1544	>
1545	>	if (display_type != DISPLAY_WINDOW)
1546	>	return false;
1547	>
1548	>	if (quartzok < 0) {
1549	>	if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1550	>	quartzok = true;
1551	>	else {
1552	>	// Quartz driver bug prevents cursor changing in SDL 1.2.11 to 1.2.13.
1553	>	const SDL_version *vp = SDL_Linked_Version();
1554	>	int version = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch);
1555	>	quartzok = (version <= SDL_VERSIONNUM(1, 2, 10) || version >= SDL_VERSIONNUM(1, 2, 14));
1556	>	}
1557	>	}
1558	>
1559	>	return quartzok;
1560		}
1561		#endif
1562
#	Line 1754 | Line 1767 | static void handle_events(void)
1767		// Mouse button
1768		case SDL_MOUSEBUTTONDOWN: {
1769		unsigned int button = event.button.button;
1770	<	if (button < 4)
1771	<	ADBMouseDown(button - 1);
1770	>	if (button == SDL_BUTTON_LEFT)
1771	>	ADBMouseDown(0);
1772	>	else if (button == SDL_BUTTON_RIGHT)
1773	>	ADBMouseDown(1);
1774	>	else if (button == SDL_BUTTON_MIDDLE)
1775	>	ADBMouseDown(2);
1776		else if (button < 6) {  // Wheel mouse
1777		if (mouse_wheel_mode == 0) {
1778		int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
#	Line 1773 | Line 1790 | static void handle_events(void)
1790		}
1791		case SDL_MOUSEBUTTONUP: {
1792		unsigned int button = event.button.button;
1793	<	if (button < 4)
1794	<	ADBMouseUp(button - 1);
1793	>	if (button == SDL_BUTTON_LEFT)
1794	>	ADBMouseUp(0);
1795	>	else if (button == SDL_BUTTON_RIGHT)
1796	>	ADBMouseUp(1);
1797	>	else if (button == SDL_BUTTON_MIDDLE)
1798	>	ADBMouseUp(2);
1799		break;
1800		}
1801
#	Line 1873 | Line 1894 | static void handle_events(void)
1894		*/
1895
1896		// Static display update (fixed frame rate, but incremental)
1897	<	static void update_display_static(driver_window *drv)
1897	>	static void update_display_static(driver_base *drv)
1898		{
1899		// Incremental update code
1900		int wide = 0, high = 0, x1, x2, y1, y2, i, j;
#	Line 1962 | Line 1983 | static void update_display_static(driver
1983
1984		} else {
1985		const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1986	+	const int dst_bytes_per_row = drv->s->pitch;
1987
1988		x1 = VIDEO_MODE_X;
1989		for (j=y1; j<=y2; j++) {
#	Line 2002 | Line 2024 | static void update_display_static(driver
2024		// Blit to screen surface
2025		for (j=y1; j<=y2; j++) {
2026		i = j * bytes_per_row + x1 * bytes_per_pixel;
2027	+	int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2028		memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2029	<	Screen_blit((uint8 *)drv->s->pixels + i, the_buffer + i, bytes_per_pixel * wide);
2029	>	Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2030		}
2031
2032		// Unlock surface, if required
#	Line 2019 | Line 2042 | static void update_display_static(driver
2042
2043		// Static display update (fixed frame rate, bounding boxes based)
2044		// XXX use NQD bounding boxes to help detect dirty areas?
2045	<	static void update_display_static_bbox(driver_window *drv)
2045	>	static void update_display_static_bbox(driver_base *drv)
2046		{
2047		const VIDEO_MODE &mode = drv->mode;
2048
#	Line 2037 | Line 2060 | static void update_display_static_bbox(d
2060		// Update the surface from Mac screen
2061		const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2062		const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2063	+	const int dst_bytes_per_row = drv->s->pitch;
2064		int x, y;
2065		for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2066		int h = N_PIXELS;
#	Line 2051 | Line 2075 | static void update_display_static_bbox(d
2075		bool dirty = false;
2076		for (int j = y; j < (y + h); j++) {
2077		const int yb = j * bytes_per_row;
2078	+	const int dst_yb = j * dst_bytes_per_row;
2079		if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2080		memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2081	<	Screen_blit((uint8 *)drv->s->pixels + yb + xb, the_buffer + yb + xb, xs);
2081	>	Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2082		dirty = true;
2083		}
2084		}
#	Line 2117 | Line 2142 | static inline void handle_palette_change
2142		UNLOCK_PALETTE;
2143		}
2144
2145	+	static void video_refresh_window_static(void);
2146	+
2147		static void video_refresh_dga(void)
2148		{
2149		// Quit DGA mode if requested
2150		possibly_quit_dga_mode();
2151	+	video_refresh_window_static();
2152		}
2153
2154		#ifdef ENABLE_VOSF
#	Line 2172 | Line 2200 | static void video_refresh_window_static(
2200		tick_counter = 0;
2201		const VIDEO_MODE &mode = drv->mode;
2202		if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2203	<	update_display_static_bbox(static_cast<driver_window *>(drv));
2203	>	update_display_static_bbox(drv);
2204		else
2205	<	update_display_static(static_cast<driver_window *>(drv));
2205	>	update_display_static(drv);
2206		}
2207		}
2208
#	Line 2220 | Line 2248 | static inline void do_video_refresh(void
2248		SDL_FreeCursor(sdl_cursor);
2249		sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2250		if (sdl_cursor) {
2251	+	SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2252		SDL_SetCursor(sdl_cursor);
2253		#ifdef WIN32
2254		// XXX Windows apparently needs an extra mouse event to
#	Line 2299 | Line 2328 | static int redraw_func(void *arg)
2328		#ifdef SHEEPSHAVER
2329		void video_set_dirty_area(int x, int y, int w, int h)
2330		{
2331	+	#ifdef ENABLE_VOSF
2332		const VIDEO_MODE &mode = drv->mode;
2333		const int screen_width = VIDEO_MODE_X;
2334		const int screen_height = VIDEO_MODE_Y;
2335		const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2336
2307	–	#ifdef ENABLE_VOSF
2337		if (use_vosf) {
2338		vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2339		return;

Diff Legend

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