Previous

199869 Revisions

Next

r35216 Sunday 22nd February, 2015 at 16:37:46 UTC by Couriersud
Fix 32bit build of sdlmame on Win32. (nw)

[src/emu/bus/gamegear]	ggext.c ggext.h smsctrladp.h
[src/emu/bus/sega8]	sega8_slot.c
[src/emu/bus/sms_ctrl]	lphaser.c
[src/emu/debug]	dvbpoints.c dvbpoints.h dvwpoints.c dvwpoints.h
[src/emu/video]	315_5124.c 315_5124.h
[src/mame/drivers]	bfm_sc1.c mpu4avan.c mpu4bwb.c mpu4concept.c mpu4crystal.c mpu4empire.c mpu4mdm.c mpu4misc.c mpu4mod2sw.c mpu4plasma.c mpu4sw.c mpu4union.c sumt8035.c vaportra.c wms.c
[src/mess/includes]	sms.h
[src/mess/machine]	sms.c
[src/osd/modules/debugger/osx]	breakpointsview.m consoleview.m debugview.h debugview.m debugwindowhandler.m disassemblyview.m errorlogview.m memoryview.m registersview.m watchpointsview.m
[src/osd/sdl]	sdl.mak

trunk/src/emu/bus/gamegear/ggext.c

r243727	r243728
1	1	/**********************************************************************
2	2
3	3	Sega Game Gear EXT port emulation
4		Also known as Gear-to-Gear (or VS, in Japan) cable connector
5	4
6	5	Copyright MESS Team.
7	6	Visit http://mamedev.org for licensing and usage restrictions.

trunk/src/emu/bus/gamegear/ggext.h

r243727	r243728
1	1	/**********************************************************************
2	2
3	3	Sega Game Gear EXT port emulation
4		Also known as Gear-to-Gear (or VS, in Japan) cable connector
5	4
6	5	Copyright MESS Team.
7	6	Visit http://mamedev.org for licensing and usage restrictions.

trunk/src/emu/bus/gamegear/smsctrladp.h

r243727	r243728
16	16
17	17	#include "emu.h"
18	18	#include "ggext.h"
19		#include "bus/sms_ctrl/smsctrl.h"
	19	#include "../sms_ctrl/smsctrl.h"
20	20
21	21
22	22

trunk/src/emu/bus/sega8/sega8_slot.c

r243727	r243728
253	253	{
254	254	if (!memcmp(&rom[0x7ff0], signatures[0], 16) || !memcmp(&rom[0x7ff0], signatures[1], 16))
255	255	xoff = 26;
256		else if (!memcmp(&rom[0x7ff0], signatures[2], 16))
	256
	257	if (!memcmp(&rom[0x7ff0], signatures[2], 16))
257	258	xoff = 36;
258		else if (!memcmp(&rom[0x7ff0], signatures[3], 16))
	259
	260	if (!memcmp(&rom[0x7ff0], signatures[3], 16))
259	261	xoff = 32;
260		else if (!memcmp(&rom[0x7ff0], signatures[4], 16))
	262
	263	if (!memcmp(&rom[0x7ff0], signatures[4], 16))
261	264	xoff = 30;
262		else if (!memcmp(&rom[0x7ff0], signatures[5], 16))
	265
	266	if (!memcmp(&rom[0x7ff0], signatures[5], 16))
263	267	xoff = 39;
264		else if (!memcmp(&rom[0x7ff0], signatures[6], 16))
	268
	269	if (!memcmp(&rom[0x7ff0], signatures[6], 16))
265	270	xoff = 38;
266	271	}
267	272

trunk/src/emu/bus/sms_ctrl/lphaser.c

r243727	r243728
137	137	{
138	138	const int r_x_r = LGUN_RADIUS * LGUN_RADIUS;
139	139	const rectangle &visarea = m_screen->visible_area();
140		rectangle aim_area;
141	140	int beam_x = m_screen->hpos();
142	141	int beam_y = m_screen->vpos();
143		int beam_x_orig = beam_x;
144		int beam_y_orig = beam_y;
145		int dy, result = 1;
	142	int dx, dy;
	143	int result = 1;
	144	int pos_changed = 0;
146	145	double dx_radius;
147		bool new_check_point = false;
148	146
149		aim_area.min_y = MAX(lgun_y - LGUN_RADIUS, visarea.min_y);
150		aim_area.max_y = MIN(lgun_y + LGUN_RADIUS, visarea.max_y);
151
152		while (!new_check_point)
	147	while (1)
153	148	{
154		/* If beam's y doesn't point to a line where the aim area is,
155		change it to the first line where the beam enters that area. */
156		if (beam_y < aim_area.min_y || beam_y > aim_area.max_y)
	149	/* If beam's y isn't at a line where the aim area is, change it
	150	the next line it enters that area. */
	151	dy = abs(beam_y - lgun_y);
	152	if (dy > LGUN_RADIUS || beam_y < visarea.min_y || beam_y > visarea.max_y)
157	153	{
158		beam_y = aim_area.min_y;
	154	beam_y = lgun_y - LGUN_RADIUS;
	155	if (beam_y < visarea.min_y)
	156	beam_y = visarea.min_y;
	157	dy = abs(beam_y - lgun_y);
	158	pos_changed = 1;
159	159	}
160		dy = abs(beam_y - lgun_y);
161	160
162	161	/* Caculate distance in x of the radius, relative to beam's y distance.
163	162	First try some shortcuts. */
r243727	r243728
176	175	dx_radius = ceil((float) sqrt((float) (r_x_r - (dy * dy))));
177	176	}
178	177
179		aim_area.min_x = MAX(lgun_x - dx_radius, visarea.min_x);
180		aim_area.max_x = MIN(lgun_x + dx_radius, visarea.max_x);
181
182		while (!new_check_point)
	178	/* If beam's x isn't in the circular aim area, change it
	179	to the next point it enters that area. */
	180	dx = abs(beam_x - lgun_x);
	181	if (dx > dx_radius || beam_x < visarea.min_x || beam_x > visarea.max_x)
183	182	{
184		/* If beam's x has passed the aim area, change it to the
185		next line and go back to recheck y/x coordinates. */
186		if (beam_x > aim_area.max_x)
	183	/* If beam's x has passed the aim area, advance to
	184	next line and recheck y/x coordinates. */
	185	if (beam_x > lgun_x)
187	186	{
188		beam_x = visarea.min_x;
	187	beam_x = 0;
189	188	beam_y++;
190		break;
	189	continue;
191	190	}
	191	beam_x = lgun_x - dx_radius;
	192	if (beam_x < visarea.min_x)
	193	beam_x = visarea.min_x;
	194	pos_changed = 1;
	195	}
192	196
193		/* If beam's x isn't in the aim area, change it to the
194		next point where the beam enters that area. */
195		if (beam_x < aim_area.min_x)
196		{
197		beam_x = aim_area.min_x;
198		}
	197	if (pos_changed)
	198	break;
199	199
200		if (beam_x_orig != beam_x || beam_y_orig != beam_y)
201		{
202		/* adopt the new coordinates to adjust the timer */
203		new_check_point = true;
204		break;
205		}
	200	if (m_sensor_last_state == 0) /* sensor is on */
	201	{
	202	/* keep sensor on until out of the aim area */
	203	result = 0;
	204	}
	205	else
	206	{
	207	rgb_t color;
	208	UINT8 brightness;
	209	/* brightness of the lightgray color in the frame drawn by Light Phaser games */
	210	const UINT8 sensor_min_brightness = 0x7f;
206	211
207		if (m_sensor_last_state == 0)
208		{
209		/* sensor is already on */
210		/* keep sensor on until out of the aim area */
211		result = 0;
212		}
213		else
214		{
215		rgb_t color;
216		UINT8 brightness;
217		/* brightness of the lightgray color in the frame drawn by Light Phaser games */
218		const UINT8 sensor_min_brightness = 0x7f;
	212	color = m_port->pixel_r();
219	213
220		color = m_port->pixel_r();
	214	/* reference: http://www.w3.org/TR/AERT#color-contrast */
	215	brightness = (color.r() * 0.299) + (color.g() * 0.587) + (color.b() * 0.114);
	216	//printf ("color brightness: %2X for x %d y %d\n", brightness, beam_x, beam_y);
221	217
222		/* reference: http://www.w3.org/TR/AERT#color-contrast */
223		brightness = (color.r() * 0.299) + (color.g() * 0.587) + (color.b() * 0.114);
224		//printf ("color brightness: %2X for x %d y %d\n", brightness, beam_x, beam_y);
	218	result = (brightness >= sensor_min_brightness) ? 0 : 1;
	219	}
225	220
226		result = (brightness >= sensor_min_brightness) ? 0 : 1;
227		}
228
229		if (result == 0) /* sensor on */
230		{
231		/* Set next check for when sensor will be off */
232		beam_x = aim_area.max_x + 1;
233
234		/* adopt the new coordinates to adjust the timer */
235		new_check_point = true;
236		}
237		else
238		{
239		/* Next check will happen after the minimum interval */
240		beam_x += LGUN_X_INTERVAL;
241		}
	221	if (result == 0)
	222	{
	223	/* Set next check for when sensor will be off */
	224	beam_x = lgun_x + dx_radius + 1;
	225	if (beam_x > visarea.max_x)
	226	beam_x = visarea.max_x + 1;
	227	break;
242	228	}
	229	else
	230	{
	231	/* Next check after the minimum interval */
	232	beam_x += LGUN_X_INTERVAL;
	233	pos_changed = 1;
	234	}
243	235	}
244
245	236	timer->adjust(m_screen->time_until_pos(beam_y, beam_x));
	237
246	238	return result;
247	239	}
248	240

trunk/src/emu/debug/dvbpoints.c

r243727	r243728
13	13
14	14
15	15
16		// Sorting functors for the qsort function
17		static int cIndexAscending(const void* a, const void* b)
18		{
19		const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
20		const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
21		return left->index() - right->index();
22		}
23
24		static int cIndexDescending(const void* a, const void* b)
25		{
26		return cIndexAscending(b, a);
27		}
28
29		static int cEnabledAscending(const void* a, const void* b)
30		{
31		const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
32		const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
33		return (left->enabled() ? 1 : 0) - (right->enabled() ? 1 : 0);
34		}
35
36		static int cEnabledDescending(const void* a, const void* b)
37		{
38		return cEnabledAscending(b, a);
39		}
40
41		static int cCpuAscending(const void* a, const void* b)
42		{
43		const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
44		const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
45		return strcmp(left->debugInterface()->device().tag(), right->debugInterface()->device().tag());
46		}
47
48		static int cCpuDescending(const void* a, const void* b)
49		{
50		return cCpuAscending(b, a);
51		}
52
53		static int cAddressAscending(const void* a, const void* b)
54		{
55		const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
56		const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
57		return (left->address() > right->address()) ? 1 : (left->address() < right->address()) ? -1 : 0;
58		}
59
60		static int cAddressDescending(const void* a, const void* b)
61		{
62		return cAddressAscending(b, a);
63		}
64
65		static int cConditionAscending(const void* a, const void* b)
66		{
67		const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
68		const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
69		return strcmp(left->condition(), right->condition());
70		}
71
72		static int cConditionDescending(const void* a, const void* b)
73		{
74		return cConditionAscending(b, a);
75		}
76
77		static int cActionAscending(const void* a, const void* b)
78		{
79		const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
80		const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
81		return strcmp(left->action(), right->action());
82		}
83
84		static int cActionDescending(const void* a, const void* b)
85		{
86		return cActionAscending(b, a);
87		}
88
89
90	16	//**************************************************************************
91	17	//  DEBUG VIEW BREAK POINTS
92	18	//**************************************************************************
r243727	r243728
100	26
101	27	debug_view_breakpoints::debug_view_breakpoints(running_machine &machine, debug_view_osd_update_func osdupdate, void *osdprivate)
102	28	: debug_view(machine, DVT_BREAK_POINTS, osdupdate, osdprivate),
103		m_sortType(cIndexAscending)
	29	m_sortType(SORT_INDEX_ASCENDING)
