自学教程：C++ D_PostEvent函数代码示例

//// RawWin32Mouse::processEvents//// Iterates our queue of RAWINPUT events and converts them to Doom event_t// and posts them for processing by the game internals.//void RawWin32Mouse::processEvents(){	if (!mActive)		return;	event_t movement_event;	movement_event.type = ev_mouse;	movement_event.data1 = movement_event.data2 = movement_event.data3 = 0;	const RAWMOUSE* mouse;	while (mouse = front())	{		popFront();		// process mouse movement and save it		processRawMouseMovement(mouse, &movement_event);		// process mouse button clicks and post the events		event_t button_event;		for (int i = 0; i < 5; i++)		{			if (processRawMouseButtons(mouse, &button_event, i))				D_PostEvent(&button_event);		}		// process mouse scroll wheel action		if (processRawMouseScrollWheel(mouse, &button_event))			D_PostEvent(&button_event);	}	// post any mouse movement events	if (movement_event.data2 || movement_event.data3)		D_PostEvent(&movement_event);}

static void MapMouseWheelToButtons(SDL_MouseWheelEvent *wheel){    // SDL2 distinguishes button events from mouse wheel events.    // We want to treat the mouse wheel as two buttons, as per    // SDL1    static event_t up, down;    int button;    if (wheel->y <= 0)    {   // scroll down        button = 4;    }    else    {   // scroll up        button = 3;    }    // post a button down event    mouse_button_state |= (1 << button);    down.type = ev_mouse;    down.data1 = mouse_button_state;    down.data2 = down.data3 = 0;    D_PostEvent(&down);    // post a button up event    mouse_button_state &= ~(1 << button);    up.type = ev_mouse;    up.data1 = mouse_button_state;    up.data2 = up.data3 = 0;    D_PostEvent(&up);}

static void postevent(SDL_Event *Event){    event_t event;    switch (Event->type)    {    case SDL_KEYDOWN:        event.type = ev_keydown;        event.data1 = getkey(&Event->key.keysym);        D_PostEvent(&event);        break;    case SDL_KEYUP:        event.type = ev_keyup;        event.data1 = getkey(&Event->key.keysym);        D_PostEvent(&event);        break;    case SDL_MOUSEBUTTONDOWN:    case SDL_MOUSEBUTTONUP:        event.type = ev_mouse;        event.data1 = getmouse(SDL_GetMouseState(NULL, NULL));        event.data2 = 0;        event.data3 = 0;        D_PostEvent(&event);        break;    case SDL_MOUSEMOTION:        event.type = ev_mouse;        event.data1 = getmouse(Event->motion.state);        event.data2 = Event->motion.xrel << 5;        event.data3 = -Event->motion.yrel << 5;        D_PostEvent(&event);        break;    case SDL_QUIT:        I_Exit(0);    default:        break;    }}

static void GetMouse(){  event_t ev;  int x, y;  int buttons, dbuttons;  static int oldbuttons;    r.x.ax = 0xb;  int86(0x33, &r, &r);  x = (signed short)r.x.cx;  y = (signed short)r.x.dx;  if(x || y)    {      ev.type = ev_mouse;      ev.data1 = 0;      ev.data2 = x;      ev.data3 = -y;        D_PostEvent(&ev);    }  // check buttons  r.x.ax = 3;  int86(0x33, &r, &r);    buttons = r.x.bx;  dbuttons = buttons ^ oldbuttons;  if(dbuttons & 1)    {      ev.type = (buttons & 1) ? ev_keydown : ev_keyup;      ev.data1 = KEYD_MOUSE1;      D_PostEvent(&ev);    }  if(dbuttons & 2)    {      ev.type = (buttons & 2) ? ev_keydown : ev_keyup;      ev.data1 = KEYD_MOUSE2;      D_PostEvent(&ev);    }  if(dbuttons & 4)    {      ev.type = (buttons & 4) ? ev_keydown : ev_keyup;      ev.data1 = KEYD_MOUSE3;      D_PostEvent(&ev);    }  oldbuttons = buttons;}

void gameControls() {    u32 kDown, kUp;    struct eventTranslate *translateTable = gameKeyTable;    int numTranslations = numGameKeys;    kDown = keysDown();    kUp   = keysUp();    if (menuactive)    {        translateTable = menuKeyTable;        numTranslations = numMenuKeys;    } else if (automapmode & am_active) {        translateTable = mapKeyTable;        numTranslations = numMapKeys;    } else {        event_t event;        if (last_weapon_key != 0 && players[displayplayer].pendingweapon != wp_nochange) {            event.type = ev_keyup;            event.data1 = last_weapon_key;            D_PostEvent(&event);            last_weapon_key = 0;        }        if(kDown & KEY_Y) {            weapontype_t weapon_index = players[displayplayer].readyweapon;            weapon_index++;            while(players[displayplayer].weaponowned[weapon_index] == false) {                weapon_index++;                if (weapon_index >= NUMWEAPONS) weapon_index = 0;            }            last_weapon_key = weapons[weapon_index];            event.type = ev_keydown;            event.data1 = last_weapon_key;            D_PostEvent(&event);        }    }    translateKeys(ev_keydown, kDown, translateTable, numTranslations);    translateKeys(ev_keyup, kUp, translateTable, numTranslations);}

void I_GetEvent(void){	// Mappings of DS keys to SRB2 keys	UINT32 dskeys[] =	{		KEY_A,		KEY_B,		KEY_X,		KEY_Y,		KEY_L,		KEY_R,		KEY_START,		KEY_SELECT	};	event_t event;	UINT32 held, up, down;	UINT32 i;	// Check how the state has changed since last time	scanKeys();	// For the d-pad, we only care about the current state	held = keysHeld();	event.type = ev_joystick;	event.data1 = 0;	// First (and only) axis set	if (held & KEY_LEFT) event.data2 = -1;	else if (held & KEY_RIGHT) event.data2 = 1;	else event.data2 = 0;	if (held & KEY_UP) event.data3 = -1;	else if (held & KEY_DOWN) event.data3 = 1;	else event.data3 = 0;	D_PostEvent(&event);	// For the buttons, we need to report changes in state	up = keysUp();	down = keysDown();	for (i = 0; i < sizeof(dskeys)/sizeof(dskeys[0]); i++)	{		// Has this button's state changed?		if ((up | down) & dskeys[i])		{			event.type = (up & dskeys[i]) ? ev_keyup : ev_keydown;			event.data1 = KEY_JOY1 + i;			D_PostEvent(&event);		}	}}

//// I_JoystickEvents//// Gathers joystick data and creates an event_t for later processing// by G_Responder().//static void I_JoystickEvents(){   HALGamePad::padstate_t *padstate;   if(!(padstate = I_PollActiveGamePad()))      return;   // turn padstate into button input events   for(int button = 0; button < HALGamePad::MAXBUTTONS; button++)   {      edefstructvar(event_t, ev);      if(padstate->buttons[button] != padstate->prevbuttons[button])      {         ev.type  = padstate->buttons[button] ? ev_keydown : ev_keyup;         ev.data1 = KEYD_JOY01 + button;         D_PostEvent(&ev);      }   }   // read axes   for(int axis = 0; axis < HALGamePad::MAXAXES; axis++)   {      // fire axis state change events      if(padstate->axes[axis] != padstate->prevaxes[axis])      {         edefstructvar(event_t, ev);         // if previous state was off, key down         if(padstate->prevaxes[axis] == 0.0)            ev.type = ev_keydown;         // if new state is off, key up         if(padstate->axes[axis] == 0.0)            ev.type = ev_keyup;         ev.data1 = KEYD_AXISON01 + axis;         D_PostEvent(&ev);      }      // post analog axis state      edefstructvar(event_t, ev);      ev.type  = ev_joystick;      ev.data1 = axis;      ev.data2 = padstate->axes[axis];      if(axisOrientation[axis]) // may need to flip, if orientation == -1         ev.data2 *= axisOrientation[axis];      D_PostEvent(&ev);   }}

static void I_GetEvent(SDL_Event *Event){  event_t event;  switch (Event->type) {  case SDL_KEYDOWN:    event.type = ev_keydown;    event.data1 = I_TranslateKey(&Event->key.keysym);    D_PostEvent(&event);    break;  case SDL_KEYUP:  {    event.type = ev_keyup;    event.data1 = I_TranslateKey(&Event->key.keysym);    D_PostEvent(&event);  }  break;  case SDL_MOUSEBUTTONDOWN:  case SDL_MOUSEBUTTONUP:  if (mouse_enabled) // recognise clicks even if the pointer isn't grabbed  {    event.type = ev_mouse;    event.data1 = I_SDLtoDoomMouseState(SDL_GetMouseState(NULL, NULL));    event.data2 = event.data3 = 0;    D_PostEvent(&event);  }  break;  case SDL_MOUSEMOTION:  if (mouse_currently_grabbed) {    event.type = ev_mouse;    event.data1 = I_SDLtoDoomMouseState(Event->motion.state);    event.data2 = Event->motion.xrel << 5;    event.data3 = -Event->motion.yrel << 5;    D_PostEvent(&event);  }  break;  case SDL_QUIT:    S_StartSound(NULL, sfx_swtchn);    M_QuitDOOM(0);  default:    break;  }}

static void I_ReadMouse(void){    int x, y;    event_t ev;    SDL_GetRelativeMouseState(&x, &y);    if (x != 0 || y != 0)     {        ev.type = ev_mouse;        ev.data1 = mouse_button_state;        ev.data2 = AccelerateMouse(x);        if (!novert)        {            ev.data3 = -AccelerateMouse(y);        }        else        {            ev.data3 = 0;        }                D_PostEvent(&ev);    }    if (MouseShouldBeGrabbed())    {        CenterMouse();    }}

//// Read the change in mouse state to generate mouse motion events//// This is to combine all mouse movement for a tic into one mouse// motion event.void I_ReadMouse(void){    int x, y;    event_t ev;    SDL_GetRelativeMouseState(&x, &y);    if (x != 0 || y != 0)     {        ev.type = ev_mouse;        ev.data1 = mouse_button_state;        ev.data2 = AccelerateMouse(x);        if (!novert)        {            ev.data3 = -AccelerateMouse(y);        }        else        {            ev.data3 = 0;        }        // XXX: undefined behaviour since event is scoped to        // this function        D_PostEvent(&ev);    }}

//// I_RunDeferredEvents//// Check the deferred events queue for events that are ready to be posted.//static void I_RunDeferredEvents(){   DLListItem<deferredevent_t> *rover = i_deferredevents.head;   static int lasttic;   // Only run once per tic.   if(lasttic == gametic)      return;   lasttic = gametic;   while(rover)   {      DLListItem<deferredevent_t> *next = rover->dllNext;      deferredevent_t *de = *rover;      if(de->tic <= gametic)      {         D_PostEvent(&de->ev);         I_PutDeferredEvent(de);      }      rover = next;   }}

//// I_StartTic//void I_StartTic(void){    event_t event;    while (sel4doom_poll_event(&event)) {        D_PostEvent(&event);    }}

void I_StartTic (void){  int key;  event_t event;  hidScanInput();  if (saveStringEnter) {    if (!saveStringCopied) {      strcpy(keyboard_string,saveOldString);      saveStringCopied = true;      if (strcmp(keyboard_string,"empty slot") == 0) keyboard_string[0] = 0;    }    key = updateKeyboard();    if (key == KEYD_ESCAPE || key == KEYD_ENTER) saveStringCopied = false;    event.type = ev_keydown;    event.data1 = key;    D_PostEvent(&event);  } else {    gameControls();  }}

static void I_ReadMouse(void){    int x, y;    event_t ev;#if SDL_VERSION_ATLEAST(1, 3, 0)    SDL_GetRelativeMouseState(0, &x, &y);#else    SDL_GetRelativeMouseState(&x, &y);#endif    if (x != 0 || y != 0)     {        ev.type = ev_mouse;        ev.data1 = MouseButtonState();        ev.data2 = AccelerateMouse(x);        ev.data3 = -AccelerateMouse(y);                D_PostEvent(&ev);    }    if (MouseShouldBeGrabbed())    {        CenterMouse();    }}

void I_PollJoystick(void) {#if 0#ifdef HAVE_SDL_JOYSTICKGETAXIS  event_t ev;  Sint16 axis_value;  if (!usejoystick || (!joystick))      return;  ev.type = ev_joystick;  ev.key =   (SDL_JoystickGetButton(joystick, 0) << 0) |             (SDL_JoystickGetButton(joystick, 1) << 1) |             (SDL_JoystickGetButton(joystick, 2) << 2) |             (SDL_JoystickGetButton(joystick, 3) << 3) |             (SDL_JoystickGetButton(joystick, 4) << 4) |             (SDL_JoystickGetButton(joystick, 5) << 5) |             (SDL_JoystickGetButton(joystick, 6) << 6) |             (SDL_JoystickGetButton(joystick, 7) << 7);  axis_value = SDL_JoystickGetAxis(joystick, 0) / 3000;  if (abs(axis_value) < 10)    axis_value = 0;  ev.data2 = axis_value;  axis_value = SDL_JoystickGetAxis(joystick, 1) / 3000;  if (abs(axis_value) < 10)    axis_value = 0;  ev.data3 = axis_value;  D_PostEvent(&ev);#endif#endif}

void DoButtonEvent(int button,bool released){  event_t event;  event.type = ev_keydown;  if (released) event.type=ev_keyup;  event.data1 = button_to_key[menuactive?1:0][button];  D_PostEvent(&event);}

//// I_ReadMouse//// haleyjd 10/23/08: from Choco-Doom://// Read the change in mouse state to generate mouse motion events//// This is to combine all mouse movement for a tic into one mouse// motion event.//static void I_ReadMouse(SDL_Window *window){   int x, y;   event_t ev;   static Uint8 previous_state = 137;   Uint8 state;   SDL_PumpEvents();   state = SDL_GetRelativeMouseState(&x, &y);   if(state != previous_state)      previous_state = state;   if(x != 0 || y != 0)   {      ev.type = ev_mouse;      ev.data1 = SDL_MOUSEMOTION;      if(mouseAccel_type == ACCELTYPE_CHOCO)      {         // SoM: So the values that go to Eternity should be 16.16 fixed point...         ev.data2 =  AccelerateMouse(x);         ev.data3 = -AccelerateMouse(y);      }      else if(mouseAccel_type == ACCELTYPE_CUSTOM) // [CG] 01/20/12 Custom acceleration      {         ev.data2 =  CustomAccelerateMouse(x);         ev.data3 = -CustomAccelerateMouse(y);      }      D_PostEvent(&ev);   }}

static void I_GetInput() {	event_t event;	event.data2 = event.data3 = 0;		uint32_t down = hidKeysDown();	uint32_t held = hidKeysHeld();	uint32_t up = hidKeysUp();	// iterate over other possible key values	int i;	for (i = 0; i < (usejoystick ? 28 : 32); i++) {		uint32_t key = 1<<i;				if (down & key) {			event.data1 = I_TranslateKey(key);			event.type = ev_keydown;			D_PostEvent(&event);		} else if (up & key) {			event.data1 = I_TranslateKey(key);			event.type = ev_keyup;			D_PostEvent(&event);		}	}	// handle touch pad movement	if (usemouse) {		static int px = 0;		static int py = 0;		touchPosition touch;		hidTouchRead(&touch);		if (down & KEY_TOUCH) {			px = touch.px;			py = touch.py;					} else if (held & KEY_TOUCH && (touch.px != px || touch.py != py)) {			event.type = ev_mouse;			event.data1 = -1;			event.data2 = (touch.px - px) << 5;			event.data3 = -(touch.py - py) << 5;			D_PostEvent(&event);						px = touch.px;			py = touch.py;		}	}}

void I_GetEvent(void){    extern void I_HandleKeyboardEvent(SDL_Event *sdlevent);    extern void I_HandleMouseEvent(SDL_Event *sdlevent);    SDL_Event sdlevent;    SDL_PumpEvents();    while (SDL_PollEvent(&sdlevent))    {        switch (sdlevent.type)        {            case SDL_KEYDOWN:                if (ToggleFullScreenKeyShortcut(&sdlevent.key.keysym))                {                    I_ToggleFullScreen();                    break;                }                // deliberate fall-though            case SDL_KEYUP:		I_HandleKeyboardEvent(&sdlevent);                break;            case SDL_MOUSEBUTTONDOWN:            case SDL_MOUSEBUTTONUP:            case SDL_MOUSEWHEEL:                if (usemouse && !nomouse && window_focused)                {                    I_HandleMouseEvent(&sdlevent);                }                break;            case SDL_QUIT:                if (screensaver_mode)                {                    I_Quit();                }                else                {                    event_t event;                    event.type = ev_quit;                    D_PostEvent(&event);                }                break;            case SDL_WINDOWEVENT:                if (sdlevent.window.windowID == SDL_GetWindowID(screen))                {                    HandleWindowEvent(&sdlevent.window);                }                break;            default:                break;        }    }}

void I_PollXInputGamepad(void){#if defined(WIN32)    if (gamepad && !noinput)    {        XINPUT_STATE    state;        XINPUT_GAMEPAD  Gamepad;        ZeroMemory(&state, sizeof(XINPUT_STATE));        pXInputGetState(0, &state);        Gamepad = state.Gamepad;        gamepadbuttons = (Gamepad.wButtons            | GAMEPAD_LEFT_TRIGGER * (Gamepad.bLeftTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD)            | GAMEPAD_RIGHT_TRIGGER * (Gamepad.bRightTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD));        if (damagevibrationtics)            if (!--damagevibrationtics && !weaponvibrationtics)                XInputVibration(idlemotorspeed);        if (weaponvibrationtics)            if (!--weaponvibrationtics && !damagevibrationtics)                XInputVibration(idlemotorspeed);        if (gamepadbuttons)        {            vibrate = true;            idclev = false;            idmus = false;            if (idbehold)            {                message_clearable = true;                HU_ClearMessages();                idbehold = false;            }        }        if (gp_sensitivity || menuactive || (gamepadbuttons & gamepadmenu))        {            event_t      ev;            ev.type = ev_gamepad;            D_PostEvent(&ev);            gamepadthumbsfunc(Gamepad.sThumbLX, Gamepad.sThumbLY, Gamepad.sThumbRX,                Gamepad.sThumbRY);        }        else        {            gamepadbuttons = 0;            gamepadthumbLX = 0;            gamepadthumbLY = 0;            gamepadthumbRX = 0;        }    }#endif}

//// I_StartTic//void I_StartTic(void){	vector<event_t> events;	doomCallbacks->PopInputEvents(events);	for (const event_t& evt : events)	{		D_PostEvent(&evt);	}}

void I_HandleKeyboardEvent(SDL_Event *sdlevent){    // XXX: passing pointers to event for access after this function    // has terminated is undefined behaviour    event_t event;    switch (sdlevent->type)    {        case SDL_KEYDOWN:            event.type = ev_keydown;            event.data1 = TranslateKey(&sdlevent->key.keysym);            event.data2 = GetLocalizedKey(&sdlevent->key.keysym);            event.data3 = GetTypedChar(&sdlevent->key.keysym);            if (event.data1 != 0)            {                D_PostEvent(&event);            }            break;        case SDL_KEYUP:            event.type = ev_keyup;            event.data1 = TranslateKey(&sdlevent->key.keysym);            // data2/data3 are initialized to zero for ev_keyup.            // For ev_keydown it's the shifted Unicode character            // that was typed, but if something wants to detect            // key releases it should do so based on data1            // (key ID), not the printable char.            event.data2 = 0;            event.data3 = 0;            if (event.data1 != 0)            {                D_PostEvent(&event);            }            break;        default:            break;    }}

void UpdateJoystickEvents(){	std::list<JoystickEvent_t*>::iterator i;	event_t    event;	if(!JoyEventList.size())		return;	i = JoyEventList.begin();	while(i != JoyEventList.end())	{		if((*i)->Event.type == SDL_JOYHATMOTION)		{			// Hat position released			if(!(SDL_JoystickGetHat(openedjoy, (*i)->Event.jhat.hat) & (*i)->Event.jhat.value))				event.type = ev_keyup;			// Hat button still held - Repeat at key repeat interval			else if((SDL_GetTicks() - (*i)->RegTick >= SDL_DEFAULT_REPEAT_DELAY) && 		            (SDL_GetTicks() - (*i)->LastTick >= SDL_DEFAULT_REPEAT_INTERVAL*2))			{				(*i)->LastTick = SDL_GetTicks();				event.type = ev_keydown;			}			else			{				i++;				continue;			}			event.data1 = event.data2 = event.data3 = 0;			if((*i)->Event.jhat.value == SDL_HAT_UP)				event.data1 = ((*i)->Event.jhat.hat * 4) + KEY_HAT1;			else if((*i)->Event.jhat.value == SDL_HAT_RIGHT)				event.data1 = ((*i)->Event.jhat.hat * 4) + KEY_HAT2;			else if((*i)->Event.jhat.value == SDL_HAT_DOWN)				event.data1 = ((*i)->Event.jhat.hat * 4) + KEY_HAT3;			else if((*i)->Event.jhat.value == SDL_HAT_LEFT)				event.data1 = ((*i)->Event.jhat.hat * 4) + KEY_HAT4;			D_PostEvent(&event);			if(event.type == ev_keyup)			{				// Delete the released event				delete *i;				i = JoyEventList.erase(i);				continue;			}		}		i++;	}}

static void keyboard_events (int scancode, int press){	event_t		event;	if (press == KEY_EVENTPRESS)		event.type = ev_keydown;	else		event.type = ev_keyup;	event.data1 = xlatekey(scancode);	if (event.data1 > 0)		D_PostEvent(&event);}

static void WheelMoved(event_t *event){	if (GUICapture)	{		if (event->type != EV_KeyUp)		{			SDLMod mod = SDL_GetModState();			event->type = EV_GUI_Event;			event->subtype = event->data1 == KEY_MWHEELUP ? EV_GUI_WheelUp : EV_GUI_WheelDown;			event->data1 = 0;			event->data3 = ((mod & KMOD_SHIFT) ? GKM_SHIFT : 0) |						  ((mod & KMOD_CTRL) ? GKM_CTRL : 0) |						  ((mod & KMOD_ALT) ? GKM_ALT : 0);			D_PostEvent(event);		}	}	else	{		D_PostEvent(event);	}}

void I_PollDirectInputGamepad(void){    if (gamepad && !noinput)    {        int     hat = SDL_JoystickGetHat(gamepad, 0);        gamepadbuttons = (GAMEPAD_X * SDL_JoystickGetButton(gamepad, 0)            | GAMEPAD_A * SDL_JoystickGetButton(gamepad, 1)            | GAMEPAD_B * SDL_JoystickGetButton(gamepad, 2)            | GAMEPAD_Y * SDL_JoystickGetButton(gamepad, 3)            | GAMEPAD_LEFT_SHOULDER * SDL_JoystickGetButton(gamepad, 4)            | GAMEPAD_RIGHT_SHOULDER * SDL_JoystickGetButton(gamepad, 5)            | GAMEPAD_LEFT_TRIGGER * SDL_JoystickGetButton(gamepad, 6)            | GAMEPAD_RIGHT_TRIGGER * SDL_JoystickGetButton(gamepad, 7)            | GAMEPAD_BACK * SDL_JoystickGetButton(gamepad, 8)            | GAMEPAD_START * SDL_JoystickGetButton(gamepad, 9)            | GAMEPAD_LEFT_THUMB * SDL_JoystickGetButton(gamepad, 10)            | GAMEPAD_RIGHT_THUMB * SDL_JoystickGetButton(gamepad, 11)            | GAMEPAD_DPAD_UP * (hat & SDL_HAT_UP)            | GAMEPAD_DPAD_RIGHT * (hat & SDL_HAT_RIGHT)            | GAMEPAD_DPAD_DOWN * (hat & SDL_HAT_DOWN)            | GAMEPAD_DPAD_LEFT * (hat & SDL_HAT_LEFT));        if (gamepadbuttons)        {            idclev = false;            idmus = false;            if (idbehold)            {                message_clearable = true;                HU_ClearMessages();                idbehold = false;            }        }        if (gp_sensitivity || menuactive || (gamepadbuttons & gamepadmenu))        {            event_t     ev;            ev.type = ev_gamepad;            D_PostEvent(&ev);            gamepadthumbsfunc(0, 1, 2, 3);        }        else        {            gamepadbuttons = 0;            gamepadthumbLX = 0;            gamepadthumbLY = 0;            gamepadthumbRX = 0;        }    }}

// Add any joystick event to a list if it will require manual polling// to detect release. This includes hat events (mostly due to d-pads not// triggering the centered event when released) and analog axis bound// as a key/button -- HyperEye//// RegisterJoystickEvent//static int RegisterJoystickEvent(SDL_Event *ev, int value){	JoystickEvent_t *evc = NULL;	event_t          event;	if(!ev)		return -1;	if(ev->type == SDL_JOYHATMOTION)	{		if(JoyEventList.size())		{			std::list<JoystickEvent_t*>::iterator i;			for(i = JoyEventList.begin(); i != JoyEventList.end(); ++i)			{				if(((*i)->Event.type == ev->type) && ((*i)->Event.jhat.which == ev->jhat.which) 							&& ((*i)->Event.jhat.hat == ev->jhat.hat) && ((*i)->Event.jhat.value == value))					return 0;			}		}		evc = new JoystickEvent_t;		memcpy(&evc->Event, ev, sizeof(SDL_Event));		evc->Event.jhat.value = value;		evc->LastTick = evc->RegTick = SDL_GetTicks();		event.data1 = event.data2 = event.data3 = 0;		event.type = ev_keydown;		if(value == SDL_HAT_UP)			event.data1 = (ev->jhat.hat * 4) + KEY_HAT1;		else if(value == SDL_HAT_RIGHT)			event.data1 = (ev->jhat.hat * 4) + KEY_HAT2;		else if(value == SDL_HAT_DOWN)			event.data1 = (ev->jhat.hat * 4) + KEY_HAT3;		else if(value == SDL_HAT_LEFT)			event.data1 = (ev->jhat.hat * 4) + KEY_HAT4;		event.data2 = event.data1;	}	if(evc)	{		JoyEventList.push_back(evc);		D_PostEvent(&event);		return 1;	}	return 0;}

void I_GetEvent(void){  event_t evnt;  int val;  int key;  //printf("begin get_event()/n/r");  do  { val= test_for_event();    switch(val)    { case EV_REDRAW:        BeginDraw();        DrawWindow(win_x,win_y,win_w,win_h,0x404040,3,0,0,0);        EndDraw();        BlitDIB();        break;      case EV_KEY:        if(!get_key(&key))        {           switch(key)          {  case 0xE0:             case 0xE1:               continue;             default:               if(key&0x80)               { //printf("key released/n/r");                 evnt.type = ev_keyup;                }               else               { //printf("key pressed %x/n/r",key);                 evnt.type = ev_keydown;                };               key&=0x7F;                evnt.data1=remap_key(key);               if ( evnt.data1 != 0 )                 D_PostEvent(&evnt);               continue;          };             };          continue;      case EV_BUTTON:        switch(get_button_id())        {  case 1:             return;                       default:;        };    };     }while(val);}

static void UpdateMouseButtonState(unsigned int button, boolean on){    event_t event;    if (button < SDL_BUTTON_LEFT || button > MAX_MOUSE_BUTTONS)    {        return;    }    // Note: button "0" is left, button "1" is right,    // button "2" is middle for Doom.  This is different    // to how SDL sees things.    switch (button)    {        case SDL_BUTTON_LEFT:            button = 0;            break;        case SDL_BUTTON_RIGHT:            button = 1;            break;        case SDL_BUTTON_MIDDLE:            button = 2;            break;        default:            // SDL buttons are indexed from 1.            --button;            break;    }    // Turn bit representing this button on or off.    if (on)    {        mouse_button_state |= (1 << button);    }    else    {        mouse_button_state &= ~(1 << button);    }    // Post an event with the new button state.    event.type = ev_mouse;    event.data1 = mouse_button_state;    event.data2 = event.data3 = 0;    D_PostEvent(&event);}