/// <summary>
/// Default constructor
/// </summary>
public UserEventArgs()
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.type = (byte)EventTypes.UserEvent;
evt.user.type = (byte)EventTypes.UserEvent;
this.EventStruct = evt;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="width">The new window width</param>
/// <param name="height">The new window height</param>
public VideoResizeEventArgs(int width, int height)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.resize.w = width;
evt.resize.h = height;
evt.type = (byte)EventTypes.VideoResize;
this.EventStruct = evt;
}
/// <summary>
/// Joystick Hat event args
/// </summary>
/// <param name="device">The joystick index</param>
/// <param name="hatIndex">The hat index</param>
/// <param name="hatValue">The new hat position</param>
public JoystickHatEventArgs(byte device, byte hatIndex, byte hatValue)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.jhat.which = device;
evt.jhat.hat = hatIndex;
evt.jhat.val = hatValue;
evt.type = (byte)EventTypes.JoystickHatMotion;
this.EventStruct = evt;
}
/// <summary>
///
/// </summary>
///<param name="device">The joystick index</param>
/// <param name="ball">The trackball index</param>
/// <param name="relativeX">The relative X position</param>
/// <param name="relativeY">The relative Y position</param>
public JoystickBallEventArgs(byte device, byte ball, short relativeX, short relativeY)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.jball.which = device;
evt.jball.ball = ball;
evt.jball.xrel = relativeX;
evt.jball.yrel = relativeY;
evt.type = (byte)EventTypes.JoystickBallMotion;
this.EventStruct = evt;
}
/// <summary>
/// Create Event args
/// </summary>
/// <param name="device">The joystick index</param>
/// <param name="axisIndex">The axis index</param>
/// <param name="axisValue">The new axis value</param>
public JoystickAxisEventArgs(byte device, byte axisIndex, float axisValue)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.jaxis.which = device;
evt.jaxis.axis = axisIndex;
evt.jaxis.val =
(short)((axisValue * JOYSTICK_SCALE) - JOYSTICK_ADJUSTMENT);
evt.type = (byte)EventTypes.JoystickAxisMotion;
this.EventStruct = evt;
}
/// <summary>
/// Constructor for ActiveEventArgs
/// </summary>
/// <remarks>
/// Creates EventArgs that can be passed to the event queue
/// </remarks>
/// <param name="gainedFocus">
/// True if the focus was gained, False if it was lost
/// </param>
/// <param name="state">
/// Set to type of input that gave the app focus
/// </param>
public ActiveEventArgs(bool gainedFocus, Focus state)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
if (gainedFocus)
{
evt.active.gain = 1;
}
else
{
evt.active.gain = 0;
}
evt.type = (byte)EventTypes.ActiveEvent;
evt.active.state = (byte)state;
this.EventStruct = evt;
}
/// <summary>
/// joystick button args
/// </summary>
/// <param name="device">The joystick index</param>
/// <param name="button">The button index</param>
/// <param name="buttonPressed">
/// True if the button was pressed,
/// False if it was released
/// </param>
public JoystickButtonEventArgs(byte device, byte button, bool buttonPressed)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.jbutton.which = device;
evt.jbutton.button = button;
if (buttonPressed)
{
evt.jbutton.state = (byte)ButtonKeyState.Pressed;
evt.type = (byte)EventTypes.JoystickButtonDown;
}
else
{
evt.jbutton.state = (byte)ButtonKeyState.NotPressed;
evt.type = (byte)EventTypes.JoystickButtonUp;
}
this.EventStruct = evt;
}
/// <summary>
///
/// </summary>
/// <param name="button">The mouse button</param>
/// <param name="buttonPressed">True if the button is pressed,
/// False if it is released</param>
/// <param name="positionX">The current X coordinate</param>
/// <param name="positionY">The current Y coordinate</param>
public MouseButtonEventArgs(MouseButton button, bool buttonPressed, short positionX, short positionY)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.button.button = (byte)button;
evt.button.which = 0;
evt.button.x = positionX;
evt.button.y = positionY;
if (buttonPressed)
{
evt.button.state = (byte)ButtonKeyState.Pressed;
evt.type = (byte)EventTypes.MouseButtonDown;
}
else
{
evt.button.state = (byte)ButtonKeyState.NotPressed;
evt.type = (byte)EventTypes.MouseButtonUp;
}
this.EventStruct = evt;
}
/// <summary>
/// MouseMotion
/// </summary>
/// <param name="buttonPressed">The current mouse button state</param>
/// <param name="button">Button pressed</param>
/// <param name="positionX">The current X coordinate</param>
/// <param name="positionY">The current Y coordinate</param>
/// <param name="relativeX">
/// The difference between the last X coordinate and current</param>
/// <param name="relativeY">
/// The difference between the last Y coordinate and current</param>
public MouseMotionEventArgs(bool buttonPressed, MouseButton button, short positionX, short positionY,
short relativeX, short relativeY)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.motion.xrel = relativeX;
evt.motion.yrel = relativeY;
evt.motion.which = (byte)button;
evt.motion.x = positionX;
evt.motion.y = positionY;
evt.type = (byte)EventTypes.MouseMotion;
if (buttonPressed)
{
evt.motion.state = (byte)ButtonKeyState.Pressed;
}
else
{
evt.motion.state = (byte)ButtonKeyState.NotPressed;
}
this.EventStruct = evt;
}
/// <summary>
/// Keyboard event args
/// </summary>
/// <param name="down">
/// True if the key is pressed, False if it was released
/// </param>
/// <param name="key">The Sdl virtual keycode</param>
/// <param name="modifierKeys">Current modifier flags</param>
public KeyboardEventArgs(
Key key,
ModifierKeys modifierKeys,
bool down)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.key.which = 0;
evt.key.keysym.scancode = 0;
evt.key.keysym.sym = (int)key;
evt.key.keysym.mod = (int)modifierKeys;
if (down)
{
evt.key.state = (byte)ButtonKeyState.Pressed;
evt.type = (byte)EventTypes.KeyDown;
}
else
{
evt.key.state = (byte)ButtonKeyState.NotPressed;
evt.type = (byte)EventTypes.KeyUp;
}
this.EventStruct = evt;
}
/// <summary>
/// Returns an array of events in the event queue.
/// </summary>
/// <param name="eventMask">Mask for event that will be removed from queue</param>
/// <param name="numberOfEvents">Number of events to remove</param>
public static void Remove(EventMask eventMask, int numberOfEvents)
{
Sdl.SDL_Event[] events = new Sdl.SDL_Event[numberOfEvents];
Sdl.SDL_PumpEvents();
int result =
Sdl.SDL_PeepEvents(
events,
events.Length,
Sdl.SDL_GETEVENT,
(int)eventMask);
if (result == (int)SdlFlag.Error)
{
throw SdlException.Generate();
}
}
/// <summary>
/// Retrieve events of a certain type
/// </summary>
/// <param name="eventMask">Event to retrieve</param>
/// <param name="numberOfEvents">Number of events to retrieve</param>
/// <returns>Array containing events</returns>
public static SdlEventArgs[] Retrieve(EventMask eventMask, int numberOfEvents)
{
Sdl.SDL_PumpEvents();
Sdl.SDL_Event[] events = new Sdl.SDL_Event[numberOfEvents];
int result = Sdl.SDL_PeepEvents(
events,
events.Length,
Sdl.SDL_GETEVENT,
(int)eventMask
);
if (result == (int)SdlFlag.Error)
{
throw SdlException.Generate();
}
SdlEventArgs[] eventsArray = new SdlEventArgs[result];
for (int i = 0; i < eventsArray.Length; i++)
{
if (events[i].type == (byte)EventTypes.UserEvent)
{
eventsArray[i] = (UserEventArgs)userEvents[events[i].user.code];
userEvents.Remove(events[i].user.code);
}
else
{
eventsArray[i] = SdlEventArgs.CreateEventArgs(events[i]);
}
}
return eventsArray;
}
public void initSDL()
{
int VideoFlags;
IntPtr ptrVideoInfo = IntPtr.Zero;
Sdl.SDL_VideoInfo SDLVideoInfo;
Sdl.SDL_Event SDLEvent = new Sdl.SDL_Event();
bool isActive = true;
// SDL Code von http://www.gamedev.de/index.php?name=News&sid=117&file=article&pageid=2
// SDL initialisieren
if(Sdl.SDL_Init(Sdl.SDL_INIT_VIDEO) < 0)
{
Console.WriteLine("SDL initialization failed:\n" + Sdl.SDL_GetError());
Sdl.SDL_Quit();
return;
}
// Video Info einlesen
ptrVideoInfo = Sdl.SDL_GetVideoInfo();
if(ptrVideoInfo == IntPtr.Zero)
{
Console.WriteLine("Video Query failed:\n" + Sdl.SDL_GetError());
Sdl.SDL_Quit();
return;
}
else
{
SDLVideoInfo = (Sdl.SDL_VideoInfo)Marshal.PtrToStructure(ptrVideoInfo, typeof(Sdl.SDL_VideoInfo));
}
// Video Flags festlegen
//VideoFlags = Sdl.SDL_OPENGL;
VideoFlags = Sdl.SDL_GL_DOUBLEBUFFER;
VideoFlags |= Sdl.SDL_HWPALETTE;
//VideoFlags |= Sdl.SDL_RESIZABLE;
// überprüfen ob wir Hardware Surfaces haben
if(SDLVideoInfo.hw_available == 1)
VideoFlags |= Sdl.SDL_HWSURFACE;
else
VideoFlags |= Sdl.SDL_SWSURFACE;
// Überprüfen ob wir Hardwareunterstützung für bliting haben
if(SDLVideoInfo.blit_hw == 1)
VideoFlags |= Sdl.SDL_HWACCEL;
// OpenGL Double Buffering einschalten
Sdl.SDL_GL_SetAttribute(Sdl.SDL_GL_DOUBLEBUFFER, 1);
// Surface Pointer holen
ptrSurface = Sdl.SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, COLOR_DEPTH, VideoFlags);
Sdl.SDL_WM_SetCaption("Arena of Glory", "");
// Surface pointer überprüfen
if(ptrSurface == IntPtr.Zero)
{
Console.WriteLine("Video Mode set failed:\n" + Sdl.SDL_GetError());
Sdl.SDL_Quit();
return;
}
else
{
SDLSurface = (Sdl.SDL_Surface)Marshal.PtrToStructure(ptrSurface, typeof(Sdl.SDL_Surface));
}
Console.WriteLine("Video Driver: " + Sdl.SDL_VideoDriverName("", 128));
while(!done)
{
// Events aus dem Eventqueue auselesen
while(Sdl.SDL_PollEvent(out SDLEvent) == 1)
{
switch(SDLEvent.type)
{
case Sdl.SDL_ACTIVEEVENT:
// Überprüfen ob wir den Focus verloren haben
if(SDLEvent.active.gain == 0)
isActive = false;
else
isActive = true;
break;
case Sdl.SDL_KEYDOWN:
// Tastatureingaben behandeln
if(this.KeyDown != null)
this.KeyDown(SDLEvent.key.keysym);
break;
case Sdl.SDL_KEYUP:
if(this.KeyUp != null)
this.KeyUp(SDLEvent.key.keysym);
break;
case Sdl.SDL_QUIT:
// Wenn das SDL Fenster geschlossen wird.
done = true;
break;
}
}
// Scene Zeichnen wenn wir den Fokus haben
//if(isActive)
//{
DrawGlScene();
Sdl.SDL_GL_SwapBuffers(); // Buffer flip
//}
Sdl.SDL_Delay(25);
}
Sdl.SDL_Quit ();
}
private static int TimerCallback(int intervalMs)
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.type = Sdl.SDL_USEREVENT;
evt.user.code = TIMER_EVENT_CODE;
evt.user.data1 = IntPtr.Zero;
evt.user.data2 = IntPtr.Zero;
Sdl.SDL_PushEvent(out evt);
return intervalMs;
}
/// <summary>
/// Holds SDL_Event
/// </summary>
/// <param name="eventStruct">Event Struct</param>
protected SdlEventArgs(Sdl.SDL_Event eventStruct)
{
this.eventStruct = eventStruct;
}
/// <summary>
/// Quit Event
/// </summary>
public QuitEventArgs()
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.type = (byte)EventTypes.Quit;
this.EventStruct = evt;
}
static Vector2 Update_GetPosition()
{
gameState = GameState.WaitForPosition;
cursorPos = currentLevel.creatures[0].pos; //Start at player's position
Vector2 currentPos = currentLevel.creatures[0].pos; //The position the cursor is on
bool done = false; //Variable for loop break
Sdl.SDL_Event keyEvent, oldKeyEvent;
Sdl.SDL_PollEvent(out keyEvent);
while (!done)
{
oldKeyEvent = keyEvent;
Sdl.SDL_PollEvent(out keyEvent);
Draw(); //Update screen
switch (keyEvent.type) //Test keyEvent
{
case Sdl.SDL_KEYDOWN: //If a key is down
if (oldKeyEvent.type != Sdl.SDL_KEYDOWN ||
oldKeyEvent.key.keysym.sym == Sdl.SDLK_RSHIFT ||
oldKeyEvent.key.keysym.sym == Sdl.SDLK_LSHIFT)
{
switch (keyEvent.key.keysym.sym)
{
case Sdl.SDLK_ESCAPE:
gameState = GameState.MainGame;
done = true;
break;
case 271: //If enter aka "271" or "13" was pressed
case 13:
gameState = GameState.MainGame;
return cursorPos;
case Sdl.SDLK_KP1:
case Sdl.SDLK_DELETE:
cursorPos.X--;
cursorPos.Y++;
break;
case Sdl.SDLK_KP2:
case Sdl.SDLK_DOWN:
cursorPos.Y++;
break;
case Sdl.SDLK_KP3:
case Sdl.SDLK_PAGEDOWN:
cursorPos.X++;
cursorPos.Y++;
break;
case Sdl.SDLK_KP4:
case Sdl.SDLK_LEFT:
cursorPos.X--;
break;
case Sdl.SDLK_KP6:
case Sdl.SDLK_RIGHT:
cursorPos.X++;
break;
case Sdl.SDLK_KP7:
case Sdl.SDLK_INSERT:
cursorPos.X--;
cursorPos.Y--;
break;
case Sdl.SDLK_KP8:
case Sdl.SDLK_UP:
cursorPos.Y--;
break;
case Sdl.SDLK_KP9:
case Sdl.SDLK_PAGEUP:
cursorPos.X++;
cursorPos.Y--;
break;
default:
done = false;
break;
}
}
break;
default:
break;
}
}
return currentPos;
}
/// <summary>
/// Constructor
/// </summary>
public VideoExposeEventArgs()
{
Sdl.SDL_Event evt = new Sdl.SDL_Event();
evt.type = (byte)EventTypes.VideoExpose;
this.EventStruct = evt;
}
public static void Run()
{
int flags = (Sdl.SDL_HWSURFACE|Sdl.SDL_DOUBLEBUF|Sdl.SDL_ANYFORMAT);
int bpp = 16;
int width = 640;
int height = 480;
bool quitFlag = false;
Random rand = new Random();
string filePath = Path.Combine("..", "..");
string fileDirectory = "Data";
string fileName = "SdlExamples.Rectangles.sound.ogg";
if (File.Exists(fileName))
{
filePath = "";
fileDirectory = "";
}
else if (File.Exists(Path.Combine(fileDirectory, fileName)))
{
filePath = "";
}
string file = Path.Combine(Path.Combine(filePath, fileDirectory), fileName);
Sdl.SDL_Event evt;
try
{
Sdl.SDL_Init(Sdl.SDL_INIT_EVERYTHING);
Sdl.SDL_WM_SetCaption("Tao.Sdl Example - Rectangles", "");
IntPtr surfacePtr = Sdl.SDL_SetVideoMode(
width,
height,
bpp,
flags);
int result = SdlMixer.Mix_OpenAudio(
SdlMixer.MIX_DEFAULT_FREQUENCY,
(short)SdlMixer.MIX_DEFAULT_FORMAT,
2,
1024);
IntPtr chunkPtr = SdlMixer.Mix_LoadMUS(file);
SdlMixer.MusicFinishedDelegate musicStopped =
new SdlMixer.MusicFinishedDelegate(musicHasStopped);
SdlMixer.Mix_HookMusicFinished(musicStopped);
result = SdlMixer.Mix_PlayMusic(chunkPtr, 1);
if (result == -1)
{
Console.WriteLine("Music Error: " + Sdl.SDL_GetError());
}
int rmask = 0x00000000;
int gmask = 0x00ff0000;
int bmask = 0x0000ff00;
int amask = 0x000000ff;
IntPtr rgbSurfacePtr = Sdl.SDL_CreateRGBSurface(
flags,
width,
height,
bpp,
rmask,
gmask,
bmask,
amask);
Sdl.SDL_Rect rect = new Sdl.SDL_Rect(
0,
0,
(short)width,
(short)height);
result = Sdl.SDL_FillRect(rgbSurfacePtr, ref rect, 0);
Sdl.SDL_Rect rect2;
IntPtr videoInfoPointer = Sdl.SDL_GetVideoInfo();
if (videoInfoPointer == IntPtr.Zero)
{
throw new ApplicationException(string.Format("Video query failed: {0}", Sdl.SDL_GetError()));
}
Sdl.SDL_VideoInfo videoInfo = (Sdl.SDL_VideoInfo)
Marshal.PtrToStructure(videoInfoPointer,
typeof(Sdl.SDL_VideoInfo));
Console.WriteLine("Hi There");
Sdl.SDL_PixelFormat pixelFormat = (Sdl.SDL_PixelFormat)
Marshal.PtrToStructure(videoInfo.vfmt,
typeof(Sdl.SDL_PixelFormat));
Console.WriteLine(videoInfo.hw_available);
Console.WriteLine(videoInfo.wm_available);
Console.WriteLine(videoInfo.blit_hw);
Console.WriteLine(videoInfo.blit_hw_CC);
Console.WriteLine(videoInfo.blit_hw_A);
Console.WriteLine(videoInfo.blit_sw);
Console.WriteLine(videoInfo.blit_hw_CC);
Console.WriteLine(videoInfo.blit_hw_A);
Console.WriteLine(videoInfo.blit_fill);
Console.WriteLine(videoInfo.video_mem);
Console.WriteLine(pixelFormat.BitsPerPixel);
Console.WriteLine(pixelFormat.BytesPerPixel);
Console.WriteLine(pixelFormat.Rmask);
Console.WriteLine(pixelFormat.Gmask);
Console.WriteLine(pixelFormat.Bmask);
Console.WriteLine(pixelFormat.Amask);
int numevents = 10;
Sdl.SDL_Event[] events = new Sdl.SDL_Event[numevents];
events[0].type = Sdl.SDL_KEYDOWN;
events[0].key.keysym.sym = (int)Sdl.SDLK_p;
events[1].type = Sdl.SDL_KEYDOWN;
events[1].key.keysym.sym = (int)Sdl.SDLK_z;
int result2 = Sdl.SDL_PeepEvents(events, numevents, Sdl.SDL_ADDEVENT, Sdl.SDL_KEYDOWNMASK);
Console.WriteLine("Addevent result: " + result2);
while (quitFlag == false)
{
result = Sdl.SDL_PollEvent(out evt);
if (evt.type == Sdl.SDL_QUIT)
{
quitFlag = true;
}
else if (evt.type == Sdl.SDL_KEYDOWN)
{
if ((evt.key.keysym.sym == (int)Sdl.SDLK_ESCAPE) ||
(evt.key.keysym.sym == (int)Sdl.SDLK_q))
{
quitFlag = true;
}
if (evt.key.keysym.sym == (int)Sdl.SDLK_p)
{
Console.WriteLine("Key p event was added");
}
if (evt.key.keysym.sym == (int)Sdl.SDLK_z)
{
Console.WriteLine("Key z event was added");
}
}
rect2 = new Sdl.SDL_Rect(
(short)rand.Next(-300, width),
(short)rand.Next(-300, height),
(short)rand.Next(20, 300),
(short)rand.Next(20, 300));
try
{
result = Sdl.SDL_FillRect(
surfacePtr,
ref rect2,
rand.Next(100000));
result = Sdl.SDL_BlitSurface(
rgbSurfacePtr,
ref rect2,
surfacePtr,
ref rect);
result = Sdl.SDL_Flip(surfacePtr);
}
catch (Exception) { }
}
}
catch
{
Sdl.SDL_Quit();
throw;
}
finally
{
Sdl.SDL_Quit();
}
}
private void HandleKeys()
{
Sdl.SDL_Event thisevent = new Sdl.SDL_Event();
while (Sdl.SDL_PollEvent(out thisevent) > 0)
{
switch (thisevent.type)
{
case Sdl.SDL_KEYDOWN:
m_keyHandler.KeyDown(ConvertKeystroke(thisevent.key.keysym.sym));
break;
case Sdl.SDL_KEYUP:
m_keyHandler.KeyUp(ConvertKeystroke(thisevent.key.keysym.sym));
break;
case Sdl.SDL_QUIT:
this.Quit();
break;
}
}
}
static string Update_GetKey()
{
Sdl.SDL_Event keyEvent, oldKeyEvent;
Sdl.SDL_PollEvent(out keyEvent);
while (keyEvent.type == Sdl.SDL_KEYDOWN)
{
Sdl.SDL_PollEvent(out keyEvent);
}
oldKeyEvent = keyEvent;
//Draw();
while (true)
{
Sdl.SDL_PollEvent(out keyEvent);
Thread.Sleep(1);
switch (keyEvent.type) //Test keyEvent
{
//case 17: //Unknown, happens during keyboard freeze
case Sdl.SDL_KEYDOWN: //If a key is down
switch (keyEvent.key.keysym.sym)
{
#region Special
case Sdl.SDLK_ESCAPE:
return "Escape";
case Sdl.SDLK_PERIOD:
if (shift)
return ">";
return ".";
case Sdl.SDLK_COMMA:
if (shift)
return "<";
return ",";
case Sdl.SDLK_SPACE:
return "Space";
case Sdl.SDLK_BACKSPACE:
return "Backspace";
case Sdl.SDLK_RSHIFT:
case Sdl.SDLK_LSHIFT:
{
shift = true; //Shift is down
break;
}
case 271: //If enter aka "271" or "13" was pressed
case 13:
return "Enter";
#endregion
#region Numbers
case Sdl.SDLK_KP1:
case Sdl.SDLK_DELETE:
return "1";
case Sdl.SDLK_KP2:
case Sdl.SDLK_DOWN:
return "2";
case Sdl.SDLK_KP3:
case Sdl.SDLK_PAGEDOWN:
return "3";
case Sdl.SDLK_KP4:
case Sdl.SDLK_LEFT:
return "4";
case Sdl.SDLK_KP5:
return "5";
case Sdl.SDLK_KP6:
case Sdl.SDLK_RIGHT:
return "6";
case Sdl.SDLK_KP7:
case Sdl.SDLK_INSERT:
return "7";
case Sdl.SDLK_KP8:
case Sdl.SDLK_UP:
return "8";
case Sdl.SDLK_KP9:
case Sdl.SDLK_PAGEUP:
return "9";
#endregion
#region Letters
case Sdl.SDLK_a:
if (shift)
return "A";
return "a";
case Sdl.SDLK_b:
if (shift)
return "B";
return "b";
case Sdl.SDLK_c:
if (shift)
return "C";
return "c";
case Sdl.SDLK_d:
if (shift)
return "D";
return "d";
case Sdl.SDLK_e:
if (shift)
return "E";
return "e";
case Sdl.SDLK_f:
if (shift)
return "F";
return "f";
case Sdl.SDLK_g:
if (shift)
return "G";
return "g";
case Sdl.SDLK_h:
if (shift)
return "H";
return "h";
case Sdl.SDLK_i:
if (shift)
return "I";
return "i";
case Sdl.SDLK_j:
if (shift)
return "J";
return "j";
case Sdl.SDLK_k:
if (shift)
return "K";
return "k";
case Sdl.SDLK_l:
if (shift)
return "L";
return "l";
case Sdl.SDLK_m:
if (shift)
return "M";
return "m";
case Sdl.SDLK_n:
if (shift)
return "N";
return "n";
case Sdl.SDLK_o:
if (shift)
return "O";
return "o";
case Sdl.SDLK_p:
if (shift)
return "P";
return "p";
case Sdl.SDLK_q:
if (shift)
return "Q";
return "q";
case Sdl.SDLK_r:
if (shift)
return "R";
return "r";
case Sdl.SDLK_s:
if (shift)
return "S";
return "s";
case Sdl.SDLK_t:
if (shift)
return "T";
return "t";
case Sdl.SDLK_u:
if (shift)
return "U";
return "u";
case Sdl.SDLK_v:
if (shift)
return "V";
return "v";
case Sdl.SDLK_w:
if (shift)
return "W";
return "w";
case Sdl.SDLK_x:
if (shift)
return "X";
return "x";
case Sdl.SDLK_y:
if (shift)
return "Y";
return "y";
case Sdl.SDLK_z:
if (shift)
return "Z";
return "z";
#endregion
default:
break;
}
break;
case Sdl.SDL_KEYUP:
switch (keyEvent.key.keysym.sym)
{
case Sdl.SDLK_LSHIFT:
case Sdl.SDLK_RSHIFT:
shift = false;
break;
}
break;
default:
break;
}
oldKeyEvent.type = keyEvent.type; //Update this
}
}