104	30	{
105	31	// fail if no available sources
106	32	enumerate_sources();
107	33	if (m_source_list.count() == 0)
108	34	throw std::bad_alloc();
	35
	36	// configure the view
	37	m_total.y = 10;
	38	m_supports_cursor = false;
109	39	}
110	40
111	41
r243727	r243728
153	83
154	84	if (clickedTopRow)
155	85	{
156		if (pos.x < tableBreaks[0])
157		m_sortType = (m_sortType == &cIndexAscending) ? &cIndexDescending : &cIndexAscending;
	86	if (pos.x < tableBreaks[0] && m_sortType == SORT_INDEX_ASCENDING)
	87	m_sortType = SORT_INDEX_DESCENDING;
	88	else if (pos.x < tableBreaks[0])
	89	m_sortType = SORT_INDEX_ASCENDING;
	90	else if (pos.x < tableBreaks[1] && m_sortType == SORT_ENABLED_ASCENDING)
	91	m_sortType = SORT_ENABLED_DESCENDING;
158	92	else if (pos.x < tableBreaks[1])
159		m_sortType = (m_sortType == &cEnabledAscending) ? &cEnabledDescending : &cEnabledAscending;
	93	m_sortType = SORT_ENABLED_ASCENDING;
	94	else if (pos.x < tableBreaks[2] && m_sortType == SORT_CPU_ASCENDING)
	95	m_sortType = SORT_CPU_DESCENDING;
160	96	else if (pos.x < tableBreaks[2])
161		m_sortType = (m_sortType == &cCpuAscending) ? &cCpuDescending : &cCpuAscending;
	97	m_sortType = SORT_CPU_ASCENDING;
	98	else if (pos.x < tableBreaks[3] && m_sortType == SORT_ADDRESS_ASCENDING)
	99	m_sortType = SORT_ADDRESS_DESCENDING;
162	100	else if (pos.x < tableBreaks[3])
163		m_sortType = (m_sortType == &cAddressAscending) ? &cAddressDescending : &cAddressAscending;
	101	m_sortType = SORT_ADDRESS_ASCENDING;
	102	else if (pos.x < tableBreaks[4] && m_sortType == SORT_CONDITION_ASCENDING)
	103	m_sortType = SORT_CONDITION_DESCENDING;
164	104	else if (pos.x < tableBreaks[4])
165		m_sortType = (m_sortType == &cConditionAscending) ? &cConditionDescending : &cConditionAscending;
	105	m_sortType = SORT_CONDITION_ASCENDING;
	106	else if (pos.x < tableBreaks[5] && m_sortType == SORT_ACTION_ASCENDING)
	107	m_sortType = SORT_ACTION_DESCENDING;
166	108	else if (pos.x < tableBreaks[5])
167		m_sortType = (m_sortType == &cActionAscending) ? &cActionDescending : &cActionAscending;
	109	m_sortType = SORT_ACTION_ASCENDING;
168	110	}
169	111	else
170	112	{
171	113	// Gather a sorted list of all the breakpoints for all the CPUs
172		gather_breakpoints();
	114	device_debug::breakpoint** bpList = NULL;
	115	const int numBPs = breakpoints(SORT_NONE, bpList);
173	116
174		int const bpIndex = pos.y - 1;
175		if ((bpIndex >= m_buffer.count()) || (bpIndex < 0))
	117	const int bpIndex = pos.y - 1;
	118	if (bpIndex > numBPs || bpIndex < 0)
176	119	return;
177	120
178	121	// Enable / disable
179		m_buffer[bpIndex]->setEnabled(!m_buffer[bpIndex]->enabled());
	122	if (bpList[bpIndex]->enabled())
	123	bpList[bpIndex]->setEnabled(false);
	124	else
	125	bpList[bpIndex]->setEnabled(true);
180	126
	127	delete[] bpList;
	128
181	129	machine().debug_view().update_all(DVT_DISASSEMBLY);
182	130	}
183	131
r243727	r243728
201	149	}
202	150
203	151
204		void debug_view_breakpoints::gather_breakpoints()
	152	// Sorting functors for the qsort function
	153	static int cIndexAscending(const void* a, const void* b)
205	154	{
206		m_buffer.resize(0);
	155	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	156	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	157	return left->index() > right->index();
	158	}
	159
	160	static int cIndexDescending(const void* a, const void* b)
	161	{
	162	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	163	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	164	return left->index() < right->index();
	165	}
	166
	167	static int cEnabledAscending(const void* a, const void* b)
	168	{
	169	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	170	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	171	return left->enabled() < right->enabled();
	172	}
	173
	174	static int cEnabledDescending(const void* a, const void* b)
	175	{
	176	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	177	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	178	return left->enabled() > right->enabled();
	179	}
	180
	181	static int cCpuAscending(const void* a, const void* b)
	182	{
	183	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	184	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	185	const int result = strcmp(left->debugInterface()->device().tag(), right->debugInterface()->device().tag());
	186	return result >= 0;
	187	}
	188
	189	static int cCpuDescending(const void* a, const void* b)
	190	{
	191	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	192	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	193	const int result = strcmp(left->debugInterface()->device().tag(), right->debugInterface()->device().tag());
	194	return result < 0;
	195	}
	196
	197	static int cAddressAscending(const void* a, const void* b)
	198	{
	199	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	200	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	201	return left->address() > right->address();
	202	}
	203
	204	static int cAddressDescending(const void* a, const void* b)
	205	{
	206	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	207	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	208	return left->address() < right->address();
	209	}
	210
	211	static int cConditionAscending(const void* a, const void* b)
	212	{
	213	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	214	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	215	const int result = strcmp(left->condition(), right->condition());
	216	return result >= 0;
	217	}
	218
	219	static int cConditionDescending(const void* a, const void* b)
	220	{
	221	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	222	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	223	const int result = strcmp(left->condition(), right->condition());
	224	return result < 0;
	225	}
	226
	227	static int cActionAscending(const void* a, const void* b)
	228	{
	229	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	230	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	231	const int result = strcmp(left->action(), right->action());
	232	return result >= 0;
	233	}
	234
	235	static int cActionDescending(const void* a, const void* b)
	236	{
	237	const device_debug::breakpoint* left = *(device_debug::breakpoint**)a;
	238	const device_debug::breakpoint* right = *(device_debug::breakpoint**)b;
	239	const int result = strcmp(left->action(), right->action());
	240	return result < 0;
	241	}
	242
	243
	244	int debug_view_breakpoints::breakpoints(SortMode sort, device_debug::breakpoint**& bpList)
	245	{
	246	// Alloc
	247	int numBPs = 0;
	248	bpList = NULL;
207	249	for (const debug_view_source *source = m_source_list.first(); source != NULL; source = source->next())
208	250	{
	251	const device_debug& debugInterface = *source->device()->debug();
	252	for (device_debug::breakpoint *bp = debugInterface.breakpoint_first(); bp != NULL; bp = bp->next())
	253	numBPs++;
	254	}
	255	bpList = new device_debug::breakpoint*[numBPs];
	256
	257	int bpAddIndex = 0;
	258	for (const debug_view_source *source = m_source_list.first(); source != NULL; source = source->next())
	259	{
209	260	// Collect
210		device_debug &debugInterface = *source->device()->debug();
	261	device_debug& debugInterface = *source->device()->debug();
211	262	for (device_debug::breakpoint *bp = debugInterface.breakpoint_first(); bp != NULL; bp = bp->next())
212		m_buffer.append() = bp;
	263	{
	264	bpList[bpAddIndex] = bp;
	265	bpAddIndex++;
	266	}
213	267	}
214	268
215	269	// And now for the sort
216		qsort(&m_buffer[0], m_buffer.count(), sizeof(device_debug::breakpoint *), m_sortType);
	270	switch (m_sortType)
	271	{
	272	case SORT_NONE:
	273	break;
	274	case SORT_INDEX_ASCENDING:
	275	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cIndexAscending);
	276	break;
	277	case SORT_INDEX_DESCENDING:
	278	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cIndexDescending);
	279	break;
	280	case SORT_ENABLED_ASCENDING:
	281	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cEnabledAscending);
	282	break;
	283	case SORT_ENABLED_DESCENDING:
	284	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cEnabledDescending);
	285	break;
	286	case SORT_CPU_ASCENDING:
	287	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cCpuAscending);
	288	break;
	289	case SORT_CPU_DESCENDING:
	290	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cCpuDescending);
	291	break;
	292	case SORT_ADDRESS_ASCENDING:
	293	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cAddressAscending);
	294	break;
	295	case SORT_ADDRESS_DESCENDING:
	296	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cAddressDescending);
	297	break;
	298	case SORT_CONDITION_ASCENDING:
	299	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cConditionAscending);
	300	break;
	301	case SORT_CONDITION_DESCENDING:
	302	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cConditionDescending);
	303	break;
	304	case SORT_ACTION_ASCENDING:
	305	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cActionAscending);
	306	break;
	307	case SORT_ACTION_DESCENDING:
	308	qsort(bpList, numBPs, sizeof(device_debug::breakpoint*), cActionDescending);
	309	break;
	310	}
	311
	312	return numBPs;
