diff --git a/reactos/subsystems/win32/win32k/objects/palobj.c b/reactos/subsystems/win32/win32k/objects/palobj.c
index 5b4a781e638..281c4228550 100644
--- a/reactos/subsystems/win32/win32k/objects/palobj.c
+++ b/reactos/subsystems/win32/win32k/objects/palobj.c
@@ -34,21 +34,21 @@ int COLOR_gapEnd;
 int COLOR_gapFilled;
 int COLOR_max;
 
-PPALETTEENTRY FASTCALL ReturnSystemPalette (VOID)
+PPALETTEENTRY FASTCALL ReturnSystemPalette(VOID)
 {
-  return COLOR_sysPal;
+    return COLOR_sysPal;
 }
 
 BOOL INTERNAL_CALL
 PALETTE_Cleanup(PVOID ObjectBody)
 {
-  PPALETTE pPal = (PPALETTE)ObjectBody;
-  if (NULL != pPal->IndexedColors)
+    PPALETTE pPal = (PPALETTE)ObjectBody;
+    if (NULL != pPal->IndexedColors)
     {
-      ExFreePool(pPal->IndexedColors);
+        ExFreePool(pPal->IndexedColors);
     }
 
-  return TRUE;
+    return TRUE;
 }
 
 HPALETTE
@@ -60,46 +60,48 @@ PALETTE_AllocPalette(ULONG Mode,
                      ULONG Green,
                      ULONG Blue)
 {
-  HPALETTE NewPalette;
-  PPALETTE PalGDI;
+    HPALETTE NewPalette;
+    PPALETTE PalGDI;
 
-  PalGDI = (PPALETTE)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PALETTE);
-  if (!PalGDI)
-  {
-      return NULL;
-  }
-
-  NewPalette = PalGDI->BaseObject.hHmgr;
-
-  PalGDI->Self = NewPalette;
-  PalGDI->Mode = Mode;
-
-  if (NULL != Colors)
+    PalGDI = (PPALETTE)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PALETTE);
+    if (!PalGDI)
     {
-      PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool, sizeof(PALETTEENTRY) * NumColors, TAG_PALETTE);
-      if (NULL == PalGDI->IndexedColors)
-	{
-	  PALETTE_UnlockPalette(PalGDI);
-	  PALETTE_FreePaletteByHandle(NewPalette);
-	  return NULL;
-	}
-      RtlCopyMemory(PalGDI->IndexedColors, Colors, sizeof(PALETTEENTRY) * NumColors);
+        return NULL;
     }
 
-  if (PAL_INDEXED == Mode)
+    NewPalette = PalGDI->BaseObject.hHmgr;
+
+    PalGDI->Self = NewPalette;
+    PalGDI->Mode = Mode;
+
+    if (NULL != Colors)
     {
-      PalGDI->NumColors = NumColors;
-    }
-  else if (PAL_BITFIELDS == Mode)
-    {
-      PalGDI->RedMask = Red;
-      PalGDI->GreenMask = Green;
-      PalGDI->BlueMask = Blue;
+        PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool,
+                                                      sizeof(PALETTEENTRY) * NumColors,
+                                                      TAG_PALETTE);
+        if (NULL == PalGDI->IndexedColors)
+        {
+            PALETTE_UnlockPalette(PalGDI);
+            PALETTE_FreePaletteByHandle(NewPalette);
+            return NULL;
+        }
+        RtlCopyMemory(PalGDI->IndexedColors, Colors, sizeof(PALETTEENTRY) * NumColors);
     }
 
-  PALETTE_UnlockPalette(PalGDI);
+    if (PAL_INDEXED == Mode)
+    {
+        PalGDI->NumColors = NumColors;
+    }
+    else if (PAL_BITFIELDS == Mode)
+    {
+        PalGDI->RedMask = Red;
+        PalGDI->GreenMask = Green;
+        PalGDI->BlueMask = Blue;
+    }
 
