uae_u8 dummy[4+4];
uae_u8 jmps[3*4];
uae_u32 mon_size;
- uae_u16 col0, col1;
+ uae_u8 col0h, col0l, col1h, col1l;
uae_u8 right;
uae_u8 keyboard;
uae_u8 key;
HRTCFG *cfg = (HRTCFG*)hrtmemory;
if (ar1200 || armodel || !cfg)
return;
+ cfg->col0h = 0x00; cfg->col0l = 0x5a;
+ cfg->col1h = 0x0f; cfg->col1l = 0xff;
cfg->a1200 = (currprefs.chipset_mask & CSMASK_AGA) ? 1 : 0;
cfg->aga = (currprefs.chipset_mask & CSMASK_AGA) ? 1 : 0;
cfg->cd32 = cd32_enabled;
}
currprefs.immediate_blits = changed_prefs.immediate_blits;
currprefs.collision_level = changed_prefs.collision_level;
- currprefs.fast_copper = changed_prefs.fast_copper;
if (currprefs.chipset_mask != changed_prefs.chipset_mask ||
currprefs.gfx_vsync != changed_prefs.gfx_vsync ||
* Debugger
*
* (c) 1995 Bernd Schmidt
+ * (c) 2006 Toni Wilen
*
*/
" O <plane> <offset> Offset a bitplane\n"
" H[H] <cnt> Show PC history (HH=full CPU info) <cnt> instructions\n"
" C <value> Search for values like energy or lifes in games\n"
+ " Cl List currently found trainer addresses\n"
+ " D Deep trainer\n"
" W <address> <value> Write into Amiga memory\n"
" w <num> <address> <length> <R/W/RW> [<value>]\n"
" Add/remove memory watchpoints\n"
return strlen (out);
}
-static uae_u32 nextaddr (uae_u32 addr)
+static uae_u32 lastaddr (void)
+{
+ if (currprefs.z3fastmem_size)
+ return z3fastmem_start + currprefs.fastmem_size;
+ if (currprefs.bogomem_size)
+ return bogomem_start + currprefs.bogomem_size;
+ if (currprefs.fastmem_size)
+ return fastmem_start + currprefs.fastmem_size;
+ return currprefs.chipmem_size;
+}
+
+static uaecptr nextaddr (uaecptr addr, uaecptr *end)
{
if (addr == 0xffffffff) {
- if (currprefs.bogomem_size)
- return 0xc00000 + currprefs.bogomem_size;
- if (currprefs.fastmem_size)
- return 0x200000 + currprefs.fastmem_size;
- return currprefs.chipmem_size;
+ if (end)
+ *end = currprefs.chipmem_size;
+ return 0;
}
+ addr++;
if (addr == currprefs.chipmem_size) {
- if (currprefs.fastmem_size)
- return 0x200000;
- else if (currprefs.bogomem_size)
- return 0xc00000;
+ if (currprefs.fastmem_size) {
+ if (end)
+ *end = fastmem_start + currprefs.fastmem_size;
+ return fastmem_start;
+ } else if (currprefs.bogomem_size) {
+ if (end)
+ *end = bogomem_start + currprefs.bogomem_size;
+ return bogomem_start;
+ } else if (currprefs.z3fastmem_size) {
+ if (end)
+ *end = z3fastmem_start + currprefs.z3fastmem_size;
+ return z3fastmem_start;
+ }
return 0xffffffff;
}
- if (addr == 0x200000 + currprefs.fastmem_size) {
- if (currprefs.bogomem_size)
- return 0xc00000;
+ if (addr == fastmem_start + currprefs.fastmem_size) {
+ if (currprefs.bogomem_size) {
+ if (end)
+ *end = fastmem_start + currprefs.bogomem_size;
+ return bogomem_start;
+ } else if (currprefs.z3fastmem_size) {
+ if (end)
+ *end = z3fastmem_start + currprefs.z3fastmem_size;
+ return z3fastmem_start;
+ }
+ return 0xffffffff;
+ }
+ if (addr == bogomem_start + currprefs.bogomem_size) {
+ if (currprefs.z3fastmem_size) {
+ if (end)
+ *end = z3fastmem_start + currprefs.z3fastmem_size;
+ return z3fastmem_start;
+ }
return 0xffffffff;
}
- if (addr == 0xc00000 + currprefs.bogomem_size)
+ if (addr == z3fastmem_start + currprefs.z3fastmem_size)
return 0xffffffff;
- return addr + 1;
+ return addr;
}
static void dumpmem (uaecptr addr, uaecptr *nxmem, int lines)
}
#define MAX_CHEAT_VIEW 100
+struct trainerstruct {
+ uaecptr addr;
+ int size;
+};
+
+static struct trainerstruct *trainerdata;
+static int totaltrainers;
+
+static void clearcheater(void)
+{
+ if (!trainerdata)
+ trainerdata = xmalloc(MAX_CHEAT_VIEW * sizeof (struct trainerstruct));
+ memset(trainerdata, 0, sizeof (struct trainerstruct) * MAX_CHEAT_VIEW);
+ totaltrainers = 0;
+}
+static int addcheater(uaecptr addr, int size)
+{
+ if (totaltrainers >= MAX_CHEAT_VIEW)
+ return 0;
+ trainerdata[totaltrainers].addr = addr;
+ trainerdata[totaltrainers].size = size;
+ totaltrainers++;
+ return 1;
+}
+static void listcheater(int mode)
+{
+ int i, skip;
+
+ if (!trainerdata)
+ return;
+ if (mode)
+ skip = 6;
+ else
+ skip = 8;
+ for(i = 0; i < totaltrainers; i++) {
+ struct trainerstruct *ts = &trainerdata[i];
+ uae_u8 b = get_byte(ts->addr);
+ if (mode)
+ console_out("%08.8X=%2.2X ", ts->addr, b, b);
+ else
+ console_out("%08.8X ", ts->addr);
+ if ((i % skip) == skip)
+ console_out("\n");
+ }
+}
+
+static void deepcheatsearch (char v)
+{
+ static int first = 1;
+ static uae_u8 *memtmp;
+ static int memsize, memsize2;
+ uae_u8 *p1, *p2;
+ uaecptr addr, end;
+ int i, wasmodified;
+ int addrcnt, cnt;
+
+ if (!memtmp || v == 'S') {
+ first = 1;
+ xfree(memtmp);
+ memsize = 0;
+ addr = 0xffffffff;
+ while ((addr = nextaddr(addr, &end)) != 0xffffffff) {
+ memsize += end - addr;
+ addr = end - 1;
+ }
+ memsize2 = (memsize + 7) / 8;
+ memtmp = xmalloc (memsize + memsize2);
+ if (!memtmp)
+ return;
+ memset (memtmp + memsize, 0xff, memsize2);
+ p1 = memtmp;
+ addr = 0xffffffff;
+ while ((addr = nextaddr(addr, &end)) != 0xffffffff) {
+ for (i = addr; i < end; i++)
+ *p1++ = get_byte (i);
+ addr = end - 1;
+ }
+ console_out("deep trainer first pass complete.\n");
+ return;
+ }
+ wasmodified = v == 'X' ? 0 : 1;
+ p1 = memtmp;
+ p2 = memtmp + memsize;
+ addrcnt = 0;
+ cnt = 0;
+ addr = 0xffffffff;
+ while ((addr = nextaddr(addr, NULL)) != 0xffffffff) {
+ uae_u8 b = get_byte (addr);
+ int addroff = addrcnt >> 3;
+ int addrmask = 1 << (addrcnt & 7);
+ if (p2[addroff] & addrmask) {
+ if ((wasmodified && b == *p1) || (!wasmodified && b != *p1))
+ p2[addroff] &= ~addrmask;
+ else
+ cnt++;
+ }
+ *p1++ = b;
+ addrcnt++;
+ }
+ console_out ("%d addresses found\n", cnt);
+ if (cnt <= MAX_CHEAT_VIEW) {
+ clearcheater();
+ cnt = 0;
+ addrcnt = 0;
+ while ((addr = nextaddr(addr, NULL)) != 0xffffffff) {
+ int addroff = addrcnt >> 3;
+ int addrmask = 1 << (addrcnt & 7);
+ if (p2[addroff] & addrmask)
+ addcheater(addr, 1);
+ addrcnt++;
+ cnt++;
+ }
+ listcheater(1);
+ } else {
+ console_out("Now continue with 'g' and use 'D' again after you have lost another life\n");
+ }
+}
+
/* cheat-search by Toni Wilen (originally by Holger Jakob) */
static void cheatsearch (char **c)
{
static int listsize;
static int first = 1;
static int size = 1;
- uae_u32 p, val, memcnt, prevmemcnt;
+ uae_u32 val, memcnt, prevmemcnt;
int i, count, vcnt, memsize;
+ uaecptr addr, end;
- memsize = allocated_chipmem + allocated_bogomem + allocated_fastmem;
+ memsize = 0;
+ addr = 0xffffffff;
+ while ((addr = nextaddr(addr, &end)) != 0xffffffff) {
+ memsize += end - addr;
+ addr = end - 1;
+ }
+ if (toupper(**c) == 'L') {
+ listcheater(1);
+ return;
+ }
ignore_ws (c);
if (!more_params(c)) {
first = 1;
vlist = xcalloc (listsize >> 3, 1);
return;
}
- val = readhex (c);
+ val = readint (c);
if (first) {
ignore_ws (c);
if (val > 255)
count = 0;
vcnt = 0;
- for (prevmemcnt = memcnt = 0; memcnt < memsize - size && memcnt < listsize; memcnt++) {
- p = memcnt;
- if (memcnt >= allocated_chipmem + allocated_bogomem && memcnt < allocated_chipmem + allocated_bogomem + allocated_fastmem)
- p = 0x200000 + memcnt - (allocated_chipmem + allocated_bogomem);
- if (memcnt >= allocated_chipmem && memcnt < allocated_chipmem + allocated_bogomem)
- p = 0xc00000 + memcnt - (allocated_chipmem);
-
- for (i = 0; i < size; i++) {
- if (get_byte(p + i) != val >> ((size - i - 1) << 8))
- break;
- }
- if (i == size) {
- int voffset = memcnt >> 3;
- int vmask = 1 << (memcnt & 7);
- if (!first) {
- while (prevmemcnt < memcnt) {
- vlist[prevmemcnt >> 3] &= ~(1 << (prevmemcnt & 7));
- prevmemcnt++;
- }
- if (vlist[voffset] & vmask) {
- count++;
- if (vcnt < MAX_CHEAT_VIEW) {
- console_out ("%08x ", p);
- vcnt++;
- if (!(vcnt % 8))
- console_out("\n");
+ clearcheater();
+ addr = 0xffffffff;
+ prevmemcnt = memcnt = 0;
+ while ((addr = nextaddr(addr, &end)) != 0xffffffff) {
+ if (addr + size < end) {
+ for (i = 0; i < size; i++) {
+ if (get_byte(addr + i) != val >> ((size - i - 1) << 8))
+ break;
+ }
+ if (i == size) {
+ int voffset = memcnt >> 3;
+ int vmask = 1 << (memcnt & 7);
+ if (!first) {
+ while (prevmemcnt < memcnt) {
+ vlist[prevmemcnt >> 3] &= ~(1 << (prevmemcnt & 7));
+ prevmemcnt++;
}
+ if (vlist[voffset] & vmask) {
+ count++;
+ addcheater(addr, size);
+ } else {
+ vlist[voffset] &= ~vmask;
+ }
+ prevmemcnt = memcnt + 1;
} else {
- vlist[voffset] &= ~vmask;
+ vlist[voffset] |= vmask;
+ count++;
}
- prevmemcnt = memcnt + 1;
- } else {
- vlist[voffset] |= vmask;
- count++;
}
}
+ memcnt++;
}
if (!first) {
while (prevmemcnt < memcnt) {
vlist[prevmemcnt >> 3] &= ~(1 << (prevmemcnt & 7));
prevmemcnt++;
}
+ listcheater(0);
}
- if (!first && (vcnt % 8))
- console_out ("\n");
console_out ("Found %d possible addresses with 0x%x (%u) (%d bytes)\n", count, val, val, size);
console_out ("Now continue with 'g' and use 'C' with a different value\n");
first = 0;
static void memory_map_dump (void)
{
- int i, j, k, max;
+ int i, j, max;
addrbank *a1 = mem_banks[0];
max = currprefs.address_space_24 ? 256 : 65536;
return;
ignore_ws (cc);
addr = 0;
- endaddr = nextaddr (0xffffffff);
+ endaddr = lastaddr ();
if (more_params (cc)) {
addr = readhex (cc);
if (more_params (cc))
endaddr = readhex (cc);
}
console_out ("Searching from %08x to %08x..\n", addr, endaddr);
- while (addr < endaddr && addr != 0xffffffff) {
+ while ((addr = nextaddr (addr, NULL)) != 0xffffffff) {
for (i = 0; i < sslen; i++) {
uae_u8 b = get_byte (addr + i);
if (stringmode) {
break;
}
}
- addr = nextaddr (addr);
}
if (!got)
console_out ("nothing found");
disk_debug_track);
}
-static uae_u32 memory_counter(int reset)
-{
- static uae_u32 p;
- if (reset) {
- p = 0xffffffff;
- return 0;
- }
- p++;
- if (p == allocated_chipmem)
- p = 0x200000;
- if (p == allocated_fastmem + 0x200000)
- p = 0xc00000;
- if (p == allocated_bogomem + 0xc00000)
- p = 0xffffffff;
- return p;
-}
-
static void find_ea (char **inptr)
{
- uae_u32 ea, sea, dea, start, end;
- int i;
+ uae_u32 ea, sea, dea;
+ uaecptr addr, end, endbank;
- start = 0;
- end = allocated_chipmem;
+ addr = 0;
+ end = lastaddr();
ea = readhex (inptr);
- if (more_params(inptr))
- start = readhex (inptr);
- if (more_params(inptr))
- end = readhex (inptr);
- memory_counter(1);
- while ((i = memory_counter(0)) != 0xffffffff) {
- sea = 0xffffffff;
- dea = 0xffffffff;
- m68k_disasm_ea (NULL, i, NULL, 1, &sea, &dea);
- if (ea == sea || ea == dea)
- m68k_disasm (stdout, i, NULL, 1);
+ if (more_params(inptr)) {
+ addr = readhex (inptr);
+ if (more_params(inptr))
+ end = readhex (inptr);
+ }
+ console_out("Searching from %08.8X to %08.8X\n", addr, end);
+ while((addr = nextaddr(addr, &endbank)) != 0xffffffff) {
+ if (addr == end)
+ break;
+ if ((addr & 1) == 0 && addr + 6 <= endbank) {
+ sea = 0xffffffff;
+ dea = 0xffffffff;
+ m68k_disasm_ea (NULL, addr, NULL, 1, &sea, &dea);
+ if (ea == sea || ea == dea)
+ m68k_disasm (stdout, addr, NULL, 1);
+ }
}
}
else
m68k_dumpstate (stdout, &nextpc);
break;
+ case 'D': deepcheatsearch (toupper(*inptr)); break;
case 'C': cheatsearch (&inptr); break;
case 'W': writeintomem (&inptr); break;
case 'w': memwatch (&inptr); break;
}
if (do_skip) {
set_special (SPCFLAG_BRK);
+ unset_special (SPCFLAG_STOP);
debugging = 1;
}
resume_sound ();
static int fastmem_check (uaecptr addr, uae_u32 size) REGPARAM;
static uae_u8 *fastmem_xlate (uaecptr addr) REGPARAM;
-static uae_u32 fastmem_start; /* Determined by the OS */
+uaecptr fastmem_start; /* Determined by the OS */
static uae_u8 *fastmemory;
uae_u32 REGPARAM2 fastmem_lget (uaecptr addr)
static int z3fastmem_check (uaecptr addr, uae_u32 size) REGPARAM;
static uae_u8 *z3fastmem_xlate (uaecptr addr) REGPARAM;
-static uae_u32 z3fastmem_start; /* Determined by the OS */
+uaecptr z3fastmem_start; /* Determined by the OS */
static uae_u8 *z3fastmem;
uae_u32 REGPARAM2 z3fastmem_lget (uaecptr addr)
#define bogomem_start 0x00C00000
#define a3000mem_start 0x07000000
#define kickmem_start 0x00F80000
+extern uaecptr z3fastmem_start;
+extern uaecptr fastmem_start;
extern int ersatzkickfile;
extern int cloanto_rom;
int leds_on_screen;
int keyboard_leds[3];
int keyboard_leds_in_use;
- int fast_copper;
int scsi;
int uaeserial;
int catweasel;
p->chipmem_size = 0x200000;
err = 1;
}
- if (p->chipmem_size > 0x80000)
- p->chipset_mask |= CSMASK_ECS_AGNUS;
-
if ((p->fastmem_size & (p->fastmem_size - 1)) != 0
|| (p->fastmem_size != 0 && (p->fastmem_size < 0x100000 || p->fastmem_size > 0x800000)))
{
p->dfxtype[3] = 0;
err = 1;
}
-
if (p->floppy_speed > 0 && p->floppy_speed < 10) {
p->floppy_speed = 100;
}
if (p->input_mouse_speed < 1 || p->input_mouse_speed > 1000) {
p->input_mouse_speed = 100;
}
- if (p->cpu_cycle_exact || p->blitter_cycle_exact)
- p->fast_copper = 0;
-
if (p->collision_level < 0 || p->collision_level > 3) {
write_log ("Invalid collision support level. Using 1.\n");
p->collision_level = 1;
err = 1;
}
-
if (p->parallel_postscript_emulation)
p->parallel_postscript_detection = 1;
size = currprefs.chipmem_size;
size += currprefs.fastmem_size;
size += currprefs.bogomem_size;
+ size += currprefs.z3fastmem_size;
buf = p = xmalloc (size);
memcpy (p, chipmemory, currprefs.chipmem_size);
p += currprefs.chipmem_size;
- mc (p, 0x200000, currprefs.fastmem_size);
+ mc (p, fastmem_start, currprefs.fastmem_size);
p += currprefs.fastmem_size;
- mc (p, 0xc00000, currprefs.bogomem_size);
+ mc (p, bogomem_start, currprefs.bogomem_size);
+ p += currprefs.bogomem_size;
+ mc (p, z3fastmem_start, currprefs.z3fastmem_size);
+ p += currprefs.z3fastmem_size;
got = 0;
canceled = 0;
return 0;
}
#endif
- if ((regs.spcflags & SPCFLAG_ACTION_REPLAY) && action_replay_flag != ACTION_REPLAY_INACTIVE )
- {
+ if ((regs.spcflags & SPCFLAG_ACTION_REPLAY) && action_replay_flag != ACTION_REPLAY_INACTIVE ) {
/*if(action_replay_flag == ACTION_REPLAY_ACTIVE && !is_ar_pc_in_rom())*/
/* write_log("PC:%p\n",m68k_getpc());*/
}
}
+ if (regs.spcflags & SPCFLAG_STOP)
+ do_specialties (0);
#ifndef JIT
m68k_run1 (currprefs.cpu_level == 0 && currprefs.cpu_cycle_exact ? m68k_run_1_ce :
currprefs.cpu_level == 0 && currprefs.cpu_compatible ? m68k_run_1 :
int avioutput_width, avioutput_height, avioutput_bits;
int avioutput_fps = VBLANK_HZ_PAL;
-int avioutput_framelimiter = 0;
+DWORD avioutput_framelimiter = 0;
char avioutput_filename[MAX_DPATH];
static char avioutput_filename_tmp[MAX_DPATH];
return fkey;
}
+static void storesettings(HKEY avikey)
+{
+ RegSetValueEx(avikey, "FrameLimiter", 0, REG_DWORD, (BYTE*)&avioutput_framelimiter, sizeof(DWORD));
+ RegSetValueEx(avikey, "FPS", 0, REG_DWORD, (BYTE*)&avioutput_fps, sizeof(DWORD));
+}
+static void getsettings(HKEY avikey)
+{
+ DWORD val;
+ DWORD ss = sizeof (DWORD);
+ if (RegQueryValueEx(avikey, "FrameLimiter", 0, NULL, (BYTE*)&val, &ss) == ERROR_SUCCESS)
+ avioutput_framelimiter = val;
+ ss = sizeof (DWORD);
+ if (RegQueryValueEx(avikey, "FPS", 0, NULL, (BYTE*)&val, &ss) == ERROR_SUCCESS)
+ avioutput_fps = val;
+}
+
+void AVIOutput_GetSettings(void)
+{
+ HKEY avikey = openavikey();
+ if (avikey) {
+ getsettings(avikey);
+ RegCloseKey(avikey);
+ }
+}
+void AVIOutput_SetSettings(void)
+{
+ HKEY avikey = openavikey();
+ if (avikey) {
+ storesettings(avikey);
+ RegCloseKey(avikey);
+ }
+}
+
static UINT CALLBACK acmFilterChooseHookProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(uMsg == MM_ACM_FORMATCHOOSE) {
avikey = openavikey();
if (!avikey)
return 0;
+ getsettings(avikey);
if (wft) {
if (RegQueryValueEx(avikey, "AudioConfigurationVars", 0, NULL, NULL, &ss) == ERROR_SUCCESS) {
if (ss <= sizeof(WAVEFORMATEX) + wft->cbSize) {
avikey = openavikey();
if (avikey) {
RegSetValueEx(avikey, "AudioConfigurationVars", 0, REG_BINARY, (BYTE*)pwfxDst, pwfxDst->cbSize + sizeof(WAVEFORMATEX));
+ storesettings(avikey);
RegCloseKey(avikey);
}
return 1;
avikey = openavikey();
if (!avikey)
return 0;
+ getsettings(avikey);
if (pcv) {
ss = pcv->cbSize;
pcv->hic = 0;
if (avikey) {
RegSetValueEx(avikey, "VideoConfigurationState", 0, REG_BINARY, state, ss);
RegSetValueEx(avikey, "VideoConfigurationVars", 0, REG_BINARY, (BYTE*)pcompvars, pcompvars->cbSize);
+ storesettings(avikey);
RegCloseKey(avikey);
}
xfree (state);
extern int avioutput_video, avioutput_audio, avioutput_enabled, avioutput_requested;
extern int avioutput_width, avioutput_height, avioutput_bits;
-extern int avioutput_fps, avioutput_framelimiter;
+extern int avioutput_fps;
+extern DWORD avioutput_framelimiter;
extern char avioutput_filename[MAX_DPATH];
extern void AVIOutput_Release(void);
extern void AVIOutput_Initialize(void);
extern void AVIOutput_RGBinfo(int,int,int,int,int,int);
+extern void AVIOutput_GetSettings(void);
+extern void AVIOutput_SetSettings(void);
#define AVIAUDIO_AVI 1
#define AVIAUDIO_WAV 2
CONTROL "NTSC [] North American and Japanese display standard, 60Hz refresh rate. Other countries use PAL (50Hz. display refresh rate)",IDC_NTSC,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,102,63,50,10
GROUPBOX "Options",IDC_STATIC,168,11,114,82
- CONTROL "Fast Copper [] Faster but less compatible copper emulation.",IDC_FASTCOPPER,
- "Button",BS_AUTOCHECKBOX | NOT WS_VISIBLE | WS_TABSTOP,176,198,98,10
CONTROL "Immediate Blitter [] Faster but less compatible blitter emulation.",IDC_BLITIMM,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,174,30,96,10
CONTROL "Cycle-exact CPU and Blitter [] The most compatible A500 emulation mode. Very fast PC recommended.",IDC_CYCLEEXACT,
EnableWindow (GetDlgItem (hDlg, IDC_GENLOCK), full_property_sheet);
EnableWindow (GetDlgItem (hDlg, IDC_BLITIMM), enable);
if (enable == FALSE) {
- workprefs.fast_copper = 0;
workprefs.immediate_blits = 0;
CheckDlgButton (hDlg, IDC_FASTCOPPER, FALSE);
CheckDlgButton (hDlg, IDC_BLITIMM, FALSE);
}
CheckDlgButton (hDlg, IDC_NTSC, workprefs.ntscmode);
CheckDlgButton (hDlg, IDC_GENLOCK, workprefs.genlock);
- CheckDlgButton (hDlg, IDC_FASTCOPPER, workprefs.fast_copper);
CheckDlgButton (hDlg, IDC_BLITIMM, workprefs.immediate_blits);
CheckRadioButton (hDlg, IDC_COLLISION0, IDC_COLLISION3, IDC_COLLISION0 + workprefs.collision_level);
CheckDlgButton (hDlg, IDC_CYCLEEXACT, workprefs.cpu_cycle_exact);
BOOL success = FALSE;
int n, snd;
- workprefs.fast_copper = IsDlgButtonChecked (hDlg, IDC_FASTCOPPER);
workprefs.genlock = IsDlgButtonChecked (hDlg, IDC_FASTCOPPER);
workprefs.immediate_blits = IsDlgButtonChecked (hDlg, IDC_BLITIMM);
n = IsDlgButtonChecked (hDlg, IDC_CYCLEEXACT) ? 1 : 0;
workprefs.m68k_speed = 0;
}
workprefs.immediate_blits = 0;
- workprefs.fast_copper = 0;
workprefs.gfx_framerate = 1;
}
}
if (f_text < 0)
return;
SendDlgItemMessage(hDlg, f_text, CB_RESETCONTENT, 0, 0);
- SendDlgItemMessage(hDlg, f_text, WM_SETTEXT, 0, (LPARAM)workprefs.df[n]);
+ SendDlgItemMessage(hDlg, f_text, WM_SETTEXT, 0, (LPARAM)workprefs.df[n]);
i = 0;
while (s = DISK_history_get (i)) {
char tmpname[MAX_DPATH], tmppath[MAX_DPATH], *p, *p2;
static void getfloppyname (HWND hDlg, int n)
{
int f_text = currentpage == QUICKSTART_ID ? floppybuttonsq[n][0] : floppybuttons[n][0];
- char tmp[1000];
+ char tmp[MAX_DPATH];
if (getfloppybox (hDlg, f_text, tmp, sizeof (tmp))) {
disk_insert (n, tmp);
#ifdef AVIOUTPUT
static void values_to_avioutputdlg(HWND hDlg)
{
- char tmpstr[256];
+ char tmpstr[256];
- updatewinfsmode (&workprefs);
- SetDlgItemText(hDlg, IDC_AVIOUTPUT_FILETEXT, avioutput_filename);
+ updatewinfsmode (&workprefs);
+ SetDlgItemText(hDlg, IDC_AVIOUTPUT_FILETEXT, avioutput_filename);
- sprintf(tmpstr, "%d fps", avioutput_fps);
- SendMessage(GetDlgItem(hDlg, IDC_AVIOUTPUT_FPS_STATIC), WM_SETTEXT, (WPARAM) 0, (LPARAM) tmpstr);
+ sprintf(tmpstr, "%d fps", avioutput_fps);
+ SendMessage(GetDlgItem(hDlg, IDC_AVIOUTPUT_FPS_STATIC), WM_SETTEXT, (WPARAM) 0, (LPARAM) tmpstr);
- sprintf(tmpstr, "Actual: %d x %d", workprefs.gfx_size.width, workprefs.gfx_size.height);
- SendMessage(GetDlgItem(hDlg, IDC_AVIOUTPUT_DIMENSIONS_STATIC), WM_SETTEXT, (WPARAM) 0, (LPARAM) tmpstr);
+ sprintf(tmpstr, "Actual: %d x %d", workprefs.gfx_size.width, workprefs.gfx_size.height);
+ SendMessage(GetDlgItem(hDlg, IDC_AVIOUTPUT_DIMENSIONS_STATIC), WM_SETTEXT, (WPARAM) 0, (LPARAM) tmpstr);
- switch(avioutput_fps)
- {
+ switch(avioutput_fps)
+ {
case VBLANK_HZ_PAL:
- CheckRadioButton(hDlg, IDC_AVIOUTPUT_PAL, IDC_AVIOUTPUT_NTSC, IDC_AVIOUTPUT_PAL);
- break;
+ CheckRadioButton(hDlg, IDC_AVIOUTPUT_PAL, IDC_AVIOUTPUT_NTSC, IDC_AVIOUTPUT_PAL);
+ break;
case VBLANK_HZ_NTSC:
- CheckRadioButton(hDlg, IDC_AVIOUTPUT_PAL, IDC_AVIOUTPUT_NTSC, IDC_AVIOUTPUT_NTSC);
- break;
+ CheckRadioButton(hDlg, IDC_AVIOUTPUT_PAL, IDC_AVIOUTPUT_NTSC, IDC_AVIOUTPUT_NTSC);
+ break;
default:
- CheckDlgButton(hDlg, IDC_AVIOUTPUT_PAL, BST_UNCHECKED);
- CheckDlgButton(hDlg, IDC_AVIOUTPUT_NTSC, BST_UNCHECKED);
- break;
- }
+ CheckDlgButton(hDlg, IDC_AVIOUTPUT_PAL, BST_UNCHECKED);
+ CheckDlgButton(hDlg, IDC_AVIOUTPUT_NTSC, BST_UNCHECKED);
+ break;
+ }
- CheckDlgButton (hDlg, IDC_AVIOUTPUT_FRAMELIMITER, avioutput_framelimiter ? FALSE : TRUE);
- CheckDlgButton (hDlg, IDC_AVIOUTPUT_ACTIVATED, avioutput_requested ? BST_CHECKED : BST_UNCHECKED);
- CheckDlgButton (hDlg, IDC_SAMPLERIPPER_ACTIVATED, sampleripper_enabled ? BST_CHECKED : BST_UNCHECKED);
+ CheckDlgButton (hDlg, IDC_AVIOUTPUT_FRAMELIMITER, avioutput_framelimiter ? FALSE : TRUE);
+ CheckDlgButton (hDlg, IDC_AVIOUTPUT_ACTIVATED, avioutput_requested ? BST_CHECKED : BST_UNCHECKED);
+ CheckDlgButton (hDlg, IDC_SAMPLERIPPER_ACTIVATED, sampleripper_enabled ? BST_CHECKED : BST_UNCHECKED);
}
static void values_from_avioutputdlg(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
avioutput_fps = (int)tmp;
AVIOutput_Restart ();
}
- avioutput_framelimiter = IsDlgButtonChecked (hDlg, IDC_AVIOUTPUT_FRAMELIMITER) ? 0 : 1;
}
static void enable_for_avioutputdlg(HWND hDlg)
EnableWindow(GetDlgItem(hDlg, IDC_AVIOUTPUT_NTSC), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_AVIOUTPUT_FPS), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_AVIOUTPUT_FILE), TRUE);
- CheckDlgButton (hDlg, IDC_AVIOUTPUT_FRAMELIMITER, avioutput_framelimiter ? FALSE : TRUE);
if(workprefs.produce_sound < 2) {
EnableWindow(GetDlgItem(hDlg, IDC_AVIOUTPUT_AUDIO), FALSE);
}
SetWindowText(GetDlgItem(hDlg, IDC_AVIOUTPUT_VIDEO_STATIC), tmp);
+ CheckDlgButton (hDlg, IDC_AVIOUTPUT_FRAMELIMITER, avioutput_framelimiter ? FALSE : TRUE);
+
EnableWindow(GetDlgItem(hDlg, IDC_AVIOUTPUT_ACTIVATED), (!avioutput_audio && !avioutput_video) ? FALSE : TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_INPREC_RECORD), input_recording >= 0);
case WM_INITDIALOG:
pages[AVIOUTPUT_ID] = hDlg;
currentpage = AVIOUTPUT_ID;
+ AVIOutput_GetSettings();
enable_for_avioutputdlg(hDlg);
SendDlgItemMessage(hDlg, IDC_AVIOUTPUT_FPS, TBM_SETRANGE, TRUE, MAKELONG(1, VBLANK_HZ_NTSC));
- SendDlgItemMessage(hDlg, IDC_AVIOUTPUT_FPS, TBM_SETPOS, TRUE, VBLANK_HZ_PAL);
+ SendDlgItemMessage(hDlg, IDC_AVIOUTPUT_FPS, TBM_SETPOS, TRUE, avioutput_fps);
SendMessage(hDlg, WM_HSCROLL, (WPARAM) NULL, (LPARAM) NULL);
if (!avioutput_filename[0]) {
fetch_path ("VideoPath", avioutput_filename, sizeof (avioutput_filename));
case WM_USER:
recursive++;
-
values_to_avioutputdlg(hDlg);
enable_for_avioutputdlg(hDlg);
-
recursive--;
return TRUE;
case WM_HSCROLL:
{
recursive++;
-
values_from_avioutputdlg(hDlg, msg, wParam, lParam);
values_to_avioutputdlg(hDlg);
enable_for_avioutputdlg(hDlg);
-
recursive--;
-
return TRUE;
}
switch(wParam)
{
+ case IDC_AVIOUTPUT_FRAMELIMITER:
+ avioutput_framelimiter = IsDlgButtonChecked (hDlg, IDC_AVIOUTPUT_FRAMELIMITER) ? 0 : 1;
+ AVIOutput_SetSettings();
+ break;
+
case IDC_INPREC_PLAYMODE:
break;
case IDC_INPREC_RECORD:
const char *help;
HACCEL accel;
int fullpanel;
+ int tmpl;
};
static int GetPanelRect (HWND hDlg, RECT *r)
return CallWindowProc (ToolTipHWNDS2[i].proc, hwnd, message, wParam, lParam);
}
+static int ignorewindows[] = {
+ IDD_FLOPPY, IDC_DF0TEXT, IDC_DF1TEXT, IDC_DF2TEXT, IDC_DF3TEXT, IDC_CREATE_NAME,
+ -1,
+ IDD_QUICKSTART, IDC_DF0TEXTQ, IDC_DF1TEXTQ, IDC_QUICKSTART_HOSTCONFIG,
+ -1,
+ IDD_AVIOUTPUT, IDC_AVIOUTPUT_FILETEXT, IDC_AVIOUTPUT_VIDEO_STATIC, IDC_AVIOUTPUT_AUDIO_STATIC,
+ -1,
+ IDD_DISK, IDC_DISKTEXT, IDC_DISKLIST,
+ -1,
+ IDD_DISPLAY, IDC_DISPLAYSELECT,
+ -1,
+ IDD_FILTER, IDC_FILTERPRESETS,
+ -1,
+ IDD_HARDDISK, IDC_VOLUMELIST,
+ -1,
+ IDD_INPUT, IDC_INPUTDEVICE, IDC_INPUTLIST, IDC_INPUTAMIGA,
+ -1,
+ IDD_KICKSTART, IDC_ROMFILE, IDC_ROMFILE2, IDC_CARTFILE, IDC_FLASHFILE,
+ -1,
+ IDD_LOADSAVE, IDC_CONFIGTREE, IDC_EDITNAME, IDC_EDITDESCRIPTION, IDC_CONFIGLINK, IDC_EDITPATH,
+ -1,
+ IDD_MISC1, IDC_LANGUAGE,
+ -1,
+ IDD_PATHS, IDC_PATHS_ROM, IDC_PATHS_CONFIG, IDC_PATHS_SCREENSHOT, IDC_PATHS_SAVESTATE, IDC_PATHS_AVIOUTPUT, IDC_PATHS_SAVEIMAGE,
+ -1,
+ IDD_PORTS, IDC_PRINTERLIST, IDC_PS_PARAMS, IDC_SERIAL, IDC_MIDIOUTLIST, IDC_MIDIINLIST,
+ -1,
+ IDD_SOUND, IDC_SOUNDCARDLIST, IDC_SOUNDDRIVESELECT,
+ -1,
+ 0
+};
+
static BOOL CALLBACK childenumproc (HWND hwnd, LPARAM lParam)
{
+ int i;
TOOLINFO ti;
char tmp[MAX_DPATH];
char *p;
LRESULT v;
+ if (GetParent(hwnd) != panelDlg)
+ return 1;
+ i = 0;
+ while (ignorewindows[i]) {
+ if (ignorewindows[i] == (int)lParam) {
+ int dlgid = GetDlgCtrlID(hwnd);
+ i++;
+ while (ignorewindows[i] > 0) {
+ if (dlgid == ignorewindows[i])
+ return 1;
+ i++;
+ }
+ break;
+ } else {
+ while (ignorewindows[i++] > 0);
+ }
+ }
tmp[0] = 0;
SendMessage (hwnd, WM_GETTEXT, (WPARAM)sizeof (tmp), (LPARAM)tmp);
p = strchr (tmp, '[');
SendMessage(ToolTipHWND, TTM_SETDELAYTIME, (WPARAM)TTDT_AUTOPOP, (LPARAM)MAKELONG(20000, 0));
SendMessage(ToolTipHWND, TTM_SETMAXTIPWIDTH, 0, 400);
- EnumChildWindows (panelDlg, &childenumproc, (LPARAM)NULL);
+ EnumChildWindows (panelDlg, &childenumproc, (LPARAM)ppage[currentpage].tmpl);
SendMessage (panelDlg, WM_NULL, 0, 0);
hAccelTable = ppage[currentpage].accel;
}
}
} else {
+ DISK_history_add (file, -1);
strcpy (workprefs.df[drv], file);
strcpy (changed_prefs.df[drv], workprefs.df[drv]);
drv++;
ppage[id].help = help;
ppage[id].idx = id;
ppage[id].accel = NULL;
+ ppage[id].tmpl = tmpl;
if (!accels)
accels = EmptyAccel;
while (accels[++i].key);
projects / francis / winuae.git / commitdiff