217	313	}
218	314
219	315
r243727	r243728
225	321	void debug_view_breakpoints::view_update()
226	322	{
227	323	// Gather a list of all the breakpoints for all the CPUs
228		gather_breakpoints();
	324	device_debug::breakpoint** bpList = NULL;
	325	const int numBPs = breakpoints(SORT_NONE, bpList);
229	326
230	327	// Set the view region so the scroll bars update
231		m_total.x = tableBreaks[ARRAY_LENGTH(tableBreaks) - 1];
232		m_total.y = m_buffer.count() + 1;
233		if (m_total.y < 10)
234		m_total.y = 10;
	328	m_total.y = numBPs+1;
235	329
236	330	// Draw
237		debug_view_char   *dest = m_viewdata;
238		astring         linebuf;
239
240		// Header
241		if (m_visible.y > 0)
	331	debug_view_char *dest = m_viewdata;
	332	for (int row = 0; row < m_visible.y; row++)
242	333	{
243		linebuf.reset();
244		linebuf.cat("ID");
245		if (m_sortType == &cIndexAscending) linebuf.cat('\\');
246		else if (m_sortType == &cIndexDescending) linebuf.cat('/');
247		pad_astring_to_length(linebuf, tableBreaks[0]);
248		linebuf.cat("En");
249		if (m_sortType == &cEnabledAscending) linebuf.cat('\\');
250		else if (m_sortType == &cEnabledDescending) linebuf.cat('/');
251		pad_astring_to_length(linebuf, tableBreaks[1]);
252		linebuf.cat("CPU");
253		if (m_sortType == &cCpuAscending) linebuf.cat('\\');
254		else if (m_sortType == &cCpuDescending) linebuf.cat('/');
255		pad_astring_to_length(linebuf, tableBreaks[2]);
256		linebuf.cat("Address");
257		if (m_sortType == &cAddressAscending) linebuf.cat('\\');
258		else if (m_sortType == &cAddressDescending) linebuf.cat('/');
259		pad_astring_to_length(linebuf, tableBreaks[3]);
260		linebuf.cat("Condition");
261		if (m_sortType == &cConditionAscending) linebuf.cat('\\');
262		else if (m_sortType == &cConditionDescending) linebuf.cat('/');
263		pad_astring_to_length(linebuf, tableBreaks[4]);
264		linebuf.cat("Action");
265		if (m_sortType == &cActionAscending) linebuf.cat('\\');
266		else if (m_sortType == &cActionDescending) linebuf.cat('/');
267		pad_astring_to_length(linebuf, tableBreaks[5]);
	334	UINT32 effrow = m_topleft.y + row;
268	335
269		for (UINT32 i = m_topleft.x; i < (m_topleft.x + m_visible.x); i++, dest++)
	336	// Header
	337	if (row == 0)
270	338	{
271		dest->byte = (i < linebuf.len()) ? linebuf[i] : ' ';
272		dest->attrib = DCA_ANCILLARY;
	339	astring header;
	340	header.printf("ID");
	341	if (m_sortType == SORT_INDEX_ASCENDING) header.catprintf("\\");
	342	else if (m_sortType == SORT_INDEX_DESCENDING) header.catprintf("/");
	343	pad_astring_to_length(header, tableBreaks[0]);
	344	header.catprintf("En");
	345	if (m_sortType == SORT_ENABLED_ASCENDING) header.catprintf("\\");
	346	else if (m_sortType == SORT_ENABLED_DESCENDING) header.catprintf("/");
	347	pad_astring_to_length(header, tableBreaks[1]);
	348	header.catprintf("CPU");
	349	if (m_sortType == SORT_CPU_ASCENDING) header.catprintf("\\");
	350	else if (m_sortType == SORT_CPU_DESCENDING) header.catprintf("/");
	351	pad_astring_to_length(header, tableBreaks[2]);
	352	header.catprintf("Address");
	353	if (m_sortType == SORT_ADDRESS_ASCENDING) header.catprintf("\\");
	354	else if (m_sortType == SORT_ADDRESS_DESCENDING) header.catprintf("/");
	355	pad_astring_to_length(header, tableBreaks[3]);
	356	header.catprintf("Condition");
	357	if (m_sortType == SORT_CONDITION_ASCENDING) header.catprintf("\\");
	358	else if (m_sortType == SORT_CONDITION_DESCENDING) header.catprintf("/");
	359	pad_astring_to_length(header, tableBreaks[4]);
	360	header.catprintf("Action");
	361	if (m_sortType == SORT_ACTION_ASCENDING) header.catprintf("\\");
	362	else if (m_sortType == SORT_ACTION_DESCENDING) header.catprintf("/");
	363	pad_astring_to_length(header, tableBreaks[5]);
	364
	365	for (int i = 0; i < m_visible.x; i++)
	366	{
	367	dest->byte = (i < header.len()) ? header[i] : ' ';
	368	dest->attrib = DCA_ANCILLARY;
	369	dest++;
	370	}
	371	continue;
273	372	}
274		}
275	373
276		for (int row = 1; row < m_visible.y; row++)
277		{
278	374	// Breakpoints
279		int bpi = row + m_topleft.y - 1;
280		if ((bpi < m_buffer.count()) && (bpi >= 0))
	375	int bpi = effrow-1;
	376	if (bpi < numBPs && bpi >= 0)
281	377	{
282		device_debug::breakpoint *const bp = m_buffer[bpi];
	378	device_debug::breakpoint* bp = bpList[bpi];
283	379
284		linebuf.reset();
285		linebuf.catprintf("%2X", bp->index());
286		pad_astring_to_length(linebuf, tableBreaks[0]);
287		linebuf.cat(bp->enabled() ? 'X' : 'O');
288		pad_astring_to_length(linebuf, tableBreaks[1]);
289		linebuf.cat(bp->debugInterface()->device().tag());
290		pad_astring_to_length(linebuf, tableBreaks[2]);
291		linebuf.cat(core_i64_hex_format(bp->address(), bp->debugInterface()->logaddrchars()));
292		pad_astring_to_length(linebuf, tableBreaks[3]);
293		if (strcmp(bp->condition(), "1"))
294		linebuf.cat(bp->condition());
295		pad_astring_to_length(linebuf, tableBreaks[4]);
296		linebuf.cat(bp->action());
297		pad_astring_to_length(linebuf, tableBreaks[5]);
	380	astring buffer;
	381	buffer.printf("%X", bp->index());
	382	pad_astring_to_length(buffer, tableBreaks[0]);
	383	buffer.catprintf("%c", bp->enabled() ? 'X' : 'O');
	384	pad_astring_to_length(buffer, tableBreaks[1]);
	385	buffer.catprintf("%s", bp->debugInterface()->device().tag());
	386	pad_astring_to_length(buffer, tableBreaks[2]);
	387	buffer.catprintf("%s", core_i64_hex_format(bp->address(), bp->debugInterface()->logaddrchars()));
	388	pad_astring_to_length(buffer, tableBreaks[3]);
	389	if (astring(bp->condition()) != astring("1"))
	390	{
	391	buffer.catprintf("%s", bp->condition());
	392	pad_astring_to_length(buffer, tableBreaks[4]);
	393	}
	394	if (astring(bp->action()) != astring(""))
	395	{
	396	buffer.catprintf("%s", bp->action());
	397	pad_astring_to_length(buffer, tableBreaks[5]);
	398	}
298	399
299		for (UINT32 i = m_topleft.x; i < (m_topleft.x + m_visible.x); i++, dest++)
	400	for (int i = 0; i < m_visible.x; i++)
300	401	{
301		dest->byte = (i < linebuf.len()) ? linebuf[i] : ' ';
	402	dest->byte = (i < buffer.len()) ? buffer[i] : ' ';
302	403	dest->attrib = DCA_NORMAL;
303	404
304	405	// Color disabled breakpoints red
305		if ((i >= tableBreaks[0]) && (i < tableBreaks[1]) && !bp->enabled())
306		dest->attrib |= DCA_CHANGED;
	406	if (i == 5 && dest->byte == 'O')
	407	dest->attrib = DCA_CHANGED;
	408
	409	dest++;
307	410	}
	411	continue;
308	412	}
309		else
	413
	414	// Fill the remaining vertical space
	415	for (int i = 0; i < m_visible.x; i++)
310	416	{
311		// Fill the remaining vertical space
312		for (UINT32 i = m_topleft.x; i < (m_topleft.x + m_visible.x); i++, dest++)
313		{
314		dest->byte = ' ';
315		dest->attrib = DCA_NORMAL;
316		}
	417	dest->byte = ' ';
	418	dest->attrib = DCA_NORMAL;
	419	dest++;
317	420	}
318	421	}
	422
	423	delete[] bpList;
319	424	}

trunk/src/emu/debug/dvbpoints.h

r243727	r243728
35	35	virtual ~debug_view_breakpoints();
36	36
37	37	public:
	38	enum SortMode
	39	{
	40	SORT_NONE,
	41	SORT_INDEX_ASCENDING,
	42	SORT_INDEX_DESCENDING,
	43	SORT_ENABLED_ASCENDING,
	44	SORT_ENABLED_DESCENDING,
	45	SORT_CPU_ASCENDING,
	46	SORT_CPU_DESCENDING,
	47	SORT_ADDRESS_ASCENDING,
	48	SORT_ADDRESS_DESCENDING,
	49	SORT_CONDITION_ASCENDING,
	50	SORT_CONDITION_DESCENDING,
	51	SORT_ACTION_ASCENDING,
	52	SORT_ACTION_DESCENDING
	53	};
	54
38	55	// getters
39	56	// setters
40	57
r243727	r243728
47	64	// internal helpers
48	65	void enumerate_sources();
49	66	void pad_astring_to_length(astring& str, int len);
50		void gather_breakpoints();
	67	int breakpoints(SortMode sort, device_debug::breakpoint**& bpList);
51	68
52	69
53	70	// internal state
54		int (*m_sortType)(void const *, void const *);
55		dynamic_array<device_debug::breakpoint *> m_buffer;
	71	SortMode m_sortType;
56	72	};
57	73
58	74

trunk/src/emu/debug/dvwpoints.c

r243727	r243728
13	13
14	14
15	15
16		static int cIndexAscending(const void* a, const void* b)
17		{
18		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
19		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
20		return left->index() - right->index();
21		}
22
23		static int cIndexDescending(const void* a, const void* b)
24		{
25		return cIndexAscending(b, a);
26		}
27
28		static int cEnabledAscending(const void* a, const void* b)
29		{
30		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
31		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
32		return (left->enabled() ? 1 : 0) - (right->enabled() ? 1 : 0);
33		}
34
35		static int cEnabledDescending(const void* a, const void* b)
36		{
37		return cEnabledAscending(b, a);
38		}
39
40		static int cCpuAscending(const void* a, const void* b)
41		{
42		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
43		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
44		return strcmp(left->debugInterface()->device().tag(), right->debugInterface()->device().tag());
45		}
46
47		static int cCpuDescending(const void* a, const void* b)
48		{
49		return cCpuAscending(b, a);
50		}
51
52		static int cSpaceAscending(const void* a, const void* b)
53		{
54		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
55		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
56		return strcmp(left->space().name(), right->space().name());
57		}
58
59		static int cSpaceDescending(const void* a, const void* b)
60		{
61		return cSpaceAscending(b, a);
62		}
63
64		static int cAddressAscending(const void* a, const void* b)
65		{
66		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
67		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
68		return (left->address() > right->address()) ? 1 : (left->address() < right->address()) ? -1 : 0;
69		}
70
71		static int cAddressDescending(const void* a, const void* b)
72		{
73		return cAddressAscending(b, a);
74		}
75
76		static int cTypeAscending(const void* a, const void* b)
77		{
78		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
79		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
80		return left->type() - right->type();
81		}
82
83		static int cTypeDescending(const void* a, const void* b)
84		{
85		return cTypeAscending(b, a);
86		}
87
88		static int cConditionAscending(const void* a, const void* b)
89		{
90		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
91		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
92		return strcmp(left->condition(), right->condition());
93		}
94
95		static int cConditionDescending(const void* a, const void* b)
96		{
97		return cConditionAscending(b, a);
98		}
99
100		static int cActionAscending(const void* a, const void* b)
101		{
102		const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
103		const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
104		return strcmp(left->action(), right->action());
105		}
106
107		static int cActionDescending(const void* a, const void* b)
108		{
109		return cActionAscending(b, a);
110		}
111
112
113	16	//**************************************************************************
114	17	//  DEBUG VIEW WATCH POINTS
115	18	//**************************************************************************
r243727	r243728
122	25
123	26	debug_view_watchpoints::debug_view_watchpoints(running_machine &machine, debug_view_osd_update_func osdupdate, void *osdprivate)
124	27	: debug_view(machine, DVT_WATCH_POINTS, osdupdate, osdprivate),
125		m_sortType(&cIndexAscending)
	28	m_sortType(SORT_INDEX_ASCENDING)