-  return NewPalette;
+    PALETTE_UnlockPalette(PalGDI);
+
+    return NewPalette;
 }
 
 HPALETTE
@@ -107,116 +109,122 @@ FASTCALL
 PALETTE_AllocPaletteIndexedRGB(ULONG NumColors,
                                CONST RGBQUAD *Colors)
 {
-  HPALETTE NewPalette;
-  PPALETTE PalGDI;
-  UINT i;
+    HPALETTE NewPalette;
+    PPALETTE PalGDI;
+    UINT i;
 
-  PalGDI = (PPALETTE)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PALETTE);
-  if (!PalGDI)
-  {
-      return NULL;
-  }
-
-  NewPalette = PalGDI->BaseObject.hHmgr;
-
-  PalGDI->Self = NewPalette;
-  PalGDI->Mode = PAL_INDEXED;
-
-  PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool, sizeof(PALETTEENTRY) * NumColors, TAG_PALETTE);
-  if (NULL == PalGDI->IndexedColors)
+    PalGDI = (PPALETTE)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PALETTE);
+    if (!PalGDI)
     {
-      PALETTE_UnlockPalette(PalGDI);
-      PALETTE_FreePaletteByHandle(NewPalette);
-      return NULL;
-    }
-  for (i = 0; i < NumColors; i++)
-    {
-      PalGDI->IndexedColors[i].peRed = Colors[i].rgbRed;
-      PalGDI->IndexedColors[i].peGreen = Colors[i].rgbGreen;
-      PalGDI->IndexedColors[i].peBlue = Colors[i].rgbBlue;
-      PalGDI->IndexedColors[i].peFlags = 0;
+        return NULL;
     }
 
-  PalGDI->NumColors = NumColors;
+    NewPalette = PalGDI->BaseObject.hHmgr;
 
-  PALETTE_UnlockPalette(PalGDI);
+    PalGDI->Self = NewPalette;
+    PalGDI->Mode = PAL_INDEXED;
 
