X11: Fix last indent issue on X11 generator

and regenerate X11 dissector

Change-Id: If2c781d346713f5a2a2e97de84c0fedcfd1958af
Reviewed-on: https://code.wireshark.org/review/15944
Reviewed-by: Anders Broman <a.broman58@gmail.com>

1 files changed, 540 insertions, 540 deletions

diff --git a/epan/dissectors/x11-enum.h b/epan/dissectors/x11-enum.h
index 4c9031acd1..90a3d88125 100644
--- a/epan/dissectors/x11-enum.h
+++ b/epan/dissectors/x11-enum.h
@@ -24,830 +24,830 @@
  */
 
 static const value_string x11_enum_render_PictType[] = {
-	{   0, "Indexed" },
-	{   1, "Direct" },
-	{   0, NULL },
+    {   0, "Indexed" },
+    {   1, "Direct" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_composite_Redirect[] = {
-	{   0, "Automatic" },
-	{   1, "Manual" },
-	{   0, NULL },
+    {   0, "Automatic" },
+    {   1, "Manual" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_damage_ReportLevel[] = {
-	{   0, "RawRectangles" },
-	{   1, "DeltaRectangles" },
-	{   2, "BoundingBox" },
-	{   3, "NonEmpty" },
-	{   0, NULL },
+    {   0, "RawRectangles" },
+    {   1, "DeltaRectangles" },
+    {   2, "BoundingBox" },
+    {   3, "NonEmpty" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xfixes_Region[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_dpms_DPMSMode[] = {
-	{   0, "On" },
-	{   1, "Standby" },
-	{   2, "Suspend" },
-	{   3, "Off" },
-	{   0, NULL },
+    {   0, "On" },
+    {   1, "Standby" },
+    {   2, "Suspend" },
+    {   3, "Off" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_dri2_Attachment[] = {
-	{   0, "BufferFrontLeft" },
-	{   1, "BufferBackLeft" },
-	{   2, "BufferFrontRight" },
-	{   3, "BufferBackRight" },
-	{   4, "BufferDepth" },
-	{   5, "BufferStencil" },
-	{   6, "BufferAccum" },
-	{   7, "BufferFakeFrontLeft" },
-	{   8, "BufferFakeFrontRight" },
-	{   9, "BufferDepthStencil" },
-	{  10, "BufferHiz" },
-	{   0, NULL },
+    {   0, "BufferFrontLeft" },
+    {   1, "BufferBackLeft" },
+    {   2, "BufferFrontRight" },
+    {   3, "BufferBackRight" },
+    {   4, "BufferDepth" },
+    {   5, "BufferStencil" },
+    {   6, "BufferAccum" },
+    {   7, "BufferFakeFrontLeft" },
+    {   8, "BufferFakeFrontRight" },
+    {   9, "BufferDepthStencil" },
+    {  10, "BufferHiz" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_dri2_DriverType[] = {
-	{   0, "DRI" },
-	{   1, "VDPAU" },
-	{   0, NULL },
+    {   0, "DRI" },
+    {   1, "VDPAU" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_randr_Connection[] = {
-	{   0, "Connected" },
-	{   1, "Disconnected" },
-	{   2, "Unknown" },
-	{   0, NULL },
+    {   0, "Connected" },
+    {   1, "Disconnected" },
+    {   2, "Unknown" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_render_SubPixel[] = {
-	{   0, "Unknown" },
-	{   1, "HorizontalRGB" },
-	{   2, "HorizontalBGR" },
-	{   3, "VerticalRGB" },
-	{   4, "VerticalBGR" },
-	{   5, "None" },
-	{   0, NULL },
+    {   0, "Unknown" },
+    {   1, "HorizontalRGB" },
+    {   2, "HorizontalBGR" },
+    {   3, "VerticalRGB" },
+    {   4, "VerticalBGR" },
+    {   5, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Property[] = {
-	{   0, "NewValue" },
-	{   1, "Delete" },
-	{   0, NULL },
+    {   0, "NewValue" },
+    {   1, "Delete" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_sync_VALUETYPE[] = {
-	{   0, "Absolute" },
-	{   1, "Relative" },
-	{   0, NULL },
+    {   0, "Absolute" },
+    {   1, "Relative" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_sync_TESTTYPE[] = {
-	{   0, "PositiveTransition" },
-	{   1, "NegativeTransition" },
-	{   2, "PositiveComparison" },
-	{   3, "NegativeComparison" },
-	{   0, NULL },
+    {   0, "PositiveTransition" },
+    {   1, "NegativeTransition" },
+    {   2, "PositiveComparison" },
+    {   3, "NegativeComparison" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_present_CompleteKind[] = {
-	{   0, "Pixmap" },
-	{   1, "NotifyMSC" },
-	{   0, NULL },
+    {   0, "Pixmap" },
+    {   1, "NotifyMSC" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_present_CompleteMode[] = {
-	{   0, "Copy" },
-	{   1, "Flip" },
-	{   2, "Skip" },
-	{   0, NULL },
+    {   0, "Copy" },
+    {   1, "Flip" },
+    {   2, "Skip" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_randr_SetConfig[] = {
-	{   0, "Success" },
-	{   1, "InvalidConfigTime" },
-	{   2, "InvalidTime" },
-	{   3, "Failed" },
-	{   0, NULL },
+    {   0, "Success" },
+    {   1, "InvalidConfigTime" },
+    {   2, "InvalidTime" },
+    {   3, "Failed" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_PropMode[] = {
-	{   0, "Replace" },
-	{   1, "Prepend" },
-	{   2, "Append" },
-	{   0, NULL },
+    {   0, "Replace" },
+    {   1, "Prepend" },
+    {   2, "Append" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_GetPropertyType[] = {
-	{   0, "Any" },
-	{   0, NULL },
+    {   0, "Any" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Atom[] = {
-	{   0, "Any" },
-	{   1, "PRIMARY" },
-	{   2, "SECONDARY" },
-	{   3, "ARC" },
-	{   4, "ATOM" },
-	{   5, "BITMAP" },
-	{   6, "CARDINAL" },
-	{   7, "COLORMAP" },
-	{   8, "CURSOR" },
-	{   9, "CUT_BUFFER0" },
-	{  10, "CUT_BUFFER1" },
-	{  11, "CUT_BUFFER2" },
-	{  12, "CUT_BUFFER3" },
-	{  13, "CUT_BUFFER4" },
-	{  14, "CUT_BUFFER5" },
-	{  15, "CUT_BUFFER6" },
-	{  16, "CUT_BUFFER7" },
-	{  17, "DRAWABLE" },
-	{  18, "FONT" },
-	{  19, "INTEGER" },
-	{  20, "PIXMAP" },
-	{  21, "POINT" },
-	{  22, "RECTANGLE" },
-	{  23, "RESOURCE_MANAGER" },
-	{  24, "RGB_COLOR_MAP" },
-	{  25, "RGB_BEST_MAP" },
-	{  26, "RGB_BLUE_MAP" },
-	{  27, "RGB_DEFAULT_MAP" },
-	{  28, "RGB_GRAY_MAP" },
-	{  29, "RGB_GREEN_MAP" },
-	{  30, "RGB_RED_MAP" },
-	{  31, "STRING" },
-	{  32, "VISUALID" },
-	{  33, "WINDOW" },
-	{  34, "WM_COMMAND" },
-	{  35, "WM_HINTS" },
-	{  36, "WM_CLIENT_MACHINE" },
-	{  37, "WM_ICON_NAME" },
-	{  38, "WM_ICON_SIZE" },
-	{  39, "WM_NAME" },
-	{  40, "WM_NORMAL_HINTS" },
-	{  41, "WM_SIZE_HINTS" },
-	{  42, "WM_ZOOM_HINTS" },
-	{  43, "MIN_SPACE" },
-	{  44, "NORM_SPACE" },
-	{  45, "MAX_SPACE" },
-	{  46, "END_SPACE" },
-	{  47, "SUPERSCRIPT_X" },
-	{  48, "SUPERSCRIPT_Y" },
-	{  49, "SUBSCRIPT_X" },
-	{  50, "SUBSCRIPT_Y" },
-	{  51, "UNDERLINE_POSITION" },
-	{  52, "UNDERLINE_THICKNESS" },
-	{  53, "STRIKEOUT_ASCENT" },
-	{  54, "STRIKEOUT_DESCENT" },
-	{  55, "ITALIC_ANGLE" },
-	{  56, "X_HEIGHT" },
-	{  57, "QUAD_WIDTH" },
-	{  58, "WEIGHT" },
-	{  59, "POINT_SIZE" },
-	{  60, "RESOLUTION" },
-	{  61, "COPYRIGHT" },
-	{  62, "NOTICE" },
-	{  63, "FONT_NAME" },
-	{  64, "FAMILY_NAME" },
-	{  65, "FULL_NAME" },
-	{  66, "CAP_HEIGHT" },
-	{  67, "WM_CLASS" },
-	{  68, "WM_TRANSIENT_FOR" },
-	{   0, NULL },
+    {   0, "Any" },
+    {   1, "PRIMARY" },
+    {   2, "SECONDARY" },
+    {   3, "ARC" },
+    {   4, "ATOM" },
+    {   5, "BITMAP" },
+    {   6, "CARDINAL" },
+    {   7, "COLORMAP" },
+    {   8, "CURSOR" },
+    {   9, "CUT_BUFFER0" },
+    {  10, "CUT_BUFFER1" },
+    {  11, "CUT_BUFFER2" },
+    {  12, "CUT_BUFFER3" },
+    {  13, "CUT_BUFFER4" },
+    {  14, "CUT_BUFFER5" },
+    {  15, "CUT_BUFFER6" },
+    {  16, "CUT_BUFFER7" },
+    {  17, "DRAWABLE" },
+    {  18, "FONT" },
+    {  19, "INTEGER" },
+    {  20, "PIXMAP" },
+    {  21, "POINT" },
+    {  22, "RECTANGLE" },
+    {  23, "RESOURCE_MANAGER" },
+    {  24, "RGB_COLOR_MAP" },
+    {  25, "RGB_BEST_MAP" },
+    {  26, "RGB_BLUE_MAP" },
+    {  27, "RGB_DEFAULT_MAP" },
+    {  28, "RGB_GRAY_MAP" },
+    {  29, "RGB_GREEN_MAP" },
+    {  30, "RGB_RED_MAP" },
+    {  31, "STRING" },
+    {  32, "VISUALID" },
+    {  33, "WINDOW" },
+    {  34, "WM_COMMAND" },
+    {  35, "WM_HINTS" },
+    {  36, "WM_CLIENT_MACHINE" },
+    {  37, "WM_ICON_NAME" },
+    {  38, "WM_ICON_SIZE" },
+    {  39, "WM_NAME" },
+    {  40, "WM_NORMAL_HINTS" },
+    {  41, "WM_SIZE_HINTS" },
+    {  42, "WM_ZOOM_HINTS" },
+    {  43, "MIN_SPACE" },
+    {  44, "NORM_SPACE" },
+    {  45, "MAX_SPACE" },
+    {  46, "END_SPACE" },
+    {  47, "SUPERSCRIPT_X" },
+    {  48, "SUPERSCRIPT_Y" },
+    {  49, "SUBSCRIPT_X" },
+    {  50, "SUBSCRIPT_Y" },
+    {  51, "UNDERLINE_POSITION" },
+    {  52, "UNDERLINE_THICKNESS" },
+    {  53, "STRIKEOUT_ASCENT" },
+    {  54, "STRIKEOUT_DESCENT" },
+    {  55, "ITALIC_ANGLE" },
+    {  56, "X_HEIGHT" },
+    {  57, "QUAD_WIDTH" },
+    {  58, "WEIGHT" },
+    {  59, "POINT_SIZE" },
+    {  60, "RESOLUTION" },
+    {  61, "COPYRIGHT" },
+    {  62, "NOTICE" },
+    {  63, "FONT_NAME" },
+    {  64, "FAMILY_NAME" },
+    {  65, "FULL_NAME" },
+    {  66, "CAP_HEIGHT" },
+    {  67, "WM_CLASS" },
+    {  68, "WM_TRANSIENT_FOR" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_randr_Notify[] = {
-	{   0, "CrtcChange" },
-	{   1, "OutputChange" },
-	{   2, "OutputProperty" },
-	{   3, "ProviderChange" },
-	{   4, "ProviderProperty" },
-	{   5, "ResourceChange" },
-	{   0, NULL },
+    {   0, "CrtcChange" },
+    {   1, "OutputChange" },
+    {   2, "OutputProperty" },
+    {   3, "ProviderChange" },
+    {   4, "ProviderProperty" },
+    {   5, "ResourceChange" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_render_Repeat[] = {
-	{   0, "None" },
-	{   1, "Normal" },
-	{   2, "Pad" },
-	{   3, "Reflect" },
-	{   0, NULL },
+    {   0, "None" },
+    {   1, "Normal" },
+    {   2, "Pad" },
+    {   3, "Reflect" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_SubwindowMode[] = {
-	{   0, "ClipByChildren" },
-	{   1, "IncludeInferiors" },
-	{   0, NULL },
+    {   0, "ClipByChildren" },
+    {   1, "IncludeInferiors" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_render_PolyEdge[] = {
-	{   0, "Sharp" },
-	{   1, "Smooth" },
-	{   0, NULL },
+    {   0, "Sharp" },
+    {   1, "Smooth" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_render_PolyMode[] = {
-	{   0, "Precise" },
-	{   1, "Imprecise" },
-	{   0, NULL },
+    {   0, "Precise" },
+    {   1, "Imprecise" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_render_PictOp[] = {
-	{   0, "Clear" },
-	{   1, "Src" },
-	{   2, "Dst" },
-	{   3, "Over" },
-	{   4, "OverReverse" },
-	{   5, "In" },
-	{   6, "InReverse" },
-	{   7, "Out" },
-	{   8, "OutReverse" },
-	{   9, "Atop" },
-	{  10, "AtopReverse" },
-	{  11, "Xor" },
-	{  12, "Add" },
-	{  13, "Saturate" },
-	{  16, "DisjointClear" },
-	{  17, "DisjointSrc" },
-	{  18, "DisjointDst" },
-	{  19, "DisjointOver" },
-	{  20, "DisjointOverReverse" },
-	{  21, "DisjointIn" },
-	{  22, "DisjointInReverse" },
-	{  23, "DisjointOut" },
-	{  24, "DisjointOutReverse" },
-	{  25, "DisjointAtop" },
-	{  26, "DisjointAtopReverse" },
-	{  27, "DisjointXor" },
-	{  32, "ConjointClear" },
-	{  33, "ConjointSrc" },
-	{  34, "ConjointDst" },
-	{  35, "ConjointOver" },
-	{  36, "ConjointOverReverse" },
-	{  37, "ConjointIn" },
-	{  38, "ConjointInReverse" },
-	{  39, "ConjointOut" },
-	{  40, "ConjointOutReverse" },
-	{  41, "ConjointAtop" },
-	{  42, "ConjointAtopReverse" },
-	{  43, "ConjointXor" },
-	{  48, "Multiply" },
-	{  49, "Screen" },
-	{  50, "Overlay" },
-	{  51, "Darken" },
-	{  52, "Lighten" },
-	{  53, "ColorDodge" },
-	{  54, "ColorBurn" },
-	{  55, "HardLight" },
-	{  56, "SoftLight" },
-	{  57, "Difference" },
-	{  58, "Exclusion" },
-	{  59, "HSLHue" },
-	{  60, "HSLSaturation" },
-	{  61, "HSLColor" },
-	{  62, "HSLLuminosity" },
-	{   0, NULL },
+    {   0, "Clear" },
+    {   1, "Src" },
+    {   2, "Dst" },
+    {   3, "Over" },
+    {   4, "OverReverse" },
+    {   5, "In" },
+    {   6, "InReverse" },
+    {   7, "Out" },
+    {   8, "OutReverse" },
+    {   9, "Atop" },
+    {  10, "AtopReverse" },
+    {  11, "Xor" },
+    {  12, "Add" },
+    {  13, "Saturate" },
+    {  16, "DisjointClear" },
+    {  17, "DisjointSrc" },
+    {  18, "DisjointDst" },
+    {  19, "DisjointOver" },
+    {  20, "DisjointOverReverse" },
+    {  21, "DisjointIn" },
+    {  22, "DisjointInReverse" },
+    {  23, "DisjointOut" },
+    {  24, "DisjointOutReverse" },
+    {  25, "DisjointAtop" },
+    {  26, "DisjointAtopReverse" },
+    {  27, "DisjointXor" },
+    {  32, "ConjointClear" },
+    {  33, "ConjointSrc" },
+    {  34, "ConjointDst" },
+    {  35, "ConjointOver" },
+    {  36, "ConjointOverReverse" },
+    {  37, "ConjointIn" },
+    {  38, "ConjointInReverse" },
+    {  39, "ConjointOut" },
+    {  40, "ConjointOutReverse" },
+    {  41, "ConjointAtop" },
+    {  42, "ConjointAtopReverse" },
+    {  43, "ConjointXor" },
+    {  48, "Multiply" },
+    {  49, "Screen" },
+    {  50, "Overlay" },
+    {  51, "Darken" },
+    {  52, "Lighten" },
+    {  53, "ColorDodge" },
+    {  54, "ColorBurn" },
+    {  55, "HardLight" },
+    {  56, "SoftLight" },
+    {  57, "Difference" },
+    {  58, "Exclusion" },
+    {  59, "HSLHue" },
+    {  60, "HSLSaturation" },
+    {  61, "HSLColor" },
+    {  62, "HSLLuminosity" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_render_Picture[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_screensaver_Kind[] = {
-	{   0, "Blanked" },
-	{   1, "Internal" },
-	{   2, "External" },
-	{   0, NULL },
+    {   0, "Blanked" },
+    {   1, "Internal" },
+    {   2, "External" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_WindowClass[] = {
-	{   0, "CopyFromParent" },
-	{   1, "InputOutput" },
-	{   2, "InputOnly" },
-	{   0, NULL },
+    {   0, "CopyFromParent" },
+    {   1, "InputOutput" },
+    {   2, "InputOnly" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_BackPixmap[] = {
-	{   0, "None" },
-	{   1, "ParentRelative" },
-	{   0, NULL },
+    {   0, "None" },
+    {   1, "ParentRelative" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Pixmap[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Gravity[] = {
-	{   0, "WinUnmap" },
-	{   1, "NorthWest" },
-	{   2, "North" },
-	{   3, "NorthEast" },
-	{   4, "West" },
-	{   5, "Center" },
-	{   6, "East" },
-	{   7, "SouthWest" },
-	{   8, "South" },
-	{   9, "SouthEast" },
-	{  10, "Static" },
-	{   0, NULL },
+    {   0, "WinUnmap" },
+    {   1, "NorthWest" },
+    {   2, "North" },
+    {   3, "NorthEast" },
+    {   4, "West" },
+    {   5, "Center" },
+    {   6, "East" },
+    {   7, "SouthWest" },
+    {   8, "South" },
+    {   9, "SouthEast" },
+    {  10, "Static" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_BackingStore[] = {
-	{   0, "NotUseful" },
-	{   1, "WhenMapped" },
-	{   2, "Always" },
-	{   0, NULL },
+    {   0, "NotUseful" },
+    {   1, "WhenMapped" },
+    {   2, "Always" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Colormap[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Cursor[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_shape_SO[] = {
-	{   0, "Set" },
-	{   1, "Union" },
-	{   2, "Intersect" },
-	{   3, "Subtract" },
-	{   4, "Invert" },
-	{   0, NULL },
+    {   0, "Set" },
+    {   1, "Union" },
+    {   2, "Intersect" },
+    {   3, "Subtract" },
+    {   4, "Invert" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_shape_SK[] = {
-	{   0, "Bounding" },
-	{   1, "Clip" },
-	{   2, "Input" },
-	{   0, NULL },
+    {   0, "Bounding" },
+    {   1, "Clip" },
+    {   2, "Input" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_ClipOrdering[] = {
-	{   0, "Unsorted" },
-	{   1, "YSorted" },
-	{   2, "YXSorted" },
-	{   3, "YXBanded" },
-	{   0, NULL },
+    {   0, "Unsorted" },
+    {   1, "YSorted" },
+    {   2, "YXSorted" },
+    {   3, "YXBanded" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_sync_ALARMSTATE[] = {
-	{   0, "Active" },
-	{   1, "Inactive" },
-	{   2, "Destroyed" },
-	{   0, NULL },
+    {   0, "Active" },
+    {   1, "Inactive" },
+    {   2, "Destroyed" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xfixes_SaveSetMode[] = {
-	{   0, "Insert" },
-	{   1, "Delete" },
-	{   0, NULL },
+    {   0, "Insert" },
+    {   1, "Delete" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xfixes_SaveSetTarget[] = {
-	{   0, "Nearest" },
-	{   1, "Root" },
-	{   0, NULL },
+    {   0, "Nearest" },
+    {   1, "Root" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xfixes_SaveSetMapping[] = {
-	{   0, "Map" },
-	{   1, "Unmap" },
-	{   0, NULL },
+    {   0, "Map" },
+    {   1, "Unmap" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xfixes_CursorNotify[] = {
-	{   0, "DisplayCursor" },
-	{   0, NULL },
+    {   0, "DisplayCursor" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_DeviceUse[] = {
-	{   0, "IsXPointer" },
-	{   1, "IsXKeyboard" },
-	{   2, "IsXExtensionDevice" },
-	{   3, "IsXExtensionKeyboard" },
-	{   4, "IsXExtensionPointer" },
-	{   0, NULL },
+    {   0, "IsXPointer" },
+    {   1, "IsXKeyboard" },
+    {   2, "IsXExtensionDevice" },
+    {   3, "IsXExtensionKeyboard" },
+    {   4, "IsXExtensionPointer" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_InputClass[] = {
-	{   0, "Key" },
-	{   1, "Button" },
-	{   2, "Valuator" },
-	{   3, "Feedback" },
-	{   4, "Proximity" },
-	{   5, "Focus" },
-	{   6, "Other" },
-	{   0, NULL },
+    {   0, "Key" },
+    {   1, "Button" },
+    {   2, "Valuator" },
+    {   3, "Feedback" },
+    {   4, "Proximity" },
+    {   5, "Focus" },
+    {   6, "Other" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ValuatorMode[] = {
-	{   0, "Relative" },
-	{   1, "Absolute" },
-	{   0, NULL },
+    {   0, "Relative" },
+    {   1, "Absolute" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_GrabStatus[] = {
-	{   0, "Success" },
-	{   1, "AlreadyGrabbed" },
-	{   2, "InvalidTime" },
-	{   3, "NotViewable" },
-	{   4, "Frozen" },
-	{   0, NULL },
+    {   0, "Success" },
+    {   1, "AlreadyGrabbed" },
+    {   2, "InvalidTime" },
+    {   3, "NotViewable" },
+    {   4, "Frozen" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_PropagateMode[] = {
-	{   0, "AddToList" },
-	{   1, "DeleteFromList" },
-	{   0, NULL },
+    {   0, "AddToList" },
+    {   1, "DeleteFromList" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Time[] = {
-	{   0, "CurrentTime" },
-	{   0, NULL },
+    {   0, "CurrentTime" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_GrabMode[] = {
-	{   0, "Sync" },
-	{   1, "Async" },
-	{   0, NULL },
+    {   0, "Sync" },
+    {   1, "Async" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ModifierDevice[] = {
-	{ 255, "UseXKeyboard" },
-	{   0, NULL },
+    { 255, "UseXKeyboard" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Grab[] = {
-	{   0, "Any" },
-	{   0, NULL },
+    {   0, "Any" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_DeviceInputMode[] = {
-	{   0, "AsyncThisDevice" },
-	{   1, "SyncThisDevice" },
-	{   2, "ReplayThisDevice" },
-	{   3, "AsyncOtherDevices" },
-	{   4, "AsyncAll" },
-	{   5, "SyncAll" },
-	{   0, NULL },
+    {   0, "AsyncThisDevice" },
+    {   1, "SyncThisDevice" },
+    {   2, "ReplayThisDevice" },
+    {   3, "AsyncOtherDevices" },
+    {   4, "AsyncAll" },
+    {   5, "SyncAll" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_InputFocus[] = {
-	{   0, "None" },
-	{   1, "PointerRoot" },
-	{   2, "Parent" },
-	{   3, "FollowKeyboard" },
-	{   0, NULL },
+    {   0, "None" },
+    {   1, "PointerRoot" },
+    {   2, "Parent" },
+    {   3, "FollowKeyboard" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_FeedbackClass[] = {
-	{   0, "Keyboard" },
-	{   1, "Pointer" },
-	{   2, "String" },
-	{   3, "Integer" },
-	{   4, "Led" },
-	{   5, "Bell" },
-	{   0, NULL },
+    {   0, "Keyboard" },
+    {   1, "Pointer" },
+    {   2, "String" },
+    {   3, "Integer" },
+    {   4, "Led" },
+    {   5, "Bell" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_MappingStatus[] = {
-	{   0, "Success" },
-	{   1, "Busy" },
-	{   2, "Failure" },
-	{   0, NULL },
+    {   0, "Success" },
+    {   1, "Busy" },
+    {   2, "Failure" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_DeviceControl[] = {
-	{   1, "resolution" },
-	{   2, "abs_calib" },
-	{   3, "core" },
-	{   4, "enable" },
-	{   5, "abs_area" },
-	{   0, NULL },
+    {   1, "resolution" },
+    {   2, "abs_calib" },
+    {   3, "core" },
+    {   4, "enable" },
+    {   5, "abs_area" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_PropertyFormat[] = {
-	{   8, "8Bits" },
-	{  16, "16Bits" },
-	{  32, "32Bits" },
-	{   0, NULL },
+    {   8, "8Bits" },
+    {  16, "16Bits" },
+    {  32, "32Bits" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_Device[] = {
-	{   0, "All" },
-	{   1, "AllMaster" },
-	{   0, NULL },
+    {   0, "All" },
+    {   1, "AllMaster" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_HierarchyChangeType[] = {
-	{   1, "AddMaster" },
-	{   2, "RemoveMaster" },
-	{   3, "AttachSlave" },
-	{   4, "DetachSlave" },
-	{   0, NULL },
+    {   1, "AddMaster" },
+    {   2, "RemoveMaster" },
+    {   3, "AttachSlave" },
+    {   4, "DetachSlave" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ChangeMode[] = {
-	{   1, "Attach" },
-	{   2, "Float" },
-	{   0, NULL },
+    {   1, "Attach" },
+    {   2, "Float" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_DeviceClassType[] = {
-	{   0, "Key" },
-	{   1, "Button" },
-	{   2, "Valuator" },
-	{   3, "Scroll" },
-	{   8, "Touch" },
-	{   0, NULL },
+    {   0, "Key" },
+    {   1, "Button" },
+    {   2, "Valuator" },
+    {   3, "Scroll" },
+    {   8, "Touch" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ScrollType[] = {
-	{   1, "Vertical" },
-	{   2, "Horizontal" },
-	{   0, NULL },
+    {   1, "Vertical" },
+    {   2, "Horizontal" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_TouchMode[] = {
-	{   1, "Direct" },
-	{   2, "Dependent" },
-	{   0, NULL },
+    {   1, "Direct" },
+    {   2, "Dependent" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_DeviceType[] = {
-	{   1, "MasterPointer" },
-	{   2, "MasterKeyboard" },
-	{   3, "SlavePointer" },
-	{   4, "SlaveKeyboard" },
-	{   5, "FloatingSlave" },
-	{   0, NULL },
+    {   1, "MasterPointer" },
+    {   2, "MasterKeyboard" },
+    {   3, "SlavePointer" },
+    {   4, "SlaveKeyboard" },
+    {   5, "FloatingSlave" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_GrabOwner[] = {
-	{   0, "NoOwner" },
-	{   1, "Owner" },
-	{   0, NULL },
+    {   0, "NoOwner" },
+    {   1, "Owner" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_EventMode[] = {
-	{   0, "AsyncDevice" },
-	{   1, "SyncDevice" },
-	{   2, "ReplayDevice" },
-	{   3, "AsyncPairedDevice" },
-	{   4, "AsyncPair" },
-	{   5, "SyncPair" },
-	{   6, "AcceptTouch" },
-	{   7, "RejectTouch" },
-	{   0, NULL },
+    {   0, "AsyncDevice" },
+    {   1, "SyncDevice" },
+    {   2, "ReplayDevice" },
+    {   3, "AsyncPairedDevice" },
+    {   4, "AsyncPair" },
+    {   5, "SyncPair" },
+    {   6, "AcceptTouch" },
+    {   7, "RejectTouch" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ModifierMask[] = {
-	{   0, NULL },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_GrabType[] = {
-	{   0, "Button" },
-	{   1, "Keycode" },
-	{   2, "Enter" },
-	{   3, "FocusIn" },
-	{   4, "TouchBegin" },
-	{   0, NULL },
+    {   0, "Button" },
+    {   1, "Keycode" },
+    {   2, "Enter" },
+    {   3, "FocusIn" },
+    {   4, "TouchBegin" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_GrabMode22[] = {
-	{   0, "Sync" },
-	{   1, "Async" },
-	{   2, "Touch" },
-	{   0, NULL },
+    {   0, "Sync" },
+    {   1, "Async" },
+    {   2, "Touch" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Window[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_NotifyDetail[] = {
-	{   0, "Ancestor" },
-	{   1, "Virtual" },
-	{   2, "Inferior" },
-	{   3, "Nonlinear" },
-	{   4, "NonlinearVirtual" },
-	{   5, "Pointer" },
-	{   6, "PointerRoot" },
-	{   7, "None" },
-	{   0, NULL },
+    {   0, "Ancestor" },
+    {   1, "Virtual" },
+    {   2, "Inferior" },
+    {   3, "Nonlinear" },
+    {   4, "NonlinearVirtual" },
+    {   5, "Pointer" },
+    {   6, "PointerRoot" },
+    {   7, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_NotifyMode[] = {
-	{   0, "Normal" },
-	{   1, "Grab" },
-	{   2, "Ungrab" },
-	{   3, "WhileGrabbed" },
-	{   0, NULL },
+    {   0, "Normal" },
+    {   1, "Grab" },
+    {   2, "Ungrab" },
+    {   3, "WhileGrabbed" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_Mapping[] = {
-	{   0, "Modifier" },
-	{   1, "Keyboard" },
-	{   2, "Pointer" },
-	{   0, NULL },
+    {   0, "Modifier" },
+    {   1, "Keyboard" },
+    {   2, "Pointer" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ChangeDevice[] = {
-	{   0, "NewPointer" },
-	{   1, "NewKeyboard" },
-	{   0, NULL },
+    {   0, "NewPointer" },
+    {   1, "NewKeyboard" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_DeviceChange[] = {
-	{   0, "Added" },
-	{   1, "Removed" },
-	{   2, "Enabled" },
-	{   3, "Disabled" },
-	{   4, "Unrecoverable" },
-	{   5, "ControlChanged" },
-	{   0, NULL },
+    {   0, "Added" },
+    {   1, "Removed" },
+    {   2, "Enabled" },
+    {   3, "Disabled" },
+    {   4, "Unrecoverable" },
+    {   5, "ControlChanged" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_ChangeReason[] = {
-	{   1, "SlaveSwitch" },
-	{   2, "DeviceChange" },
-	{   0, NULL },
+    {   1, "SlaveSwitch" },
+    {   2, "DeviceChange" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_NotifyMode[] = {
-	{   0, "Normal" },
-	{   1, "Grab" },
-	{   2, "Ungrab" },
-	{   3, "WhileGrabbed" },
-	{   4, "PassiveGrab" },
-	{   5, "PassiveUngrab" },
-	{   0, NULL },
+    {   0, "Normal" },
+    {   1, "Grab" },
+    {   2, "Ungrab" },
+    {   3, "WhileGrabbed" },
+    {   4, "PassiveGrab" },
+    {   5, "PassiveUngrab" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_NotifyDetail[] = {
-	{   0, "Ancestor" },
-	{   1, "Virtual" },
-	{   2, "Inferior" },
-	{   3, "Nonlinear" },
-	{   4, "NonlinearVirtual" },
-	{   5, "Pointer" },
-	{   6, "PointerRoot" },
-	{   7, "None" },
-	{   0, NULL },
+    {   0, "Ancestor" },
+    {   1, "Virtual" },
+    {   2, "Inferior" },
+    {   3, "Nonlinear" },
+    {   4, "NonlinearVirtual" },
+    {   5, "Pointer" },
+    {   6, "PointerRoot" },
+    {   7, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_PropertyFlag[] = {
-	{   0, "Deleted" },
-	{   1, "Created" },
-	{   2, "Modified" },
-	{   0, NULL },
+    {   0, "Deleted" },
+    {   1, "Created" },
+    {   2, "Modified" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xinput_TouchOwnershipFlags[] = {
-	{   0, "None" },
-	{   0, NULL },
+    {   0, "None" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_IMFlag[] = {
-	{   0, NULL },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_IMGroupsWhich[] = {
-	{   0, NULL },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_SetOfGroup[] = {
-	{   0, NULL },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_IMModsWhich[] = {
-	{   0, NULL },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_LedClass[] = {
-	{   0, "KbdFeedbackClass" },
-	{   4, "LedFeedbackClass" },
-	{ 768, "DfltXIClass" },
-	{ 1280, "AllXIClasses" },
-	{   0, NULL },
+    {   0, "KbdFeedbackClass" },
+    {   4, "LedFeedbackClass" },
+    { 768, "DfltXIClass" },
+    { 1280, "AllXIClasses" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_ID[] = {
-	{ 256, "UseCoreKbd" },
-	{ 512, "UseCorePtr" },
-	{ 768, "DfltXIClass" },
-	{ 1024, "DfltXIId" },
-	{ 1280, "AllXIClass" },
-	{ 1536, "AllXIId" },
-	{ 65280, "XINone" },
-	{   0, NULL },
+    { 256, "UseCoreKbd" },
+    { 512, "UseCorePtr" },
+    { 768, "DfltXIClass" },
+    { 1024, "DfltXIId" },
+    { 1280, "AllXIClass" },
+    { 1536, "AllXIId" },
+    { 65280, "XINone" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_SAType[] = {
-	{   0, "NoAction" },
-	{   1, "SetMods" },
-	{   2, "LatchMods" },
-	{   3, "LockMods" },
-	{   4, "SetGroup" },
-	{   5, "LatchGroup" },
-	{   6, "LockGroup" },
-	{   7, "MovePtr" },
-	{   8, "PtrBtn" },
-	{   9, "LockPtrBtn" },
-	{  10, "SetPtrDflt" },
-	{  11, "ISOLock" },
-	{  12, "Terminate" },
-	{  13, "SwitchScreen" },
-	{  14, "SetControls" },
-	{  15, "LockControls" },
-	{  16, "ActionMessage" },
-	{  17, "RedirectKey" },
-	{  18, "DeviceBtn" },
-	{  19, "LockDeviceBtn" },
-	{  20, "DeviceValuator" },
-	{   0, NULL },
+    {   0, "NoAction" },
+    {   1, "SetMods" },
+    {   2, "LatchMods" },
+    {   3, "LockMods" },
+    {   4, "SetGroup" },
+    {   5, "LatchGroup" },
+    {   6, "LockGroup" },
+    {   7, "MovePtr" },
+    {   8, "PtrBtn" },
+    {   9, "LockPtrBtn" },
+    {  10, "SetPtrDflt" },
+    {  11, "ISOLock" },
+    {  12, "Terminate" },
+    {  13, "SwitchScreen" },
+    {  14, "SetControls" },
+    {  15, "LockControls" },
+    {  16, "ActionMessage" },
+    {  17, "RedirectKey" },
+    {  18, "DeviceBtn" },
+    {  19, "LockDeviceBtn" },
+    {  20, "DeviceValuator" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_SAValWhat[] = {
-	{   0, "IgnoreVal" },
-	{   1, "SetValMin" },
-	{   2, "SetValCenter" },
-	{   3, "SetValMax" },
-	{   4, "SetValRelative" },
-	{   5, "SetValAbsolute" },
-	{   0, NULL },
+    {   0, "IgnoreVal" },
+    {   1, "SetValMin" },
+    {   2, "SetValCenter" },
+    {   3, "SetValMax" },
+    {   4, "SetValRelative" },
+    {   5, "SetValAbsolute" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_SymInterpretMatch[] = {
-	{   0, "NoneOf" },
-	{   1, "AnyOfOrNone" },
-	{   2, "AnyOf" },
-	{   3, "AllOf" },
-	{   4, "Exactly" },
-	{   0, NULL },
+    {   0, "NoneOf" },
+    {   1, "AnyOfOrNone" },
+    {   2, "AnyOf" },
+    {   3, "AllOf" },
+    {   4, "Exactly" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_Group[] = {
-	{   0, "1" },
-	{   1, "2" },
-	{   2, "3" },
-	{   3, "4" },
-	{   0, NULL },
+    {   0, "1" },
+    {   1, "2" },
+    {   2, "3" },
+    {   3, "4" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_BellClassResult[] = {
-	{   0, "KbdFeedbackClass" },
-	{   5, "BellFeedbackClass" },
-	{   0, NULL },
+    {   0, "KbdFeedbackClass" },
+    {   5, "BellFeedbackClass" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xkb_LedClassResult[] = {
-	{   0, "KbdFeedbackClass" },
-	{   4, "LedFeedbackClass" },
-	{   0, NULL },
+    {   0, "KbdFeedbackClass" },
+    {   4, "LedFeedbackClass" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xv_ImageFormatInfoType[] = {
-	{   0, "RGB" },
-	{   1, "YUV" },
-	{   0, NULL },
+    {   0, "RGB" },
+    {   1, "YUV" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xproto_ImageOrder[] = {
-	{   0, "LSBFirst" },
-	{   1, "MSBFirst" },
-	{   0, NULL },
+    {   0, "LSBFirst" },
+    {   1, "MSBFirst" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xv_ImageFormatInfoFormat[] = {
-	{   0, "Packed" },
-	{   1, "Planar" },
-	{   0, NULL },
+    {   0, "Packed" },
+    {   1, "Planar" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xv_ScanlineOrder[] = {
-	{   0, "TopToBottom" },
-	{   1, "BottomToTop" },
-	{   0, NULL },
+    {   0, "TopToBottom" },
+    {   1, "BottomToTop" },
+    {   0, NULL },
 };
 
 static const value_string x11_enum_xv_GrabPortStatus[] = {
-	{   0, "Success" },
-	{   1, "BadExtension" },
-	{   2, "AlreadyGrabbed" },
-	{   3, "InvalidTime" },
-	{   4, "BadReply" },
-	{   5, "BadAlloc" },
-	{   0, NULL },
+    {   0, "Success" },
+    {   1, "BadExtension" },
+    {   2, "AlreadyGrabbed" },
+    {   3, "InvalidTime" },
+    {   4, "BadReply" },
+    {   5, "BadAlloc" },
+    {   0, NULL },
 };