126	29	{
127	30	// fail if no available sources
128	31	enumerate_sources();
129	32	if (m_source_list.count() == 0)
130	33	throw std::bad_alloc();
	34
	35	// configure the view
	36	m_total.y = 10;
	37	m_supports_cursor = false;
131	38	}
132	39
133	40
r243727	r243728
171	78
172	79	void debug_view_watchpoints::view_click(const int button, const debug_view_xy& pos)
173	80	{
174		bool const clickedTopRow = (m_topleft.y == pos.y);
	81	bool clickedTopRow = (m_topleft.y == pos.y);
175	82
176	83	if (clickedTopRow)
177	84	{
178		if (pos.x < tableBreaks[0])
179		m_sortType = (m_sortType == &cIndexAscending) ? &cIndexDescending : &cIndexAscending;
	85	if (pos.x < tableBreaks[0] && m_sortType == SORT_INDEX_ASCENDING)
	86	m_sortType = SORT_INDEX_DESCENDING;
	87	else if (pos.x < tableBreaks[0])
	88	m_sortType = SORT_INDEX_ASCENDING;
	89	else if (pos.x < tableBreaks[1] && m_sortType == SORT_ENABLED_ASCENDING)
	90	m_sortType = SORT_ENABLED_DESCENDING;
180	91	else if (pos.x < tableBreaks[1])
181		m_sortType = (m_sortType == &cEnabledAscending) ? &cEnabledDescending : &cEnabledAscending;
	92	m_sortType = SORT_ENABLED_ASCENDING;
	93	else if (pos.x < tableBreaks[2] && m_sortType == SORT_CPU_ASCENDING)
	94	m_sortType = SORT_CPU_DESCENDING;
182	95	else if (pos.x < tableBreaks[2])
183		m_sortType = (m_sortType == &cCpuAscending) ? &cCpuDescending : &cCpuAscending;
	96	m_sortType = SORT_CPU_ASCENDING;
	97	else if (pos.x < tableBreaks[3] && m_sortType == SORT_SPACE_ASCENDING)
	98	m_sortType = SORT_SPACE_DESCENDING;
184	99	else if (pos.x < tableBreaks[3])
185		m_sortType = (m_sortType == &cSpaceAscending) ? &cSpaceDescending : &cSpaceAscending;
	100	m_sortType = SORT_SPACE_ASCENDING;
	101	else if (pos.x < tableBreaks[4] && m_sortType == SORT_ADDRESS_ASCENDING)
	102	m_sortType = SORT_ADDRESS_DESCENDING;
186	103	else if (pos.x < tableBreaks[4])
187		m_sortType = (m_sortType == &cAddressAscending) ? &cAddressDescending : &cAddressAscending;
	104	m_sortType = SORT_ADDRESS_ASCENDING;
	105	else if (pos.x < tableBreaks[5] && m_sortType == SORT_TYPE_ASCENDING)
	106	m_sortType = SORT_TYPE_DESCENDING;
188	107	else if (pos.x < tableBreaks[5])
189		m_sortType = (m_sortType == &cTypeAscending) ? &cTypeDescending : &cTypeAscending;
	108	m_sortType = SORT_TYPE_ASCENDING;
	109	else if (pos.x < tableBreaks[6] && m_sortType == SORT_CONDITION_ASCENDING)
	110	m_sortType = SORT_CONDITION_DESCENDING;
190	111	else if (pos.x < tableBreaks[6])
191		m_sortType = (m_sortType == &cConditionAscending) ? &cConditionDescending : &cConditionAscending;
	112	m_sortType = SORT_CONDITION_ASCENDING;
	113	else if (pos.x < tableBreaks[7] && m_sortType == SORT_ACTION_ASCENDING)
	114	m_sortType = SORT_ACTION_DESCENDING;
192	115	else if (pos.x < tableBreaks[7])
193		m_sortType = (m_sortType == &cActionAscending) ? &cActionDescending : &cActionAscending;
	116	m_sortType = SORT_ACTION_ASCENDING;
194	117	}
195	118	else
196	119	{
197	120	// Gather a sorted list of all the watchpoints for all the CPUs
198		gather_watchpoints();
	121	device_debug::watchpoint** wpList = NULL;
	122	const int numWPs = watchpoints(SORT_NONE, wpList);
199	123
200		int const wpIndex = pos.y - 1;
201		if ((wpIndex >= m_buffer.count()) || (wpIndex < 0))
	124	const int wpIndex = pos.y - 1;
	125	if (wpIndex > numWPs || wpIndex < 0)
202	126	return;
203	127
204	128	// Enable / disable
205		m_buffer[wpIndex]->setEnabled(!m_buffer[wpIndex]->enabled());
	129	if (wpList[wpIndex]->enabled())
	130	wpList[wpIndex]->setEnabled(false);
	131	else
	132	wpList[wpIndex]->setEnabled(true);
	133
	134	delete[] wpList;
206	135	}
207	136
208	137	begin_update();
r243727	r243728
225	154	}
226	155
227	156
228		void debug_view_watchpoints::gather_watchpoints()
	157	// Sorting functors for the qsort function
	158	static int cIndexAscending(const void* a, const void* b)
229	159	{
230		m_buffer.resize(0);
	160	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	161	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	162	return left->index() > right->index();
	163	}
	164
	165	static int cIndexDescending(const void* a, const void* b)
	166	{
	167	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	168	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	169	return left->index() < right->index();
	170	}
	171
	172	static int cEnabledAscending(const void* a, const void* b)
	173	{
	174	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	175	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	176	return left->enabled() < right->enabled();
	177	}
	178
	179	static int cEnabledDescending(const void* a, const void* b)
	180	{
	181	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	182	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	183	return left->enabled() > right->enabled();
	184	}
	185
	186	static int cCpuAscending(const void* a, const void* b)
	187	{
	188	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	189	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	190	const int result = strcmp(left->debugInterface()->device().tag(), right->debugInterface()->device().tag());
	191	return result >= 0;
	192	}
	193
	194	static int cCpuDescending(const void* a, const void* b)
	195	{
	196	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	197	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	198	const int result = strcmp(left->debugInterface()->device().tag(), right->debugInterface()->device().tag());
	199	return result < 0;
	200	}
	201
	202	static int cSpaceAscending(const void* a, const void* b)
	203	{
	204	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	205	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	206	const int result = strcmp(left->space().name(), right->space().name());
	207	return result >= 0;
	208	}
	209
	210	static int cSpaceDescending(const void* a, const void* b)
	211	{
	212	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	213	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	214	const int result = strcmp(left->space().name(), right->space().name());
	215	return result < 0;
	216	}
	217
	218	static int cAddressAscending(const void* a, const void* b)
	219	{
	220	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	221	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	222	return left->address() > right->address();
	223	}
	224
	225	static int cAddressDescending(const void* a, const void* b)
	226	{
	227	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	228	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	229	return left->address() < right->address();
	230	}
	231
	232	static int cTypeAscending(const void* a, const void* b)
	233	{
	234	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	235	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	236	return left->type() > right->type();
	237	}
	238
	239	static int cTypeDescending(const void* a, const void* b)
	240	{
	241	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	242	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	243	return left->type() < right->type();
	244	}
	245
	246	static int cConditionAscending(const void* a, const void* b)
	247	{
	248	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	249	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	250	const int result = strcmp(left->condition(), right->condition());
	251	return result >= 0;
	252	}
	253
	254	static int cConditionDescending(const void* a, const void* b)
	255	{
	256	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	257	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	258	const int result = strcmp(left->condition(), right->condition());
	259	return result < 0;
	260	}
	261
	262	static int cActionAscending(const void* a, const void* b)
	263	{
	264	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	265	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	266	const int result = strcmp(left->action(), right->action());
	267	return result >= 0;
	268	}
	269
	270	static int cActionDescending(const void* a, const void* b)
	271	{
	272	const device_debug::watchpoint* left = *(device_debug::watchpoint**)a;
	273	const device_debug::watchpoint* right = *(device_debug::watchpoint**)b;
	274	const int result = strcmp(left->action(), right->action());
	275	return result < 0;
	276	}
	277
	278
	279	int debug_view_watchpoints::watchpoints(SortMode sort, device_debug::watchpoint**& wpList)
	280	{
	281	// Alloc
	282	int numWPs = 0;
	283	wpList = NULL;
231	284	for (const debug_view_source *source = m_source_list.first(); source != NULL; source = source->next())
232	285	{
	286	for (address_spacenum spacenum = AS_0; spacenum < ADDRESS_SPACES; spacenum++)
	287	{
	288	/* loop over the watchpoints */
	289	const device_debug& debugInterface = *source->device()->debug();
	290	for (device_debug::watchpoint *wp = debugInterface.watchpoint_first(spacenum); wp != NULL; wp = wp->next())
	291	numWPs++;
	292	}
	293	}
	294	wpList = new device_debug::watchpoint*[numWPs];
	295
	296	int wpAddIndex = 0;
	297	for (const debug_view_source *source = m_source_list.first(); source != NULL; source = source->next())
	298	{
233	299	// Collect
234		device_debug &debugInterface = *source->device()->debug();
235	300	for (address_spacenum spacenum = AS_0; spacenum < ADDRESS_SPACES; spacenum++)
236	301	{
	302	device_debug& debugInterface = *source->device()->debug();
237	303	for (device_debug::watchpoint *wp = debugInterface.watchpoint_first(spacenum); wp != NULL; wp = wp->next())
238		m_buffer.append() = wp;
	304	{
	305	wpList[wpAddIndex] = wp;
	306	wpAddIndex++;
	307	}
239	308	}
240	309	}
241	310
242	311	// And now for the sort
243		qsort(&m_buffer[0], m_buffer.count(), sizeof(device_debug::watchpoint *), m_sortType);
	312	switch (m_sortType)
	313	{
	314	case SORT_NONE:
	315	break;
	316	case SORT_INDEX_ASCENDING:
	317	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cIndexAscending);
	318	break;
	319	case SORT_INDEX_DESCENDING:
	320	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cIndexDescending);
	321	break;
	322	case SORT_ENABLED_ASCENDING:
	323	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cEnabledAscending);
	324	break;
	325	case SORT_ENABLED_DESCENDING:
	326	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cEnabledDescending);
	327	break;
	328	case SORT_CPU_ASCENDING:
	329	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cCpuAscending);
	330	break;
	331	case SORT_CPU_DESCENDING:
	332	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cCpuDescending);
	333	break;
	334	case SORT_SPACE_ASCENDING:
	335	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cSpaceAscending);
	336	break;
	337	case SORT_SPACE_DESCENDING:
	338	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cSpaceDescending);
	339	break;
	340	case SORT_ADDRESS_ASCENDING:
	341	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cAddressAscending);
	342	break;
	343	case SORT_ADDRESS_DESCENDING:
	344	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cAddressDescending);
	345	break;
	346	case SORT_TYPE_ASCENDING:
	347	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cTypeAscending);
	348	break;
	349	case SORT_TYPE_DESCENDING:
	350	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cTypeDescending);
	351	break;
	352	case SORT_CONDITION_ASCENDING:
	353	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cConditionAscending);
	354	break;
	355	case SORT_CONDITION_DESCENDING:
	356	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cConditionDescending);
	357	break;
	358	case SORT_ACTION_ASCENDING:
	359	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cActionAscending);
	360	break;
	361	case SORT_ACTION_DESCENDING:
	362	qsort(wpList, numWPs, sizeof(device_debug::watchpoint*), cActionDescending);
	363	break;
	364	}
	365
	366	return numWPs;