-  return NewPalette;
+    PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool,
+                                                  sizeof(PALETTEENTRY) * NumColors,
+                                                  TAG_PALETTE);
+    if (NULL == PalGDI->IndexedColors)
+    {
+        PALETTE_UnlockPalette(PalGDI);
+        PALETTE_FreePaletteByHandle(NewPalette);
+        return NULL;
+    }
+
+    for (i = 0; i < NumColors; i++)
+    {
+        PalGDI->IndexedColors[i].peRed = Colors[i].rgbRed;
+        PalGDI->IndexedColors[i].peGreen = Colors[i].rgbGreen;
+        PalGDI->IndexedColors[i].peBlue = Colors[i].rgbBlue;
+        PalGDI->IndexedColors[i].peFlags = 0;
+    }
+
+    PalGDI->NumColors = NumColors;
+
+    PALETTE_UnlockPalette(PalGDI);
+
+    return NewPalette;
 }
 
 // Create the system palette
 HPALETTE FASTCALL PALETTE_Init(VOID)
 {
-  int i;
-  HPALETTE hpalette;
-  PLOGPALETTE palPtr;
+    int i;
+    HPALETTE hpalette;
+    PLOGPALETTE palPtr;
 #ifndef NO_MAPPING
-  PALOBJ *palObj;
+    PALOBJ *palObj;
 #endif
-  const PALETTEENTRY* __sysPalTemplate = (const PALETTEENTRY*)COLOR_GetSystemPaletteTemplate();
+    const PALETTEENTRY* __sysPalTemplate = (const PALETTEENTRY*)COLOR_GetSystemPaletteTemplate();
 
-  // create default palette (20 system colors)
-  palPtr = ExAllocatePoolWithTag(PagedPool, sizeof(LOGPALETTE) + (NB_RESERVED_COLORS * sizeof(PALETTEENTRY)), TAG_PALETTE);
-  if (!palPtr) return FALSE;
+    // create default palette (20 system colors)
+    palPtr = ExAllocatePoolWithTag(PagedPool,
+                                   sizeof(LOGPALETTE) +
+                                       (NB_RESERVED_COLORS * sizeof(PALETTEENTRY)),
+                                   TAG_PALETTE);
+    if (!palPtr) return FALSE;
 
-  palPtr->palVersion = 0x300;
-  palPtr->palNumEntries = NB_RESERVED_COLORS;
-  for(i=0; i<NB_RESERVED_COLORS; i++)
-  {
-    palPtr->palPalEntry[i].peRed = __sysPalTemplate[i].peRed;
-    palPtr->palPalEntry[i].peGreen = __sysPalTemplate[i].peGreen;
-    palPtr->palPalEntry[i].peBlue = __sysPalTemplate[i].peBlue;
-    palPtr->palPalEntry[i].peFlags = 0;
-  }
-
-  hpalette = NtGdiCreatePaletteInternal(palPtr,NB_RESERVED_COLORS);
-  ExFreePoolWithTag(palPtr, TAG_PALETTE);
-
-#ifndef NO_MAPPING
-  palObj = (PALOBJ*)PALETTE_LockPalette(hpalette);
-  if (palObj)
-  {
-    if (!(palObj->mapping = ExAllocatePool(PagedPool, sizeof(int) * 20)))
+    palPtr->palVersion = 0x300;
+    palPtr->palNumEntries = NB_RESERVED_COLORS;
+    for (i=0; i<NB_RESERVED_COLORS; i++)
     {
-      DbgPrint("Win32k: Can not create palette mapping -- out of memory!");
-      return FALSE;
+        palPtr->palPalEntry[i].peRed = __sysPalTemplate[i].peRed;
+        palPtr->palPalEntry[i].peGreen = __sysPalTemplate[i].peGreen;
+        palPtr->palPalEntry[i].peBlue = __sysPalTemplate[i].peBlue;
+        palPtr->palPalEntry[i].peFlags = 0;
+    }
+
+    hpalette = NtGdiCreatePaletteInternal(palPtr,NB_RESERVED_COLORS);
+    ExFreePoolWithTag(palPtr, TAG_PALETTE);
+
+#ifndef NO_MAPPING
+    palObj = (PALOBJ*)PALETTE_LockPalette(hpalette);
+    if (palObj)
+    {
+        if (!(palObj->mapping = ExAllocatePool(PagedPool, sizeof(int) * 20)))
+        {
+            DbgPrint("Win32k: Can not create palette mapping -- out of memory!");
+            return FALSE;
+        }
+        PALETTE_UnlockPalette(palObj);
     }
-    PALETTE_UnlockPalette(palObj);
-  }
 #endif
 
-/*  palette_size = visual->map_entries; */
+    /*  palette_size = visual->map_entries; */
 
-  return hpalette;
+    return hpalette;
 }
 
 #ifndef NO_MAPPING
 static void FASTCALL PALETTE_FormatSystemPalette(void)
 {
-  // Build free list so we'd have an easy way to find
-  // out if there are any available colorcells.
+    // Build free list so we'd have an easy way to find
+    // out if there are any available colorcells.
 
-  int i, j = PALETTE_firstFree = NB_RESERVED_COLORS/2;
+    int i, j = PALETTE_firstFree = NB_RESERVED_COLORS/2;
 
-  COLOR_sysPal[j].peFlags = 0;
-  for(i = (NB_RESERVED_COLORS>>1) + 1 ; i < 256 - (NB_RESERVED_COLORS>>1) ; i++)
-  {
-    if( i < COLOR_gapStart || i > COLOR_gapEnd )
+    COLOR_sysPal[j].peFlags = 0;
+    for (i = (NB_RESERVED_COLORS>>1) + 1 ; i < 256 - (NB_RESERVED_COLORS>>1) ; i++)
     {
-      COLOR_sysPal[i].peFlags = 0;  // unused tag
-      PALETTE_freeList[j] = i; // next
-      j = i;
+        if (i < COLOR_gapStart || i > COLOR_gapEnd)
+        {
+            COLOR_sysPal[i].peFlags = 0;  // unused tag
+            PALETTE_freeList[j] = i; // next
+            j = i;
+        }
     }
-  }
-  PALETTE_freeList[j] = 0;
+    PALETTE_freeList[j] = 0;
 }
 #endif
 
 VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, INT size)
 {
-  int i = 0;
-  for( ; i<size ; i++ )
-    lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
+    int i = 0;
+    for (; i<size ; i++)
+        lpPalE[i].peFlags = PC_SYS_USED | (lpPalE[i].peFlags & 0x07);
 }
 
 #ifndef NO_MAPPING
