cfgfile_dwrite_str (f, L"magic_mousecursor", magiccursors[p->input_magic_mouse_cursor]);
cfgfile_dwrite_str (f, L"absolute_mouse", abspointers[p->input_tablet]);
cfgfile_dwrite_bool (f, L"clipboard_sharing", p->clipboard_sharing);
+ cfgfile_dwrite_bool (f, L"native_code", p->native_code);
cfgfile_write (f, L"gfx_display", L"%d", p->gfx_display);
cfgfile_dwrite_str (f, L"gfx_display_name", p->gfx_display_name);
cfgfile_write (f, L"gfx_backbuffers", L"%d", p->gfx_apmode[0].gfx_backbuffers);
cfgfile_write (f, L"gfx_backbuffers_rtg", L"%d", p->gfx_apmode[1].gfx_backbuffers);
+ if (p->gfx_apmode[0].gfx_interlaced)
+ cfgfile_write_bool (f, L"gfx_interlace", p->gfx_apmode[0].gfx_interlaced);
cfgfile_write_str (f, L"gfx_vsync", vsyncmodes[p->gfx_apmode[0].gfx_vsync]);
cfgfile_write_str (f, L"gfx_vsyncmode", vsyncmodes2[p->gfx_apmode[0].gfx_vsyncmode]);
cfgfile_write_str (f, L"gfx_vsync_picasso", vsyncmodes[p->gfx_apmode[1].gfx_vsync]);
if (p->cr[i].rate <= 0)
continue;
struct chipset_refresh *cr = &p->cr[i];
+ cr->index = i;
_stprintf (tmp, L"%f", cr->rate);
TCHAR *s = tmp + _tcslen (tmp);
if (cr->label[0] > 0 && i < MAX_CHIPSET_REFRESH)
|| cfgfile_yesno (option, value, L"gfx_autoresolution", &p->gfx_autoresolution)
|| cfgfile_intval (option, value, L"gfx_backbuffers", &p->gfx_apmode[0].gfx_backbuffers, 1)
|| cfgfile_intval (option, value, L"gfx_backbuffers_rtg", &p->gfx_apmode[1].gfx_backbuffers, 1)
+ || cfgfile_yesno (option, value, L"gfx_interlace", &p->gfx_apmode[0].gfx_interlaced)
|| cfgfile_intval (option, value, L"gfx_center_horizontal_position", &p->gfx_xcenter_pos, 1)
|| cfgfile_intval (option, value, L"gfx_center_vertical_position", &p->gfx_ycenter_pos, 1)
|| cfgfile_yesno (option, value, L"warp", &p->turbo_emulation)
|| cfgfile_yesno (option, value, L"headless", &p->headless)
|| cfgfile_yesno (option, value, L"clipboard_sharing", &p->clipboard_sharing)
+ || cfgfile_yesno (option, value, L"native_code", &p->native_code)
|| cfgfile_yesno (option, value, L"bsdsocket_emu", &p->socket_emu))
return 1;
p->cart_internal = 1;
p->sana2 = 0;
p->clipboard_sharing = false;
+ p->native_code = false;
p->cs_compatible = 1;
p->cs_rtc = 2;
struct chipset_refresh *cr;
for (int i = 0; i < MAX_CHIPSET_REFRESH_TOTAL; i++) {
cr = &p->cr[i];
+ cr->index = i;
cr->rate = -1;
}
cr = &p->cr[CHIPSET_REFRESH_PAL];
+ cr->index = CHIPSET_REFRESH_PAL;
cr->horiz = -1;
cr->vert = -1;
cr->lace = -1;
cr->locked = false;
_tcscpy (cr->label, L"PAL");
cr = &p->cr[CHIPSET_REFRESH_NTSC];
+ cr->index = CHIPSET_REFRESH_NTSC;
cr->horiz = -1;
cr->vert = -1;
cr->lace = -1;
static int lol;
static int next_lineno, prev_lineno;
static enum nln_how nextline_how;
-static int lof_changed = 0;
+static int lof_changed = 0, interlace_changed = 0;
static int scandoubled_line;
static bool vsync_rendered;
static int jitcount = 0;
int minfirstline = VBLANK_ENDLINE_PAL;
int equ_vblank_endline = EQU_ENDLINE_PAL;
double vblank_hz = VBLANK_HZ_PAL, fake_vblank_hz, vblank_hz_stored;
-int vblank_skip, doublescan;
+static int vblank_hz_mult, vblank_hz_state;
+static struct chipset_refresh *stored_chipset_refresh;
+int doublescan;
frame_time_t syncbase;
static int fmode;
uae_u16 beamcon0, new_beamcon0;
void compute_vsynctime (void)
{
fake_vblank_hz = 0;
+ vblank_hz_mult = 0;
+ vblank_hz_state = 1;
if (abs (currprefs.chipset_refreshrate) > 0.1) {
vblank_hz = currprefs.chipset_refreshrate;
if (isvsync_chipset ()) {
- vblank_skip = 1;
- if (!fake_vblank_hz && getvsyncrate (vblank_hz) != vblank_hz) {
- vblank_hz = getvsyncrate (vblank_hz);
- vblank_skip = -1;
+ int mult = 0;
+ if (!fake_vblank_hz && getvsyncrate (vblank_hz, &mult) != vblank_hz) {
+ vblank_hz = getvsyncrate (vblank_hz, &vblank_hz_mult);
+ if (vblank_hz_mult > 0)
+ vblank_hz_state = 0;
}
}
}
vsynctime = vsynctime_orig = 1;
else
vsynctime = vsynctime_orig = syncbase / fake_vblank_hz;
+#if 0
if (!picasso_on) {
updatedisplayarea ();
}
+#endif
if (currprefs.produce_sound > 1)
update_sound (fake_vblank_hz, (bplcon0 & 4) ? -1 : lof_store, islinetoggle ());
}
return maxvpos + (lof_store ? 1 : 0);
}
+static struct chipset_refresh *get_chipset_refresh (void)
+{
+ int islace = (bplcon0 & 4) ? 1 : 0;
+ int isntsc = (beamcon0 & 0x20) ? 0 : 1;
+
+ if (!(currprefs.chipset_mask & CSMASK_ECS_AGNUS))
+ isntsc = currprefs.ntscmode ? 1 : 0;
+
+ for (int i = 0; i < MAX_CHIPSET_REFRESH_TOTAL; i++) {
+ struct chipset_refresh *cr = &currprefs.cr[i];
+ if ((cr->horiz < 0 || cr->horiz == maxhpos) &&
+ (cr->vert < 0 || cr->vert == maxvpos_nom) &&
+ (cr->ntsc < 0 || (cr->ntsc > 0 && isntsc) || (cr->ntsc == 0 && !isntsc)) &&
+ (cr->lace < 0 || (cr->lace > 0 && islace) || (cr->lace == 0 && !islace)) &&
+ (cr->framelength < 0 || (cr->framelength > 0 && lof_store) || (cr->framelength == 0 && !lof_store) || (cr->framelength >= 0 && islace)) &&
+ ((cr->rtg && picasso_on) || (!cr->rtg && !picasso_on)) &&
+ (cr->vsync < 0 || (cr->vsync > 0 && isvsync_chipset ()) || (cr->vsync == 0 && !isvsync_chipset ())))
+ return cr;
+ }
+ return NULL;
+}
+
+static bool changed_chipset_refresh (void)
+{
+ return stored_chipset_refresh != get_chipset_refresh ();
+}
+
+static void compute_framesync (void)
+{
+ int islace = (bplcon0 & 4) ? 1 : 0;
+ int isntsc = (beamcon0 & 0x20) ? 0 : 1;
+ bool found = false;
+
+ struct chipset_refresh *cr = get_chipset_refresh ();
+ while (cr) {
+ double v = -1;
+ if (!picasso_on) {
+ if (isvsync_chipset ()) {
+ if (cr->index == CHIPSET_REFRESH_PAL || cr->index == CHIPSET_REFRESH_NTSC) {
+ if ((abs (vblank_hz - 50) < 1 || abs (vblank_hz - 60) < 1) && currprefs.gfx_apmode[0].gfx_vsync == 2 && currprefs.gfx_apmode[0].gfx_fullscreen > 0) {
+ vsync_switchmode (vblank_hz > 55 ? 60 : 50);
+ }
+ }
+ if (isvsync_chipset () < 0) {
+ double v2;
+ v2 = vblank_calibrate (cr->locked ? cr->rate : vblank_hz, cr->locked);
+ if (!cr->locked)
+ v = v2;
+ }
+ } else {
+ if (cr->locked == false) {
+ changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = vblank_hz;
+ cfgfile_parse_lines (&changed_prefs, cr->commands, -1);
+ break;
+ } else {
+ v = cr->rate;
+ }
+ }
+ if (v < 0)
+ v = cr->rate;
+ if (v > 0) {
+ changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = v;
+ cfgfile_parse_lines (&changed_prefs, cr->commands, -1);
+ }
+ } else {
+ if (cr->locked == false)
+ v = vblank_hz;
+ else
+ v = cr->rate;
+ changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = v;
+ cfgfile_parse_lines (&changed_prefs, cr->commands, -1);
+ }
+ found = true;
+ break;
+ }
+ if (!found) {
+ changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = vblank_hz;
+ }
+ stored_chipset_refresh = cr;
+ interlace_changed = islace;
+
+ if (beamcon0 & 0x80) {
+ int res = GET_RES_AGNUS (bplcon0);
+ int vres = islace ? 1 : 0;
+ int res2, vres2;
+
+ res2 = currprefs.gfx_resolution;
+ if (doublescan)
+ res2++;
+ if (res2 > RES_MAX)
+ res2 = RES_MAX;
+
+ vres2 = currprefs.gfx_vresolution;
+ if (doublescan && !islace)
+ vres2--;
+
+ if (vres2 < 0)
+ vres2 = 0;
+ if (vres2 > VRES_QUAD)
+ vres2 = VRES_QUAD;
+
+ gfxvidinfo.drawbuffer.inwidth = (((hbstrt > hbstop ? 0 : (maxhpos - (hbstop - hbstrt))) * 2) << res2);
+ gfxvidinfo.drawbuffer.extrawidth = 0;
+ gfxvidinfo.drawbuffer.inwidth2 = gfxvidinfo.drawbuffer.inwidth;
+
+ gfxvidinfo.drawbuffer.inheight = (maxvpos - minfirstline) << vres2;
+ gfxvidinfo.drawbuffer.inheight2 = gfxvidinfo.drawbuffer.inheight;
+
+ } else {
+
+ gfxvidinfo.drawbuffer.inwidth = AMIGA_WIDTH_MAX << currprefs.gfx_resolution;
+ gfxvidinfo.drawbuffer.extrawidth = 1;
+ gfxvidinfo.drawbuffer.inwidth2 = gfxvidinfo.drawbuffer.inwidth;
+ gfxvidinfo.drawbuffer.inheight = (maxvpos - minfirstline) << currprefs.gfx_vresolution;
+ gfxvidinfo.drawbuffer.inheight2 = gfxvidinfo.drawbuffer.inheight;
+
+ }
+
+
+ if (gfxvidinfo.drawbuffer.inwidth > gfxvidinfo.drawbuffer.width)
+ gfxvidinfo.drawbuffer.inwidth = gfxvidinfo.drawbuffer.width;
+ if (gfxvidinfo.drawbuffer.inwidth2 > gfxvidinfo.drawbuffer.width)
+ gfxvidinfo.drawbuffer.inwidth2 = gfxvidinfo.drawbuffer.width;
+
+ if (gfxvidinfo.drawbuffer.inheight > gfxvidinfo.drawbuffer.height)
+ gfxvidinfo.drawbuffer.inheight = gfxvidinfo.drawbuffer.height;
+ if (gfxvidinfo.drawbuffer.inheight2 > gfxvidinfo.drawbuffer.height)
+ gfxvidinfo.drawbuffer.inheight2 = gfxvidinfo.drawbuffer.height;
+
+ compute_vsynctime ();
+
+ write_log (L"%s mode%s%s V=%.4fHz H=%0.4fHz (%dx%d+%d) IDX=%d\n",
+ isntsc ? L"NTSC" : L"PAL",
+ islace ? L" laced" : L"",
+ doublescan > 0 ? L" dblscan" : L"",
+ vblank_hz, vblank_hz * maxvpos_nom,
+ maxhpos, maxvpos, lof_store ? 1 : 0,
+ cr ? cr->index : -1
+ );
+
+ config_changed = 1;
+}
+
/* set PAL/NTSC or custom timing variables */
void init_hz (bool fullinit)
{
reset_drawing ();
}
- bool found = false;
- for (int i = 0; i < MAX_CHIPSET_REFRESH_TOTAL; i++) {
- struct chipset_refresh *cr = &currprefs.cr[i];
- if ((cr->horiz < 0 || cr->horiz == maxhpos) &&
- (cr->vert < 0 || cr->vert == maxvpos_nom) &&
- (cr->ntsc < 0 || (cr->ntsc > 0 && isntsc) || (cr->ntsc == 0 && !isntsc)) &&
- (cr->lace < 0 || (cr->lace > 0 && islace) || (cr->lace == 0 && !islace)) &&
- (cr->framelength < 0 || (cr->framelength > 0 && lof_store) || (cr->framelength == 0 && !lof_store) || (cr->framelength >= 0 && islace)) &&
- ((cr->rtg && picasso_on) || (!cr->rtg && !picasso_on)) &&
- (cr->vsync < 0 || (cr->vsync > 0 && isvsync_chipset ()) || (cr->vsync == 0 && !isvsync_chipset ()))) {
- double v = -1;
-
- if (!picasso_on) {
- if (isvsync_chipset ()) {
- if (i == CHIPSET_REFRESH_PAL || i == CHIPSET_REFRESH_NTSC) {
- if ((abs (vblank_hz - 50) < 1 || abs (vblank_hz - 60) < 1) && currprefs.gfx_apmode[0].gfx_vsync == 2 && currprefs.gfx_apmode[0].gfx_fullscreen > 0) {
- vsync_switchmode (vblank_hz > 55 ? 60 : 50);
- }
- }
- if (isvsync_chipset () < 0) {
- double v2;
- v2 = vblank_calibrate (cr->locked ? vblank_hz : cr->rate, cr->locked);
- if (!cr->locked)
- v = v2;
- }
- } else {
- if (cr->locked == false) {
- changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = vblank_hz;
- cfgfile_parse_lines (&changed_prefs, cr->commands, -1);
- break;
- }
- v = cr->rate;
- }
- if (v < 0)
- v = cr->rate;
- if (v > 0) {
- changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = v;
- cfgfile_parse_lines (&changed_prefs, cr->commands, -1);
- }
- } else {
- if (cr->locked == false)
- v = vblank_hz;
- else
- v = cr->rate;
- changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = v;
- cfgfile_parse_lines (&changed_prefs, cr->commands, -1);
- }
- found = true;
- break;
- }
- }
-
- if (!found) {
- changed_prefs.chipset_refreshrate = currprefs.chipset_refreshrate = vblank_hz;
- }
-
maxvpos_total = (currprefs.chipset_mask & CSMASK_ECS_AGNUS) ? 2047 : 511;
if (maxvpos_total > MAXVPOS)
maxvpos_total = MAXVPOS;
vblank_hz_stored = vblank_hz;
}
- if (beamcon0 & 0x80) {
- int res = GET_RES_AGNUS (bplcon0);
- int vres = islace ? 1 : 0;
- int res2, vres2;
-
- res2 = currprefs.gfx_resolution;
- if (doublescan)
- res2++;
- if (res2 > RES_MAX)
- res2 = RES_MAX;
-
- vres2 = currprefs.gfx_vresolution;
- if (doublescan && !islace)
- vres2--;
-
- if (vres2 < 0)
- vres2 = 0;
- if (vres2 > VRES_QUAD)
- vres2 = VRES_QUAD;
-
- gfxvidinfo.drawbuffer.inwidth = (((hbstrt > hbstop ? 0 : (maxhpos - (hbstop - hbstrt))) * 2) << res2);
- gfxvidinfo.drawbuffer.extrawidth = 0;
- gfxvidinfo.drawbuffer.inwidth2 = gfxvidinfo.drawbuffer.inwidth;
-
- gfxvidinfo.drawbuffer.inheight = (maxvpos - minfirstline) << vres2;
- gfxvidinfo.drawbuffer.inheight2 = gfxvidinfo.drawbuffer.inheight;
-
- } else {
-
- gfxvidinfo.drawbuffer.inwidth = AMIGA_WIDTH_MAX << currprefs.gfx_resolution;
- gfxvidinfo.drawbuffer.extrawidth = 1;
- gfxvidinfo.drawbuffer.inwidth2 = gfxvidinfo.drawbuffer.inwidth;
- gfxvidinfo.drawbuffer.inheight = (maxvpos - minfirstline) << currprefs.gfx_vresolution;
- gfxvidinfo.drawbuffer.inheight2 = gfxvidinfo.drawbuffer.inheight;
-
- }
-
+ compute_framesync ();
- if (gfxvidinfo.drawbuffer.inwidth > gfxvidinfo.drawbuffer.width)
- gfxvidinfo.drawbuffer.inwidth = gfxvidinfo.drawbuffer.width;
- if (gfxvidinfo.drawbuffer.inwidth2 > gfxvidinfo.drawbuffer.width)
- gfxvidinfo.drawbuffer.inwidth2 = gfxvidinfo.drawbuffer.width;
-
- if (gfxvidinfo.drawbuffer.inheight > gfxvidinfo.drawbuffer.height)
- gfxvidinfo.drawbuffer.inheight = gfxvidinfo.drawbuffer.height;
- if (gfxvidinfo.drawbuffer.inheight2 > gfxvidinfo.drawbuffer.height)
- gfxvidinfo.drawbuffer.inheight2 = gfxvidinfo.drawbuffer.height;
-
- compute_vsynctime ();
#ifdef PICASSO96
init_hz_p96 ();
#endif
if (vblank_hz != ovblank)
updatedisplayarea ();
inputdevice_tablet_strobe ();
- write_log (L"%s mode%s%s V=%.4fHz H=%0.4fHz (%dx%d+%d)\n",
- isntsc ? L"NTSC" : L"PAL",
- islace ? L" laced" : L"",
- doublescan > 0 ? L" dblscan" : L"",
- vblank_hz, vblank_hz * maxvpos_nom,
- maxhpos, maxvpos, lof_store ? 1 : 0);
- config_changed = 1;
}
void init_hz (void)
if (bplcon0 == v)
return;
+ if ((bplcon0 & 4) != (v & 4))
+ write_log (L"lace=%d\n", v & 4);
+
if (!issyncstopped ()) {
vpos_previous = vpos;
hpos_previous = hpos;
int freetime;
extern int extraframewait;
- vsyncmintime = vsynctime;
+ if (!vblank_hz_state)
+ return;
+
+ vsyncmintime = vsynctime;
+
if (vs == -2 || vs == -3) {
// fastest possible
curr_time = vsync_busywait_end ();
if (!vsync_rendered) {
vsync_handle_redraw (lof_store, lof_changed);
vsync_rendered = true;
- if (isvsync_chipset () == -3) {
+ if (vblank_hz_state != 0 && isvsync_chipset () == -3) {
render_screen ();
show_screen_maybe ();
}
}
+ if (vblank_hz_mult > 0)
+ vblank_hz_state ^= 1;
+ else
+ vblank_hz_state = 1;
+
vsync_handle_check ();
}
}
if ((beamcon0 & (0x20 | 0x80)) != (new_beamcon0 & (0x20 | 0x80)) || (abs (vpos_count - vpos_count_prev) > 1))
init_hz ();
+ else if (lof_changed || interlace_changed != ((bplcon0 & 4) ? 1 : 0) || changed_chipset_refresh ())
+ compute_framesync ();
+#if 0
if (lof_changed)
compute_vsynctime ();
+#endif
vpos_count_prev = vpos_count;
lof_changed = 0;
/* fastest possible + last line, render the frame as early as possible */
vsync_rendered = true;
vsync_handle_redraw (lof_store, lof_changed);
- render_screen ();
- show_screen_maybe ();
+ if (vblank_hz_state) {
+ render_screen ();
+ show_screen_maybe ();
+ }
}
rtg_vsynccheck ();
#include <math.h>
-double getvsyncrate (double hz)
+double getvsyncrate (double hz, int *mult)
{
- if (hz > 85)
+ if (hz > 85) {
+ *mult = -1;
return hz / 2;
+ }
+ if (hz < 35) {
+ *mult = 1;
+ return hz * 2;
+ }
+ *mult = 0;
return hz;
}
extern struct inputdevice_functions inputdevicefunc_keyboard;
extern int pause_emulation;
+struct uae_input_device_default_node
+{
+ int evt;
+ int flags;
+};
+
struct uae_input_device_kbr_default {
int scancode;
- int evt;
- int flags;
+ struct uae_input_device_default_node node[MAX_INPUT_SUB_EVENT];
};
struct inputevent {
int data;
};
+#define MAX_INPUT_QUALIFIERS (8+4)
+
/* event flags */
#define ID_FLAG_AUTOFIRE 1
#define ID_FLAG_TOGGLE 2
#define ID_FLAG_GAMEPORTSCUSTOM2 8
#define ID_FLAG_INVERTTOGGLE 16
-#define ID_FLAG_SAVE_MASK 0xff
#define ID_FLAG_GAMEPORTSCUSTOM_MASK (ID_FLAG_GAMEPORTSCUSTOM1 | ID_FLAG_GAMEPORTSCUSTOM2)
#define ID_FLAG_AUTOFIRE_MASK (ID_FLAG_TOGGLE | ID_FLAG_INVERTTOGGLE | ID_FLAG_AUTOFIRE)
-#define ID_FLAG_TOGGLED 0x100
+#define ID_FLAG_CANRELEASE 0x2000
+#define ID_FLAG_TOGGLED 0x4000
+#define ID_FLAG_CUSTOMEVENT_TOGGLED 0x8000
+#define ID_FLAG_QUALIFIER1 0x00010000
+#define ID_FLAG_QUALIFIER2 0x00020000
+#define ID_FLAG_QUALIFIER3 0x00040000
+#define ID_FLAG_QUALIFIER4 0x00080000
+#define ID_FLAG_QUALIFIER5 0x00100000
+#define ID_FLAG_QUALIFIER6 0x00200000
+#define ID_FLAG_QUALIFIER7 0x00400000
+#define ID_FLAG_QUALIFIER8 0x00800000
+#define ID_FLAG_QUALIFIER_SPECIAL 0x01000000
+#define ID_FLAG_QUALIFIER_SHIFT 0x02000000
+#define ID_FLAG_QUALIFIER_CONTROL 0x04000000
+#define ID_FLAG_QUALIFIER_ALT 0x08000000
+#define ID_FLAG_QUALIFIER_MASK 0x0fff0000
+
+#define ID_FLAG_SAVE_MASK_CONFIG 0xff
+#define ID_FLAG_SAVE_MASK_QUALIFIERS ID_FLAG_QUALIFIER_MASK
+#define ID_FLAG_SAVE_MASK_FULL (ID_FLAG_SAVE_MASK_CONFIG | ID_FLAG_SAVE_MASK_QUALIFIERS)
#define IDEV_WIDGET_NONE 0
#define IDEV_WIDGET_BUTTON 1
#define IDEV_MAPPED_INVERTTOGGLE 8
#define IDEV_MAPPED_GAMEPORTSCUSTOM1 16
#define IDEV_MAPPED_GAMEPORTSCUSTOM2 32
+#define IDEV_MAPPED_QUALIFIER1 0x00010000
+#define IDEV_MAPPED_QUALIFIER2 0x00020000
+#define IDEV_MAPPED_QUALIFIER3 0x00040000
+#define IDEV_MAPPED_QUALIFIER4 0x00080000
+#define IDEV_MAPPED_QUALIFIER5 0x00100000
+#define IDEV_MAPPED_QUALIFIER6 0x00200000
+#define IDEV_MAPPED_QUALIFIER7 0x00400000
+#define IDEV_MAPPED_QUALIFIER8 0x00800000
+#define IDEV_MAPPED_QUALIFIER_SPECIAL 0x01000000
+#define IDEV_MAPPED_QUALIFIER_SHIFT 0x02000000
+#define IDEV_MAPPED_QUALIFIER_CONTROL 0x04000000
+#define IDEV_MAPPED_QUALIFIER_ALT 0x08000000
+#define IDEV_MAPPED_QUALIFIER_MASK 0x0fff0000
#define ID_BUTTON_OFFSET 0
#define ID_BUTTON_TOTAL 32
extern int inputdevice_set_mapping (int devnum, int num, const TCHAR *name, TCHAR *custom, int flags, int port, int sub);
extern int inputdevice_get_mapping (int devnum, int num, int *pflags, int *port, TCHAR *name, TCHAR *custom, int sub);
extern void inputdevice_copyconfig (const struct uae_prefs *src, struct uae_prefs *dst);
-extern void inputdevice_copy_single_config (struct uae_prefs *p, int src, int dst, int devnum);
+extern void inputdevice_copy_single_config (struct uae_prefs *p, int src, int dst, int devnum, int selectedwidget);
extern void inputdevice_swap_ports (struct uae_prefs *p, int devnum);
extern void inputdevice_swap_compa_ports (struct uae_prefs *p, int portswap);
extern void inputdevice_config_change (void);
extern void inputdevice_devicechange (struct uae_prefs *prefs);
extern int inputdevice_translatekeycode (int keyboard, int scancode, int state);
+extern void inputdevice_checkqualifierkeycode (int keyboard, int scancode, int state);
extern void inputdevice_setkeytranslation (struct uae_input_device_kbr_default **trans, int **kbmaps);
extern void inputdevice_do_keyboard (int code, int state);
extern int inputdevice_iskeymapped (int keyboard, int scancode);
extern void inputdevice_tablet_info (int maxx, int maxy, int maxz, int maxax, int maxay, int maxaz, int xres, int yres);
extern void inputdevice_tablet_strobe (void);
+extern int input_getqualifiers (void);
+
#define JSEM_MODE_DEFAULT 0
#define JSEM_MODE_MOUSE 1
AKS_DISK_PREV0, AKS_DISK_PREV1, AKS_DISK_PREV2, AKS_DISK_PREV3,
AKS_DISK_NEXT0, AKS_DISK_NEXT1, AKS_DISK_NEXT2, AKS_DISK_NEXT3,
AKS_CDTV_FRONT_PANEL_STOP, AKS_CDTV_FRONT_PANEL_PLAYPAUSE, AKS_CDTV_FRONT_PANEL_PREV,
- AKS_CDTV_FRONT_PANEL_NEXT, AKS_CDTV_FRONT_PANEL_REW, AKS_CDTV_FRONT_PANEL_FF
+ AKS_CDTV_FRONT_PANEL_NEXT, AKS_CDTV_FRONT_PANEL_REW, AKS_CDTV_FRONT_PANEL_FF,
+ AKS_QUALIFIER1, AKS_QUALIFIER2, AKS_QUALIFIER3, AKS_QUALIFIER4,
+ AKS_QUALIFIER5, AKS_QUALIFIER6, AKS_QUALIFIER7, AKS_QUALIFIER8,
+ AKS_QUALIFIER_SPECIAL, AKS_QUALIFIER_SHIFT, AKS_QUALIFIER_CONTROL,
+ AKS_QUALIFIER_ALT
};
extern int target_checkcapslock (int, int *);
\ No newline at end of file
/* 4 different customization settings */
#define MAX_INPUT_SETTINGS 4
#define GAMEPORT_INPUT_SETTINGS 3 // last slot is for gameport panel mappings
-#define MAX_INPUT_SUB_EVENT 4
-#define MAX_INPUT_SUB_EVENT_ALL 5
-#define SPARE_SUB_EVENT 4
+
+#define MAX_INPUT_SUB_EVENT 8
+#define MAX_INPUT_SUB_EVENT_ALL 9
+#define SPARE_SUB_EVENT 8
struct uae_input_device {
TCHAR *name;
TCHAR *configname;
uae_s16 eventid[MAX_INPUT_DEVICE_EVENTS][MAX_INPUT_SUB_EVENT_ALL];
TCHAR *custom[MAX_INPUT_DEVICE_EVENTS][MAX_INPUT_SUB_EVENT_ALL];
- uae_u16 flags[MAX_INPUT_DEVICE_EVENTS][MAX_INPUT_SUB_EVENT_ALL];
+ uae_u32 flags[MAX_INPUT_DEVICE_EVENTS][MAX_INPUT_SUB_EVENT_ALL];
uae_s8 port[MAX_INPUT_DEVICE_EVENTS][MAX_INPUT_SUB_EVENT_ALL];
uae_s16 extra[MAX_INPUT_DEVICE_EVENTS];
uae_s8 enabled;
#define CHIPSET_REFRESH_NTSC (MAX_CHIPSET_REFRESH + 1)
struct chipset_refresh
{
+ int index;
bool locked;
bool rtg;
int horiz;
bool gfx_vflip;
int gfx_vsyncmode;
int gfx_backbuffers;
+ bool gfx_interlaced;
};
struct uae_prefs {
bool mmkeyboard;
int uae_hide;
bool clipboard_sharing;
+ bool native_code;
int mountitems;
struct uaedev_config_info mountconfig[MOUNT_CONFIG_SIZE];
int win32_soundcard;
int win32_samplersoundcard;
bool win32_norecyclebin;
- int win32_specialkey;
int win32_guikey;
int win32_kbledmode;
TCHAR win32_commandpathstart[MAX_DPATH];
extern void setup_greydither_maxcol (int maxcol, allocfunc_type allocfunc);
extern void setup_dither (int bits, allocfunc_type allocfunc);
extern void DitherLine (uae_u8 *l, uae_u16 *r4g4b4, int x, int y, uae_s16 len, int bits) ASM_SYM_FOR_FUNC("DitherLine");
-extern double getvsyncrate (double hz);
+extern double getvsyncrate (double hz, int *mult);
/* The graphics code has a choice whether it wants to use a large buffer
* for the whole display, or only a small buffer for a single line.
#define AM_DUMMY 128 /* placeholder */
#define AM_CUSTOM 256 /* custom event */
#define AM_K (AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT|AM_AF) /* generic button/switch */
+#define AM_KK (AM_KEY|AM_JOY_BUT|AM_MOUSE_BUT)
#define JOYMOUSE_CDTV 8
static int sublevdir[2][MAX_INPUT_SUB_EVENT];
+static const int slotorder1[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+static const int slotorder2[] = { 8, 1, 2, 3, 4, 5, 6, 7 };
+
struct uae_input_device2 {
uae_u32 buttonmask;
int states[MAX_INPUT_DEVICE_EVENTS / 2];
static struct uae_input_device2 joysticks2[MAX_INPUT_DEVICES];
static struct uae_input_device2 mice2[MAX_INPUT_DEVICES];
static uae_u8 scancodeused[MAX_INPUT_DEVICES][256];
+static int qualifiers;
// fire/left mouse button pullup resistors enabled?
static bool mouse_pullup = true;
static bool write_slot (TCHAR *p, struct uae_input_device *uid, int i, int j)
{
bool ok = false;
+ int flags = uid->flags[i][j];
if (uid->custom[i][j] && _tcslen (uid->custom[i][j]) > 0) {
- _stprintf (p, L"'%s'.%d", uid->custom[i][j], uid->flags[i][j] & ID_FLAG_SAVE_MASK);
+ _stprintf (p, L"'%s'.%d", uid->custom[i][j], flags & ID_FLAG_SAVE_MASK_CONFIG);
ok = true;
} else if (uid->eventid[i][j] > 0) {
- _stprintf (p, L"%s.%d", events[uid->eventid[i][j]].confname, uid->flags[i][j] & ID_FLAG_SAVE_MASK);
+ _stprintf (p, L"%s.%d", events[uid->eventid[i][j]].confname, flags & ID_FLAG_SAVE_MASK_CONFIG);
ok = true;
} else {
_tcscpy (p, L"NULL");
}
+ if (ok && (flags & ID_FLAG_SAVE_MASK_QUALIFIERS)) {
+ TCHAR *p2 = p + _tcslen (p);
+ *p2++ = '.';
+ for (int i = 0; i < MAX_INPUT_QUALIFIERS; i++) {
+ if ((ID_FLAG_QUALIFIER1 << i) & flags) {
+ _stprintf (p2, L"%c", 'A' + i);
+ p2++;
+ }
+ }
+ }
return ok;
}
TCHAR tmp2[200], tmp3[200], *p;
int evt, got, j, k;
TCHAR *custom;
- int slotorder1[] = { 0, 1, 2, 3 };
- int slotorder2[] = { 4, 1, 2, 3 };
- int *slotorder;
+ const int *slotorder;
int io = i + offset;
tmp2[0] = 0;
{
TCHAR tmp1[200], tmp2[200], tmp3[200], tmp4[200], tmp5[200], *p;
int i, j, k, evt, skip;
- int slotorder1[] = { 0, 1, 2, 3 };
- int slotorder2[] = { 4, 1, 2, 3 };
- int *slotorder;
+ const int *slotorder;
if (!keyboard_default)
return;
while (keyboard_default[k].scancode >= 0) {
if (keyboard_default[k].scancode == kbr->extra[i]) {
skip = 1;
- for (j = 1; j < MAX_INPUT_SUB_EVENT; j++) {
- if ((kbr->flags[i][slotorder[j]] & ID_FLAG_SAVE_MASK) != 0 || kbr->eventid[i][slotorder[j]] > 0)
+ for (j = 0; j < MAX_INPUT_SUB_EVENT; j++) {
+ if (keyboard_default[k].node[j].evt != 0) {
+ if (keyboard_default[k].node[j].evt != kbr->eventid[i][slotorder[j]] || keyboard_default[k].node[j].flags != (kbr->flags[i][slotorder[j]] & ID_FLAG_SAVE_MASK_FULL))
+ skip = 0;
+ } else if ((kbr->flags[i][slotorder[j]] & ID_FLAG_SAVE_MASK_FULL) != 0 || kbr->eventid[i][slotorder[j]] > 0) {
skip = 0;
+ }
}
- if (keyboard_default[k].evt != kbr->eventid[i][slotorder[0]] || keyboard_default[k].flags != (kbr->flags[i][slotorder[0]] & ID_FLAG_SAVE_MASK))
- skip = 0;
break;
}
k++;
}
bool isdefaultspare =
kbr->port[i][SPARE_SUB_EVENT] &&
- keyboard_default[k].evt == kbr->eventid[i][SPARE_SUB_EVENT] && keyboard_default[k].flags == (kbr->flags[i][SPARE_SUB_EVENT] & ID_FLAG_SAVE_MASK);
+ keyboard_default[k].node[0].evt == kbr->eventid[i][SPARE_SUB_EVENT] && keyboard_default[k].node[0].flags == (kbr->flags[i][SPARE_SUB_EVENT] & ID_FLAG_SAVE_MASK_FULL);
if (kbr->port[i][0] > 0 && !(kbr->flags[i][0] & ID_FLAG_GAMEPORTSCUSTOM_MASK) &&
(kbr->eventid[i][1] <= 0 && kbr->eventid[i][2] <= 0 && kbr->eventid[i][3] <= 0) &&
(kbr->port[i][SPARE_SUB_EVENT] == 0 || isdefaultspare))
skip = 1;
- if (kbr->eventid[i][0] == 0 && (kbr->flags[i][0] & ID_FLAG_SAVE_MASK) == 0 && keyboard_default[k].scancode < 0)
+ if (kbr->eventid[i][0] == 0 && (kbr->flags[i][0] & ID_FLAG_SAVE_MASK_FULL) == 0 && keyboard_default[k].scancode < 0)
skip = 1;
if (skip) {
i++;
}
}
+static int getqual (const TCHAR **pp)
+{
+ const TCHAR *p = *pp;
+ int mask = 0;
+
+ while (*p >= 'A' && *p <= 'Z') {
+ mask |= ID_FLAG_QUALIFIER1 << (*p - 'A');
+ p++;
+ }
+ while (*p != 0 && *p !='.' && *p != ',')
+ p++;
+ if (*p == '.' || *p == ',')
+ p++;
+ *pp = p;
+ return mask;
+}
+
static int getnum (const TCHAR **pp)
{
const TCHAR *p = *pp;
static void set_kbr_default_event (struct uae_input_device *kbr, struct uae_input_device_kbr_default *trans, int num)
{
- for (int i = 0; trans[i].scancode >= 0; i++) {
+ for (int i = 0; trans[i].scancode >= 0; i++) {
if (kbr->extra[num] == trans[i].scancode) {
int k;
for (k = 0; k < MAX_INPUT_SUB_EVENT; k++) {
write_log (L"corrupt default keyboard mappings\n");
return;
}
- kbr->eventid[num][k] = trans[i].evt;
- kbr->flags[num][k] = trans[i].flags;
+ int l = 0;
+ while (k < MAX_INPUT_SUB_EVENT && trans[i].node[l].evt) {
+ int evt = trans[i].node[l].evt;
+ if (evt < 0 || evt >= INPUTEVENT_SPC_LAST)
+ gui_message(L"invalid event in default keyboard table!");
+ kbr->eventid[num][k] = evt;
+ kbr->flags[num][k] = trans[i].node[l].flags;
+ l++;
+ k++;
+ }
break;
}
}
}
-static void set_kbr_default (struct uae_prefs *p, int index, int devnum)
+static void clear_id (struct uae_input_device *id)
+{
+#ifndef _DEBUG
+ int i, j;
+ for (i = 0; i < MAX_INPUT_DEVICE_EVENTS; i++) {
+ for (j = 0; j < MAX_INPUT_SUB_EVENT_ALL; j++)
+ xfree (id->custom[i][j]);
+ }
+#endif
+ TCHAR *cn = id->configname;
+ TCHAR *n = id->name;
+ memset (id, 0, sizeof (struct uae_input_device));
+ id->configname = cn;
+ id->name = n;
+}
+
+static void set_kbr_default (struct uae_prefs *p, int index, int devnum, struct uae_input_device_kbr_default *trans)
{
int i, j;
- struct uae_input_device_kbr_default *trans = keyboard_default;
struct uae_input_device *kbr;
struct inputdevice_functions *id = &idev[IDTYPE_KEYBOARD];
uae_u32 scancode;
continue;
kbr = &p->keyboard_settings[index][j];
for (i = 0; i < MAX_INPUT_DEVICE_EVENTS; i++) {
- memset (kbr, 0, sizeof (struct uae_input_device));
+ clear_id (kbr);
kbr->extra[i] = -1;
}
if (j < id->get_num ()) {
}
}
-static void inputdevice_default_kb (struct uae_prefs *p)
+static void inputdevice_default_kb (struct uae_prefs *p, int num)
{
- keyboard_default = keyboard_default_table[p->input_keyboard_type];
- for (int i = 0; i < MAX_INPUT_SETTINGS; i++) {
- if (i == GAMEPORT_INPUT_SETTINGS) {
- if (p->jports[0].id != JPORT_CUSTOM || p->jports[1].id != JPORT_CUSTOM) {
- reset_inputdevice_slot (p, i);
- }
- }
- set_kbr_default (p, i, -1);
+ if (num == GAMEPORT_INPUT_SETTINGS) {
+ if (p->jports[0].id != JPORT_CUSTOM || p->jports[1].id != JPORT_CUSTOM)
+ reset_inputdevice_slot (p, num);
}
+ set_kbr_default (p, num, -1, keyboard_default);
}
-
-static void clear_id (struct uae_input_device *id)
+static void inputdevice_default_kb_all (struct uae_prefs *p)
{
-#ifndef _DEBUG
- int i, j;
- for (i = 0; i < MAX_INPUT_DEVICE_EVENTS; i++) {
- for (j = 0; j < MAX_INPUT_SUB_EVENT_ALL; j++)
- xfree (id->custom[i][j]);
- }
-#endif
- TCHAR *cn = id->configname;
- TCHAR *n = id->name;
- memset (id, 0, sizeof (struct uae_input_device));
- id->configname = cn;
- id->name = n;
+ for (int i = 0; i < MAX_INPUT_SETTINGS; i++)
+ inputdevice_default_kb (p, i);
}
-
-static bool readslot (TCHAR *parm, int num, int joystick, int button, struct uae_input_device *id, int keynum, int subnum, struct inputevent *ie, int flags, int port, TCHAR *custom)
+static bool read_slot (TCHAR *parm, int num, int joystick, int button, struct uae_input_device *id, int keynum, int subnum, struct inputevent *ie, int flags, int port, TCHAR *custom)
{
int mask;
pr->input_analog_joystick_offset = _tstol (value);
if (!strcasecmp (p, L"keyboard_type")) {
cfgfile_strval (option, value, NULL, &pr->input_analog_joystick_offset, kbtypes, 0);
- inputdevice_default_kb (pr);
+ keyboard_default = keyboard_default_table[pr->input_keyboard_type];
+ inputdevice_default_kb_all (pr);
}
if (!strcasecmp (p, L"contact_bounce"))
if (idnum == GAMEPORT_INPUT_SETTINGS) {
clear_id (id);
if (joystick < 0)
- set_kbr_default (pr, idnum, devnum);
+ set_kbr_default (pr, idnum, devnum, keyboard_default);
id->enabled = iscustom;
} else {
id->enabled = false;
clear_id (id);
if (!empty) {
if (joystick < 0)
- set_kbr_default (pr, idnum, devnum);
+ set_kbr_default (pr, idnum, devnum, keyboard_default);
}
id->enabled = 1;
if (idnum == GAMEPORT_INPUT_SETTINGS)
flags = 0;
port = 0;
if (p[-1] == '.')
- flags = getnum (&p);
+ flags = getnum (&p) & ID_FLAG_SAVE_MASK_CONFIG;
if (p[-1] == '.') {
- port = getnum (&p) + 1;
+ if (p[0] >= 'A' && p[0] <= 'Z')
+ flags |= getqual (&p);
+ if (p[-1] == '.')
+ port = getnum (&p) + 1;
}
if (idnum == GAMEPORT_INPUT_SETTINGS && port == 0)
continue;
if (p2) {
int flags2 = 0;
if (p[-1] == '.')
- flags2 = getnum (&p);
+ flags2 = getnum (&p) & ID_FLAG_SAVE_MASK_CONFIG;
+ if (p[-1] == '.' && p[0] >= 'A' && p[0] <= 'Z')
+ flags |= getqual (&p);
TCHAR *custom2 = NULL;
struct inputevent *ie2 = readevent (p2, &custom2);
- readslot (p2, num, joystick, button, id, keynum, SPARE_SUB_EVENT, ie2, flags2, MAX_JPORTS + 1, custom2);
+ read_slot (p2, num, joystick, button, id, keynum, SPARE_SUB_EVENT, ie2, flags2, MAX_JPORTS + 1, custom2);
}
}
break;
p++;
}
- if (!readslot (p2, num, joystick, button, id, keynum, subnum, ie, flags, port, custom))
+ if (!read_slot (p2, num, joystick, button, id, keynum, subnum, ie, flags, port, custom))
continue;
custom = NULL;
}
}
}
-int handle_custom_event (TCHAR *custom)
+static int handle_custom_event (TCHAR *custom)
{
TCHAR *p, *buf, *nextp;
if (custom == NULL)
return 0;
+ //write_log (L"%s\n", custom);
p = buf = my_strdup (custom);
while (p && *p) {
TCHAR *p2;
cfgfile_parse_line (&changed_prefs, p, 0);
p = nextp;
}
- xfree(buf);
+ xfree (buf);
config_changed = 1;
return 0;
}
+static int isqual (int evt)
+{
+ if (evt > INPUTEVENT_SPC_QUALIFIER_START && evt < INPUTEVENT_SPC_QUALIFIER_END)
+ return ID_FLAG_QUALIFIER1 << (evt - INPUTEVENT_SPC_QUALIFIER1);
+ return 0;
+}
+
static int handle_input_event (int nr, int state, int max, int autofire, bool canstopplayback, bool playbackevent)
{
struct inputevent *ie;
if (nr <= 0)
return 0;
ie = &events[nr];
- if (ie->unit == 0 && ie->data >= 0x200)
+ if (isqual (nr))
+ return 0; // qualifiers do nothing
+ if (ie->unit == 0 && ie->data >= 0x200) {
isaks = true;
+ if (!state) // release AKS_ does nothing
+ return 0;
+ }
if (!isaks) {
if (input_record && input_record != INPREC_RECORD_PLAYING)
}
if ((inputdevice_logging & 1) || input_record || input_play)
- write_log (L"'%s' STATE=%d MAX=%d AF=%d\n", ie->name, state, max, autofire);
+ write_log (L"STATE=%05d MAX=%05d AF=%d QUAL=%08x '%s' \n", state, max, autofire, qualifiers, ie->name);
if (autofire) {
if (state)
queue_input_event (nr, state, max, currprefs.input_autofire_linecnt, 1);
return 0;
}
-static void process_custom_event (struct uae_input_device *id, int offset, int state)
+int input_getqualifiers (void)
+{
+ return qualifiers;
+}
+
+static bool checkqualifiers (int evt, int flags, int qualmask)
+{
+ flags &= ID_FLAG_QUALIFIER_MASK;
+ /* special set and new qualifier pressed? do not sent it to Amiga-side */
+ if ((qualifiers & ID_FLAG_QUALIFIER_SPECIAL) && isqual (evt))
+ return false;
+ if (!qualmask) // no qualifiers in any slot
+ return true;
+ if (flags == qualifiers || (flags && flags == (qualifiers & ~ID_FLAG_QUALIFIER_SPECIAL)))
+ return true;
+ return false;
+}
+static void setqualifiers (int evt, int state)
{
- int idx = -1;
- int custompos = (id->flags[offset][0] >> 15) & 1;
+ int mask = isqual (evt);
+ if (!mask)
+ return;
+ if (state)
+ qualifiers |= mask;
+ else
+ qualifiers &= ~mask;
+}
+static int getqualmask (struct uae_input_device *id, int num, bool *qualonly)
+{
+ int mask = 0, mask2 = 0;
+ for (int i = 0; i < MAX_INPUT_SUB_EVENT; i++) {
+ int evt = id->eventid[num][i];
+ mask |= id->flags[num][i];
+ mask2 |= isqual (evt);
+ }
+ mask &= ID_FLAG_QUALIFIER_MASK;
+ *qualonly = false;
+ if (qualifiers & ID_FLAG_QUALIFIER_SPECIAL) {
+ // ID_FLAG_QUALIFIER_SPECIAL already active and this event has one or more qualifiers configured
+ *qualonly = mask2 != 0;
+ }
+ return mask;
+}
+
+static void process_custom_event (struct uae_input_device *id, int offset, int state, int qualmask)
+{
+ int idx, slotoffset, flags, custompos;
TCHAR *custom;
+ slotoffset = 0;
+ if (!checkqualifiers (id->eventid[offset][slotoffset], id->flags[offset][slotoffset], qualmask)) {
+ slotoffset = 4;
+ if (!checkqualifiers (id->eventid[offset][slotoffset], id->flags[offset][slotoffset], qualmask))
+ return;
+ }
+
+ flags = id->flags[offset][slotoffset];
+ custompos = (flags & ID_FLAG_CUSTOMEVENT_TOGGLED) ? 1 : 0;
+
+ idx = -1;
if (state < 0) {
idx = 0;
custompos = 0;
if (state == 0)
custompos ^= 1;
}
- custom = id->custom[offset][idx];
+
+ custom = id->custom[offset][idx + slotoffset];
if (custom == NULL) {
if (idx >= 2)
- custom = id->custom[offset][idx - 2];
+ custom = id->custom[offset][idx - 2 + slotoffset];
}
+
handle_custom_event (custom);
- id->flags[offset][0] &= ~(1 << 15);
- id->flags[offset][0] |= custompos << 15;
+
+ id->flags[offset][slotoffset] &= ~ID_FLAG_CUSTOMEVENT_TOGGLED;
+ id->flags[offset][slotoffset] |= custompos ? ID_FLAG_CUSTOMEVENT_TOGGLED : 0;
}
static void setbuttonstateall (struct uae_input_device *id, struct uae_input_device2 *id2, int button, int state)
uae_u32 mask = 1 << button;
uae_u32 omask = id2->buttonmask & mask;
uae_u32 nmask = (state ? 1 : 0) << button;
+ int qualmask;
+ bool qualonly;
if (input_play && state)
inprec_realtime ();
if (button >= ID_BUTTON_TOTAL)
return;
+ qualmask = getqualmask (id, ID_BUTTON_OFFSET + button, &qualonly);
+
for (i = 0; i < MAX_INPUT_SUB_EVENT; i++) {
+ uae_u32 *flagsp = &id->flags[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]];
int evt = evt = id->eventid[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]];
- int autofire = (id->flags[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]] & ID_FLAG_AUTOFIRE) ? 1 : 0;
- int toggle = (id->flags[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]] & ID_FLAG_TOGGLE) ? 1 : 0;
- int inverttoggle = (id->flags[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]] & ID_FLAG_INVERTTOGGLE) ? 1 : 0;
+ int flags = flagsp[0];
+ int autofire = (flags & ID_FLAG_AUTOFIRE) ? 1 : 0;
+ int toggle = (flags & ID_FLAG_TOGGLE) ? 1 : 0;
+ int inverttoggle = (flags & ID_FLAG_INVERTTOGGLE) ? 1 : 0;
+
+ setqualifiers (flags, state > 0);
+ if (qualonly)
+ continue;
if (state < 0) {
+ if (!checkqualifiers (evt, flags, qualmask))
+ continue;
handle_input_event (evt, 1, 1, 0, true, false);
queue_input_event (evt, 0, 1, 1, 0); /* send release event next frame */
if (i == 0)
- process_custom_event (id, ID_BUTTON_OFFSET + button, state);
+ process_custom_event (id, ID_BUTTON_OFFSET + button, state, qualmask);
} else if (inverttoggle) {
/* pressed = firebutton, not pressed = autofire */
if (state) {
handle_input_event (evt, 1, 1, autofire, true, false);
}
if (i == 0)
- process_custom_event (id, ID_BUTTON_OFFSET + button, 1);
+ process_custom_event (id, ID_BUTTON_OFFSET + button, 1, qualmask);
} else if (toggle) {
if (!state)
continue;
if (omask & mask)
continue;
- id->flags[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]] ^= ID_FLAG_TOGGLED;
- int toggled = (id->flags[ID_BUTTON_OFFSET + button][sublevdir[state <= 0 ? 1 : 0][i]] & ID_FLAG_TOGGLED) ? 1 : 0;
+ if (!checkqualifiers (evt, flags, qualmask))
+ continue;
+ *flagsp ^= ID_FLAG_TOGGLED;
+ int toggled = (*flagsp & ID_FLAG_TOGGLED) ? 1 : 0;
handle_input_event (evt, toggled, 1, autofire, true, false);
if (i == 0)
- process_custom_event (id, ID_BUTTON_OFFSET + button, toggled);
+ process_custom_event (id, ID_BUTTON_OFFSET + button, toggled, qualmask);
} else {
+ if (!checkqualifiers (evt, flags, qualmask)) {
+ if (!state && !(flags & ID_FLAG_CANRELEASE))
+ continue;
+ else if (state)
+ continue;
+ }
+ if (!state)
+ *flagsp &= ~ID_FLAG_CANRELEASE;
+ else
+ *flagsp |= ID_FLAG_CANRELEASE;
if ((omask ^ nmask) & mask) {
handle_input_event (evt, state, 1, autofire, true, false);
if (i == 0)
- process_custom_event (id, ID_BUTTON_OFFSET + button, state);
+ process_custom_event (id, ID_BUTTON_OFFSET + button, state, qualmask);
}
}
}
return 0;
}
+static void isqualifier (int ei)
+{
+}
+
static void scanevents (struct uae_prefs *p)
{
int i, j, k, ei;
cd32_pad_enabled[0] = cd32_pad_enabled[1] = 0;
parport_joystick_enabled = 0;
mouse_port[0] = mouse_port[1] = 0;
+ qualifiers = 0;
for (i = 0; i < NORMAL_JPORTS; i++) {
for (j = 0; j < 2; j++) {
isparport (ei);
ismouse (ei);
isdigitalbutton (ei);
+ isqualifier (ei);
if (joysticks[i].eventid[ID_BUTTON_OFFSET + j][k] > 0)
use_joysticks[i] = 1;
}
isparport (ei);
ismouse (ei);
isdigitalbutton (ei);
+ isqualifier (ei);
if (mice[i].eventid[ID_BUTTON_OFFSET + j][k] > 0)
use_mice[i] = 1;
}
ismouse (ei);
isanalog (ei);
isdigitalbutton (ei);
+ isqualifier (ei);
if (ei > 0)
use_joysticks[i] = 1;
}
ismouse (ei);
isanalog (ei);
isdigitalbutton (ei);
+ isqualifier (ei);
if (ei > 0)
use_mice[i] = 1;
}
isparport (ei);
ismouse (ei);
isdigitalbutton (ei);
+ isqualifier (ei);
if (ei > 0)
scancodeused[i][keyboards[i].extra[j]] = ei;
}
struct uae_input_device *uid = &keyboards[0];
while (kb[j] >= 0) {
int id = kb[j];
- int evt = 0;
+ int evt0 = 0, evt1 = 0;
k = 0;
while (keyboard_default[k].scancode >= 0) {
if (keyboard_default[k].scancode == kb[j]) {
- evt = keyboard_default[k].evt;
+ for (int l = 0; l < MAX_INPUT_DEVICE_EVENTS; l++) {
+ if (uid->extra[l] == id) {
+ for (int m = 0; m < MAX_INPUT_SUB_EVENT && keyboard_default[k].node[m].evt; m++) {
+ uid->eventid[l][m] = keyboard_default[k].node[m].evt;
+ }
+ break;
+ }
+ }
break;
}
k++;
}
- for (int l = 0; l < MAX_INPUT_DEVICE_EVENTS; l++) {
- if (uid->extra[l] == id) {
- uid->eventid[l][0] = evt;
- break;
- }
- }
j++;
}
j++;
p->input_mouse_speed = 100;
p->input_autofire_linecnt = 600;
p->input_keyboard_type = 0;
- inputdevice_default_kb (p);
+ keyboard_default = keyboard_default_table[p->input_keyboard_type];
+ inputdevice_default_kb_all (p);
}
// set default keyboard and keyboard>joystick layouts
return -1;
}
-static int inputdevice_translatekeycode_2 (int keyboard, int scancode, int state)
+static int inputdevice_translatekeycode_2 (int keyboard, int scancode, int state, bool qualifiercheckonly)
{
struct uae_input_device *na = &keyboards[keyboard];
int j, k;
j = 0;
while (j < MAX_INPUT_DEVICE_EVENTS && na->extra[j] >= 0) {
if (na->extra[j] == scancode) {
+ bool qualonly;
+ int qualmask = getqualmask (na, j, &qualonly);
+ if (qualonly)
+ qualifiercheckonly = true;
for (k = 0; k < MAX_INPUT_SUB_EVENT; k++) {/* send key release events in reverse order */
- int autofire = (na->flags[j][sublevdir[state == 0 ? 1 : 0][k]] & ID_FLAG_AUTOFIRE) ? 1 : 0;
- int toggle = (na->flags[j][sublevdir[state == 0 ? 1 : 0][k]] & ID_FLAG_TOGGLE) ? 1 : 0;
- int inverttoggle = (na->flags[j][sublevdir[state == 0 ? 1 : 0][k]] & ID_FLAG_INVERTTOGGLE) ? 1 : 0;
+ uae_u32 *flagsp = &na->flags[j][sublevdir[state == 0 ? 1 : 0][k]];
int evt = na->eventid[j][sublevdir[state == 0 ? 1 : 0][k]];
+ int flags = *flagsp;
+ int autofire = (flags & ID_FLAG_AUTOFIRE) ? 1 : 0;
+ int toggle = (flags & ID_FLAG_TOGGLE) ? 1 : 0;
+ int inverttoggle = (flags & ID_FLAG_INVERTTOGGLE) ? 1 : 0;
int toggled;
+ setqualifiers (evt, state > 0);
+ if (qualifiercheckonly)
+ continue;
+
// if evt == caps and scan == caps: sync with native caps led
if (evt == INPUTEVENT_KEY_CAPS_LOCK) {
int v;
} else if (toggle) {
if (!state)
continue;
- na->flags[j][sublevdir[state == 0 ? 1 : 0][k]] ^= ID_FLAG_TOGGLED;
- toggled = (na->flags[j][sublevdir[state == 0 ? 1 : 0][k]] & ID_FLAG_TOGGLED) ? 1 : 0;
+ if (!checkqualifiers (evt, flags, qualmask))
+ continue;
+ *flagsp ^= ID_FLAG_TOGGLED;
+ toggled = (*flagsp & ID_FLAG_TOGGLED) ? 1 : 0;
handled |= handle_input_event (evt, toggled, 1, autofire, true, false);
} else {
+ if (!checkqualifiers (evt, flags, qualmask)) {
+ if (!state && !(flags & ID_FLAG_CANRELEASE))
+ continue;
+ else if (state)
+ continue;
+ }
+ if (state)
+ *flagsp |= ID_FLAG_CANRELEASE;
+ else
+ *flagsp &= ~ID_FLAG_CANRELEASE;
handled |= handle_input_event (evt, state, 1, autofire, true, false);
+
}
}
- process_custom_event (na, j, state);
+ process_custom_event (na, j, state, qualmask);
return handled;
}
j++;
// main keyboard press/release entry point
int inputdevice_translatekeycode (int keyboard, int scancode, int state)
{
- if (inputdevice_translatekeycode_2 (keyboard, scancode, state))
+ if (inputdevice_translatekeycode_2 (keyboard, scancode, state, false))
return 1;
if (currprefs.mmkeyboard && scancode > 0)
sendmmcodes (scancode, state);
return 0;
}
+void inputdevice_checkqualifierkeycode (int keyboard, int scancode, int state)
+{
+ inputdevice_translatekeycode_2 (keyboard, scancode, state, true);
+}
static struct inputdevice_functions idev[3];
flags |= IDEV_MAPPED_GAMEPORTSCUSTOM1;
if (flag & ID_FLAG_GAMEPORTSCUSTOM2)
flags |= IDEV_MAPPED_GAMEPORTSCUSTOM2;
+ if (flag & ID_FLAG_QUALIFIER_MASK)
+ flags |= flag & ID_FLAG_QUALIFIER_MASK;
+ if (pflags)
+ *pflags = flags;
+ if (pport)
+ *pport = port;
if (!data)
return 0;
if (events[data].allow_mask & AM_AF)
flags |= IDEV_MAPPED_AUTOFIRE_POSSIBLE;
if (pflags)
*pflags = flags;
- if (pport)
- *pport = port;
inputdevice_get_eventname (&events[data], name);
return data;
}
return 0;
if (data >= 0) {
amask = events[eid].allow_mask;
- flag &= ~(ID_FLAG_AUTOFIRE_MASK | ID_FLAG_GAMEPORTSCUSTOM_MASK);
+ flag &= ~(ID_FLAG_AUTOFIRE_MASK | ID_FLAG_GAMEPORTSCUSTOM_MASK | IDEV_MAPPED_QUALIFIER_MASK);
if (amask & AM_AF) {
flag |= (flags & IDEV_MAPPED_AUTOFIRE_SET) ? ID_FLAG_AUTOFIRE : 0;
flag |= (flags & IDEV_MAPPED_TOGGLE) ? ID_FLAG_TOGGLE : 0;
}
flag |= (flags & IDEV_MAPPED_GAMEPORTSCUSTOM1) ? ID_FLAG_GAMEPORTSCUSTOM1 : 0;
flag |= (flags & IDEV_MAPPED_GAMEPORTSCUSTOM2) ? ID_FLAG_GAMEPORTSCUSTOM2 : 0;
+ flag |= flags & IDEV_MAPPED_QUALIFIER_MASK;
if (port >= 0)
portp = port;
put_event_data (idf, devindex, num, eid, custom, flag, portp, sub);
}
}
+//memcpy (p->joystick_settings[dst], p->joystick_settings[src], sizeof (struct uae_input_device) * MAX_INPUT_DEVICES);
+static void copydev (struct uae_input_device *dst, struct uae_input_device *src)
+{
+ for (int i = 0; i < MAX_INPUT_DEVICES; i++) {
+ for (int j = 0; j < MAX_INPUT_DEVICE_EVENTS; j++) {
+ for (int k = 0; k < MAX_INPUT_SUB_EVENT_ALL; k++) {
+ xfree (dst[i].custom[j][k]);
+ }
+ }
+ xfree (dst[i].configname);
+ xfree (dst[i].name);
+ }
+ memcpy (dst, src, sizeof (struct uae_input_device) * MAX_INPUT_DEVICES);
+ for (int i = 0; i < MAX_INPUT_DEVICES; i++) {
+ for (int j = 0; j < MAX_INPUT_DEVICE_EVENTS; j++) {
+ for (int k = 0; k < MAX_INPUT_SUB_EVENT_ALL; k++) {
+ if (dst[i].custom)
+ dst[i].custom[j][k] = my_strdup (dst[i].custom[j][k]);
+ }
+ }
+ dst[i].configname = my_strdup (dst[i].configname);
+ dst[i].name = my_strdup (dst[i].name);
+ }
+}
+
// copy whole configuration #x-slot to another
-void inputdevice_copy_single_config (struct uae_prefs *p, int src, int dst, int devnum)
+// +1 = default
+// +2 = default (pc keyboard)
+void inputdevice_copy_single_config (struct uae_prefs *p, int src, int dst, int devnum, int selectedwidget)
{
+ if (src >= MAX_INPUT_SETTINGS) {
+ if (gettype (devnum) == IDTYPE_KEYBOARD) {
+ p->input_keyboard_type = src > MAX_INPUT_SETTINGS ? 1 : 0;
+ keyboard_default = keyboard_default_table[p->input_keyboard_type];
+ inputdevice_default_kb (p, dst);
+ }
+ }
if (src == dst)
return;
- if (devnum < 0 || gettype (devnum) == IDTYPE_JOYSTICK)
- memcpy (p->joystick_settings[dst], p->joystick_settings[src], sizeof (struct uae_input_device) * MAX_INPUT_DEVICES);
- if (devnum < 0 || gettype (devnum) == IDTYPE_MOUSE)
- memcpy (p->mouse_settings[dst], p->mouse_settings[src], sizeof (struct uae_input_device) * MAX_INPUT_DEVICES);
- if (devnum < 0 || gettype (devnum) == IDTYPE_KEYBOARD)
- memcpy (p->keyboard_settings[dst], p->keyboard_settings[src], sizeof (struct uae_input_device) * MAX_INPUT_DEVICES);
+ if (src < MAX_INPUT_SETTINGS) {
+ if (devnum < 0 || gettype (devnum) == IDTYPE_JOYSTICK)
+ copydev (p->joystick_settings[dst], p->joystick_settings[src]);
+ if (devnum < 0 || gettype (devnum) == IDTYPE_MOUSE)
+ copydev (p->mouse_settings[dst], p->mouse_settings[src]);
+ if (devnum < 0 || gettype (devnum) == IDTYPE_KEYBOARD)
+ copydev (p->keyboard_settings[dst], p->keyboard_settings[src]);
+ }
}
void inputdevice_acquire (int allmode)
{
int i;
- inputdevice_unacquire ();
+ for (i = 0; i < MAX_INPUT_DEVICES; i++)
+ idev[IDTYPE_JOYSTICK].unacquire (i);
+ for (i = 0; i < MAX_INPUT_DEVICES; i++)
+ idev[IDTYPE_MOUSE].unacquire (i);
+ for (i = 0; i < MAX_INPUT_DEVICES; i++)
+ idev[IDTYPE_KEYBOARD].unacquire (i);
+
for (i = 0; i < MAX_INPUT_DEVICES; i++) {
if ((use_joysticks[i] && allmode >= 0) || (allmode && !idev[IDTYPE_JOYSTICK].get_flags (i)))
idev[IDTYPE_JOYSTICK].acquire (i, 0);
if ((use_keyboards[i] && allmode >= 0) || (allmode < 0 && !idev[IDTYPE_KEYBOARD].get_flags (i)))
idev[IDTYPE_KEYBOARD].acquire (i, allmode < 0);
}
+
+ if (input_acquired)
+ return;
+
+ idev[IDTYPE_JOYSTICK].acquire (-1, 0);
+ idev[IDTYPE_MOUSE].acquire (-1, 0);
+ idev[IDTYPE_KEYBOARD].acquire (-1, 0);
// if (!input_acquired)
// write_log (L"input devices acquired (%s)\n", allmode ? "all" : "selected only");
input_acquired = 1;
{
int i;
- // if (input_acquired)
- // write_log (L"input devices unacquired\n");
- input_acquired = 0;
for (i = 0; i < MAX_INPUT_DEVICES; i++)
idev[IDTYPE_JOYSTICK].unacquire (i);
for (i = 0; i < MAX_INPUT_DEVICES; i++)
idev[IDTYPE_MOUSE].unacquire (i);
for (i = 0; i < MAX_INPUT_DEVICES; i++)
idev[IDTYPE_KEYBOARD].unacquire (i);
+
+ if (!input_acquired)
+ return;
+
+ input_acquired = 0;
+ idev[IDTYPE_JOYSTICK].unacquire (-1);
+ idev[IDTYPE_MOUSE].unacquire (-1);
+ idev[IDTYPE_KEYBOARD].unacquire (-1);
}
void inputdevice_testrecord (int type, int num, int wtype, int wnum, int state)
DEFEVENT(PAR_JOY_END, L"", AM_DUMMY, 0,0,0)
+/* qualifiers */
+
+DEFEVENT(SPC_QUALIFIER_START,L"Qualifiers",AM_INFO, 0,0,0)
+
+DEFEVENT(SPC_QUALIFIER1,L"Qualifier 1",AM_KK,0,0,AKS_QUALIFIER1)
+DEFEVENT(SPC_QUALIFIER2,L"Qualifier 2",AM_KK,0,0,AKS_QUALIFIER2)
+DEFEVENT(SPC_QUALIFIER3,L"Qualifier 3",AM_KK,0,0,AKS_QUALIFIER3)
+DEFEVENT(SPC_QUALIFIER4,L"Qualifier 4",AM_KK,0,0,AKS_QUALIFIER4)
+DEFEVENT(SPC_QUALIFIER5,L"Qualifier 5",AM_KK,0,0,AKS_QUALIFIER5)
+DEFEVENT(SPC_QUALIFIER6,L"Qualifier 6",AM_KK,0,0,AKS_QUALIFIER6)
+DEFEVENT(SPC_QUALIFIER7,L"Qualifier 7",AM_KK,0,0,AKS_QUALIFIER7)
+DEFEVENT(SPC_QUALIFIER8,L"Qualifier 8",AM_KK,0,0,AKS_QUALIFIER8)
+DEFEVENT(SPC_QUALIFIER_SPECIAL,L"Qualifier Special",AM_KK,0,0,AKS_QUALIFIER_SPECIAL)
+DEFEVENT(SPC_QUALIFIER_SHIFT,L"Qualifier Shift",AM_KK,0,0,AKS_QUALIFIER_SHIFT)
+DEFEVENT(SPC_QUALIFIER_CONTROL,L"Qualifier Control",AM_KK,0,0,AKS_QUALIFIER_CONTROL)
+DEFEVENT(SPC_QUALIFIER_ALT,L"Qualifier Alt",AM_KK,0,0,AKS_QUALIFIER_ALT)
+
+DEFEVENT(SPC_QUALIFIER_END, L"", AM_DUMMY, 0,0,0)
+
/* keys */
DEFEVENT(KEY_START,L"Keyboard",AM_INFO, 0,0,0)
DEFEVENT(SPC_TOGGLEFULLSCREEN,L"Toggle windowed/fullscreen",AM_K,0,0,AKS_TOGGLEWINDOWEDFULLSCREEN)
DEFEVENT(SPC_TOGGLEFULLWINDOWFULLSCREEN,L"Toggle full-window/fullscreen",AM_K,0,0,AKS_TOGGLEFULLWINDOWFULLSCREEN)
DEFEVENT(SPC_TOGGLEWINDOWFULLWINDOW,L"Toggle window/full-window",AM_K,0,0,AKS_TOGGLEWINDOWFULLWINDOW)
+DEFEVENT(SPC_TOGGLEDEFAULTSCREEN,L"Toggle window/default screen",AM_K,0,0,AKS_TOGGLEDEFAULTSCREEN)
DEFEVENT(SPC_TOGGLEMOUSEGRAB,L"Toggle between mouse grabbed and un-grabbed",AM_K,0,0,AKS_TOGGLEMOUSEGRAB)
DEFEVENT(SPC_DECREASE_REFRESHRATE,L"Decrease emulation speed",AM_K,0,0,AKS_DECREASEREFRESHRATE)
DEFEVENT(SPC_INCREASE_REFRESHRATE,L"Increase emulation speed",AM_K,0,0,AKS_INCREASEREFRESHRATE)
DEFEVENT(SPC_CDTV_FRONT_PANEL_REW,L"CDTV Front Panel Rewind",AM_K,0,0,AKS_CDTV_FRONT_PANEL_REW)
DEFEVENT(SPC_CDTV_FRONT_PANEL_FF,L"CDTV Front Panel Fast Forward",AM_K,0,0,AKS_CDTV_FRONT_PANEL_FF)
+DEFEVENT(SPC_LAST, L"", AM_DUMMY, 0,0,0)
case 100: // open dll
{
+ if (!currprefs.native_code)
+ return 0;
TCHAR *dlldir = TEXT ("winuae_dll");
TCHAR *dllname;
uaecptr dllptr;
case 101: //get dll label
{
- HMODULE m;
- uaecptr funcaddr;
- char *funcname;
- m = (HMODULE) m68k_dreg (regs, 1);
- funcaddr = m68k_areg (regs, 0);
- funcname = (char*)get_real_address (funcaddr);
- return (uae_u32) GetProcAddress (m, funcname);
+ if (currprefs.native_code) {
+ HMODULE m;
+ uaecptr funcaddr;
+ char *funcname;
+ m = (HMODULE) m68k_dreg (regs, 1);
+ funcaddr = m68k_areg (regs, 0);
+ funcname = (char*)get_real_address (funcaddr);
+ return (uae_u32) GetProcAddress (m, funcname);
+ }
+ return 0;
}
case 102: //execute native code
{
- uae_u32 ret;
- unsigned long rate1;
- double v;
- rate1 = read_processor_time ();
- ret = emulib_ExecuteNativeCode2 (context);
- rate1 = read_processor_time () - rate1;
- v = syncdivisor * rate1;
- if (v > 0) {
- if (v > 1000000 * CYCLE_UNIT)
- v = 1000000 * CYCLE_UNIT;
- do_extra_cycles ((unsigned long)(syncdivisor * rate1)); //compensate the time stay in native func
+ uae_u32 ret = 0;
+ if (currprefs.native_code) {
+ unsigned long rate1;
+ double v;
+ rate1 = read_processor_time ();
+ ret = emulib_ExecuteNativeCode2 (context);
+ rate1 = read_processor_time () - rate1;
+ v = syncdivisor * rate1;
+ if (v > 0) {
+ if (v > 1000000 * CYCLE_UNIT)
+ v = 1000000 * CYCLE_UNIT;
+ do_extra_cycles ((unsigned long)(syncdivisor * rate1)); //compensate the time stay in native func
+ }
}
return ret;
}
case 103: //close dll
{
- HMODULE libaddr;
- libaddr = (HMODULE) m68k_dreg (regs, 1);
- FreeLibrary (libaddr);
+ if (currprefs.native_code) {
+ HMODULE libaddr;
+ libaddr = (HMODULE) m68k_dreg (regs, 1);
+ FreeLibrary (libaddr);
+ }
return 0;
}
#endif
free(bswap_buffer);
bswap_buffer = (void*)malloc(bswap_buffer_size);
}
+ if (!bswap_buffer)
+ return 0;
+
__asm {
mov esi, dword ptr [src]
mov edi, dword ptr [bswap_buffer]
free(bswap_buffer);
bswap_buffer = (void*)malloc(bswap_buffer_size);
}
+ if (!bswap_buffer)
+ return 0;
__asm {
mov esi, dword ptr [src]
mov edi, dword ptr [bswap_buffer]
s = ua (pctxt);
txt = pctoamiga (s);
- txtlen = strlen (s);
+ txtlen = strlen (txt);
xfree (to_amiga);
size = txtlen + sizeof b + (txtlen & 1) - 8;
b[4] = size >> 24;
*/
int rawinput_enabled_hid = -1;
+int rawinput_log = 0;
#define _WIN32_WINNT 0x501 /* enable RAWINPUT support */
#define DI_DEBUG 1
-#define DI_DEBUG2 0
-#define DI_DEBUG_RAWINPUT_KB 0
-#define DI_DEBUG_RAWINPUT_MOUSE 0
-#define DI_DEBUG_RAWINPUT_HID 0
#define IGNOREEVERYTHING 0
#include "sysconfig.h"
static int rawinput_available;
static bool rawinput_registered;
+static int rawinput_reg;
static bool test_rawinput (int usage)
{
rid.usUsagePage = 1;
rid.usUsage = usage;
- if (RegisterRawInputDevices (&rid, 1, sizeof (RAWINPUTDEVICE)) == FALSE) {
+ if (RegisterRawInputDevices (&rid, 1, sizeof RAWINPUTDEVICE) == FALSE) {
write_log (L"RAWINPUT test failed, usage=%d ERR=%d\n", usage, GetLastError ());
return false;
}
rid.dwFlags |= RIDEV_REMOVE;
- if (RegisterRawInputDevices (&rid, 1, sizeof (RAWINPUTDEVICE)) == FALSE) {
+ if (RegisterRawInputDevices (&rid, 1, sizeof RAWINPUTDEVICE) == FALSE) {
write_log (L"RAWINPUT test failed (release), usage=%d, ERR=%d\n", usage, GetLastError ());
return false;
}
}
//write_log (L"RegisterRawInputDevices = %d (%d)\n", activate, num);
- if (RegisterRawInputDevices (rid, num, sizeof (RAWINPUTDEVICE)) == FALSE) {
+ rawinput_reg = num;
+ if (!add)
+ rawinput_reg = -rawinput_reg;
+ //write_log (L"+++++++++++++++++++++++++++%x\n", hMainWnd);
+ if (RegisterRawInputDevices (rid, num, sizeof RAWINPUTDEVICE) == FALSE) {
write_log (L"RAWINPUT %sregistration failed %d\n",
add ? L"" : L"un", GetLastError ());
return 0;
}
+ //write_log (L"-------------------------- %x\n", hMainWnd);
return 1;
}
#if DI_DEBUG
if (did->axles + did->buttons > 0) {
- write_log (L"%s: (%x/%x)\n", did->name, did->vid, did->pid);
+ write_log (L"%s: (%04X/%04X)\n", did->name, did->vid, did->pid);
if (did->connection == DIDC_DX)
write_log (L"PGUID=%s\n", outGUID (&did->pguid));
for (i = 0; i < did->axles; i++) {
break;
}
}
-#if DI_DEBUG_RAWINPUT_MOUSE
- write_log (L"HANDLE=%08x %04x %04x %04x %08x %3d %3d %08x M=%d\n",
- raw->header.hDevice,
- rm->usFlags,
- rm->usButtonFlags,
- rm->usButtonData,
- rm->ulRawButtons,
- rm->lLastX,
- rm->lLastY,
- rm->ulExtraInformation, num < num_mouse ? num + 1 : -1);
-#endif
+ if (rawinput_log & 2)
+ write_log (L"HANDLE=%08x %04x %04x %04x %08x %3d %3d %08x M=%d\n",
+ raw->header.hDevice,
+ rm->usFlags,
+ rm->usButtonFlags,
+ rm->usButtonData,
+ rm->ulRawButtons,
+ rm->lLastX,
+ rm->lLastY,
+ rm->ulExtraInformation, num < num_mouse ? num + 1 : -1);
+
if (num == num_mouse)
return;
PRAWHID hid = &raw->data.hid;
HANDLE h = raw->header.hDevice;
PCHAR rawdata;
-#if DI_DEBUG_RAWINPUT_HID
- uae_u8 *r = hid->bRawData;
- write_log (L"%d %d %02x%02x%02x%02x%02x%02x%02x\n", hid->dwCount, hid->dwSizeHid,
- r[0], r[1], r[2], r[3], r[4], r[5], r[6]);
-#endif
+ if (rawinput_log & 4) {
+ uae_u8 *r = hid->bRawData;
+ write_log (L"%d %d %02x%02x%02x%02x%02x%02x%02x\n", hid->dwCount, hid->dwSizeHid,
+ r[0], r[1], r[2], r[3], r[4], r[5], r[6]);
+ }
for (num = 0; num < num_joystick; num++) {
did = &di_joystick[num];
if (did->connection != DIDC_RAW)
break;
}
if (j == did->maxusagelistlength || did->prevusagelist[j].Usage == 0) {
-#if DI_DEBUG_RAWINPUT_HID
- write_log (L"%d/%d ON\n", did->usagelist[k].UsagePage, did->usagelist[k].Usage);
-#endif
+ if (rawinput_log & 4)
+ write_log (L"%d/%d ON\n", did->usagelist[k].UsagePage, did->usagelist[k].Usage);
+
for (int l = 0; l < did->buttons; l++) {
if (did->buttonmappings[l] == did->usagelist[k].Usage)
setjoybuttonstate (num, l, 1);
}
for (j = 0; j < did->maxusagelistlength; j++) {
if (did->prevusagelist[j].Usage) {
-#if DI_DEBUG_RAWINPUT_HID
- write_log (L"%d/%d OFF\n", did->prevusagelist[j].UsagePage, did->prevusagelist[j].Usage);
-#endif
+ if (rawinput_log & 4)
+ write_log (L"%d/%d OFF\n", did->prevusagelist[j].UsagePage, did->prevusagelist[j].Usage);
+
for (int l = 0; l < did->buttons; l++) {
if (did->buttonmappings[l] == did->prevusagelist[j].Usage)
setjoybuttonstate (num, l, 0);
int scancode = rk->MakeCode & 0x7f;
int pressed = (rk->Flags & RI_KEY_BREAK) ? 0 : 1;
-#if DI_DEBUG_RAWINPUT_KB
- write_log (L"HANDLE=%x CODE=%x Flags=%x VK=%x MSG=%x EXTRA=%x SC=%x\n",
- raw->header.hDevice,
- rk->MakeCode,
- rk->Flags,
- rk->VKey,
- rk->Message,
- rk->ExtraInformation,
- scancode);
-#endif
+ if (rawinput_log & 1)
+ write_log (L"HANDLE=%x CODE=%x Flags=%x VK=%x MSG=%x EXTRA=%x SC=%x\n",
+ raw->header.hDevice,
+ rk->MakeCode,
+ rk->Flags,
+ rk->VKey,
+ rk->Message,
+ rk->ExtraInformation,
+ scancode);
+
// eat E1 extended keys
if (rk->Flags & (RI_KEY_E1))
return;
if (scancode == 0) {
scancode = MapVirtualKey (rk->VKey, MAPVK_VK_TO_VSC);
-#if DI_DEBUG_RAWINPUT_KB
- write_log (L"VK->CODE: %x\n", scancode);
-#endif
+ if (rawinput_log & 1)
+ write_log (L"VK->CODE: %x\n", scancode);
+
}
if (rk->VKey == 0xff || (rk->Flags & RI_KEY_E0))
scancode |= 0x80;
if (!rawinput_available)
return;
- GetRawInputData ((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof (RAWINPUTHEADER));
- if (dwSize <= sizeof (lpb)) {
- if (GetRawInputData ((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof (RAWINPUTHEADER)) == dwSize) {
- raw = (RAWINPUT*)lpb;
- handle_rawinput_2 (raw);
- DefRawInputProc (&raw, 1, sizeof (RAWINPUTHEADER));
+ if (GetRawInputData ((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof (RAWINPUTHEADER)) >= 0) {
+ if (dwSize <= sizeof (lpb)) {
+ if (GetRawInputData ((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof (RAWINPUTHEADER)) == dwSize) {
+ raw = (RAWINPUT*)lpb;
+ handle_rawinput_2 (raw);
+ DefRawInputProc (&raw, 1, sizeof (RAWINPUTHEADER));
+ } else {
+ write_log (L"GetRawInputData(%d) failed, %d\n", dwSize, GetLastError ());
+ }
}
+ } else {
+ write_log (L"GetRawInputData(-1) failed, %d\n", GetLastError ());
}
}
DIPROPDWORD dipdw;
HRESULT hr;
+ if (num < 0) {
+ doregister_rawinput ();
+ return 1;
+ }
+
unacquire (lpdi, L"mouse");
if (did->connection == DIDC_DX && lpdi) {
setcoop (&di_mouse[num], flags ? (DISCL_FOREGROUND | DISCL_EXCLUSIVE) : (DISCL_BACKGROUND | DISCL_NONEXCLUSIVE), L"mouse");
} else
normalmouse++;
}
- doregister_rawinput ();
return di_mouse[num].acquired > 0 ? 1 : 0;
}
static void unacquire_mouse (int num)
{
+ if (num < 0) {
+ doregister_rawinput ();
+ return;
+ }
unacquire (di_mouse[num].lpdi, L"mouse");
if (di_mouse[num].acquired > 0) {
if (di_mouse[num].rawinput)
normalmouse--;
di_mouse[num].acquired = 0;
}
- doregister_rawinput ();
}
static void read_mouse (void)
int dimofs = didod[j].dwOfs;
int data = didod[j].dwData;
int state = (data & 0x80) ? 1 : 0;
-#if DI_DEBUG2
- write_log (L"MOUSE: %d OFF=%d DATA=%d STATE=%d\n", i, dimofs, data, state);
-#endif
+ if (rawinput_log & 8)
+ write_log (L"MOUSE: %d OFF=%d DATA=%d STATE=%d\n", i, dimofs, data, state);
+
if (istest || isfocus () > 0) {
for (k = 0; k < did->axles; k++) {
if (did->axismappings[k] == dimofs)
static int acquire_kb (int num, int flags)
{
- LPDIRECTINPUTDEVICE8 lpdi = di_keyboard[num].lpdi;
+ LPDIRECTINPUTDEVICE8 lpdi;
+
+ if (num < 0) {
+ doregister_rawinput ();
+ return 1;
+ }
+ lpdi = di_keyboard[num].lpdi;
unacquire (lpdi, L"keyboard");
if (currprefs.keyboard_leds_in_use) {
#ifdef WINDDK
normalkb++;
di_keyboard[num].acquired = 1;
}
- doregister_rawinput ();
return di_keyboard[num].acquired > 0 ? 1 : 0;
}
static void unacquire_kb (int num)
{
- LPDIRECTINPUTDEVICE8 lpdi = di_keyboard[num].lpdi;
-
+ LPDIRECTINPUTDEVICE8 lpdi;
+ if (num < 0) {
+ doregister_rawinput ();
+ return;
+ }
+ lpdi = di_keyboard[num].lpdi;
unacquire (lpdi, L"keyboard");
if (di_keyboard[num].acquired > 0) {
if (di_keyboard[num].rawinput)
}
#endif
}
- doregister_rawinput ();
//unlock_kb ();
}
if (bstate >= 0 && axisold[i][k] != bstate) {
setjoybuttonstate (i, k, bstate);
axisold[i][k] = bstate;
-#if DI_DEBUG2
- write_log (L"AB:NUM=%d OFF=%d AXIS=%d DIR=%d NAME=%s VAL=%d STATE=%d BS=%d\n",
- k, dimofs, axis, dir, did->buttonname[k], data, state, bstate);
-#endif
+ if (rawinput_log & 8)
+ write_log (L"AB:NUM=%d OFF=%d AXIS=%d DIR=%d NAME=%s VAL=%d STATE=%d BS=%d\n",
+ k, dimofs, axis, dir, did->buttonname[k], data, state, bstate);
+
}
} else if (did->buttonaxisparent[k] < 0 && did->buttonmappings[k] == dimofs) {
-#if DI_DEBUG2
- write_log (L"B:NUM=%d OFF=%d NAME=%s VAL=%d STATE=%d\n",
- k, dimofs, did->buttonname[k], data, state);
-#endif
+ if (rawinput_log & 8)
+ write_log (L"B:NUM=%d OFF=%d NAME=%s VAL=%d STATE=%d\n",
+ k, dimofs, did->buttonname[k], data, state);
setjoybuttonstate (i, k, state);
}
}
setjoystickstate (i, k, (data2 >= 20250 && data2 <= 33750) ? -1 : (data2 >= 2250 && data2 <= 15750) ? 1 : 0, 1);
} else if (did->axistype[k] == 2) {
setjoystickstate (i, k, ((data2 >= 29250 && data2 <= 33750) || (data2 >= 0 && data2 <= 6750)) ? -1 : (data2 >= 11250 && data2 <= 24750) ? 1 : 0, 1);
-#if DI_DEBUG2
- write_log (L"P:NUM=%d OFF=%d NAME=%s VAL=%d\n", k, dimofs, did->axisname[k], data2);
-#endif
+ if (rawinput_log & 8)
+ write_log (L"P:NUM=%d OFF=%d NAME=%s VAL=%d\n", k, dimofs, did->axisname[k], data2);
} else if (did->axistype[k] == 0) {
-#if DI_DEBUG2
- if (data < -20000 || data > 20000)
- write_log (L"A:NUM=%d OFF=%d NAME=%s VAL=%d\n", k, dimofs, did->axisname[k], data);
-#endif
+ if (rawinput_log & 8) {
+ if (data < -20000 || data > 20000)
+ write_log (L"A:NUM=%d OFF=%d NAME=%s VAL=%d\n", k, dimofs, did->axisname[k], data);
+ }
if (istest) {
if (data < -20000)
data = -20000;
static int acquire_joystick (int num, int flags)
{
- LPDIRECTINPUTDEVICE8 lpdi = di_joystick[num].lpdi;
+ LPDIRECTINPUTDEVICE8 lpdi;
DIPROPDWORD dipdw;
HRESULT hr;
+ if (num < 0) {
+ doregister_rawinput ();
+ return 1;
+ }
+ lpdi = di_joystick[num].lpdi;
unacquire (lpdi, L"joystick");
if (di_joystick[num].connection == DIDC_DX && lpdi) {
setcoop (&di_joystick[num], flags ? (DISCL_FOREGROUND | DISCL_EXCLUSIVE) : (DISCL_BACKGROUND | DISCL_NONEXCLUSIVE), L"joystick");
} else {
di_joystick[num].acquired = 1;
}
- doregister_rawinput ();
return di_joystick[num].acquired > 0 ? 1 : 0;
}
{
struct didata *did = &di_joystick[num];
+ if (num < 0) {
+ doregister_rawinput ();
+ return;
+ }
+
unacquire (did->lpdi, L"joystick");
if (did->connection == DIDC_RAW) {
if (di_joystick[num].acquired)
rawhid--;
}
di_joystick[num].acquired = 0;
- doregister_rawinput ();
}
static int get_joystick_flags (int num)
fDims.x = (FLOAT) Desc.Width;
fDims.y = (FLOAT) Desc.Height;
}
- fTexelSize.x = 1 / fDims.x;
- fTexelSize.y = 1 / fDims.y;
+ fTexelSize.x = 1.0f / fDims.x;
+ fTexelSize.y = 1.0f / fDims.y;
if (m_SourceDimsEffectHandle) {
hr = pEffect->SetVector (m_SourceDimsEffectHandle, &fDims);
if (FAILED (hr)) {
return true;
}
+void D3D_vblank_reset (void)
+{
+ if (!isd3d ())
+ return;
+}
+
static int getd3dadapter (IDirect3D9 *d3d)
{
struct MultiDisplay *md = getdisplay (&currprefs);
modeex.Width = w_w;
modeex.Height = w_h;
modeex.RefreshRate = 0;
- modeex.ScanLineOrdering = D3DSCANLINEORDERING_PROGRESSIVE;
+ modeex.ScanLineOrdering = ap->gfx_interlaced ? D3DSCANLINEORDERING_INTERLACED : D3DSCANLINEORDERING_PROGRESSIVE;
modeex.Format = mode.Format;
vsync2 = 0;
modeex.RefreshRate = dpp.FullScreen_RefreshRateInHz;
if (vsync > 0) {
dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
- if (getvsyncrate (dpp.FullScreen_RefreshRateInHz) != dpp.FullScreen_RefreshRateInHz) {
+ getvsyncrate (dpp.FullScreen_RefreshRateInHz, &mult);
+ if (mult < 0) {
if (d3dCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO;
else
- vsync2 = 1;
+ vsync2 = -1;
+ } else if (mult > 0) {
+ vsync2 = 1;
}
}
}
(d3dCaps.PixelShaderVersion >> 8) & 0xff, d3dCaps.PixelShaderVersion & 0xff,
(d3dCaps.VertexShaderVersion >> 8) & 0xff, d3dCaps.VertexShaderVersion & 0xff,
max_texture_w, max_texture_h,
- dpp.Windowed ? 0 : dpp.FullScreen_RefreshRateInHz,
+ dpp.FullScreen_RefreshRateInHz,
dpp.Windowed ? L"" : L" FS",
vsync, dpp.BackBufferCount,
dpp.PresentationInterval & D3DPRESENT_INTERVAL_IMMEDIATE ? L"I" : L"F",
bool D3D_renderframe (void)
{
+ static int vsync2_cnt;
+
if (!isd3d ())
return false;
+ if (vsync2 > 0) {
+ vsync2_cnt ^= 1;
+ if (vsync2_cnt == 0)
+ return true;
+ }
D3D_render2 ();
- if (vsync2 && !currprefs.turbo_emulation) {
+ if (vsync2 < 0 && !currprefs.turbo_emulation) {
D3D_render2 ();
}
extern void D3D_setcursor (int x, int y, int width, int height, bool visible);
extern bool D3D_getvblankpos (int *vpos);
extern double D3D_getrefreshrate (void);
+extern void D3D_vblank_reset (void);
extern LPDIRECT3DTEXTURE9 cursorsurfaced3d;
#define CURSORMAXWIDTH 64
if (dxdata.fsmodeset && dxdata.width == width && dxdata.height == height &&
dxdata.depth == bits && dxdata.freq == freq)
return DD_OK;
+
+ getvsyncrate (freq, &dxdata.vblank_skip);
+ dxdata.vblank_skip_cnt = 0;
ddrval = IDirectDraw7_SetDisplayMode (dxdata.maindd, width, height, bits, freq, 0);
if (FAILED (ddrval)) {
write_log (L"IDirectDraw7_SetDisplayMode: %s\n", DXError (ddrval));
DirectDraw_FillSurface (dxdata.primary, NULL, 0);
}
-extern int vblank_skip;
static void flip (void)
{
int result = 0;
HRESULT ddrval = DD_OK;
DWORD flags = DDFLIP_DONOTWAIT;
int vsync = isvsync ();
+ bool novsync = false;
struct apmode *ap = WIN32GFX_IsPicassoScreen () ? &currprefs.gfx_apmode[1] : &currprefs.gfx_apmode[0];
- if (currprefs.turbo_emulation || !ap->gfx_vflip)
+ if (currprefs.turbo_emulation || !ap->gfx_vflip) {
+ novsync = true;
flags |= DDFLIP_NOVSYNC;
+ }
if (dxdata.backbuffers == 2) {
DirectDraw_Blit (dxdata.flipping[1], dxdata.flipping[0]);
if (vsync) {
- if (vblank_skip >= 0 || currprefs.turbo_emulation) {
+ if (currprefs.turbo_emulation || dxdata.vblank_skip == 0) {
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ } else if (dxdata.vblank_skip > 0) {
+ dxdata.vblank_skip_cnt ^= 1;
+ if (dxdata.vblank_skip_cnt == 0)
+ return;
ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ } else if (flipinterval_supported && !novsync) {
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags | DDFLIP_INTERVAL2);
} else {
- if (flipinterval_supported) {
- ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags | DDFLIP_INTERVAL2);
- } else {
- ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
- DirectDraw_Blit (dxdata.flipping[1], dxdata.primary);
- ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
- }
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ DirectDraw_Blit (dxdata.flipping[1], dxdata.primary);
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
}
} else {
ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags| DDFLIP_NOVSYNC);
}
} else if(dxdata.backbuffers == 1) {
- if (!vsync)
- flags |= DDFLIP_NOVSYNC;
- ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
- DirectDraw_Blit (dxdata.flipping[0], dxdata.primary);
+ if (vsync) {
+ if (currprefs.turbo_emulation || dxdata.vblank_skip == 0) {
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ } else if (dxdata.vblank_skip > 0) {
+ dxdata.vblank_skip_cnt ^= 1;
+ if (dxdata.vblank_skip_cnt == 0)
+ return;
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ } else if (flipinterval_supported && !novsync) {
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags | DDFLIP_INTERVAL2);
+ } else {
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ DirectDraw_Blit (dxdata.flipping[0], dxdata.primary);
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags);
+ }
+ DirectDraw_Blit (dxdata.flipping[0], dxdata.primary);
+ } else {
+ ddrval = IDirectDrawSurface7_Flip (dxdata.primary, NULL, flags | DDFLIP_NOVSYNC);
+ DirectDraw_Blit (dxdata.flipping[0], dxdata.primary);
+ }
}
if (ddrval == DDERR_SURFACELOST) {
static int recurse;
*vpos = -1;
return true;
}
+
+void DD_vblank_reset (void)
+{
+ dx_check ();
+ if ((dxdata.primary == NULL && dxdata.fsmodeset > 0) || dxdata.islost || !dxdata.maindd)
+ return;
+ IDirectDraw7_WaitForVerticalBlank (dxdata.maindd, DDWAITVB_BLOCKBEGIN, NULL);
+}
DWORD overlayflags;
int fsmodeset, backbuffers;
int width, height, depth, freq;
+ int vblank_skip, vblank_skip_cnt;
int swidth, sheight;
DDSURFACEDESC2 native;
DDSURFACEDESC2 locksurface;
void DirectDraw_Fill (RECT *rect, uae_u32 color);
void DirectDraw_FillPrimary (void);
bool DD_getvblankpos (int *vpos);
+void DD_vblank_reset (void);
void dx_check (void);
int dx_islost (void);
{ DIK_ESCAPE, INPUTEVENT_KEY_ESC },
- { DIK_F1, INPUTEVENT_KEY_F1 },
- { DIK_F2, INPUTEVENT_KEY_F2 },
- { DIK_F3, INPUTEVENT_KEY_F3 },
- { DIK_F4, INPUTEVENT_KEY_F4 },
- { DIK_F5, INPUTEVENT_KEY_F5 },
-
- { DIK_F6, INPUTEVENT_KEY_F6 },
- { DIK_F7, INPUTEVENT_KEY_F7 },
- { DIK_F8, INPUTEVENT_KEY_F8 },
- { DIK_F9, INPUTEVENT_KEY_F9 },
+ { DIK_F1, INPUTEVENT_KEY_F1, 0, INPUTEVENT_SPC_FLOPPY0, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_EFLOPPY0, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+ { DIK_F2, INPUTEVENT_KEY_F2, 0, INPUTEVENT_SPC_FLOPPY1, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_EFLOPPY1, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+ { DIK_F3, INPUTEVENT_KEY_F3, 0, INPUTEVENT_SPC_FLOPPY2, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_EFLOPPY2, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+ { DIK_F4, INPUTEVENT_KEY_F4, 0, INPUTEVENT_SPC_FLOPPY3, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_EFLOPPY3, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+
+ { DIK_F5, INPUTEVENT_KEY_F5, 0, INPUTEVENT_SPC_STATERESTOREDIALOG, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_STATESAVEDIALOG, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+ { DIK_F6, INPUTEVENT_KEY_F6 },
+ { DIK_F7, INPUTEVENT_KEY_F7 },
+ { DIK_F8, INPUTEVENT_KEY_F8 },
+ { DIK_F9, INPUTEVENT_KEY_F9 },
{ DIK_F10, INPUTEVENT_KEY_F10 },
{ DIK_1, INPUTEVENT_KEY_1 },
{ DIK_NUMPAD9, INPUTEVENT_KEY_NP_9 },
{ DIK_NUMPAD0, INPUTEVENT_KEY_NP_0 },
{ DIK_DECIMAL, INPUTEVENT_KEY_NP_PERIOD },
- { DIK_ADD, INPUTEVENT_KEY_NP_ADD },
- { DIK_SUBTRACT, INPUTEVENT_KEY_NP_SUB },
- { DIK_MULTIPLY, INPUTEVENT_KEY_NP_MUL },
- { DIK_DIVIDE, INPUTEVENT_KEY_NP_DIV },
+ { DIK_ADD, INPUTEVENT_KEY_NP_ADD, 0, INPUTEVENT_SPC_VOLUME_UP, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_MASTER_VOLUME_UP, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_CONTROL, INPUTEVENT_SPC_INCREASE_REFRESHRATE, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+ { DIK_SUBTRACT, INPUTEVENT_KEY_NP_SUB, 0, INPUTEVENT_SPC_VOLUME_DOWN, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_MASTER_VOLUME_DOWN, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_CONTROL, INPUTEVENT_SPC_DECREASE_REFRESHRATE, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
+ { DIK_MULTIPLY, INPUTEVENT_KEY_NP_MUL, 0, INPUTEVENT_SPC_VOLUME_MUTE, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_MASTER_VOLUME_MUTE, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_CONTROL },
+ { DIK_DIVIDE, INPUTEVENT_KEY_NP_DIV, 0, INPUTEVENT_SPC_STATEREWIND, ID_FLAG_QUALIFIER_SPECIAL },
{ DIK_NUMPADENTER, INPUTEVENT_KEY_ENTER },
{ DIK_MINUS, INPUTEVENT_KEY_SUB },
{ DIK_RETURN, INPUTEVENT_KEY_RETURN },
{ DIK_SPACE, INPUTEVENT_KEY_SPACE },
- { DIK_LSHIFT, INPUTEVENT_KEY_SHIFT_LEFT },
- { DIK_LCONTROL, INPUTEVENT_KEY_CTRL },
+ { DIK_LSHIFT, INPUTEVENT_KEY_SHIFT_LEFT, 0, INPUTEVENT_SPC_QUALIFIER_SHIFT },
+ { DIK_LCONTROL, INPUTEVENT_KEY_CTRL, 0, INPUTEVENT_SPC_QUALIFIER_CONTROL },
{ DIK_LWIN, INPUTEVENT_KEY_AMIGA_LEFT },
- { DIK_LMENU, INPUTEVENT_KEY_ALT_LEFT },
- { DIK_RMENU, INPUTEVENT_KEY_ALT_RIGHT },
+ { DIK_LMENU, INPUTEVENT_KEY_ALT_LEFT, 0, INPUTEVENT_SPC_QUALIFIER_ALT },
+ { DIK_RMENU, INPUTEVENT_KEY_ALT_RIGHT, 0, INPUTEVENT_SPC_QUALIFIER_ALT },
{ DIK_RWIN, INPUTEVENT_KEY_AMIGA_RIGHT },
{ DIK_APPS, INPUTEVENT_KEY_AMIGA_RIGHT },
- { DIK_RCONTROL, INPUTEVENT_KEY_CTRL },
- { DIK_RSHIFT, INPUTEVENT_KEY_SHIFT_RIGHT },
+ { DIK_RCONTROL, INPUTEVENT_KEY_CTRL, 0, INPUTEVENT_SPC_QUALIFIER_CONTROL },
+ { DIK_RSHIFT, INPUTEVENT_KEY_SHIFT_RIGHT, 0, INPUTEVENT_SPC_QUALIFIER_SHIFT },
{ DIK_UP, INPUTEVENT_KEY_CURSOR_UP },
{ DIK_DOWN, INPUTEVENT_KEY_CURSOR_DOWN },
{ DIK_PERIOD, INPUTEVENT_KEY_PERIOD },
{ DIK_SLASH, INPUTEVENT_KEY_DIV },
{ DIK_OEM_102, INPUTEVENT_KEY_30 },
+ { DIK_SYSRQ, INPUTEVENT_SPC_SCREENSHOT_CLIPBOARD, 0, INPUTEVENT_SPC_SCREENSHOT_CLIPBOARD, ID_FLAG_QUALIFIER_SPECIAL },
-// { DIK_VOLUMEDOWN, INPUTEVENT_SPC_MASTER_VOLUME_DOWN },
-// { DIK_VOLUMEUP, INPUTEVENT_SPC_MASTER_VOLUME_UP },
-// { DIK_MUTE, INPUTEVENT_SPC_MASTER_VOLUME_MUTE },
+ { DIK_END, INPUTEVENT_SPC_QUALIFIER_SPECIAL },
+ { DIK_PAUSE, INPUTEVENT_SPC_PAUSE, 0, INPUTEVENT_SPC_WARP, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_IRQ7, ID_FLAG_QUALIFIER_SPECIAL | ID_FLAG_QUALIFIER_SHIFT },
-// { DIK_HOME, INPUTEVENT_KEY_70 },
- { DIK_END, INPUTEVENT_KEY_END },
-// { DIK_SYSRQ, INPUTEVENT_KEY_6E },
-// { DIK_F12, INPUTEVENT_KEY_6F },
-// { DIK_INSERT, INPUTEVENT_KEY_47 },
-// { DIK_PRIOR, INPUTEVENT_KEY_48 },
-// { DIK_NEXT, INPUTEVENT_KEY_49 },
- { DIK_F11, INPUTEVENT_KEY_F11 },
+ { DIK_F12, INPUTEVENT_SPC_ENTERGUI, 0, INPUTEVENT_SPC_ENTERDEBUGGER, ID_FLAG_QUALIFIER_SPECIAL, INPUTEVENT_SPC_ENTERDEBUGGER, ID_FLAG_QUALIFIER_SHIFT, INPUTEVENT_SPC_TOGGLEDEFAULTSCREEN, ID_FLAG_QUALIFIER_CONTROL },
{ DIK_MEDIASTOP, INPUTEVENT_KEY_CDTV_STOP },
{ DIK_PLAYPAUSE, INPUTEVENT_KEY_CDTV_PLAYPAUSE },
kb_xa1, kb_xa2, kb_arcadia, kb_arcadiaxa, kb_cdtv
};
-extern int ispressed (int key);
-
-static int specialkeycode (void)
-{
- if (currprefs.input_keyboard_type == 0)
- return currprefs.win32_specialkey;
- return -1;
-}
static int specialpressed (void)
{
- return ispressed (specialkeycode ());
+ return input_getqualifiers () & ID_FLAG_QUALIFIER_SPECIAL;
}
-
static int shiftpressed (void)
{
- return ispressed (DIK_LSHIFT) || ispressed (DIK_RSHIFT);
+ return input_getqualifiers () & ID_FLAG_QUALIFIER_SHIFT;
}
-
static int altpressed (void)
{
- return ispressed (DIK_LMENU) || ispressed (DIK_RMENU);
+ return input_getqualifiers () & ID_FLAG_QUALIFIER_ALT;
}
-
static int ctrlpressed (void)
{
- return ispressed (DIK_LCONTROL) || ispressed (DIK_RCONTROL);
+ return input_getqualifiers () & ID_FLAG_QUALIFIER_CONTROL;
}
static int capslockstate;
inputdevice_updateconfig (&currprefs);
}
-static int np[] = {
+static const int np[] = {
DIK_NUMPAD0, 0, DIK_NUMPADPERIOD, 0, DIK_NUMPAD1, 1, DIK_NUMPAD2, 2,
DIK_NUMPAD3, 3, DIK_NUMPAD4, 4, DIK_NUMPAD5, 5, DIK_NUMPAD6, 6, DIK_NUMPAD7, 7,
DIK_NUMPAD8, 8, DIK_NUMPAD9, 9, -1 };
int scancode_new;
int defaultguikey;
bool amode = currprefs.input_keyboard_type == 0;
+ bool special = false;
static int swapperdrive = 0;
- if (scancode == specialkeycode ())
+#if 0
+ if (scancode == specialkeycode ()) {
+ inputdevice_checkqualifierkeycode (keyboard, scancode, newstate);
return;
+ }
+#endif
if (amode && scancode == DIK_F11 && currprefs.win32_ctrl_F11_is_quit && ctrlpressed ())
code = AKS_QUIT;
//write_log (L"keyboard = %d scancode = 0x%02x state = %d\n", keyboard, scancode, newstate );
- if (amode && newstate == 0 && code == 0) {
- switch (scancode)
- {
- case DIK_SYSRQ:
- screenshot (specialpressed () ? 1 : 0, 1);
- break;
- }
- }
-
-
- if (newstate && code == 0) {
-
- if (scancode == defaultguikey || scancode == currprefs.win32_guikey) {
- if (ctrlpressed ()) {
- code = AKS_TOGGLEDEFAULTSCREEN;
- } else if (shiftpressed () || specialpressed ()) {
- if (isfullscreen() <= 0) {
- disablecapture ();
- code = AKS_ENTERDEBUGGER;
- }
- } else {
- code = AKS_ENTERGUI;
- }
- }
-
- }
-
if (newstate && code == 0 && amode) {
switch (scancode)
{
+#if 0
case DIK_F1:
case DIK_F2:
case DIK_F3:
code = AKS_FLOPPY0 + (scancode - DIK_F1);
}
}
+ special = true;
break;
case DIK_F5:
#if 0
else
code = AKS_STATERESTOREDIALOG;
}
+ special = true;
break;
+#endif
+
case DIK_1:
case DIK_2:
case DIK_3:
_tcscpy (changed_prefs.floppyslots[swapperdrive].df, currprefs.dfxlist[num]);
config_changed = 1;
}
+ special = true;
}
break;
case DIK_NUMPAD0:
}
if (v >= 0)
code = AKS_STATESAVEQUICK + v * 2 + ((shiftpressed () || ctrlpressed ()) ? 0 : 1);
+ special = true;
}
break;
+#if 0
case DIK_PAUSE:
if (specialpressed ()) {
if (shiftpressed ())
} else {
code = AKS_PAUSE;
}
+ special = true;
break;
#if 0
case DIK_SCROLL:
else
code = AKS_VOLDOWN;
}
+ special = true;
break;
case DIK_NUMPADPLUS:
if (specialpressed ()) {
else
code = AKS_VOLUP;
}
+ special = true;
break;
case DIK_NUMPADSTAR:
if (specialpressed ()) {
else
code = AKS_VOLMUTE;
}
+ special = true;
break;
case DIK_NUMPADSLASH:
if (specialpressed ())
code = AKS_STATEREWIND;
+ special = true;
break;
+#endif
}
}
return;
}
+
scancode = scancode_new;
if (!specialpressed () && newstate) {
if (scancode == DIK_CAPITAL) {
capslockstate = host_scrolllockstate;
}
}
- if (specialpressed ())
+
+ if (special) {
+ inputdevice_checkqualifierkeycode (keyboard, scancode, newstate);
return;
+ }
inputdevice_translatekeycode (keyboard, scancode, newstate);
}
static int vsynccnt;
int thisisvsync = 1;
int vsync = isvsync_rtg ();
+ int mult;
#ifdef RETROPLATFORM
rp_vsync ();
if (!picasso_on)
createwindowscursor (0, 0, 0, 0, 0, 1);
- if (vsync >= 0 && currprefs.chipset_refreshrate >= 85) {
+ getvsyncrate (currprefs.chipset_refreshrate, &mult);
+ if (vsync >= 0 && mult < 0) {
vsynccnt++;
if (vsynccnt < 2)
thisisvsync = 0;
#define IDS_FILTER_NOOVERLAYS 269
#define IDS_STMENUNOCD 270
#define IDS_ON 271
+#define IDS_INPUTQUALIFIER 272
#define IDS_NUMSG_NEEDEXT2 300
#define IDS_NUMSG_NOROMKEY 301
#define IDS_NUMSG_KSROMCRCERROR 302
#define IDS_AUTOSCALE_INTEGER 375
#define IDS_SCREEN_VSYNC2_AUTOSWITCH 376
#define IDS_SCREEN_VSYNC2 377
-#define IDS_STRING23 378
#define IDS_SCREEN_VSYNC_NONE 378
#define IDS_QS_MODELS 1000
#define IDS_QS_MODEL_A500 1001
#define IDC_AVIOUTPUT_VIDEO 1613
#define IDC_INPUTAUTOFIRE 1613
#define IDC_PORT_MOUSETRICK 1613
+#define IDC_CLIPBOARDSHARE2 1613
+#define IDC_NATIVECODE 1613
#define IDC_AVIOUTPUT_AUDIO 1614
#define IDC_INPUTCOPYFROM 1614
#define IDC_SANA2 1614
GROUPBOX "Miscellaneous Options",IDC_STATIC,4,2,293,165\r
CONTROL "Untrap = middle button",IDC_JULIAN,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,19,110,10\r
CONTROL "Show GUI on startup",IDC_SHOWGUI,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,43,109,10\r
- CONTROL "Native on-screen display",IDC_SHOWLEDS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,139,109,10\r
+ CONTROL "Native on-screen display",IDC_SHOWLEDS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,182,103,109,10\r
CONTROL "Don't show taskbar button",IDC_NOTASKBARBUTTON,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,67,109,10\r
CONTROL "Use CTRL-F11 to quit",IDC_CTRLF11,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,55,110,10\r
GROUPBOX "Keyboard LEDs",IDC_STATIC,3,207,294,29\r
CONTROL "Synchronize clock",IDC_CLOCKSYNC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,103,111,10\r
CONTROL "Faster RTG [] Enables less accurate custom chipset emulation mode when Picasso96 is enabled.",IDC_FASTERRTG,\r
"Button",BS_AUTOCHECKBOX | BS_LEFT | WS_GROUP | WS_TABSTOP,19,115,111,10\r
- CONTROL "RTG on-screen display",IDC_SHOWLEDSRTG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,151,109,10\r
+ CONTROL "RTG on-screen display",IDC_SHOWLEDSRTG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,182,114,109,10\r
RTEXT "Graphics API:",IDC_STATIC,130,62,79,10,SS_CENTERIMAGE\r
COMBOBOX IDC_DXMODE,213,60,79,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
CONTROL "Minimize when focus is lost",IDC_FOCUSMINIMIZE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,31,110,10\r
RTEXT "Windowed style:",IDC_STATIC,128,45,81,10,SS_CENTERIMAGE\r
COMBOBOX IDC_WINDOWEDMODE,213,43,79,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
CONTROL "Clipboard sharing",IDC_CLIPBOARDSHARE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,127,111,10\r
+ CONTROL "Allow native code",IDC_NATIVECODE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,19,139,111,10\r
END\r
\r
IDD_HARDFILE DIALOGEX 0, 0, 299, 249\r
IDS_SCREEN_VSYNC_NONE "-"\r
END\r
\r
+STRINGTABLE\r
+BEGIN\r
+ IDS_INPUTQUALIFIER "Qualifiers"\r
+END\r
+\r
#endif // English resources\r
/////////////////////////////////////////////////////////////////////////////\r
\r
extern int harddrive_dangerous, do_rdbdump, aspi_allow_all, no_rawinput;
extern int force_directsound;
extern int log_a2065, a2065_promiscuous;
-extern int rawinput_enabled_hid;
+extern int rawinput_enabled_hid, rawinput_log;
int log_scsi;
int log_net;
int log_vsync;
if (WIN32GFX_IsPicassoScreen ())
WIN32GFX_EnablePicasso ();
getcapslock ();
- inputdevice_acquire (FALSE);
wait_keyrelease ();
inputdevice_acquire (TRUE);
if (isfullscreen() != 0 && !gui_active)
p->win32_iconified_priority = 3;
p->win32_notaskbarbutton = 0;
p->win32_alwaysontop = 0;
- p->win32_specialkey = 0xcf; // DIK_END
p->win32_guikey = -1;
p->win32_automount_removable = 0;
p->win32_automount_drives = 0;
cfgfile_target_dwrite_bool (f, L"notaskbarbutton", p->win32_notaskbarbutton);
cfgfile_target_dwrite_bool (f, L"always_on_top", p->win32_alwaysontop);
cfgfile_target_dwrite_bool (f, L"no_recyclebin", p->win32_norecyclebin);
- cfgfile_target_dwrite (f, L"specialkey", L"0x%x", p->win32_specialkey);
if (p->win32_guikey >= 0)
cfgfile_target_dwrite (f, L"guikey", L"0x%x", p->win32_guikey);
cfgfile_target_dwrite (f, L"kbledmode", L"%d", p->win32_kbledmode);
L"sound_sync", L"sound_tweak", L"directx6", L"sound_style",
L"file_path", L"iconified_nospeed", L"activepriority", L"magic_mouse",
L"filesystem_codepage", L"aspi", L"no_overlay", L"soundcard_exclusive",
+ L"specialkey",
0
};
|| cfgfile_string (option, value, L"parjoyport0", p->win32_parjoyport0, sizeof p->win32_parjoyport0 / sizeof (TCHAR))
|| cfgfile_string (option, value, L"parjoyport1", p->win32_parjoyport1, sizeof p->win32_parjoyport1 / sizeof (TCHAR))
|| cfgfile_string (option, value, L"gui_page", p->win32_guipage, sizeof p->win32_guipage / sizeof (TCHAR))
- || cfgfile_intval (option, value, L"specialkey", &p->win32_specialkey, 1)
|| cfgfile_intval (option, value, L"guikey", &p->win32_guikey, 1)
|| cfgfile_intval (option, value, L"kbledmode", &p->win32_kbledmode, 1)
|| cfgfile_intval (option, value, L"cpu_idle", &p->cpu_idle, 1));
if (!np)
return 0;
+ if (!_tcscmp (arg, L"inputlog")) {
+ rawinput_log = getval (np);
+ return 2;
+ }
if (!_tcscmp (arg, L"vsyncbusywait")) {
vsync_busy_wait_mode = getval (np);
return 2;
#define LANG_DLL 1
//#define WINUAEBETA L""
-#define WINUAEBETA L"Beta 13"
-#define WINUAEDATE MAKEBD(2012, 1, 20)
+#define WINUAEBETA L"Beta 14"
+#define WINUAEDATE MAKEBD(2012, 1, 28)
#define WINUAEEXTRA L""
+//#define WINUAEEXTRA L"AmiKit Preview"
#define WINUAEREV L""
#define IHF_WINDOWHIDDEN 6
c |= _tcscmp (currprefs.gfx_display_name, changed_prefs.gfx_display_name) ? (2|4|8) : 0;
c |= currprefs.gfx_blackerthanblack != changed_prefs.gfx_blackerthanblack ? (2 | 8) : 0;
c |= currprefs.gfx_apmode[0].gfx_backbuffers != changed_prefs.gfx_apmode[0].gfx_backbuffers ? (2 | 8) : 0;
+ c |= currprefs.gfx_apmode[0].gfx_interlaced != changed_prefs.gfx_apmode[0].gfx_interlaced ? (2 | 8) : 0;
c |= currprefs.gfx_apmode[1].gfx_backbuffers != changed_prefs.gfx_apmode[1].gfx_backbuffers ? (2 | 8) : 0;
c |= currprefs.win32_alwaysontop != changed_prefs.win32_alwaysontop ? 32 : 0;
_tcscpy (currprefs.gfx_display_name, changed_prefs.gfx_display_name);
currprefs.gfx_blackerthanblack = changed_prefs.gfx_blackerthanblack;
currprefs.gfx_apmode[0].gfx_backbuffers = changed_prefs.gfx_apmode[0].gfx_backbuffers;
+ currprefs.gfx_apmode[0].gfx_interlaced = changed_prefs.gfx_apmode[0].gfx_interlaced;
currprefs.gfx_apmode[1].gfx_backbuffers = changed_prefs.gfx_apmode[1].gfx_backbuffers;
currprefs.win32_alwaysontop = changed_prefs.win32_alwaysontop;
}
}
-bool vblank_wait (void)
+static bool vblank_wait (void)
{
int vp;
}
}
-bool vblank_getstate (bool *state)
+static bool vblank_getstate (bool *state)
{
int vp, opos;
return true;
}
+void vblank_reset (void)
+{
+ if (currprefs.gfx_api)
+ D3D_vblank_reset ();
+ else
+ DD_vblank_reset ();
+}
static unsigned int __stdcall flipthread (void *dummy)
{
int width, height, depth, rate, mode;
bool rtg;
double remembered_rate, remembered_rate2;
+ int maxscanline, maxvpos;
};
double vblank_calibrate (double approx_vblank, bool waitonly)
{
frame_time_t t1, t2;
- double tsum, tsum2, tval, tfirst;
+ double tsum, tsum2, tval, tfirst, div;
int maxcnt, maxtotal, total, cnt, tcnt2;
HANDLE th;
- int maxvpos, div;
+ int maxvpos, mult;
int width, height, depth, rate, mode;
struct remembered_vsync *rv;
double rval = -1;
struct apmode *ap = picasso_on ? &currprefs.gfx_apmode[1] : &currprefs.gfx_apmode[0];
+ bool remembered = false;
if (picasso_on) {
width = picasso96_state.Width;
height = currentmode->native_height;
depth = (currentmode->native_depth + 7) / 8;
}
+
rate = currprefs.gfx_refreshrate;
mode = isfullscreen ();
rv = vsyncmemory;
if (rv->width == width && rv->height == height && rv->depth == depth && rv->rate == rate && rv->mode == mode && rv->rtg == picasso_on) {
approx_vblank = rv->remembered_rate2;
rval = rv->remembered_rate;
+ maxscanline = rv->maxscanline;
+ maxvpos = rv->maxvpos;
waitonly = true;
- write_log (L"VSync calibration: remembered rate %.6fHz (%.6fHz)\n", rval, approx_vblank);
- break;
+ remembered = true;
+ goto skip;
}
rv = rv->next;
}
- if (waitonly) {
- vblankbasefull = syncbase / approx_vblank;
- vblankbasewait = (syncbase / approx_vblank) * 3 / 4;
- vblankbasewait2 = (syncbase / approx_vblank) * 70 / 100;
- vblankbasewait3 = (syncbase / approx_vblank) * 90 / 100;
- vblank_prev_time = read_processor_time ();
- return rval;
- }
-
th = GetCurrentThread ();
int oldpri = GetThreadPriority (th);
SetThreadPriority (th, THREAD_PRIORITY_HIGHEST);
changevblankthreadmode (VBLANKTH_CALIBRATE);
}
sleep_millis (100);
+
maxtotal = 10;
maxcnt = maxtotal;
+ maxscanline = 0;
tsum2 = 0;
tcnt2 = 0;
for (maxcnt = 0; maxcnt < maxtotal; maxcnt++) {
} else {
tsum /= total;
}
- div = 1;
- if (tsum >= 85)
- div = 2;
+
+skip:
+ if (waitonly)
+ tsum = approx_vblank;
+
+ getvsyncrate (tsum, &mult);
+ if (mult < 0)
+ div = 2.0;
+ else if (mult > 0)
+ div = 0.5;
+ else
+ div = 1.0;
tsum2 = tsum / div;
+
vblankbasefull = (syncbase / tsum2);
vblankbasewait = (syncbase / tsum2) * 3 / 4;
vblankbasewait2 = (syncbase / tsum2) * 70 / 100;
vblankbasewait3 = (syncbase / tsum2) * 90 / 100;
- write_log (L"VSync calibration: %.6fHz/%d=%.6fHz. MaxV=%d Units=%d\n", tsum, div, tsum2, maxvpos, vblankbasefull);
+ write_log (L"VSync %s: %.6fHz/%.1f=%.6fHz. MaxV=%d Units=%d\n", waitonly ? L"remembered" : L"calibrated", tsum, div, tsum2, maxvpos, vblankbasefull);
remembered_vblank = tsum;
vblank_prev_time = read_processor_time ();
- rv = xcalloc (struct remembered_vsync, 1);
- rv->width = width;
- rv->height = height;
- rv->depth = depth;
- rv->rate = rate;
- rv->mode = isfullscreen ();
- rv->rtg = picasso_on;
- rv->remembered_rate = tsum;
- rv->remembered_rate2 = tsum2;
- if (vsyncmemory == NULL) {
- vsyncmemory = rv;
- } else {
- rv->next = vsyncmemory;
- vsyncmemory = rv;
- }
+ if (!remembered) {
+ rv = xcalloc (struct remembered_vsync, 1);
+ rv->width = width;
+ rv->height = height;
+ rv->depth = depth;
+ rv->rate = rate;
+ rv->mode = isfullscreen ();
+ rv->rtg = picasso_on;
+ rv->remembered_rate = tsum;
+ rv->remembered_rate2 = tsum2;
+ rv->maxscanline = maxscanline;
+ rv->maxvpos = maxvpos;
+ if (vsyncmemory == NULL) {
+ vsyncmemory = rv;
+ } else {
+ rv->next = vsyncmemory;
+ vsyncmemory = rv;
+ }
+ }
+ vblank_reset ();
return tsum;
fail:
write_log (L"VSync calibration failed\n");
void centerdstrect (RECT *);
struct MultiDisplay *getdisplay (struct uae_prefs *p);
double getcurrentvblankrate (void);
+void vblank_reset (void);
#endif
D3D_guimode (opengui);
if (opengui)
DirectDraw_FlipToGDISurface ();
+ else
+ vblank_reset ();
}
static int GetSettings (int all_options, HWND hwnd);
clearallkeys ();
inputdevice_acquire (TRUE);
setmouseactive (1);
- flipgui (false);
#ifdef AVIOUTPUT
AVIOutput_Begin ();
#endif
fpscounter_reset ();
screenshot_free ();
write_disk_history ();
+ flipgui (false);
gui_active--;
here--;
}
static int input_selected_device, input_selected_widget, input_total_devices;
static int input_selected_event, input_selected_sub_num;
+static int input_copy_from;
+
+static void getqualifiername (TCHAR *p, int mask)
+{
+ int i, j;
+ *p = 0;
+ if (mask == IDEV_MAPPED_QUALIFIER_SPECIAL) {
+ _tcscpy (p, L"*");
+ } else if (mask == IDEV_MAPPED_QUALIFIER_SHIFT) {
+ _tcscpy (p, L"Shift");
+ } else if (mask == IDEV_MAPPED_QUALIFIER_CONTROL) {
+ _tcscpy (p, L"Ctrl");
+ } else if (mask == IDEV_MAPPED_QUALIFIER_ALT) {
+ _tcscpy (p, L"Alt");
+ } else {
+ for (i = IDEV_MAPPED_QUALIFIER1, j = 0; i <= IDEV_MAPPED_QUALIFIER8; i <<= 1, j++) {
+ if (i == mask)
+ _stprintf (p, L"%d", j + 1);
+ }
+ }
+}
static void set_lventry_input (HWND list, int index)
{
else if (flags & IDEV_MAPPED_AUTOFIRE_POSSIBLE)
WIN32GUI_LoadUIString (IDS_NO, toggle, sizeof toggle / sizeof (TCHAR));
else
- _tcscpy (toggle, L"-");
+ _tcscpy (toggle, L"-");
if (port > 0) {
TCHAR tmp[256];
_tcscpy (tmp, name);
ListView_SetItemText (list, index, 1, custom[0] ? custom : name);
ListView_SetItemText (list, index, 2, af);
ListView_SetItemText (list, index, 3, toggle);
+ _tcscpy (name, L"-");
+ if (flags & IDEV_MAPPED_QUALIFIER_MASK) {
+ TCHAR *p;
+ p = name;
+ for (i = 0; i < MAX_INPUT_QUALIFIERS; i++) {
+ int mask = IDEV_MAPPED_QUALIFIER1 << i;
+ if (flags & mask) {
+ if (p != name)
+ *p++ = ',';
+ getqualifiername (p, mask);
+ p += _tcslen (p);
+ }
+ }
+ }
+ ListView_SetItemText (list, index, 4, name);
sub = 0;
for (i = 0; i < MAX_INPUT_SUB_EVENT; i++) {
if (inputdevice_get_mapping (input_selected_device, index, &flags, NULL, name, custom, i) || custom[0])
sub++;
}
_stprintf (name, L"%d", sub);
- ListView_SetItemText (list, index, 4, name);
+ ListView_SetItemText (list, index, 5, name);
}
static void update_listview_input (HWND hDlg)
static int clicked_entry = -1;
#define LOADSAVE_COLUMNS 2
-#define INPUT_COLUMNS 5
+#define INPUT_COLUMNS 6
#define HARDDISK_COLUMNS 8
#define DISK_COLUMNS 3
#define MISC2_COLUMNS 2
WIN32GUI_LoadUIString (IDS_INPUTAMIGAEVENT, column_heading[1], MAX_COLUMN_HEADING_WIDTH);
WIN32GUI_LoadUIString (IDS_INPUTAUTOFIRE, column_heading[2], MAX_COLUMN_HEADING_WIDTH);
WIN32GUI_LoadUIString (IDS_INPUTTOGGLE, column_heading[3], MAX_COLUMN_HEADING_WIDTH);
- _tcscpy (column_heading[4], L"#");
+ WIN32GUI_LoadUIString (IDS_INPUTQUALIFIER, column_heading[4], MAX_COLUMN_HEADING_WIDTH);
+ _tcscpy (column_heading[5], L"#");
list = GetDlgItem (hDlg, IDC_INPUTLIST);
} else if (hDlg == pages[INPUTMAP_ID]) {
listview_column_width[1] = 260;
listview_column_width[2] = 65;
listview_column_width[3] = 65;
- listview_column_width[4] = 30;
+ listview_column_width[4] = 65;
+ listview_column_width[5] = 30;
update_listview_input (hDlg);
} else if (lv_type == LV_INPUTMAP) {
ew (hDlg, IDC_SCSIMODE, FALSE);
ew (hDlg, IDC_CLOCKSYNC, FALSE);
ew (hDlg, IDC_CLIPBOARDSHARE, FALSE);
+ ew (hDlg, IDC_NATIVECODE, FALSE);
} else {
#if !defined (SCSIEMU)
EnableWindow (GetDlgItem(hDlg, IDC_SCSIMODE), TRUE);
CheckDlgButton (hDlg, IDC_ALWAYSONTOP, workprefs.win32_alwaysontop);
CheckDlgButton (hDlg, IDC_CLOCKSYNC, workprefs.tod_hack);
CheckDlgButton (hDlg, IDC_CLIPBOARDSHARE, workprefs.clipboard_sharing);
+ CheckDlgButton (hDlg, IDC_NATIVECODE, workprefs.native_code);
CheckDlgButton (hDlg, IDC_POWERSAVE, workprefs.win32_powersavedisabled);
CheckDlgButton (hDlg, IDC_FASTERRTG, workprefs.picasso96_nocustom);
case IDC_CLIPBOARDSHARE:
workprefs.clipboard_sharing = ischecked (hDlg, IDC_CLIPBOARDSHARE);
break;
+ case IDC_NATIVECODE:
+ workprefs.native_code = ischecked (hDlg, IDC_NATIVECODE);
+ break;
case IDC_NOTASKBARBUTTON:
workprefs.win32_notaskbarbutton = ischecked (hDlg, IDC_NOTASKBARBUTTON);
break;
}
WIN32GUI_LoadUIString (IDS_INPUT_COPY_DEFAULT, buf, sizeof (buf) / sizeof (TCHAR));
SendDlgItemMessage (hDlg, IDC_INPUTCOPYFROM, CB_ADDSTRING, 0, (LPARAM)buf);
- SendDlgItemMessage (hDlg, IDC_INPUTCOPYFROM, CB_SETCURSEL, 0, 0);
+ SendDlgItemMessage (hDlg, IDC_INPUTCOPYFROM, CB_ADDSTRING, 0, (LPARAM)L"Default");
+ SendDlgItemMessage (hDlg, IDC_INPUTCOPYFROM, CB_ADDSTRING, 0, (LPARAM)L"Default (PC KB)");
+ SendDlgItemMessage (hDlg, IDC_INPUTCOPYFROM, CB_SETCURSEL, input_copy_from, 0);
SendDlgItemMessage (hDlg, IDC_INPUTAMIGACNT, CB_RESETCONTENT, 0, 0L);
LRESULT src = SendDlgItemMessage (hDlg, IDC_INPUTCOPYFROM, CB_GETCURSEL, 0, 0L);
if (src == CB_ERR)
return;
- int v = (int)src;
- if (v >= 0 && v <= 3) {
- inputdevice_copy_single_config (&workprefs, v, workprefs.input_selected_setting, input_selected_device);
- }
+ input_copy_from = src;
+ inputdevice_copy_single_config (&workprefs, (int)src, workprefs.input_selected_setting, input_selected_device, input_selected_widget);
init_inputdlg (hDlg);
}
inputdevice_set_mapping (input_selected_device, input_selected_widget,
name, custom, flags, -1, input_selected_sub_num);
}
+
+static int genericpopupmenu (HWND hwnd, TCHAR **items, int *flags, int num)
+{
+ int i, item;
+ HMENU menu;
+ POINT pt;
+
+ menu = CreatePopupMenu ();
+ for (i = 0; i < num; i++) {
+ MENUITEMINFO mii = { 0 };
+ mii.cbSize = sizeof mii;
+ mii.fMask = MIIM_STRING | MIIM_ID | MIIM_STATE;
+ mii.fType = MFT_STRING;
+ mii.fState = MFS_ENABLED;
+ if (flags[i])
+ mii.fState |= MFS_CHECKED;
+ mii.wID = i + 1;
+ mii.dwTypeData = items[i];
+ mii.cch = _tcslen (mii.dwTypeData);
+ InsertMenuItem (menu, -1, TRUE, &mii);
+ }
+ GetCursorPos (&pt);
+ item = TrackPopupMenu (menu, TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RETURNCMD,
+ pt.x, pt.y, 0, hwnd, NULL);
+ PostMessage (hwnd, WM_NULL, 0, 0);
+ DestroyMenu (menu);
+ return item - 1;
+}
+
+static void input_qualifiers (HWND hDlg)
+{
+ int flags, evt, item;
+ TCHAR name[256];
+ TCHAR custom[MAX_DPATH];
+ TCHAR *names[MAX_INPUT_QUALIFIERS];
+ int mflags[MAX_INPUT_QUALIFIERS];
+ TCHAR tmp[MAX_DPATH];
+
+ if (input_selected_device < 0 || input_selected_widget < 0)
+ return;
+ evt = inputdevice_get_mapping (input_selected_device, input_selected_widget,
+ &flags, NULL, name, custom, input_selected_sub_num);
+ if (evt <= 0)
+ name[0] = 0;
+
+ for (int i = 0; i < MAX_INPUT_QUALIFIERS; i++) {
+ getqualifiername (tmp, IDEV_MAPPED_QUALIFIER1 << i);
+ mflags[i] = 0;
+ if (flags & (IDEV_MAPPED_QUALIFIER1 << i))
+ mflags[i] = 1;
+ names[i] = my_strdup (tmp);
+ }
+ item = genericpopupmenu (hDlg, names, mflags, MAX_INPUT_QUALIFIERS);
+ if (item >= 0)
+ flags ^= IDEV_MAPPED_QUALIFIER1 << item;
+
+ inputdevice_set_mapping (input_selected_device, input_selected_widget,
+ name, custom, flags, -1, input_selected_sub_num);
+
+ for (int i = 0; i < MAX_INPUT_QUALIFIERS; i++) {
+ xfree (names[i]);
+ }
+}
static void input_toggletoggle (void)
{
int flags, evt;
list = nmlistview->hdr.hwndFrom;
switch (nmlistview->hdr.code)
{
+ case NM_RDBLCLK:
+ case NM_RCLICK:
+ input_selected_widget = -1;
+ ListView_SetItemState (list, -1, 0, LVIS_SELECTED);
+ update_listview_input (hDlg);
+ init_inputdlg_2 (hDlg);
+ break;
case NM_DBLCLK:
dblclick = 1;
/* fall-through */
input_toggleautofire ();
if (row == 3 && entry == oldentry)
input_toggletoggle ();
- if (row == 4) {
+ if (row == 4 && entry == oldentry)
+ input_qualifiers (hDlg);
+ if (row == 5) {
input_selected_sub_num++;
if (input_selected_sub_num >= MAX_INPUT_SUB_EVENT)
input_selected_sub_num = 0;
} else {
input_selected_widget = -1;
}
- if (dblclick)
+ if (dblclick && row <= 1)
doinputcustom (hDlg, 0);
update_listview_input (hDlg);
init_inputdlg_2 (hDlg);
+Beta 14:
+
+- Input panel qualifier key/button support. I think this was requested many many years ago.
+ (I didn't originally plan to this now but someone reminded me few days ago..)
+ - Any key or button can be configured as a qualifier (like a shift or control key that modifies behavior
+ of other keys)
+ - Any Input Target can be configured to require qualifiers. Input Target only triggers if it's
+ Input Source and all configured qualifiers are active at the same time.
+ - If multiple slots are configured, only slot(s) that have matching qualifier will be triggered,
+ for example if slot 1 has qualifier and slot 2 has none: Only slot 2 triggers if Input Source matches
+ without qualifier active and only slot 1 if Input Source matches with active qualifier.
+ - Same qualifer code (1-8) can be configured to more than one key/button.
+ - Qualifier(s) set to any other types than keys or buttons is currently undefined.
+ - End ("*" in GUI), Shift, Alt and Control keys are mapped to built-in qualifiers.
+ - Most previously hardwired key mappings (END+F1 etc..) are now implemented using Input qualifier system
+ Exceptions: F12 so that there is no way for users to accidentally disable GUI access.
+ END+<number> and END+<numpad number> disk swapper and statefile shortcuts, I didn't want to add 30+
+ new mostly pointless input targets.. Disabled if END-key's qualifier flag is removed.
+ - Qualifiers and custom events: slots 1 to 4 and 5 to 8 can have different qualifiers.
+
+- Doubled number of input target slots (4 to 8)
+- "Copy from"-button corrupted memory.
+- Added keyboard default options to "Copy from"-button. Can select either Amiga or PC default mapping.
+- TODO: restore only single input target to default.
+
+- Less than 35Hz vsync display refresh rate: show only every other frame.
+- Workaround for strange Windows feature or a bug. First call raw input RegisterRawInputDevices() to unregister
+ HID devices and then immediately call to register them again: Windows randomly stops reporting HID events.
+- Windows to Amiga clipboard sharing wrong string size if string contained cr/lf line endings.
+- Low latency VSync screen mode switch fixes and updates.
+- Native code execution (winlauch.alib etc..) is not anymore allowed by default. Option in misc panel.
+
Beta 13:
- bsdsocket emulation: use SOCK_DGRAM if requesting IPPROTO_UDP + SOCK_RAW. Raw sockets require
projects / francis / winuae.git / commitdiff