244	367	}
245	368
246	369
r243727	r243728
252	375	void debug_view_watchpoints::view_update()
253	376	{
254	377	// Gather a list of all the watchpoints for all the CPUs
255		gather_watchpoints();
	378	device_debug::watchpoint** wpList = NULL;
	379	const int numWPs = watchpoints(SORT_NONE, wpList);
256	380
257	381	// Set the view region so the scroll bars update
258		m_total.x = tableBreaks[ARRAY_LENGTH(tableBreaks) - 1];
259		m_total.y = m_buffer.count() + 1;
260		if (m_total.y < 10)
261		m_total.y = 10;
	382	m_total.y = numWPs+1;
262	383
263	384	// Draw
264		debug_view_char   *dest = m_viewdata;
265		astring         linebuf;
266
267		// Header
268		if (m_visible.y > 0)
	385	debug_view_char *dest = m_viewdata;
	386	for (int row = 0; row < m_visible.y; row++)
269	387	{
270		linebuf.reset();
271		linebuf.cat("ID");
272		if (m_sortType == &cIndexAscending) linebuf.cat('\\');
273		else if (m_sortType == &cIndexDescending) linebuf.cat('/');
274		pad_astring_to_length(linebuf, tableBreaks[0]);
275		linebuf.cat("En");
276		if (m_sortType == &cEnabledAscending) linebuf.cat('\\');
277		else if (m_sortType == &cEnabledDescending) linebuf.cat('/');
278		pad_astring_to_length(linebuf, tableBreaks[1]);
279		linebuf.cat("CPU");
280		if (m_sortType == &cCpuAscending) linebuf.cat('\\');
281		else if (m_sortType == &cCpuDescending) linebuf.cat('/');
282		pad_astring_to_length(linebuf, tableBreaks[2]);
283		linebuf.cat("Space");
284		if (m_sortType == &cSpaceAscending) linebuf.cat('\\');
285		else if (m_sortType == &cSpaceDescending) linebuf.cat('/');
286		pad_astring_to_length(linebuf, tableBreaks[3]);
287		linebuf.cat("Addresses");
288		if (m_sortType == &cAddressAscending) linebuf.cat('\\');
289		else if (m_sortType == &cAddressDescending) linebuf.cat('/');
290		pad_astring_to_length(linebuf, tableBreaks[4]);
291		linebuf.cat("Type");
292		if (m_sortType == &cTypeAscending) linebuf.cat('\\');
293		else if (m_sortType == &cTypeDescending) linebuf.cat('/');
294		pad_astring_to_length(linebuf, tableBreaks[5]);
295		linebuf.cat("Condition");
296		if (m_sortType == &cConditionAscending) linebuf.cat('\\');
297		else if (m_sortType == &cConditionDescending) linebuf.cat('/');
298		pad_astring_to_length(linebuf, tableBreaks[6]);
299		linebuf.cat("Action");
300		if (m_sortType == &cActionAscending) linebuf.cat('\\');
301		else if (m_sortType == &cActionDescending) linebuf.cat('/');
302		pad_astring_to_length(linebuf, tableBreaks[7]);
	388	UINT32 effrow = m_topleft.y + row;
303	389
304		for (UINT32 i = m_topleft.x; i < (m_topleft.x + m_visible.x); i++, dest++)
	390	// Header
	391	if (row == 0)
305	392	{
306		dest->byte = (i < linebuf.len()) ? linebuf[i] : ' ';
307		dest->attrib = DCA_ANCILLARY;
	393	astring header;
	394	header.printf("ID");
	395	if (m_sortType == SORT_INDEX_ASCENDING) header.catprintf("\\");
	396	else if (m_sortType == SORT_INDEX_DESCENDING) header.catprintf("/");
	397	pad_astring_to_length(header, tableBreaks[0]);
	398	header.catprintf("En");
	399	if (m_sortType == SORT_ENABLED_ASCENDING) header.catprintf("\\");
	400	else if (m_sortType == SORT_ENABLED_DESCENDING) header.catprintf("/");
	401	pad_astring_to_length(header, tableBreaks[1]);
	402	header.catprintf("CPU");
	403	if (m_sortType == SORT_CPU_ASCENDING) header.catprintf("\\");
	404	else if (m_sortType == SORT_CPU_DESCENDING) header.catprintf("/");
	405	pad_astring_to_length(header, tableBreaks[2]);
	406	header.catprintf("Space");
	407	if (m_sortType == SORT_SPACE_ASCENDING) header.catprintf("\\");
	408	else if (m_sortType == SORT_SPACE_DESCENDING) header.catprintf("/");
	409	pad_astring_to_length(header, tableBreaks[3]);
	410	header.catprintf("Addresses");
	411	if (m_sortType == SORT_ADDRESS_ASCENDING) header.catprintf("\\");
	412	else if (m_sortType == SORT_ADDRESS_DESCENDING) header.catprintf("/");
	413	pad_astring_to_length(header, tableBreaks[4]);
	414	header.catprintf("Type");
	415	if (m_sortType == SORT_TYPE_ASCENDING) header.catprintf("\\");
	416	else if (m_sortType == SORT_TYPE_DESCENDING) header.catprintf("/");
	417	pad_astring_to_length(header, tableBreaks[5]);
	418	header.catprintf("Condition");
	419	if (m_sortType == SORT_CONDITION_ASCENDING) header.catprintf("\\");
	420	else if (m_sortType == SORT_CONDITION_DESCENDING) header.catprintf("/");
	421	pad_astring_to_length(header, tableBreaks[6]);
	422	header.catprintf("Action");
	423	if (m_sortType == SORT_ACTION_ASCENDING) header.catprintf("\\");
	424	else if (m_sortType == SORT_ACTION_DESCENDING) header.catprintf("/");
	425	pad_astring_to_length(header, tableBreaks[7]);
	426
	427	for (int i = 0; i < m_visible.x; i++)
	428	{
	429	dest->byte = (i < header.len()) ? header[i] : ' ';
	430	dest->attrib = DCA_ANCILLARY;
	431	dest++;
	432	}
	433	continue;
308	434	}
309		}
310	435
311		for (int row = 1; row < m_visible.y; row++)
312		{
313	436	// watchpoints
314		int const wpi = row + m_topleft.y - 1;
315		if ((wpi < m_buffer.count()) && wpi >= 0)
	437	int wpi = effrow-1;
	438	if (wpi < numWPs && wpi >= 0)
316	439	{
317		static char const *const types[] = { "unkn ", "read ", "write", "r/w  " };
318		device_debug::watchpoint *const wp = m_buffer[wpi];
	440	static const char *const types[] = { "unkn ", "read ", "write", "r/w  " };
	441	device_debug::watchpoint* wp = wpList[wpi];
319	442
320		linebuf.reset();
321		linebuf.catprintf("%2X", wp->index());
322		pad_astring_to_length(linebuf, tableBreaks[0]);
323		linebuf.cat(wp->enabled() ? 'X' : 'O');
324		pad_astring_to_length(linebuf, tableBreaks[1]);
325		linebuf.cat(wp->debugInterface()->device().tag());
326		pad_astring_to_length(linebuf, tableBreaks[2]);
327		linebuf.cat(wp->space().name());
328		pad_astring_to_length(linebuf, tableBreaks[3]);
329		linebuf.cat(core_i64_hex_format(wp->space().byte_to_address(wp->address()), wp->space().addrchars()));
330		linebuf.cat('-');
331		linebuf.cat(core_i64_hex_format(wp->space().byte_to_address_end(wp->address() + wp->length()) - 1, wp->space().addrchars()));
332		pad_astring_to_length(linebuf, tableBreaks[4]);
333		linebuf.cat(types[wp->type() & 3]);
334		pad_astring_to_length(linebuf, tableBreaks[5]);
335		if (strcmp(wp->condition(), "1"))
336		linebuf.cat(wp->condition());
337		pad_astring_to_length(linebuf, tableBreaks[6]);
338		linebuf.cat(wp->action());
339		pad_astring_to_length(linebuf, tableBreaks[7]);
	443	astring buffer;
	444	buffer.printf("%X", wp->index());
	445	pad_astring_to_length(buffer, tableBreaks[0]);
	446	buffer.catprintf("%c", wp->enabled() ? 'X' : 'O');
	447	pad_astring_to_length(buffer, tableBreaks[1]);
	448	buffer.catprintf("%s", wp->debugInterface()->device().tag());
	449	pad_astring_to_length(buffer, tableBreaks[2]);
	450	buffer.catprintf("%s", wp->space().name());
	451	pad_astring_to_length(buffer, tableBreaks[3]);
	452	buffer.catprintf("%s-%s",
	453	core_i64_hex_format(wp->space().byte_to_address(wp->address()), wp->space().addrchars()),
	454	core_i64_hex_format(wp->space().byte_to_address_end(wp->address() + wp->length()) - 1, wp->space().addrchars()));
	455	pad_astring_to_length(buffer, tableBreaks[4]);
	456	buffer.catprintf("%s", types[wp->type() & 3]);
	457	pad_astring_to_length(buffer, tableBreaks[5]);
	458	if (astring(wp->condition()) != astring("1"))
	459	{
	460	buffer.catprintf("%s", wp->condition());
	461	pad_astring_to_length(buffer, tableBreaks[6]);
	462	}
	463	if (astring(wp->action()) != astring(""))
	464	{
	465	buffer.catprintf("%s", wp->action());
	466	pad_astring_to_length(buffer, tableBreaks[7]);
	467	}
340	468
341		for (UINT32 i = m_topleft.x; i < (m_topleft.x + m_visible.x); i++, dest++)
	469	for (int i = 0; i < m_visible.x; i++)
342	470	{
343		dest->byte = (i < linebuf.len()) ? linebuf[i] : ' ';
	471	dest->byte = (i < buffer.len()) ? buffer[i] : ' ';
344	472	dest->attrib = DCA_NORMAL;
345	473
346	474	// Color disabled watchpoints red
347		if ((i >= tableBreaks[0]) && (i < tableBreaks[1]) && !wp->enabled())
348		dest->attrib |= DCA_CHANGED;
	475	if (i == 5 && dest->byte == 'O')
	476	dest->attrib = DCA_CHANGED;
	477
	478	dest++;
349	479	}
	480	continue;
350	481	}
351		else
	482
	483	// Fill the remaining vertical space
	484	for (int i = 0; i < m_visible.x; i++)
352	485	{
353		// Fill the remaining vertical space
354		for (int i = 0; i < m_visible.x; i++, dest++)
355		{
356		dest->byte = ' ';
357		dest->attrib = DCA_NORMAL;
358		}
	486	dest->byte = ' ';
	487	dest->attrib = DCA_NORMAL;
	488	dest++;
359	489	}
360	490	}
	491
	492	delete[] wpList;
361	493	}

trunk/src/emu/debug/dvwpoints.h

r243727	r243728
34	34	debug_view_watchpoints(running_machine &machine, debug_view_osd_update_func osdupdate, void *osdprivate);
35	35	virtual ~debug_view_watchpoints();
36	36
	37	public:
	38	enum SortMode
	39	{
	40	SORT_NONE,
	41	SORT_INDEX_ASCENDING,
	42	SORT_INDEX_DESCENDING,
	43	SORT_ENABLED_ASCENDING,
	44	SORT_ENABLED_DESCENDING,
	45	SORT_CPU_ASCENDING,
	46	SORT_CPU_DESCENDING,
	47	SORT_SPACE_ASCENDING,
	48	SORT_SPACE_DESCENDING,
	49	SORT_ADDRESS_ASCENDING,
	50	SORT_ADDRESS_DESCENDING,
	51	SORT_TYPE_ASCENDING,
	52	SORT_TYPE_DESCENDING,
	53	SORT_CONDITION_ASCENDING,
	54	SORT_CONDITION_DESCENDING,
	55	SORT_ACTION_ASCENDING,
	56	SORT_ACTION_DESCENDING
	57	};
	58
	59	// getters
	60	// setters
	61
37	62	protected:
38	63	// view overrides
39	64	virtual void view_update();
r243727	r243728
43	68	// internal helpers
44	69	void enumerate_sources();
45	70	void pad_astring_to_length(astring& str, int len);
46		void gather_watchpoints();
	71	int watchpoints(SortMode sort, device_debug::watchpoint**& bpList);
47	72
48	73
49	74	// internal state
50		int (*m_sortType)(void const *, void const *);
51		dynamic_array<device_debug::watchpoint *> m_buffer;
	75	SortMode m_sortType;
52	76	};
53	77
54	78

trunk/src/emu/video/315_5124.c

