EmulatorPkg: Remove all trailing whitespace

Signed-off-by: jljusten

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11919 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 119 insertions, 119 deletions

diff --git a/EmulatorPkg/Unix/Host/X11GraphicsWindow.c b/EmulatorPkg/Unix/Host/X11GraphicsWindow.c
index ddcf1e7675..00d8c58a5b 100644
--- a/EmulatorPkg/Unix/Host/X11GraphicsWindow.c
+++ b/EmulatorPkg/Unix/Host/X11GraphicsWindow.c
@@ -40,7 +40,7 @@ typedef struct {
   EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsIo;
 
   Display     *display;
-  int         screen;      // values for window_size in main 
+  int         screen;      // values for window_size in main
   Window      win;
   GC          gc;
   Visual      *visual;
@@ -65,11 +65,11 @@ typedef struct {
   EFI_KEY_DATA keys[NBR_KEYS];
 
   EFI_KEY_STATE KeyState;
-  
+
   EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    MakeRegisterdKeyCallback;
   EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    BreakRegisterdKeyCallback;
   VOID                                                *RegisterdKeyCallbackContext;
-  
+
   int                        previous_x;
   int                        previous_y;
   EFI_SIMPLE_POINTER_STATE   pointer_state;
@@ -83,7 +83,7 @@ HandleEvents(
 
 void
 fill_shift_mask (
-  IN  struct uga_drv_shift_mask *sm, 
+  IN  struct uga_drv_shift_mask *sm,
   IN  unsigned long             mask
   )
 {
@@ -134,18 +134,18 @@ TryCreateShmImage (
     XDestroyImage(Drv->image);
     return 0;
   }
-      
+
   Drv->image_data = shmat (Drv->xshm_info.shmid, NULL, 0);
   if(!Drv->image_data) {
     shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
     XDestroyImage(Drv->image);
     return 0;
   }
-  
-#ifndef __APPLE__  
+
+#ifndef __APPLE__
   //
   // This closes shared memory in real time on OS X. Only closes after folks quit using
-  // it on Linux. 
+  // it on Linux.
   //
   shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
 #endif
@@ -164,18 +164,18 @@ TryCreateShmImage (
 
 EFI_STATUS
 X11Size (
-  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo, 
-  IN  UINT32                        Width, 
+  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo,
+  IN  UINT32                        Width,
   IN  UINT32                        Height
   )
 {
   GRAPHICS_IO_PRIVATE *Drv;
   XSizeHints          size_hints;
 
-  // Destroy current buffer if created. 
+  // Destroy current buffer if created.
   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
   if (Drv->image != NULL) {
-    // Before destroy buffer, need to make sure the buffer available for access. 
+    // Before destroy buffer, need to make sure the buffer available for access.
     XDestroyImage (Drv->image);
 
     if (Drv->use_shm) {
@@ -190,7 +190,7 @@ X11Size (
   Drv->height = Height;
   XResizeWindow (Drv->display, Drv->win, Width, Height);
 
-  // Allocate image. 
+  // Allocate image.
   if (XShmQueryExtension(Drv->display) && TryCreateShmImage(Drv)) {
     Drv->use_shm = 1;
   } else {
@@ -202,7 +202,7 @@ X11Size (
     } else {
       Drv->pixel_shift = 0;
     }
-      
+
     Drv->image_data = malloc ((Drv->width * Drv->height) << Drv->pixel_shift);
     Drv->image = XCreateImage (
                     Drv->display, Drv->visual, Drv->depth,
@@ -211,14 +211,14 @@ X11Size (
                     8 << Drv->pixel_shift, 0
                     );
   }
-  
+
   Drv->line_bytes = Drv->image->bytes_per_line;
 
   fill_shift_mask (&Drv->r, Drv->image->red_mask);
   fill_shift_mask (&Drv->g, Drv->image->green_mask);
   fill_shift_mask (&Drv->b, Drv->image->blue_mask);
 
-  // Set WM hints.  
+  // Set WM hints.
   size_hints.flags = PSize | PMinSize | PMaxSize;
   size_hints.min_width = size_hints.max_width = size_hints.base_width = Width;
   size_hints.min_height = size_hints.max_height = size_hints.base_height = Height;
@@ -231,15 +231,15 @@ X11Size (
 
 void
 handleKeyEvent (
-  IN  GRAPHICS_IO_PRIVATE *Drv, 
-  IN  XEvent              *ev, 
+  IN  GRAPHICS_IO_PRIVATE *Drv,
+  IN  XEvent              *ev,
   IN  BOOLEAN             Make
   )
 {
   KeySym        *KeySym;
   EFI_KEY_DATA  KeyData;
   int           KeySymArraySize;
- 
+
   if (Make) {
     if (Drv->key_count == NBR_KEYS) {
       return;
@@ -252,16 +252,16 @@ handleKeyEvent (
   //
   // Returns an array of KeySymArraySize of KeySym for the keycode. [0] is lower case, [1] is upper case,
   // [2] and [3] are based on option and command modifiers. The problem we have is command V
-  // could be mapped to a crazy Unicode character so the old scheme of returning a string. 
+  // could be mapped to a crazy Unicode character so the old scheme of returning a string.
   //
   KeySym = XGetKeyboardMapping (Drv->display, ev->xkey.keycode, 1, &KeySymArraySize);
-   
+
   KeyData.Key.ScanCode = 0;
   KeyData.Key.UnicodeChar = 0;
   KeyData.KeyState.KeyShiftState = 0;
 
   //
-  // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs  
+  // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs
   //
   if ((ev->xkey.state & LockMask) == 0) {
     Drv->KeyState.KeyToggleState &= ~EFI_CAPS_LOCK_ACTIVE;
@@ -270,9 +270,9 @@ handleKeyEvent (
       Drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
     }
   }
-  
+
   // Skipping EFI_MENU_KEY_PRESSED and EFI_SYS_REQ_PRESSED
-  
+
   switch (*KeySym) {
   case XK_Control_R:
     if (Make) {
@@ -282,7 +282,7 @@ handleKeyEvent (
     }
    break;
   case XK_Control_L:
-    if (Make) {    
+    if (Make) {
       Drv->KeyState.KeyShiftState |=  EFI_LEFT_CONTROL_PRESSED;
     } else {
       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_CONTROL_PRESSED;
@@ -303,7 +303,7 @@ handleKeyEvent (
       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_SHIFT_PRESSED;
     }
     break;
-  
+
   case XK_Mode_switch:
     if (Make) {
       Drv->KeyState.KeyShiftState |=  EFI_LEFT_ALT_PRESSED;
@@ -326,44 +326,44 @@ handleKeyEvent (
       Drv->KeyState.KeyShiftState &= ~EFI_LEFT_LOGO_PRESSED;
     }
     break;
-  
+
   case XK_KP_Home:
   case XK_Home:       KeyData.Key.ScanCode = SCAN_HOME;       break;
-  
+
   case XK_KP_End:
   case XK_End:        KeyData.Key.ScanCode = SCAN_END;        break;
-  
-  case XK_KP_Left: 
+
+  case XK_KP_Left:
   case XK_Left:       KeyData.Key.ScanCode = SCAN_LEFT;       break;
-  
+
   case XK_KP_Right:
   case XK_Right:      KeyData.Key.ScanCode = SCAN_RIGHT;      break;
-  
+
   case XK_KP_Up:
   case XK_Up:         KeyData.Key.ScanCode = SCAN_UP;         break;
-  
+
   case XK_KP_Down:
   case XK_Down:       KeyData.Key.ScanCode = SCAN_DOWN;       break;
-  
+
   case XK_KP_Delete:
   case XK_Delete:       KeyData.Key.ScanCode = SCAN_DELETE;     break;
-  
-  case XK_KP_Insert:  
+
+  case XK_KP_Insert:
   case XK_Insert:     KeyData.Key.ScanCode = SCAN_INSERT;     break;
-  
+
   case XK_KP_Page_Up:
   case XK_Page_Up:    KeyData.Key.ScanCode = SCAN_PAGE_UP;    break;
-  
+
   case XK_KP_Page_Down:
   case XK_Page_Down:  KeyData.Key.ScanCode = SCAN_PAGE_DOWN;  break;
-  
+
   case XK_Escape:     KeyData.Key.ScanCode = SCAN_ESC;        break;
 
   case XK_Pause:      KeyData.Key.ScanCode = SCAN_PAUSE;      break;
 
   case XK_KP_F1:
   case XK_F1:   KeyData.Key.ScanCode = SCAN_F1;   break;
-  
+
   case XK_KP_F2:
   case XK_F2:   KeyData.Key.ScanCode = SCAN_F2;   break;
 
@@ -376,18 +376,18 @@ handleKeyEvent (
   case XK_F5:   KeyData.Key.ScanCode = SCAN_F5;   break;
   case XK_F6:   KeyData.Key.ScanCode = SCAN_F6;   break;
   case XK_F7:   KeyData.Key.ScanCode = SCAN_F7;   break;
-  
+
   // Don't map into X11 by default on a Mac
-  // System Preferences->Keyboard->Keyboard Shortcuts can be configured 
+  // System Preferences->Keyboard->Keyboard Shortcuts can be configured
   // to not use higher function keys as shortcuts and the will show up
-  // in X11. 
+  // in X11.
   case XK_F8:   KeyData.Key.ScanCode = SCAN_F8;   break;
   case XK_F9:   KeyData.Key.ScanCode = SCAN_F9;   break;
   case XK_F10:  KeyData.Key.ScanCode = SCAN_F10;  break;
-  
+
   case XK_F11:  KeyData.Key.ScanCode = SCAN_F11;  break;
   case XK_F12:  KeyData.Key.ScanCode = SCAN_F12;  break;
-  
+
   case XK_F13:  KeyData.Key.ScanCode = SCAN_F13;  break;
   case XK_F14:  KeyData.Key.ScanCode = SCAN_F14;  break;
   case XK_F15:  KeyData.Key.ScanCode = SCAN_F15;  break;
@@ -402,16 +402,16 @@ handleKeyEvent (
   case XK_F24:  KeyData.Key.ScanCode = SCAN_F24;  break;
 
   // No mapping in X11
-  //case XK_:   KeyData.Key.ScanCode = SCAN_MUTE;            break;             
-  //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_UP;       break;            
-  //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_DOWN;     break;       
-  //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_UP;   break;      
-  //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_DOWN; break;    
-  //case XK_:   KeyData.Key.ScanCode = SCAN_SUSPEND;         break; 
-  //case XK_:   KeyData.Key.ScanCode = SCAN_HIBERNATE;       break; 
-  //case XK_:   KeyData.Key.ScanCode = SCAN_TOGGLE_DISPLAY;  break;       
-  //case XK_:   KeyData.Key.ScanCode = SCAN_RECOVERY;        break;      
-  //case XK_:   KeyData.Key.ScanCode = SCAN_EJECT;           break;     
+  //case XK_:   KeyData.Key.ScanCode = SCAN_MUTE;            break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_UP;       break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_DOWN;     break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_UP;   break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_DOWN; break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_SUSPEND;         break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_HIBERNATE;       break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_TOGGLE_DISPLAY;  break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_RECOVERY;        break;
+  //case XK_:   KeyData.Key.ScanCode = SCAN_EJECT;           break;
 
   case XK_BackSpace:  KeyData.Key.UnicodeChar = 0x0008; break;
 
@@ -419,28 +419,28 @@ handleKeyEvent (
   case XK_Tab:        KeyData.Key.UnicodeChar = 0x0009; break;
 
   case XK_Linefeed:   KeyData.Key.UnicodeChar = 0x000a; break;
-  
+
   case XK_KP_Enter:
   case XK_Return:     KeyData.Key.UnicodeChar = 0x000d; break;
 
-  case XK_KP_Equal      : KeyData.Key.UnicodeChar = L'='; break;                     
-  case XK_KP_Multiply   : KeyData.Key.UnicodeChar = L'*'; break;                  
-  case XK_KP_Add        : KeyData.Key.UnicodeChar = L'+'; break;                       
-  case XK_KP_Separator  : KeyData.Key.UnicodeChar = L'~'; break;                  
-  case XK_KP_Subtract   : KeyData.Key.UnicodeChar = L'-'; break;                  
-  case XK_KP_Decimal    : KeyData.Key.UnicodeChar = L'.'; break;                   
-  case XK_KP_Divide     : KeyData.Key.UnicodeChar = L'/'; break;                    
-
-  case XK_KP_0    : KeyData.Key.UnicodeChar = L'0'; break;                         
-  case XK_KP_1    : KeyData.Key.UnicodeChar = L'1'; break;                         
-  case XK_KP_2    : KeyData.Key.UnicodeChar = L'2'; break;                         
-  case XK_KP_3    : KeyData.Key.UnicodeChar = L'3'; break;                         
-  case XK_KP_4    : KeyData.Key.UnicodeChar = L'4'; break;                        
-  case XK_KP_5    : KeyData.Key.UnicodeChar = L'5'; break;                         
-  case XK_KP_6    : KeyData.Key.UnicodeChar = L'6'; break;                         
-  case XK_KP_7    : KeyData.Key.UnicodeChar = L'7'; break;                         
-  case XK_KP_8    : KeyData.Key.UnicodeChar = L'8'; break;                        
-  case XK_KP_9    : KeyData.Key.UnicodeChar = L'9'; break;                         
+  case XK_KP_Equal      : KeyData.Key.UnicodeChar = L'='; break;
+  case XK_KP_Multiply   : KeyData.Key.UnicodeChar = L'*'; break;
+  case XK_KP_Add        : KeyData.Key.UnicodeChar = L'+'; break;
+  case XK_KP_Separator  : KeyData.Key.UnicodeChar = L'~'; break;
+  case XK_KP_Subtract   : KeyData.Key.UnicodeChar = L'-'; break;
+  case XK_KP_Decimal    : KeyData.Key.UnicodeChar = L'.'; break;
+  case XK_KP_Divide     : KeyData.Key.UnicodeChar = L'/'; break;
+
+  case XK_KP_0    : KeyData.Key.UnicodeChar = L'0'; break;
+  case XK_KP_1    : KeyData.Key.UnicodeChar = L'1'; break;
+  case XK_KP_2    : KeyData.Key.UnicodeChar = L'2'; break;
+  case XK_KP_3    : KeyData.Key.UnicodeChar = L'3'; break;
+  case XK_KP_4    : KeyData.Key.UnicodeChar = L'4'; break;
+  case XK_KP_5    : KeyData.Key.UnicodeChar = L'5'; break;
+  case XK_KP_6    : KeyData.Key.UnicodeChar = L'6'; break;
+  case XK_KP_7    : KeyData.Key.UnicodeChar = L'7'; break;
+  case XK_KP_8    : KeyData.Key.UnicodeChar = L'8'; break;
+  case XK_KP_9    : KeyData.Key.UnicodeChar = L'9'; break;
 
   default:
     ;
@@ -453,23 +453,23 @@ handleKeyEvent (
   if (*KeySym < XK_BackSpace) {
     if (((Drv->KeyState.KeyShiftState & (EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED)) != 0) ||
         ((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) != 0) ) {
-      
+
       KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_UPPER];
 
-      // Per UEFI spec since we converted the Unicode clear the shift bits we pass up 
+      // Per UEFI spec since we converted the Unicode clear the shift bits we pass up
       KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED);
     } else {
       KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_LOWER];
     }
   } else {
-    // XK_BackSpace is the start of XK_MISCELLANY. These are the XK_? keys we process in this file 
-    ; 
+    // XK_BackSpace is the start of XK_MISCELLANY. These are the XK_? keys we process in this file
+    ;
   }
-  
+
   if (Make) {
     memcpy (&Drv->keys[Drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA));
     Drv->key_wr = (Drv->key_wr + 1) % NBR_KEYS;
-    Drv->key_count++; 
+    Drv->key_count++;
     if (Drv->MakeRegisterdKeyCallback != NULL) {
       ReverseGasketUint64Uint64 (Drv->MakeRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData);
     }
@@ -483,7 +483,7 @@ handleKeyEvent (
 
 void
 handleMouseMoved(
-  IN  GRAPHICS_IO_PRIVATE   *Drv, 
+  IN  GRAPHICS_IO_PRIVATE   *Drv,
   IN  XEvent                *ev
   )
 {
@@ -504,8 +504,8 @@ handleMouseMoved(
 
 void
 handleMouseDown (
-  IN  GRAPHICS_IO_PRIVATE *Drv, 
-  IN  XEvent              *ev, 
+  IN  GRAPHICS_IO_PRIVATE *Drv,
+  IN  XEvent              *ev,
   IN  BOOLEAN             Pressed
   )
 {
@@ -521,10 +521,10 @@ handleMouseDown (
 
 void
 Redraw (
-  IN  GRAPHICS_IO_PRIVATE *Drv, 
-  IN  UINTN               X, 
-  IN  UINTN               Y, 
-  IN  UINTN               Width, 
+  IN  GRAPHICS_IO_PRIVATE *Drv,
+  IN  UINTN               X,
+  IN  UINTN               Y,
+  IN  UINTN               Width,
   IN  UINTN               Height
   )
 {
@@ -597,7 +597,7 @@ HandleEvents (
 
 unsigned long
 X11PixelToColor (
-  IN  GRAPHICS_IO_PRIVATE *Drv, 
+  IN  GRAPHICS_IO_PRIVATE *Drv,
   IN  EFI_UGA_PIXEL       pixel
   )
 {
@@ -608,14 +608,14 @@ X11PixelToColor (
 
 EFI_UGA_PIXEL
 X11ColorToPixel (
-  IN  GRAPHICS_IO_PRIVATE *Drv, 
+  IN  GRAPHICS_IO_PRIVATE *Drv,
   IN  unsigned long       val
   )
 {
   EFI_UGA_PIXEL Pixel;
 
   memset (&Pixel, 0, sizeof (EFI_UGA_PIXEL));
-  
+
   // Truncation not an issue since X11 and EFI are both using 8 bits per color
   Pixel.Red =   (val >> Drv->r.shift) << Drv->r.csize;
   Pixel.Green = (val >> Drv->g.shift) << Drv->g.csize;
@@ -631,52 +631,52 @@ X11CheckKey (
   )
 {
   GRAPHICS_IO_PRIVATE  *Drv;
-  
+
   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
-  
+
   HandleEvents (Drv);
-  
+
   if (Drv->key_count != 0) {
     return EFI_SUCCESS;
   }
-  
+
   return EFI_NOT_READY;
 }
 
 EFI_STATUS
 X11GetKey (
-  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo, 
+  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo,
   IN  EFI_KEY_DATA                  *KeyData
   )
 {
   EFI_STATUS          EfiStatus;
   GRAPHICS_IO_PRIVATE *Drv;
-  
+
   Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 
   EfiStatus = X11CheckKey (GraphicsIo);
   if (EFI_ERROR (EfiStatus)) {
     return EfiStatus;
   }
-  
+
   CopyMem (KeyData, &Drv->keys[Drv->key_rd], sizeof (EFI_KEY_DATA));
   Drv->key_rd = (Drv->key_rd + 1) % NBR_KEYS;
   Drv->key_count--;
-  
+
   return EFI_SUCCESS;
 }
 
 
 EFI_STATUS
 X11KeySetState (
-  IN EMU_GRAPHICS_WINDOW_PROTOCOL   *GraphicsIo, 
+  IN EMU_GRAPHICS_WINDOW_PROTOCOL   *GraphicsIo,
   IN EFI_KEY_TOGGLE_STATE           *KeyToggleState
   )
 {
   GRAPHICS_IO_PRIVATE  *Drv;
-  
-  Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;  
-  
+
+  Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+
   if (*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) {
     if ((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == 0) {
       //
@@ -685,7 +685,7 @@ X11KeySetState (
       //
     }
   }
-    
+
   Drv->KeyState.KeyToggleState = *KeyToggleState;
   return EFI_SUCCESS;
 }
@@ -693,7 +693,7 @@ X11KeySetState (
 
 EFI_STATUS
 X11RegisterKeyNotify (
-  IN EMU_GRAPHICS_WINDOW_PROTOCOL                        *GraphicsIo, 
+  IN EMU_GRAPHICS_WINDOW_PROTOCOL                        *GraphicsIo,
   IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    MakeCallBack,
   IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    BreakCallBack,
   IN VOID                                                *Context
@@ -701,7 +701,7 @@ X11RegisterKeyNotify (
 {
   GRAPHICS_IO_PRIVATE  *Drv;
 
-  Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;  
+  Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
 
   Drv->MakeRegisterdKeyCallback    = MakeCallBack;
   Drv->BreakRegisterdKeyCallback   = BreakCallBack;
@@ -834,10 +834,10 @@ X11Blt (
   case EfiUgaVideoToVideo:
     XCopyArea(
       Private->display, Private->win, Private->win, Private->gc,
-      Args->SourceX, Args->SourceY, Args->Width, Args->Height, 
+      Args->SourceX, Args->SourceY, Args->Width, Args->Height,
       Args->DestinationX, Args->DestinationY
       );
-      
+
     while (1) {
       XNextEvent (Private->display, &ev);
       HandleEvent (Private, &ev);
@@ -878,14 +878,14 @@ X11CheckPointer (
   if (Drv->pointer_state_changed != 0) {
     return EFI_SUCCESS;
   }
-  
+
   return EFI_NOT_READY;
 }
 
 
 EFI_STATUS
 X11GetPointerState (
-  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo, 
+  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo,
   IN  EFI_SIMPLE_POINTER_STATE      *State
   )
 {
@@ -898,7 +898,7 @@ X11GetPointerState (
   if (EfiStatus != EFI_SUCCESS) {
     return EfiStatus;
   }
-  
+
   memcpy (State, &Drv->pointer_state, sizeof (EFI_SIMPLE_POINTER_STATE));
 
   Drv->pointer_state.RelativeMovementX = 0;
@@ -932,7 +932,7 @@ X11GraphicsWindowOpen (
   Drv->GraphicsIo.Blt                 = GasketX11Blt;
   Drv->GraphicsIo.CheckPointer        = GasketX11CheckPointer;
   Drv->GraphicsIo.GetPointerState     = GasketX11GetPointerState;
-  
+
 
   Drv->key_count = 0;
   Drv->key_rd = 0;
@@ -942,8 +942,8 @@ X11GraphicsWindowOpen (
   Drv->MakeRegisterdKeyCallback    = NULL;
   Drv->BreakRegisterdKeyCallback   = NULL;
   Drv->RegisterdKeyCallbackContext = NULL;
-  
-  
+
+
   Drv->display = XOpenDisplay (display_name);
   if (Drv->display == NULL) {
     fprintf (stderr, "uga: cannot connect to X server %s\n", XDisplayName (display_name));
@@ -960,16 +960,16 @@ X11GraphicsWindowOpen (
                 );
 
   Drv->depth = DefaultDepth (Drv->display, Drv->screen);
-  XDefineCursor (Drv->display, Drv->win, XCreateFontCursor (Drv->display, XC_pirate)); 
+  XDefineCursor (Drv->display, Drv->win, XCreateFontCursor (Drv->display, XC_pirate));
 
-  Drv->Title = malloc (StrSize (This->ConfigString));  
+  Drv->Title = malloc (StrSize (This->ConfigString));
   UnicodeStrToAsciiStr (This->ConfigString, Drv->Title);
   XStoreName (Drv->display, Drv->win, Drv->Title);
 
 //  XAutoRepeatOff (Drv->display);
   XSelectInput (
     Drv->display, Drv->win,
-    ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask 
+    ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask
     );
   Drv->gc = DefaultGC (Drv->display, Drv->screen);
 
@@ -991,7 +991,7 @@ X11GraphicsWindowClose (
   if (Drv == NULL) {
     return EFI_SUCCESS;
   }
-  
+
   if (Drv->image != NULL) {
     XDestroyImage(Drv->image);
 
@@ -1004,12 +1004,12 @@ X11GraphicsWindowClose (
   }
   XDestroyWindow (Drv->display, Drv->win);
   XCloseDisplay (Drv->display);
-  
+
 #ifdef __APPLE__
   // Free up the shared memory
   shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
 #endif
-  
+
   free (Drv);
   return EFI_SUCCESS;
 }