@@ -224,130 +232,131 @@ VOID FASTCALL PALETTE_ValidateFlags(PALETTEENTRY* lpPalE, INT size)
 // Return number of entries which mapping has changed.
 INT APIENTRY PALETTE_SetMapping(PALOBJ *palPtr, UINT uStart, UINT uNum, BOOL mapOnly)
 {
-  char flag;
-  int  prevMapping = (palPtr->mapping) ? 1 : 0;
-  int  index, iRemapped = 0;
-  int *mapping;
-  HPALETTE hSysPal = NtGdiGetStockObject(DEFAULT_PALETTE);
-  PPALETTE pSysPal = PALETTE_LockPalette(hSysPal);
-  PPALETTE palGDI = CONTAINING_RECORD(palPtr,PALETTE,PalObj);
-  /* FIXME - handle pSysPal == NULL!!!!!!! */
+    char flag;
+    int  prevMapping = (palPtr->mapping) ? 1 : 0;
+    int  index, iRemapped = 0;
+    int *mapping;
+    HPALETTE hSysPal = NtGdiGetStockObject(DEFAULT_PALETTE);
+    PPALETTE pSysPal = PALETTE_LockPalette(hSysPal);
+    PPALETTE palGDI = CONTAINING_RECORD(palPtr,PALETTE,PalObj);
+    /* FIXME - handle pSysPal == NULL!!!!!!! */
 
-  COLOR_sysPal = pSysPal->IndexedColors;
-  PALETTE_UnlockPalette(pSysPal); // FIXME: Is this a right way to obtain pointer to the system palette?
+    COLOR_sysPal = pSysPal->IndexedColors;
+    PALETTE_UnlockPalette(pSysPal); // FIXME: Is this a right way to obtain pointer to the system palette?
 
 
-  // reset dynamic system palette entries
+    // reset dynamic system palette entries
 
-  if( !mapOnly && PALETTE_firstFree != -1) PALETTE_FormatSystemPalette();
+    if (!mapOnly && PALETTE_firstFree != -1) PALETTE_FormatSystemPalette();
 
-  // initialize palette mapping table
+    // initialize palette mapping table
 
-  //mapping = HeapReAlloc( GetProcessHeap(), 0, palPtr->mapping,
-  //                       sizeof(int)*palPtr->logpalette->palNumEntries);
-  ExFreePool(palPtr->mapping);
-  mapping = ExAllocatePoolWithTag(PagedPool, sizeof(int)*palGDI->NumColors, TAG_PALETTEMAP);
+    //mapping = HeapReAlloc( GetProcessHeap(), 0, palPtr->mapping,
+    //                       sizeof(int)*palPtr->logpalette->palNumEntries);
+    ExFreePool(palPtr->mapping);
+    mapping = ExAllocatePoolWithTag(PagedPool, sizeof(int)*palGDI->NumColors, TAG_PALETTEMAP);
 
-  if (!mapping)
-  {
-      DPRINT1("Failed allocating memory for palette mapping!\n");
-      return 0;
-  }
-
-  palPtr->mapping = mapping;
-
-  for(uNum += uStart; uStart < uNum; uStart++)
-  {
-    index = -1;
-    flag = PC_SYS_USED;
-
-    switch( palGDI->IndexedColors[uStart].peFlags & 0x07 )
+    if (!mapping)
     {
-      case PC_EXPLICIT:   // palette entries are indices into system palette
-                          // The PC_EXPLICIT flag is used to copy an entry from the system palette into the logical palette
-        index = *(WORD*)(palGDI->IndexedColors + uStart);
-        if(index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd))
+        DPRINT1("Failed allocating memory for palette mapping!\n");
+        return 0;
+    }
+
+    palPtr->mapping = mapping;
+
+    for (uNum += uStart; uStart < uNum; uStart++)
+    {
+        index = -1;
+        flag = PC_SYS_USED;
+
+        switch (palGDI->IndexedColors[uStart].peFlags & 0x07)
         {
-          DbgPrint("Win32k: PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index);
-          index = 0;
-        }
-        break;
+            case PC_EXPLICIT:   // palette entries are indices into system palette
+                // The PC_EXPLICIT flag is used to copy an entry from the system palette into the logical palette
+                index = *(WORD*)(palGDI->IndexedColors + uStart);
+                if (index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd))
+                {
+                    DbgPrint("Win32k: PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index);
+                    index = 0;
+                }
+                break;
 
-      case PC_RESERVED:   // forbid future mappings to this entry
-                          // For palette animation, the entries in the logical palette need the PC_RESERVED flag
-        flag |= PC_SYS_RESERVED;
+            case PC_RESERVED:   // forbid future mappings to this entry
+                // For palette animation, the entries in the logical palette need the PC_RESERVED flag
+                flag |= PC_SYS_RESERVED;
 
-      // fall through
-      default: // try to collapse identical colors
-        index = COLOR_PaletteLookupExactIndex(COLOR_sysPal, 256,
-                                              *(COLORREF*)(palGDI->IndexedColors + uStart));
-            // fall through
+                // fall through
+            default: // try to collapse identical colors
+                index = COLOR_PaletteLookupExactIndex(COLOR_sysPal, 256,
+                                                      *(COLORREF*)(palGDI->IndexedColors + uStart));
+                // fall through
 
-      case PC_NOCOLLAPSE:
-        // If an entry in the logical palette is marked with the PC_NOCOLLAPSE flag, the palette
-        // manager allocates a free entry in the system palette if one is available and only uses the
-        // closest colour match if there are no (more) free entries in the system palette
+            case PC_NOCOLLAPSE:
+                // If an entry in the logical palette is marked with the PC_NOCOLLAPSE flag, the palette
+                // manager allocates a free entry in the system palette if one is available and only uses the
+                // closest colour match if there are no (more) free entries in the system palette
 
-        DbgPrint("Win32k: WARNING: PC_NOCOLLAPSE is not yet working properly\n");
+                DbgPrint("Win32k: WARNING: PC_NOCOLLAPSE is not yet working properly\n");
 
-        if( index < 0 )
-        {
-          if(PALETTE_firstFree > 0 /* && !(PALETTE_PaletteFlags & PALETTE_FIXED) FIXME */ )
-          {
-            DbgPrint("Win32k: Unimplemented Palette Operation: PC_NOCOLLAPSE [objects/palette.c]\n");
-/*            XColor color;
-            index = PALETTE_firstFree;  // ought to be available
-            PALETTE_firstFree = PALETTE_freeList[index];
+                if (index < 0)
+                {
+                    if (PALETTE_firstFree > 0 /* && !(PALETTE_PaletteFlags & PALETTE_FIXED) FIXME */)
+                    {
+                        DbgPrint("Win32k: Unimplemented Palette Operation: PC_NOCOLLAPSE [objects/palette.c]\n");
+                        /*            XColor color;
+                                    index = PALETTE_firstFree;  // ought to be available
+                                    PALETTE_firstFree = PALETTE_freeList[index];
 
-            color.pixel = (PALETTE_PaletteToXPixel) ? PALETTE_PaletteToXPixel[index] : index;
-            color.red = palPtr->logpalette->palPalEntry[uStart].peRed << 8;
-            color.green = palPtr->logpalette->palPalEntry[uStart].peGreen << 8;
-            color.blue = palPtr->logpalette->palPalEntry[uStart].peBlue << 8;
-            color.flags = DoRed | DoGreen | DoBlue;
-            TSXStoreColor(display, PALETTE_PaletteXColormap, &color);
+                                    color.pixel = (PALETTE_PaletteToXPixel) ? PALETTE_PaletteToXPixel[index] : index;
+                                    color.red = palPtr->logpalette->palPalEntry[uStart].peRed << 8;
+                                    color.green = palPtr->logpalette->palPalEntry[uStart].peGreen << 8;
+                                    color.blue = palPtr->logpalette->palPalEntry[uStart].peBlue << 8;
+                                    color.flags = DoRed | DoGreen | DoBlue;
+                                    TSXStoreColor(display, PALETTE_PaletteXColormap, &color);
 
-            COLOR_sysPal[index] = palPtr->logpalette->palPalEntry[uStart];
-            COLOR_sysPal[index].peFlags = flag;
-            PALETTE_freeList[index] = 0;
+                                    COLOR_sysPal[index] = palPtr->logpalette->palPalEntry[uStart];
+                                    COLOR_sysPal[index].peFlags = flag;
+                                    PALETTE_freeList[index] = 0;
 
-            if(PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; */
-            break;
-          }
-/*          else if (PALETTE_PaletteFlags & PALETTE_VIRTUAL)
-          {
-            index = PALETTE_ToPhysical(NULL, 0x00ffffff &
-                                       *(COLORREF*)(palPtr->logpalette->palPalEntry + uStart));
-             break;
-           } FIXME */
+                                    if(PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; */
+                        break;
+                    }
+                    /*          else if (PALETTE_PaletteFlags & PALETTE_VIRTUAL)
+                              {
+                                index = PALETTE_ToPhysical(NULL, 0x00ffffff &
+                                                           *(COLORREF*)(palPtr->logpalette->palPalEntry + uStart));
+                                 break;
+                               } FIXME */
 
-           // we have to map to existing entry in the system palette
+                    // we have to map to existing entry in the system palette
 
-           index = COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL,
-                                            *(COLORREF*)(palGDI->IndexedColors + uStart), TRUE);
-           }
-           palGDI->IndexedColors[uStart].peFlags |= PC_SYS_USED;
+                    index = COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL,
+                                                     *(COLORREF*)(palGDI->IndexedColors + uStart), TRUE);
+                }
+                palGDI->IndexedColors[uStart].peFlags |= PC_SYS_USED;
 
-/*         if(PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; FIXME */
-           break;
+                /*         if(PALETTE_PaletteToXPixel) index = PALETTE_PaletteToXPixel[index]; FIXME */
+                break;
         }
 
-        if( !prevMapping || palPtr->mapping[uStart] != index ) iRemapped++;
+        if (!prevMapping || palPtr->mapping[uStart] != index) iRemapped++;
         palPtr->mapping[uStart] = index;
-  }
-  return iRemapped;
+    }
+    return iRemapped;
 }
 #endif
 
 INT FASTCALL
 PALETTE_GetObject(PPALETTE pGdiObject, INT cbCount, LPLOGBRUSH lpBuffer)
 {
-  if (!lpBuffer)
-  {
+    if (!lpBuffer)
+    {
+        return sizeof(WORD);
+    }
+
+    if ((UINT)cbCount < sizeof(WORD)) return 0;
+    *((WORD*)lpBuffer) = (WORD)pGdiObject->NumColors;
     return sizeof(WORD);
-  }
-  if ((UINT)cbCount < sizeof(WORD)) return 0;
-  *((WORD*)lpBuffer) = (WORD)pGdiObject->NumColors;
-  return sizeof(WORD);
 }
 
 /* EOF */