r243727	r243728
254	254	}
255	255	}
256	256
257		set_frame_timing();
258		m_cram_dirty = 1;
259		}
260
261
262		void sega315_5124_device::set_frame_timing()
263		{
264	257	switch (m_y_pixels)
265	258	{
266		case 192:
267		m_frame_timing = (m_is_pal) ? pal_192 : ntsc_192;
268		break;
	259	case 192:
	260	m_frame_timing = (m_is_pal) ? pal_192 : ntsc_192;
	261	break;
269	262
270		case 224:
271		m_frame_timing = (m_is_pal) ? pal_224 : ntsc_224;
272		break;
	263	case 224:
	264	m_frame_timing = (m_is_pal) ? pal_224 : ntsc_224;
	265	break;
273	266
274		case 240:
275		m_frame_timing = (m_is_pal) ? pal_240 : ntsc_240;
276		break;
	267	case 240:
	268	m_frame_timing = (m_is_pal) ? pal_240 : ntsc_240;
	269	break;
277	270	}
	271	m_cram_dirty = 1;
278	272	}
279	273
280	274
r243727	r243728
681	675	case 2:     /* VDP register write */
682	676	reg_num = data & 0x0f;
683	677	m_reg[reg_num] = m_addr & 0xff;
684		//logerror("%s: %s: setting register %x to %02x\n", machine().describe_context(), tag(), reg_num, m_addr & 0xff);
	678	//logerror("%s: %s: setting register %x to %02x\n", machine().describe_context(), tag(), reg_num, m_addr & 0xf );
685	679
686	680	switch (reg_num)
687	681	{
r243727	r243728
1447	1441	{
1448	1442	int i;
1449	1443
1450		/* Exit if palette has no changes */
	1444	/* Exit if palette is has no changes */
1451	1445	if (m_cram_dirty == 0)
1452	1446	{
1453	1447	return;
r243727	r243728
1474	1468	{
1475	1469	int i;
1476	1470
1477		/* Exit if palette has no changes */
	1471	/* Exit if palette is has no changes */
1478	1472	if (m_cram_dirty == 0)
1479	1473	{
1480	1474	return;
r243727	r243728
1563	1557
1564	1558	void sega315_5124_device::vdp_postload()
1565	1559	{
1566		set_frame_timing();
	1560	switch (m_y_pixels)
	1561	{
	1562	case 192:
	1563	m_frame_timing = (m_is_pal) ? pal_192 : ntsc_192;
	1564	break;
	1565
	1566	case 224:
	1567	m_frame_timing = (m_is_pal) ? pal_224 : ntsc_224;
	1568	break;
	1569
	1570	case 240:
	1571	m_frame_timing = (m_is_pal) ? pal_240 : ntsc_240;
	1572	break;
	1573	}
1567	1574	}
1568	1575
1569	1576	void sega315_5124_device::device_start()

trunk/src/emu/video/315_5124.h

r243727	r243728
91	91
92	92	protected:
93	93	void set_display_settings();
94		void set_frame_timing();
95	94	virtual void update_palette();
96	95	virtual void cram_write(UINT8 data);
97	96	virtual void draw_scanline( int pixel_offset_x, int pixel_plot_y, int line );

trunk/src/mame/drivers/bfm_sc1.c

r243727	r243728
2601	2601	#define GAME_FLAGS GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK|GAME_NOT_WORKING|GAME_MECHANICAL
2602	2602
2603	2603	//Adder 2
2604		GAME( 1996, m_tppokr        , 0         ,  scorpion1_adder2 , toppoker  , bfm_sc1_state, toppoker       , 0,       "BFM/ELAM",    "Top Poker (Dutch, Game Card 95-750-899)", GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
	2604	GAME( 1996, m_tppokr        , 0         ,  scorpion1_adder2 , toppoker  , bfm_sc1_state, toppoker       , 0,       "BFM/ELAM",    "Top Poker (Dutch, Game Card 95-750-899)", GAME_FLAGS )
2605	2605
2606	2606
2607	2607	/********************************************************************************************************************************************************************************************************************

trunk/src/mame/drivers/mpu4avan.c

r243727	r243728
12	12	MACHINE_CONFIG_EXTERN( mod4oki );
13	13	INPUT_PORTS_EXTERN( mpu4 );
14	14
15		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	15	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
16	16
17	17
18	18

trunk/src/mame/drivers/mpu4bwb.c

r243727	r243728
29	29	MACHINE_CONFIG_EXTERN( mod2 );
30	30	INPUT_PORTS_EXTERN( mpu4 );
31	31
32		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	32	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
33	33
34	34
35	35	#define M4BIGMT_EXTRA_ROMS \

trunk/src/mame/drivers/mpu4concept.c

r243727	r243728
6	6	MACHINE_CONFIG_EXTERN( mod4oki );
7	7	INPUT_PORTS_EXTERN( mpu4 );
8	8
9		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	9	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
10	10
11	11
12	12	#define M4RHFEVC_EXTRA_ROMS \

trunk/src/mame/drivers/mpu4crystal.c

r243727	r243728
9	9	MACHINE_CONFIG_EXTERN( mpu4crys );
10	10	INPUT_PORTS_EXTERN( mpu4 );
11	11
12		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	12	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
13	13
14	14
15	15

trunk/src/mame/drivers/mpu4empire.c

r243727	r243728
7	7	MACHINE_CONFIG_EXTERN( mod4oki );
8	8	INPUT_PORTS_EXTERN( mpu4 );
9	9
10		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	10	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
11	11
12	12
13	13	ROM_START( m4apachg )

trunk/src/mame/drivers/mpu4mdm.c

r243727	r243728
7	7	MACHINE_CONFIG_EXTERN( mod4oki );
8	8	INPUT_PORTS_EXTERN( mpu4 );
9	9
10		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	10	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
11	11
12	12
13	13

trunk/src/mame/drivers/mpu4misc.c

r243727	r243728
6	6	MACHINE_CONFIG_EXTERN( mod4oki );
7	7	INPUT_PORTS_EXTERN( mpu4 );
8	8
9		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	9	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
10	10
11	11
12	12

trunk/src/mame/drivers/mpu4mod2sw.c

r243727	r243728
24	24
25	25
26	26
27		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	27	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
28	28
29	29	DRIVER_INIT_MEMBER( mpu4_state, m4_showstring_mod2 )
30	30	{

trunk/src/mame/drivers/mpu4plasma.c

r243727	r243728
189	189	M4ELITE_PLASMA
190	190	ROM_END
191	191
192		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	192	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
193	193
194	194	GAMEL(199?, m4bigchf    ,0          ,mpu4plasma     ,mpu4               , mpu4_state,m4default          ,ROT0,   "Barcrest","Big Chief (Barcrest) (MPU4 w/ Plasma DMD) (set 1)",                        GAME_FLAGS|GAME_NO_SOUND,layout_mpu4plasma )
195	195	GAMEL(199?, m4bigchfa   ,m4bigchf   ,mpu4plasma     ,mpu4               , mpu4_state,m4default          ,ROT0,   "Barcrest","Big Chief (Barcrest) (MPU4 w/ Plasma DMD) (set 2)",                        GAME_FLAGS|GAME_NO_SOUND,layout_mpu4plasma )

trunk/src/mame/drivers/mpu4sw.c

r243727	r243728
25	25	INPUT_PORTS_EXTERN( mpu4jackpot8tkn );
26	26	INPUT_PORTS_EXTERN( mpu4jackpot8per );
27	27
28		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	28	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
29	29
30	30	DRIVER_INIT_MEMBER(mpu4_state,m4debug)
31	31	{

trunk/src/mame/drivers/mpu4union.c

r243727	r243728
7	7	MACHINE_CONFIG_EXTERN( mod2 );
8	8	INPUT_PORTS_EXTERN( mpu4 );
9	9
10		#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK|GAME_MECHANICAL)
	10	#define GAME_FLAGS (GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK)
11	11
12	12
13	13	ROM_START( m4cwalk )

trunk/src/mame/drivers/sumt8035.c

r243727	r243728
254	254	ROM_END
255	255
256	256
257		GAME( 1981, sm_ngacc,  0,    summit, summit, driver_device,  0, ROT270, "Summit Coin", "Nudge Accumulator (Summit Coin)", GAME_IS_SKELETON_MECHANICAL )
258		GAME( 1981, sm_ultng,  0,    summit, summit, driver_device,  0, ROT270, "Summit Coin", "Ultimate Nudge (Summit Coin)", GAME_IS_SKELETON_MECHANICAL )
	257	GAME( 1981, sm_ngacc,  0,    summit, summit, driver_device,  0, ROT270, "Summit Coin", "Nudge Accumulator (Summit Coin)", GAME_IS_SKELETON )
	258	GAME( 1981, sm_ultng,  0,    summit, summit, driver_device,  0, ROT270, "Summit Coin", "Ultimate Nudge (Summit Coin)", GAME_IS_SKELETON )

trunk/src/mame/drivers/vaportra.c

r243727	r243728
215	215	static MACHINE_CONFIG_START( vaportra, vaportra_state )
216	216
217	217	/* basic machine hardware */
218		MCFG_CPU_ADD("maincpu", M68000,XTAL_24MHz/2) /* Custom chip 59 */
	218	MCFG_CPU_ADD("maincpu", M68000,12000000) /* Custom chip 59 */
219	219	MCFG_CPU_PROGRAM_MAP(main_map)
220	220	MCFG_CPU_VBLANK_INT_DRIVER("screen", vaportra_state,  irq6_line_hold)
221	221
222		MCFG_CPU_ADD("audiocpu", H6280, XTAL_24MHz/4) /* Custom chip 45; Audio section crystal is 32.220 MHz but CPU clock is confirmed as coming from the 24MHz crystal (6Mhz exactly on the CPU) */
	222	MCFG_CPU_ADD("audiocpu", H6280, 32220000/4) /* Custom chip 45; Audio section crystal is 32.220 MHz */
223	223	MCFG_CPU_PROGRAM_MAP(sound_map)
224	224
225	225
r243727	r243728
278	278	/* sound hardware */
279	279	MCFG_SPEAKER_STANDARD_MONO("mono")
280	280
281		MCFG_SOUND_ADD("ym1", YM2203, XTAL_32_22MHz/8)
	281	MCFG_SOUND_ADD("ym1", YM2203, 32220000/8)
282	282	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.60)
283	283
284		MCFG_YM2151_ADD("ym2", XTAL_32_22MHz/9) // uses a preset LS163 to force the odd speed
	284	MCFG_YM2151_ADD("ym2", 32220000/9)
285	285	MCFG_YM2151_IRQ_HANDLER(INPUTLINE("audiocpu", 1)) /* IRQ 2 */
286	286	MCFG_SOUND_ROUTE(0, "mono", 0.60)
287	287	MCFG_SOUND_ROUTE(1, "mono", 0.60)
288	288
289		MCFG_OKIM6295_ADD("oki1", XTAL_32_22MHz/32, OKIM6295_PIN7_HIGH)
	289	MCFG_OKIM6295_ADD("oki1", 32220000/32, OKIM6295_PIN7_HIGH)
290	290	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75)
291	291
292		MCFG_OKIM6295_ADD("oki2", XTAL_32_22MHz/16, OKIM6295_PIN7_HIGH)
	292	MCFG_OKIM6295_ADD("oki2", 32220000/16, OKIM6295_PIN7_HIGH)
293	293	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.60)
294	294	MACHINE_CONFIG_END
295	295
r243727	r243728
840	840	int i;
841	841
842	842	for (i = 0x00000; i < 0x80000; i++)
843		RAM[i] = BITSWAP8(RAM[i],0,6,5,4,3,2,1,7);
	843	RAM[i] = (RAM[i] & 0x7e) | ((RAM[i] & 0x01) << 7) | ((RAM[i] & 0x80) >> 7);
844	844	}
845	845
846	846	/******************************************************************************/

trunk/src/mame/drivers/wms.c

r243727	r243728
376	376	{
377	377	}
378	378
379		GAME( 200?, wms,        0,       wms, wms, wms_state, wms, ROT0, "WMS", "WMS SetUp/Clear Chips (set 1)", GAME_IS_SKELETON_MECHANICAL )
380		GAME( 200?, wmsa,       wms,     wms, wms, wms_state, wms, ROT0, "WMS", "WMS SetUp/Clear Chips (set 2)", GAME_IS_SKELETON_MECHANICAL )
381		GAME( 200?, wmsb,       wms,     wms, wms, wms_state, wms, ROT0, "WMS", "WMS SetUp/Clear Chips (set 3)", GAME_IS_SKELETON_MECHANICAL )
	379	GAME( 200?, wms,        0,       wms, wms, wms_state, wms, ROT0, "WMS", "WMS SetUp/Clear Chips (set 1)", GAME_IS_SKELETON )
	380	GAME( 200?, wmsa,       wms,     wms, wms, wms_state, wms, ROT0, "WMS", "WMS SetUp/Clear Chips (set 2)", GAME_IS_SKELETON )
	381	GAME( 200?, wmsb,       wms,     wms, wms, wms_state, wms, ROT0, "WMS", "WMS SetUp/Clear Chips (set 3)", GAME_IS_SKELETON )
382	382
383		GAME( 200?, btippers,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Big Tippers (Russia)", GAME_IS_SKELETON_MECHANICAL )
384		GAME( 200?, wmsboom,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Boom (Russia)", GAME_IS_SKELETON_MECHANICAL )
385		GAME( 200?, cashcrop,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Cash Crop (Russia)", GAME_IS_SKELETON_MECHANICAL )
386		GAME( 200?, filthyr,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Filthy Rich (Russia)", GAME_IS_SKELETON_MECHANICAL )
387		GAME( 200?, hottop,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Hot Toppings (Russia)", GAME_IS_SKELETON_MECHANICAL )
388		GAME( 200?, inwinner,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Instant Winner (Russia)", GAME_IS_SKELETON_MECHANICAL )
389		GAME( 200?, jptparty,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Jackpot Party (Russia)", GAME_IS_SKELETON_MECHANICAL )
390		GAME( 200?, leprgld,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Leprechaun's Gold (Russia)", GAME_IS_SKELETON_MECHANICAL )
391		GAME( 200?, lol,        0,       wms, wms, wms_state, wms, ROT0, "WMS", "Life of Luxury (Russia)", GAME_IS_SKELETON_MECHANICAL )
392		GAME( 200?, lovewin,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Love To Win (Russia)", GAME_IS_SKELETON_MECHANICAL )
393		GAME( 200?, mtburn,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Money To Burn (Russia)", GAME_IS_SKELETON_MECHANICAL )
394		GAME( 200?, otchart,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Off The Charts (Russia)", GAME_IS_SKELETON_MECHANICAL )
395		GAME( 200?, perfect,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Perfect Game (Russia)", GAME_IS_SKELETON_MECHANICAL )
396		GAME( 200?, reelemin,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Reel 'Em In (Russia)", GAME_IS_SKELETON_MECHANICAL )
397		GAME( 200?, sonoth,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Something For Nothing (Russia)", GAME_IS_SKELETON_MECHANICAL )
398		GAME( 200?, swingin,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Swingin In The Green (Russia)", GAME_IS_SKELETON_MECHANICAL )
399		GAME( 200?, wmstopb,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Top Banana (Russia)", GAME_IS_SKELETON_MECHANICAL )
400		GAME( 200?, wdun,       0,       wms, wms, wms_state, wms, ROT0, "WMS", "Who Dunnit (Russia)", GAME_IS_SKELETON_MECHANICAL )
401		GAME( 200?, winbid,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Winning Bid (Russia)", GAME_IS_SKELETON_MECHANICAL )
402		GAME( 200?, wldstrek,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Wild Streak (Russia)", GAME_IS_SKELETON_MECHANICAL )
403		GAME( 200?, yukongld,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Yukon Gold (Russia)", GAME_IS_SKELETON_MECHANICAL )
	383	GAME( 200?, btippers,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Big Tippers (Russia)", GAME_IS_SKELETON )
	384	GAME( 200?, wmsboom,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Boom (Russia)", GAME_IS_SKELETON )
	385	GAME( 200?, cashcrop,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Cash Crop (Russia)", GAME_IS_SKELETON )
	386	GAME( 200?, filthyr,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Filthy Rich (Russia)", GAME_IS_SKELETON )
	387	GAME( 200?, hottop,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Hot Toppings (Russia)", GAME_IS_SKELETON )
	388	GAME( 200?, inwinner,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Instant Winner (Russia)", GAME_IS_SKELETON )
	389	GAME( 200?, jptparty,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Jackpot Party (Russia)", GAME_IS_SKELETON )
	390	GAME( 200?, leprgld,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Leprechaun's Gold (Russia)", GAME_IS_SKELETON )
	391	GAME( 200?, lol,        0,       wms, wms, wms_state, wms, ROT0, "WMS", "Life of Luxury (Russia)", GAME_IS_SKELETON )
	392	GAME( 200?, lovewin,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Love To Win (Russia)", GAME_IS_SKELETON )
	393	GAME( 200?, mtburn,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Money To Burn (Russia)", GAME_IS_SKELETON )
	394	GAME( 200?, otchart,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Off The Charts (Russia)", GAME_IS_SKELETON )
	395	GAME( 200?, perfect,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Perfect Game (Russia)", GAME_IS_SKELETON )
	396	GAME( 200?, reelemin,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Reel 'Em In (Russia)", GAME_IS_SKELETON )
	397	GAME( 200?, sonoth,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Something For Nothing (Russia)", GAME_IS_SKELETON )
	398	GAME( 200?, swingin,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Swingin In The Green (Russia)", GAME_IS_SKELETON )
	399	GAME( 200?, wmstopb,    0,       wms, wms, wms_state, wms, ROT0, "WMS", "Top Banana (Russia)", GAME_IS_SKELETON )
	400	GAME( 200?, wdun,       0,       wms, wms, wms_state, wms, ROT0, "WMS", "Who Dunnit (Russia)", GAME_IS_SKELETON )
	401	GAME( 200?, winbid,     0,       wms, wms, wms_state, wms, ROT0, "WMS", "Winning Bid (Russia)", GAME_IS_SKELETON )
	402	GAME( 200?, wldstrek,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Wild Streak (Russia)", GAME_IS_SKELETON )
	403	GAME( 200?, yukongld,   0,       wms, wms, wms_state, wms, ROT0, "WMS", "Yukon Gold (Russia)", GAME_IS_SKELETON )

trunk/src/mess/includes/sms.h

r243727	r243728
19	19	#define CONTROL1_TAG   "ctrl1"
20	20	#define CONTROL2_TAG   "ctrl2"
21	21
22		#include "bus/sega8/sega8_slot.h"
23		#include "bus/sms_exp/smsexp.h"
24		#include "bus/sms_ctrl/smsctrl.h"
25	22	#include "bus/gamegear/ggext.h"
	23	#include "bus/sms_ctrl/smsctrl.h"
	24	#include "bus/sms_exp/smsexp.h"
	25	#include "bus/sega8/sega8_slot.h"
26	26
27	27
28	28	class sms_state : public driver_device
r243727	r243728
32	32	: driver_device(mconfig, type, tag),
33	33	m_maincpu(*this, "maincpu"),
34	34	m_vdp(*this, "sms_vdp"),
35		m_main_scr(*this, "screen"),
36	35	m_ym(*this, "ym2413"),
	36	m_main_scr(*this, "screen"),
	37	m_region_maincpu(*this, "maincpu"),
37	38	m_port_ctrl1(*this, CONTROL1_TAG),
38	39	m_port_ctrl2(*this, CONTROL2_TAG),
39	40	m_port_gg_ext(*this, "ext"),
r243727	r243728
44	45	m_port_scope(*this, "SEGASCOPE"),
45	46	m_port_scope_binocular(*this, "SSCOPE_BINOCULAR"),
46	47	m_port_persist(*this, "PERSISTENCE"),
47		m_region_maincpu(*this, "maincpu"),
48	48	m_mainram(NULL),
49	49	m_is_gamegear(0),
50	50	m_is_gg_region_japan(0),
r243727	r243728
61	61	// devices
62	62	required_device<cpu_device> m_maincpu;
63	63	required_device<sega315_5124_device> m_vdp;
64		required_device<screen_device> m_main_scr;
65	64	optional_device<ym2413_device> m_ym;
	65	required_device<screen_device> m_main_scr;
	66	required_memory_region m_region_maincpu;
66	67	optional_device<sms_control_port_device> m_port_ctrl1;
67	68	optional_device<sms_control_port_device> m_port_ctrl2;
68	69	optional_device<gg_ext_port_device> m_port_gg_ext;
69
70	70	optional_ioport m_port_gg_dc;
71	71	optional_ioport m_port_pause;
72	72	optional_ioport m_port_reset;
r243727	r243728
75	75	optional_ioport m_port_scope_binocular;
76	76	optional_ioport m_port_persist;
77	77
78		required_memory_region m_region_maincpu;
79	78	address_space *m_space;
80	79	UINT8 *m_mainram;
81	80	UINT8 *m_BIOS;
r243727	r243728
122	121	UINT8 m_gg_sio[5];
123	122	int m_paused;
124	123
	124	// Data needed for Light Phaser
125	125	UINT8 m_ctrl1_th_state;
126	126	UINT8 m_ctrl2_th_state;
127	127	UINT8 m_ctrl1_th_latch;
128	128	UINT8 m_ctrl2_th_latch;
129
130		// Data needed for Light Phaser
131	129	int m_lphaser_x_offs;   /* Needed to 'calibrate' lphaser; set at cart loading */
132	130
133	131	// Data needed for SegaScope (3D glasses)
r243727	r243728
162	160	DECLARE_READ8_MEMBER(sms_input_port_dc_r);
163	161	DECLARE_READ8_MEMBER(sms_input_port_dd_r);
164	162	DECLARE_READ8_MEMBER(gg_input_port_00_r);
165		DECLARE_READ8_MEMBER(gg_sio_r);
166	163	DECLARE_WRITE8_MEMBER(gg_sio_w);
167		DECLARE_READ8_MEMBER(sms_fm_detect_r);
	164	DECLARE_READ8_MEMBER(gg_sio_r);
168	165	DECLARE_WRITE8_MEMBER(sms_fm_detect_w);
	166	DECLARE_READ8_MEMBER(sms_fm_detect_r);
169	167	DECLARE_WRITE8_MEMBER(sms_ym2413_register_port_w);
170	168	DECLARE_WRITE8_MEMBER(sms_ym2413_data_port_w);
171	169	DECLARE_READ8_MEMBER(sms_sscope_r);

trunk/src/mess/machine/sms.c

r243727	r243728
869	869	// a bug in the program code. The only way this cartridge could have run
870	870	// successfully on a real unit is if the RAM would be initialized with
871	871	// a F0 pattern on power up; F0 = RET P.
872		// This initialization breaks some Game Gear games though (e.g.
	872	// This initialization breaks the some Game Gear games though (e.g.
873	873	// tempojr), suggesting that not all systems had the same initialization.
874		// This also breaks some homebrew software (e.g. Nine Pixels).
875	874	// For the moment we apply this to systems that have the Japanese SMS
876	875	// cartridge slot.
877	876	if (m_has_jpn_sms_cart_slot)

trunk/src/osd/modules/debugger/osx/breakpointsview.m

r243727	r243728
17	17	@implementation MAMEBreakpointsView
18	18
19	19	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
20		if (!(self = [super initWithFrame:f type:DVT_BREAK_POINTS machine:m wholeLineScroll:YES]))
	20	if (!(self = [super initWithFrame:f type:DVT_BREAK_POINTS machine:m]))
21	21	return nil;
22	22	return self;
23	23	}

trunk/src/osd/modules/debugger/osx/consoleview.m

r243727	r243728
17	17	@implementation MAMEConsoleView
18	18
19	19	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
20		if (!(self = [super initWithFrame:f type:DVT_CONSOLE machine:m wholeLineScroll:NO]))
	20	if (!(self = [super initWithFrame:f type:DVT_CONSOLE machine:m]))
21	21	return nil;
22	22	return self;
23	23	}

trunk/src/osd/modules/debugger/osx/debugview.h

r243727	r243728
22	22	int            type;
23	23	running_machine   *machine;
24	24	debug_view      *view;
25		BOOL         wholeLineScroll;
26	25
27	26	INT32         totalWidth, totalHeight, originTop;
28	27
r243727	r243728
36	35
37	36	+ (NSFont *)defaultFont;
38	37
39		- (id)initWithFrame:(NSRect)f type:(debug_view_type)t machine:(running_machine &)m wholeLineScroll:(BOOL)w;
	38	- (id)initWithFrame:(NSRect)f type:(debug_view_type)t machine:(running_machine &)m;
40	39
41	40	- (void)update;
42	41

trunk/src/osd/modules/debugger/osx/debugview.m

r243727	r243728
168	168	// this gets all the lines that are at least partially visible
169	169	debug_view_xy origin(0, 0), size(totalWidth, totalHeight);
170	170	[self convertBounds:[self visibleRect] toFirstAffectedLine:&origin.y count:&size.y];
171		size.y = MIN(size.y, totalHeight - origin.y);
172	171
173	172	// tell the underlying view how much real estate is available
174	173	view->set_visible_size(size);
r243727	r243728
197	196
198	197	- (void)adjustSizeAndRecomputeVisible {
199	198	NSSize const clip = [[[self enclosingScrollView] contentView] bounds].size;
200		NSSize content = NSMakeSize((fontWidth * totalWidth) + (2 * [textContainer lineFragmentPadding]),
201		fontHeight * totalHeight);
202		if (wholeLineScroll)
203		content.height += (fontHeight * 2) - 1;
204		[self setFrameSize:NSMakeSize(ceil(MAX(clip.width, content.width)),
205		ceil(MAX(clip.height, content.height)))];
	199	NSSize const content = NSMakeSize((fontWidth * totalWidth) + (2 * [textContainer lineFragmentPadding]),
	200	fontHeight * totalHeight);
	201	[self setFrameSize:NSMakeSize(MAX(clip.width, content.width), MAX(clip.height, content.height))];
206	202	[self recomputeVisible];
207	203	}
208	204
r243727	r243728
212	208	}
213	209
214	210
215		- (id)initWithFrame:(NSRect)f type:(debug_view_type)t machine:(running_machine &)m wholeLineScroll:(BOOL)w {
	211	- (id)initWithFrame:(NSRect)f type:(debug_view_type)t machine:(running_machine &)m {
216	212	if (!(self = [super initWithFrame:f]))
217	213	return nil;
218	214	type = t;
r243727	r243728
222	218	[self release];
223	219	return nil;
224	220	}
225		wholeLineScroll = w;
226		debug_view_xy const size = view->total_size();
227		totalWidth = size.x;
228		totalHeight = size.y;
	221	totalWidth = totalHeight = 0;
229	222	originTop = 0;
230	223
231	224	text = [[NSTextStorage alloc] init];
r243727	r243728
265	258	if (scroller)
266	259	{
267	260	NSSize const clip = [[scroller contentView] bounds].size;
268		NSSize content = NSMakeSize((fontWidth * newSize.x) + (2 * [textContainer lineFragmentPadding]),
269		fontHeight * newSize.y);
270		if (wholeLineScroll)
271		content.height += (fontHeight * 2) - 1;
272		[self setFrameSize:NSMakeSize(ceil(MAX(clip.width, content.width)),
273		ceil(MAX(clip.height, content.height)))];
	261	NSSize const content = NSMakeSize((fontWidth * newSize.x) + (2 * [textContainer lineFragmentPadding]),
	262	fontHeight * newSize.y);
	263	[self setFrameSize:NSMakeSize(MAX(clip.width, content.width), MAX(clip.height, content.height))];
	264	[self recomputeVisible];
274	265	}
275	266	totalWidth = newSize.x;
276	267	totalHeight = newSize.y;
r243727	r243728
282	273	{
283	274	NSRect const visible = [self visibleRect];
284	275	NSPoint scroll = NSMakePoint(visible.origin.x, newOrigin.y * fontHeight);
	276	if ((newOrigin.y + view->visible_size().y) == totalHeight)
	277	scroll.y += (view->visible_size().y * fontHeight) - visible.size.height;
285	278	[self scrollPoint:scroll];
286	279	originTop = newOrigin.y;
287	280	}
r243727	r243728
294	287	- (NSSize)maximumFrameSize {
295	288	debug_view_xy const max = view->total_size();
296	289	return NSMakeSize(ceil((max.x * fontWidth) + (2 * [textContainer lineFragmentPadding])),
297		ceil((max.y + (wholeLineScroll ? 1 : 0)) * fontHeight));
	290	ceil(max.y * fontHeight));
298	291	}
299	292
300	293
r243727	r243728
526	519	selector:@selector(viewFrameDidChange:)
527	520	name:NSViewFrameDidChangeNotification
528	521	object:[scroller contentView]];
529		[self adjustSizeAndRecomputeVisible];
530	522	}
531	523	}
532	524
r243727	r243728
566	558	}
567	559
568	560
569		- (NSRect)adjustScroll:(NSRect)proposedVisibleRect {
570		if (wholeLineScroll)
571		{
572		CGFloat const clamp = [self bounds].size.height - fontHeight - proposedVisibleRect.size.height;
573		proposedVisibleRect.origin.y = MIN(proposedVisibleRect.origin.y, MAX(clamp, 0));
574		proposedVisibleRect.origin.y -= fmod(proposedVisibleRect.origin.y, fontHeight);
575		}
576		return proposedVisibleRect;
577		}
578
579
580	561	- (void)drawRect:(NSRect)dirtyRect {
581	562	// work out what's available
582	563	[self recomputeVisible];

trunk/src/osd/modules/debugger/osx/debugwindowhandler.m

r243727	r243728
316	316	}
317	317
318	318	- (void)cascadeWindowWithDesiredSize:(NSSize)desired forView:(NSView *)view {
319		// convert desired size to an adjustment and apply it to the current window frame
320		NSSize const current = [view frame].size;
	319	NSRect   available = [[NSScreen mainScreen] visibleFrame];
	320	NSRect   windowFrame = [window frame];
	321	NSSize   current = [view frame].size;
	322
321	323	desired.width -= current.width;
322	324	desired.height -= current.height;
323		NSRect windowFrame = [window frame];
324		windowFrame.size.width += desired.width;
325		windowFrame.size.height += desired.height;
326	325
327		// limit the size to the minimum size
328		NSSize const minimum = [window minSize];
329		windowFrame.size.width = MAX(windowFrame.size.width, minimum.width);
330		windowFrame.size.height = MAX(windowFrame.size.height, minimum.height);
331
332		// limit the size to the main screen size
333		NSRect const available = [[NSScreen mainScreen] visibleFrame];
	326	windowFrame.size.width += desired.width;
334	327	windowFrame.size.width = MIN(windowFrame.size.width, available.size.width);
335		windowFrame.size.height = MIN(windowFrame.size.height, available.size.height);
336
337		// arbitrary additional height limit
338		windowFrame.size.height = MIN(windowFrame.size.height, 320);
339
340		// place it in the bottom right corner and apply
	328	windowFrame.size.height += desired.height;
	329	windowFrame.size.height = MIN(MIN(MAX(windowFrame.size.height, 120), 320), available.size.height);
341	330	windowFrame.origin.x = available.origin.x + available.size.width - windowFrame.size.width;
342	331	windowFrame.origin.y = available.origin.y;
343	332	[window setFrame:windowFrame display:YES];
344	333	[[self class] cascadeWindow:window];
	334
	335	windowFrame = [[window contentView] frame];
	336	desired = [window contentMinSize];
	337	[window setContentMinSize:NSMakeSize(MIN(windowFrame.size.width, desired.width),
	338	MIN(windowFrame.size.height, desired.height))];
345	339	}
346	340
347	341	@end

trunk/src/osd/modules/debugger/osx/disassemblyview.m

r243727	r243728
17	17	@implementation MAMEDisassemblyView
18	18
19	19	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
20		if (!(self = [super initWithFrame:f type:DVT_DISASSEMBLY machine:m wholeLineScroll:NO]))
	20	if (!(self = [super initWithFrame:f type:DVT_DISASSEMBLY machine:m]))
21	21	return nil;
22	22	return self;
23	23	}

trunk/src/osd/modules/debugger/osx/errorlogview.m

r243727	r243728
17	17	@implementation MAMEErrorLogView
18	18
19	19	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
20		if (!(self = [super initWithFrame:f type:DVT_LOG machine:m wholeLineScroll:NO]))
	20	if (!(self = [super initWithFrame:f type:DVT_LOG machine:m]))
21	21	return nil;
22	22	return self;
23	23	}

trunk/src/osd/modules/debugger/osx/memoryview.m

r243727	r243728
18	18	@implementation MAMEMemoryView
19	19
20	20	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
21		if (!(self = [super initWithFrame:f type:DVT_MEMORY machine:m wholeLineScroll:NO]))
	21	if (!(self = [super initWithFrame:f type:DVT_MEMORY machine:m]))
22	22	return nil;
23	23	return self;
24	24	}

trunk/src/osd/modules/debugger/osx/registersview.m

r243727	r243728
18	18	@implementation MAMERegistersView
19	19
20	20	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
21		if (!(self = [super initWithFrame:f type:DVT_STATE machine:m wholeLineScroll:NO]))
	21	if (!(self = [super initWithFrame:f type:DVT_STATE machine:m]))
22	22	return nil;
23	23	return self;
24	24	}

trunk/src/osd/modules/debugger/osx/watchpointsview.m

r243727	r243728
17	17	@implementation MAMEWatchpointsView
18	18
19	19	- (id)initWithFrame:(NSRect)f machine:(running_machine &)m {
20		if (!(self = [super initWithFrame:f type:DVT_WATCH_POINTS machine:m wholeLineScroll:YES]))
	20	if (!(self = [super initWithFrame:f type:DVT_WATCH_POINTS machine:m]))
21	21	return nil;
22	22	return self;
23	23	}

trunk/src/osd/sdl/sdl.mak

r243727	r243728
734	734	LIBS += -lSDL2 -limm32 -lversion -lole32 -loleaut32 -lws2_32 -static
735	735	BASELIBS += -lSDL2 -limm32 -lversion -lole32 -loleaut32 -lws2_32 -static
736	736	else
737		LIBS += -lSDL -static
738		BASELIBS += -lSDL -static
	737	LIBS += -lSDL -lws2_32 -static
	738	BASELIBS += -lSDL -lws2_32 -static
739	739	endif
740	740	LIBS += -luser32 -lgdi32 -lddraw -ldsound -ldxguid -lwinmm -ladvapi32 -lcomctl32 -lshlwapi
741	741	BASELIBS += -luser32 -lgdi32 -lddraw -ldsound -ldxguid -lwinmm -ladvapi32 -lcomctl32 -lshlwapi

https://github.com/mamedev/mame/commit/4ca1df404eb09cf02c5006ee7ec558ab7db843c0

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team