From 961cd3c6ce821c21000d8009b562fc5fafbd0d7a Mon Sep 17 00:00:00 2001 From: Jeff Morriss Date: Fri, 11 Sep 2009 01:57:59 +0000 Subject: [PATCH] From Peter Harris via https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=2981 : This patch adds extension support to the X11 dissector. I've removed the perl script from the make file, since the new one depends on perl 5.10, xcbproto (at least git as of today), and mesa (at least the mesa/src/mesa/glapi directory). It seemed easier to just add the generated header files to svn directly. svn path=/trunk/; revision=29854 --- AUTHORS | 4 + epan/dissectors/Makefile.am | 13 +- epan/dissectors/Makefile.common | 9 +- epan/dissectors/Makefile.nmake | 12 - epan/dissectors/README.X11 | 23 + epan/dissectors/packet-x11.c | 311 +- epan/dissectors/process-x11-fields.pl | 46 +- epan/dissectors/process-x11-xcb.pl | 1217 + epan/dissectors/x11-declarations.h | 4118 +++ epan/dissectors/x11-extension-errors.h | 174 + .../dissectors/x11-extension-implementation.h | 21965 ++++++++++++++++ epan/dissectors/x11-glx-render-enum.h | 1905 ++ epan/dissectors/x11-register-info.h | 4118 +++ 13 files changed, 33855 insertions(+), 60 deletions(-) create mode 100644 epan/dissectors/README.X11 create mode 100755 epan/dissectors/process-x11-xcb.pl create mode 100644 epan/dissectors/x11-declarations.h create mode 100644 epan/dissectors/x11-extension-errors.h create mode 100644 epan/dissectors/x11-extension-implementation.h create mode 100644 epan/dissectors/x11-glx-render-enum.h create mode 100644 epan/dissectors/x11-register-info.h diff --git a/AUTHORS b/AUTHORS index 7e5a464dd7..529bd4886e 100644 --- a/AUTHORS +++ b/AUTHORS @@ -2828,6 +2828,10 @@ David Castleford { Simulcrypt dissector } +Peter Harris { + X11 extension decoding +} + Martin Lutz { IEC 61850 GOOSE Dissector } diff --git a/epan/dissectors/Makefile.am b/epan/dissectors/Makefile.am index 21862d5e7a..6729628942 100644 --- a/epan/dissectors/Makefile.am +++ b/epan/dissectors/Makefile.am @@ -48,22 +48,11 @@ EXTRA_DIST = \ Makefile.common \ Makefile.nmake \ ncp2222.py \ - packet-ncp2222.inc \ - process-x11-fields.pl \ - x11-fields + packet-ncp2222.inc packet-ncp2222.c : $(srcdir)/ncp2222.py $(PYTHON) $< -o $@ -# -# Build various header files for the X11 dissector. -# -PROC_X11_FIELDS = $(srcdir)/process-x11-fields.pl -X11_FIELDS = $(srcdir)/x11-fields - -x11-declarations.h x11-register-info.h: $(PROC_X11_FIELDS) $(X11_FIELDS) - $(PERL) $(PROC_X11_FIELDS) < $(X11_FIELDS) - # # Build register.c, which contains a function register_all_protocols() # that calls the register routines for all protocols and a function diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common index 9fd10461b5..d19d8feffd 100644 --- a/epan/dissectors/Makefile.common +++ b/epan/dissectors/Makefile.common @@ -24,10 +24,6 @@ # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # "BUILT_SOURCES" are built before any "make all" or "make check" targets. -BUILT_HEADER_FILES = \ - x11-declarations.h \ - x11-register-info.h - BUILT_C_FILES = \ register.c @@ -1241,6 +1237,11 @@ DISSECTOR_INCLUDES = \ packet-wtp.h \ packet-x11-keysym.h \ packet-x11-keysymdef.h \ + x11-declarations.h \ + x11-register-info.h \ + x11-extension-implementation.h \ + x11-extension-errors.h \ + x11-glx-render-enum.h \ packet-x411.h \ packet-x420.h \ packet-x509af.h \ diff --git a/epan/dissectors/Makefile.nmake b/epan/dissectors/Makefile.nmake index 60f30f9ad6..7e3f563a2e 100644 --- a/epan/dissectors/Makefile.nmake +++ b/epan/dissectors/Makefile.nmake @@ -38,18 +38,6 @@ packet-rrc.obj : packet-rrc.c $(CC) $(CVARSDLL) $(CFLAGS) /Zd /Fd.\ -c $? !ENDIF -# -# The header files listed here are built from x11-fields using Perl; -# we declare a dependency here so that they get built. -# -packet-x11.obj : packet-x11.c x11-declarations.h x11-register-info.h - -# -# Build various header files for the X11 dissector. -# -x11-declarations.h x11-register-info.h: x11-fields process-x11-fields.pl - $(PERL) process-x11-fields.pl #include #include +#include #include #include "packet-frame.h" @@ -91,6 +92,8 @@ #define UNKNOWN_OPCODE 0 #define MAX_OPCODES (255 + 1) /* 255 + INITIAL_CONN */ +#define LastExtensionError 255 +#define LastExtensionEvent 127 #define BYTE_ORDER_BE 0 #define BYTE_ORDER_LE 1 @@ -129,6 +132,13 @@ typedef struct _x11_conv_data { GHashTable *valtable;/* hashtable of sequencenumber <-> &opcode_vals */ /* major opcodes including extensions (NULL terminated) */ value_string opcode_vals[MAX_OPCODES+1]; + /* error codes including extensions (NULL terminated) */ + value_string errorcode_vals[LastExtensionError + 2]; + /* event codes including extensions (NULL terminated) */ + value_string eventcode_vals[LastExtensionEvent + 2]; + GHashTable *eventcode_funcs; /* hashtable of eventcode <-> dissect_event() */ + GHashTable *reply_funcs; /* hashtable of opcode <-> dissect_reply() */ + int sequencenumber; /* sequencenumber of current packet. */ guint32 iconn_frame; /* frame # of initial connection request */ guint32 iconn_reply; /* frame # of initial connection reply */ @@ -150,6 +160,11 @@ typedef struct _x11_conv_data { static x11_conv_data_t *x11_conv_data_list; +static GHashTable *extension_table; /* hashtable of extension name <-> dispatch function */ +static GHashTable *event_table; /* hashtable of extension name <-> event info list */ +static GHashTable *error_table; /* hashtable of extension name <-> error list */ +static GHashTable *reply_table; /* hashtable of extension name <-> reply list */ + /* Initialize the protocol and registered fields */ static int proto_x11 = -1; @@ -162,6 +177,8 @@ static gint ett_x11_list_of_arc = -1; static gint ett_x11_arc = -1; static gint ett_x11_list_of_atom = -1; static gint ett_x11_list_of_card32 = -1; +static gint ett_x11_list_of_float = -1; +static gint ett_x11_list_of_double = -1; static gint ett_x11_list_of_color_item = -1; static gint ett_x11_color_item = -1; static gint ett_x11_list_of_keycode = -1; @@ -866,8 +883,6 @@ static const value_string opcode_vals[] = { #define ColormapNotify 32 #define ClientMessage 33 #define MappingNotify 34 -#define FirstExtensionEvent 64 -#define LastExtensionEvent 127 static const value_string eventcode_vals[] = { { KeyPress, "KeyPress" }, @@ -934,9 +949,6 @@ static const value_string eventcode_vals[] = { #define BadLength 16 /* Request length incorrect */ #define BadImplementation 17 /* server is defective */ -#define FirstExtensionError 128 -#define LastExtensionError 255 - static const value_string errorcode_vals[] = { { Success, "Success" }, { BadRequest, "BadRequest" }, @@ -956,8 +968,6 @@ static const value_string errorcode_vals[] = { { BadName, "BadName" }, { BadLength, "BadLength" }, { BadImplementation, "BadImplementation" }, - { FirstExtensionError, "FirstExtensionError" }, - { LastExtensionError, "LastExtensionError" }, { 0, NULL } }; @@ -1058,6 +1068,8 @@ static const value_string zero_is_none_vals[] = { #define VALUE8(tvb, offset) (tvb_get_guint8(tvb, offset)) #define VALUE16(tvb, offset) (little_endian ? tvb_get_letohs(tvb, offset) : tvb_get_ntohs(tvb, offset)) #define VALUE32(tvb, offset) (little_endian ? tvb_get_letohl(tvb, offset) : tvb_get_ntohl(tvb, offset)) +#define FLOAT(tvb, offset) (little_endian ? tvb_get_letohieee_float(tvb, offset) : tvb_get_ntohieee_float(tvb, offset)) +#define DOUBLE(tvb, offset) (little_endian ? tvb_get_letohieee_double(tvb, offset) : tvb_get_ntohieee_double(tvb, offset)) #define FIELD8(name) (field8(tvb, offsetp, t, hf_x11_##name, little_endian)) #define FIELD16(name) (field16(tvb, offsetp, t, hf_x11_##name, little_endian)) @@ -1144,7 +1156,7 @@ static const value_string zero_is_none_vals[] = { ti = proto_tree_add_text(t, next_tvb, 0, -1, "event: %d (%s)", \ eventcode, \ val_to_str(eventcode & 0x7F, \ - eventcode_vals, \ + state->eventcode_vals, \ "")); \ proto_tree = proto_item_add_subtree(ti, ett_x11_event); \ decode_x11_event(next_tvb, eventcode, sent, proto_tree, \ @@ -1169,7 +1181,15 @@ static const value_string zero_is_none_vals[] = { #define LISTofSTRING8(name, length) { listOfString8(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_string, (length), little_endian); } #define LISTofTEXTITEM8(name) { listOfTextItem(tvb, offsetp, t, hf_x11_##name, FALSE, next_offset, little_endian); } #define LISTofTEXTITEM16(name) { listOfTextItem(tvb, offsetp, t, hf_x11_##name, TRUE, next_offset, little_endian); } -#define OPCODE() { opcode = FIELD8(opcode); } +#define OPCODE() { \ + const gchar *enumValue = NULL; \ + opcode = VALUE8(tvb, *offsetp); \ + enumValue = match_strval(opcode, state->opcode_vals); \ + proto_tree_add_uint_format(t, hf_x11_opcode, tvb, *offsetp, 1, opcode, \ + "opcode: %u (%s)", opcode, enumValue); \ + *offsetp += 1; \ + } + #define PIXMAP(name) { FIELD32(name); } #define REQUEST_LENGTH() (requestLength(tvb, offsetp, t, little_endian)) #define SETofEVENT(name) { setOfEvent(tvb, offsetp, t, little_endian); } @@ -1212,20 +1232,20 @@ static const value_string zero_is_none_vals[] = { *offsetp, sizeof(seqno), seqno, \ "sequencenumber: %d (%s)", \ (int)seqno, \ - val_to_str(opcode, state->opcode_vals, "")); \ + val_to_str(opcode & 0xFF, state->opcode_vals, "")); \ *offsetp += sizeof(seqno); \ } while (0) #define REPLYCONTENTS_COMMON() do { \ REPLY(reply); \ - proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, \ + proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp, \ 1, little_endian); \ - ++offset; \ + ++(*offsetp); \ SEQUENCENUMBER_REPLY(sequencenumber); \ REPLYLENGTH(replylength); \ - proto_tree_add_item(t, hf_x11_undecoded, tvb, offset, \ - tvb_reported_length_remaining(tvb, offset), little_endian); \ - offset += tvb_reported_length_remaining(tvb, offset); \ + proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp, \ + tvb_reported_length_remaining(tvb, *offsetp), little_endian); \ + *offsetp += tvb_reported_length_remaining(tvb, *offsetp); \ } while (0) @@ -1447,6 +1467,28 @@ static void listOfByte(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, *offsetp += length; } +static void listOfCard16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, + int hf_item, int length, gboolean little_endian) +{ + proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 2, little_endian); + proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32); + while(length--) { + proto_tree_add_uint(tt, hf_item, tvb, *offsetp, 2, VALUE16(tvb, *offsetp)); + *offsetp += 2; + } +} + +static void listOfInt16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, + int hf_item, int length, gboolean little_endian) +{ + proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 2, little_endian); + proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32); + while(length--) { + proto_tree_add_int(tt, hf_item, tvb, *offsetp, 2, VALUE16(tvb, *offsetp)); + *offsetp += 2; + } +} + static void listOfCard32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, int hf_item, int length, gboolean little_endian) { @@ -1458,6 +1500,39 @@ static void listOfCard32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, } } +static void listOfInt32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, + int hf_item, int length, gboolean little_endian) +{ + proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, little_endian); + proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32); + while(length--) { + proto_tree_add_int(tt, hf_item, tvb, *offsetp, 4, VALUE32(tvb, *offsetp)); + *offsetp += 4; + } +} + +static void listOfFloat(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, + int hf_item, int length, gboolean little_endian) +{ + proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, little_endian); + proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_float); + while(length--) { + proto_tree_add_float(tt, hf_item, tvb, *offsetp, 4, FLOAT(tvb, *offsetp)); + *offsetp += 4; + } +} + +static void listOfDouble(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, + int hf_item, int length, gboolean little_endian) +{ + proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, little_endian); + proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_double); + while(length--) { + proto_tree_add_double(tt, hf_item, tvb, *offsetp, 8, DOUBLE(tvb, *offsetp)); + *offsetp += 8; + } +} + static void listOfColorItem(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf, int length, gboolean little_endian) { @@ -2949,6 +3024,127 @@ static void dissect_x11_initial_reply(tvbuff_t *tvb, packet_info *pinfo, } +typedef struct x11_reply_info { + const guint8 minor; + void (*dissect)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian); +} x11_reply_info; + +typedef struct event_info { + const gchar *name; + void (*dissect)(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian); +} x11_event_info; + +static void set_handler(const char *name, void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian), + const char **errors, + const x11_event_info *event_info, + const x11_reply_info *reply_info) +{ + g_hash_table_insert(extension_table, (gpointer)name, (gpointer)func); + g_hash_table_insert(error_table, (gpointer)name, (gpointer)errors); + g_hash_table_insert(event_table, (gpointer)name, (gpointer)event_info); + g_hash_table_insert(reply_table, (gpointer)name, (gpointer)reply_info); +} + + +#include "x11-extension-errors.h" +#include "x11-extension-implementation.h" + +static void tryExtension(int opcode, tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, + x11_conv_data_t *state, gboolean little_endian) +{ + const gchar *extension; + void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian); + + extension = match_strval(opcode, state->opcode_vals); + if (!extension) + return; + + func = g_hash_table_lookup(extension_table, extension); + if (func) + func(tvb, pinfo, offsetp, t, little_endian); +} + +static void tryExtensionReply(int opcode, tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, + x11_conv_data_t *state, gboolean little_endian) +{ + void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian); + + func = g_hash_table_lookup(state->reply_funcs, GINT_TO_POINTER(opcode)); + if (func) + func(tvb, pinfo, offsetp, t, little_endian); + else + REPLYCONTENTS_COMMON(); +} + +static void tryExtensionEvent(int event, tvbuff_t *tvb, int *offsetp, proto_tree *t, + x11_conv_data_t *state, gboolean little_endian) +{ + void (*func)(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian); + + func = g_hash_table_lookup(state->eventcode_funcs, GINT_TO_POINTER(event)); + if (func) + func(tvb, offsetp, t, little_endian); +} + +static void register_extension(x11_conv_data_t *state, value_string *vals_p, + int major_opcode, unsigned int first_event, unsigned int first_error) +{ + const char **error_string; + x11_event_info *event_info; + x11_reply_info *reply_info; + int i; + + vals_p->value = major_opcode; + + error_string = g_hash_table_lookup(error_table, vals_p->strptr); + while (error_string && *error_string && first_error <= LastExtensionError) { + /* store string of extension error */ + for (i = 0; i <= LastExtensionError; i++) { + if (state->errorcode_vals[i].strptr == NULL) { + state->errorcode_vals[i].value = first_error; + state->errorcode_vals[i].strptr = *error_string; + break; + } else if (state->errorcode_vals[i].value == first_error) { + /* TODO: Warn about extensions stepping on each other */ + state->errorcode_vals[i].strptr = *error_string; + break; + } + } + first_error++; + error_string++; + } + + event_info = g_hash_table_lookup(event_table, vals_p->strptr); + while (event_info && event_info->name && first_event <= LastExtensionEvent) { + /* store string of extension event */ + for (i = 0; i <= LastExtensionEvent; i++) { + if (state->eventcode_vals[i].strptr == NULL) { + state->eventcode_vals[i].value = first_event; + state->eventcode_vals[i].strptr = event_info->name; + break; + } else if (state->eventcode_vals[i].value == first_event) { + /* TODO: Warn about extensions stepping on each other */ + state->eventcode_vals[i].strptr = event_info->name; + break; + } + } + + /* store event decode function */ + g_hash_table_insert(state->eventcode_funcs, GINT_TO_POINTER(first_event), (gpointer)event_info->dissect); + + first_event++; + event_info++; + } + + reply_info = g_hash_table_lookup(reply_table, vals_p->strptr); + if (reply_info) + for (i = 0; reply_info[i].dissect; i++) + g_hash_table_insert(state->reply_funcs, + GINT_TO_POINTER(major_opcode | (reply_info[i].minor << 8)), + (gpointer)reply_info[i].dissect); +} + + static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const char *sep, x11_conv_data_t *state, gboolean little_endian) @@ -3009,6 +3205,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, while(i < MAX_OPCODES) { if (state->opcode_vals[i].strptr == NULL) { state->opcode_vals[i].strptr = name; + state->opcode_vals[i].value = -1; g_hash_table_insert(state->valtable, GINT_TO_POINTER(state->sequencenumber), (int *)&state->opcode_vals[i]); @@ -3078,9 +3275,12 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, * With Extension, we don't know, so assume there could be one */ if (opcode >= X_FirstExtension && opcode <= X_LastExtension) { + guint32 minor; + minor = tvb_get_guint8(tvb, 1); + g_hash_table_insert(state->seqtable, GINT_TO_POINTER(state->sequencenumber), - GINT_TO_POINTER(opcode)); + GINT_TO_POINTER(opcode | (minor << 8))); } /* @@ -4060,6 +4260,9 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo, UNUSED(1); REQUEST_LENGTH(); break; + default: + tryExtension(opcode, tvb, pinfo, offsetp, t, state, little_endian); + break; } if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) @@ -4378,6 +4581,36 @@ x11_stateinit(conversation_t *conversation) i++; } + /* initialise errorcodes */ + i = 0; + while (1) { + if (errorcode_vals[i].strptr == NULL) break; + state->errorcode_vals[i].value = errorcode_vals[i].value; + state->errorcode_vals[i].strptr = errorcode_vals[i].strptr; + i++; + } + while (i <= LastExtensionError + 1) { + state->errorcode_vals[i].value = 0; + state->errorcode_vals[i].strptr = NULL; + i++; + } + + /* initialise eventcodes */ + i = 0; + while (1) { + if (eventcode_vals[i].strptr == NULL) break; + state->eventcode_vals[i].value = eventcode_vals[i].value; + state->eventcode_vals[i].strptr = eventcode_vals[i].strptr; + i++; + } + while (i <= LastExtensionEvent + 1) { + state->eventcode_vals[i].value = 0; + state->eventcode_vals[i].strptr = NULL; + i++; + } + state->eventcode_funcs = g_hash_table_new(g_direct_hash, g_direct_equal); + state->reply_funcs = g_hash_table_new(g_direct_hash, g_direct_equal); + state->seqtable = g_hash_table_new(g_direct_hash, g_direct_equal); state->valtable = g_hash_table_new(g_direct_hash, g_direct_equal); g_hash_table_insert(state->seqtable, (int *)0, (int *)NOTHING_SEEN); @@ -4533,7 +4766,7 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean little_endian) { int offset = 0, *offsetp = &offset, length, left, opcode; - int major_opcode, sequence_number; + int major_opcode, sequence_number, first_error, first_event; value_string *vals_p; proto_item *ti; proto_tree *t; @@ -4586,11 +4819,17 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, if (check_col(pinfo->cinfo, COL_INFO)) col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", sep, - val_to_str(opcode, state->opcode_vals, + val_to_str(opcode & 0xFF, state->opcode_vals, "")); - proto_item_append_text(ti, ", Reply, opcode: %d (%s)", - opcode, val_to_str(opcode, + if (opcode > 0xFF) + proto_item_append_text(ti, ", Reply, opcode: %d.%d (%s)", + opcode & 0xFF, opcode >> 8, val_to_str(opcode & 0xFF, + state->opcode_vals, + "")); + else + proto_item_append_text(ti, ", Reply, opcode: %d (%s)", + opcode, val_to_str(opcode, state->opcode_vals, "")); } @@ -4617,7 +4856,10 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, GINT_TO_POINTER(sequence_number)); if (vals_p != NULL) { major_opcode = VALUE8(tvb, offset + 9); - vals_p->value = major_opcode; + first_event = VALUE8(tvb, offset + 10); + first_error = VALUE8(tvb, offset + 11); + + register_extension(state, vals_p, major_opcode, first_event, first_error); g_hash_table_remove(state->valtable, GINT_TO_POINTER(sequence_number)); } @@ -4883,8 +5125,12 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, state->keycodes_per_modifier); break; - default: + case UNKNOWN_OPCODE: REPLYCONTENTS_COMMON(); + break; + + default: + tryExtensionReply(opcode, tvb, pinfo, offsetp, t, state, little_endian); } if ((left = tvb_reported_length_remaining(tvb, offset)) > 0) @@ -4932,12 +5178,12 @@ dissect_x11_event(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, if (check_col(pinfo->cinfo, COL_INFO)) col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s%s", sep, sent, - val_to_str(eventcode & 0x7F, eventcode_vals, + val_to_str(eventcode & 0x7F, state->eventcode_vals, "")); proto_item_append_text(ti, ", Event, eventcode: %d (%s%s)", eventcode, sent, - val_to_str(eventcode & 0x7F, eventcode_vals, + val_to_str(eventcode & 0x7F, state->eventcode_vals, "")); if (tree == NULL) @@ -4959,7 +5205,7 @@ decode_x11_event(tvbuff_t *tvb, unsigned char eventcode, const char *sent, eventcode, "eventcode: %d (%s%s)", eventcode, sent, - val_to_str(eventcode & 0x7F, eventcode_vals, + val_to_str(eventcode & 0x7F, state->eventcode_vals, "")); ++offset; @@ -5248,6 +5494,7 @@ decode_x11_event(tvbuff_t *tvb, unsigned char eventcode, const char *sent, break; default: + tryExtensionEvent(eventcode & 0x7F, tvb, offsetp, t, state, little_endian); break; } @@ -5276,18 +5523,18 @@ dissect_x11_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, errorcode = tvb_get_guint8(tvb, offset); if (check_col(pinfo->cinfo, COL_INFO)) col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", - sep, val_to_str(errorcode, errorcode_vals, "")); + sep, val_to_str(errorcode, state->errorcode_vals, "")); proto_tree_add_uint_format(t, hf_x11_errorcode, tvb, offset, 1, errorcode, "errorcode: %d (%s)", errorcode, - val_to_str(errorcode, errorcode_vals, + val_to_str(errorcode, state->errorcode_vals, "")); ++offset; proto_item_append_text(ti, ", Error, errorcode: %d (%s)", - errorcode, val_to_str(errorcode, errorcode_vals, + errorcode, val_to_str(errorcode, state->errorcode_vals, "")); if (tree == NULL) @@ -5347,6 +5594,8 @@ void proto_register_x11(void) &ett_x11_arc, &ett_x11_list_of_atom, &ett_x11_list_of_card32, + &ett_x11_list_of_float, + &ett_x11_list_of_double, &ett_x11_list_of_color_item, &ett_x11_color_item, &ett_x11_list_of_keycode, @@ -5383,6 +5632,12 @@ void proto_register_x11(void) register_init_routine(x11_init_protocol); + extension_table = g_hash_table_new(g_str_hash, g_str_equal); + error_table = g_hash_table_new(g_str_hash, g_str_equal); + event_table = g_hash_table_new(g_str_hash, g_str_equal); + reply_table = g_hash_table_new(g_str_hash, g_str_equal); + register_x11_extensions(); + x11_module = prefs_register_protocol(proto_x11, NULL); prefs_register_bool_preference(x11_module, "desegment", "Reassemble X11 messages spanning multiple TCP segments", diff --git a/epan/dissectors/process-x11-fields.pl b/epan/dissectors/process-x11-fields.pl index b1c21cb2a3..e444858338 100755 --- a/epan/dissectors/process-x11-fields.pl +++ b/epan/dissectors/process-x11-fields.pl @@ -4,7 +4,7 @@ # X11 dissector, into header files declaring field-index # values and field definitions for those fields. # -# Copyright 2000, Christophe Tronche +# Copyright 2000, Christophe Tronche # # $Id$ # @@ -30,9 +30,47 @@ open(DECL, ">x11-declarations.h") || die; open(REG, ">x11-register-info.h") || die; -$comment = "/* This file is generated by $0, do not edit. */\n\n"; -print DECL $comment; -print REG $comment; +sub add_generated_header { + my ($out) = @_; + + print $out < + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +eot + ; +} + +add_generated_header(DECL); +add_generated_header(REG); $prefix = ''; $subfieldStringLength = 0; diff --git a/epan/dissectors/process-x11-xcb.pl b/epan/dissectors/process-x11-xcb.pl new file mode 100755 index 0000000000..c4133c3dc9 --- /dev/null +++ b/epan/dissectors/process-x11-xcb.pl @@ -0,0 +1,1217 @@ +#!/usr/bin/perl +# +# Script to convert xcbproto and mesa protocol files for +# X11 dissector. Creates header files containing code to +# dissect X11 extensions. +# +# Copyright 2008, 2009 Open Text Corporation +# +# $Id$ +# +# Wireshark - Network traffic analyzer +# By Gerald Combs +# Copyright 1998 Gerald Combs +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# + +#TODO +# - look ahead to see if values are ever used again before creating an "int" in the output +# - support constructs that are legal in XCB, but don't appear to be used + +use 5.010; + +use warnings; +use strict; + +use IO::File; +use XML::Twig; + +use File::Spec; + +my @reslist = grep {!/xproto\.xml$/} glob File::Spec->catfile('xcbproto', 'src', '*.xml'); +my @register; + +my %basictype = ( + char => { size => 1, type => 'FT_STRING', base => 'BASE_NONE', get => 'VALUE8', list => 'listOfByte', }, + void => { size => 1, type => 'FT_BYTES', base => 'BASE_NONE', get => 'VALUE8', list => 'listOfByte', }, + BYTE => { size => 1, type => 'FT_BYTES', base => 'BASE_NONE', get => 'VALUE8', list => 'listOfByte', }, + CARD8 => { size => 1, type => 'FT_BYTES', base => 'BASE_NONE', get => 'VALUE8', list => 'listOfByte', }, + CARD16 => { size => 2, type => 'FT_UINT16', base => 'BASE_HEX_DEC', get => 'VALUE16', list => 'listOfCard16', }, + CARD32 => { size => 4, type => 'FT_UINT32', base => 'BASE_HEX_DEC', get => 'VALUE32', list => 'listOfCard32', }, + INT8 => { size => 1, type => 'FT_BYTES', base => 'BASE_NONE', get => 'VALUE8', list => 'listOfByte', }, + INT16 => { size => 2, type => 'FT_INT16', base => 'BASE_DEC', get => 'VALUE16', list => 'listOfInt16', }, + INT32 => { size => 4, type => 'FT_INT32', base => 'BASE_DEC', get => 'VALUE32', list => 'listOfInt32', }, + float => { size => 4, type => 'FT_FLOAT', base => 'BASE_NONE', get => 'FLOAT', list => 'listOfFloat', }, + double => { size => 8, type => 'FT_DOUBLE', base => 'BASE_NONE', get => 'DOUBLE', list => 'listOfDouble', }, + BOOL => { size => 1, type => 'FT_BOOLEAN',base => 'BASE_NONE', get => 'VALUE8', list => 'listOfByte', }, +); + +my %simpletype; # Reset at the beginning of each extension +my %gltype; # No need to reset, since it's only used once + +my %struct = # Not reset; contains structures already defined. + # Also contains this black-list of structures never used by any + # extension (to avoid generating useless code). +( + # structures defined by xproto, but not used by any extension + CHAR2B => 1, + POINT => 1, + ARC => 1, + FORMAT => 1, + VISUALTYPE => 1, + DEPTH => 1, + SCREEN => 1, + SetupRequest => 1, + SetupFailed => 1, + SetupAuthenticate => 1, + Setup => 1, + TIMECOORD => 1, + FONTPROP => 1, + CHARINFO => 1, + SEGMENT => 1, + COLORITEM => 1, + RGB => 1, + HOST => 1, + + # structures defined by xinput, but never used (except by each other)(bug in xcb?) + InputInfo => 1, + KeyInfo => 1, + ButtonInfo => 1, + AxisInfo => 1, + ValuatorInfo => 1, + DeviceTimeCoord => 1, + FeedbackState => 1, + KbdFeedbackState => 1, + PtrFeedbackState => 1, + IntegerFeedbackState => 1, + StringFeedbackState => 1, + BellFeedbackState => 1, + LedFeedbackState => 1, + FeedbackCtl => 1, + KbdFeedbackCtl => 1, + PtrFeedbackCtl => 1, + IntegerFeedbackCtl => 1, + StringFeedbackCtl => 1, + BellFeedbackCtl => 1, + LedFeedbackCtl => 1, + InputState => 1, + KeyState => 1, + ButtonState => 1, + ValuatorState => 1, + DeviceState => 1, + DeviceResolutionState => 1, + DeviceAbsCalibState => 1, + DeviceAbsAreaState => 1, + DeviceCoreState => 1, + DeviceEnableState => 1, + DeviceCtl => 1, + DeviceResolutionCtl => 1, + DeviceAbsCalibCtl => 1, + DeviceAbsAreaCtrl => 1, + DeviceCoreCtrl => 1, + DeviceEnableCtrl => 1, + + # structures defined by xv, but never used (bug in xcb?) + Image => 1, +); +my $header; +my $extname; +my $parentclass; +my %request; +my %event; +my %reply; + +# Output files +my $impl; +my $reg; +my $decl; +my $error; + +# glRender sub-op output files +my $enum; + + +sub mesa_category_start { + my ($t, $elt) = @_; + my $name = $elt->att('name'); + my $comment; + if ($name =~ /^\d\.\d$/) { + $comment = "version $name"; + } else { + $comment = "extension $name"; + } + + print $enum "/* OpenGL $comment */\n"; + print(" - $comment\n"); +} + +sub mesa_category { + my ($t, $elt) = @_; + $t->purge; +} + +sub mesa_enum { + my ($t, $elt) = @_; + my $name = $elt->att('name'); + my $value = $elt->att('value'); + + print $enum " { $value, \"$name\" },\n" if (length($value) > 3 && length($value) < 10); + $t->purge; +} + +sub mesa_type { + my ($t, $elt) = @_; + + my $name = $elt->att('name'); + my $size = $elt->att('size'); + my $float = $elt->att('float'); + my $unsigned = $elt->att('unsigned'); + my $base; + + $t->purge; + + if($name eq 'enum') { + # enum does not have a direct X equivalent + $gltype{'GLenum'} = { size => 4, type => 'FT_UINT32', base => 'BASE_HEX', + get => 'VALUE32', list => 'listOfCard32', + val => 'VALS(mesa_enum)', }; + return; + } + + $name = 'GL'.$name; + if (defined($float) && $float eq 'true') { + $base = 'float'; + $base = 'double' if ($size == 8); + } else { + $base = 'INT'; + if (defined($unsigned) && $unsigned eq 'true') { + $base = 'CARD'; + } + $base .= ($size * 8); + + $base = 'BOOL' if ($name eq 'bool'); + $base = 'BYTE' if ($name eq 'void'); + } + + $gltype{$name} = $basictype{$base}; +} + +sub registered_name($$) +{ + my $name = shift; + my $field = shift; + + return "hf_x11_$header"."_$name"."_$field"; +} + +sub mesa_function { + my ($t, $elt) = @_; + # rop == glRender sub-op + # sop == GLX minor opcode + my $glx = $elt->first_child('glx'); + unless(defined $glx) { $t->purge; return; } + + my $rop = $glx->att('rop'); + unless (defined $rop) { $t->purge; return; } + + # Ideally, we want the main name, not the alias name. + # Practically, we'd have to scan the file twice to find + # the functions that we want to skip. + my $alias = $elt->att('alias'); + if (defined $alias) { $t->purge; return; } + + my $name = $elt->att('name'); + $request{$rop} = $name; + + my $image; + + my $length = 0; + my @elements = $elt->children('param'); + + # Wireshark defines _U_ to mean "Unused" (compiler specific define) + if (!@elements) { + print $impl <att('type'); + $type =~ s/^const //; + my $list; + $list = 1 if ($type =~ /\*$/); + $type =~ s/ \*$//; + + my $fieldname = $e->att('name'); + my $regname = registered_name($name, $fieldname); + + my $info = $gltype{$type}; + my $ft = $info->{'type'}; + my $base = $info->{'base'}; + my $val = $info->{'val'} // 'NULL'; + + print $decl "static int $regname = -1;\n"; + if ($list and $info->{'size'} > 1) { + print $reg "{ &$regname, { \"$fieldname\", \"x11.glx.render.$name.$fieldname\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n"; + $regname .= '_item'; + print $decl "static int $regname = -1;\n"; + } + print $reg "{ &$regname, { \"$fieldname\", \"x11.glx.render.$name.$fieldname\", $ft, $base, $val, 0, NULL, HFILL }},\n"; + + if ($e->att('counter')) { + print $impl " int $fieldname;\n"; + } + + if ($list) { + if ($e->att('img_format')) { + $image = 1; + foreach my $wholename (('swap bytes', 'lsb first')) { + # Boolean values + my $varname = $wholename; + $varname =~ s/\s//g; + my $regname = registered_name($name, $varname); + print $decl "static int $regname = -1;\n"; + print $reg "{ &$regname, { \"$wholename\", \"x11.glx.render.$name.$varname\", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }},\n"; + } + foreach my $wholename (('row length', 'skip rows', 'skip pixels', 'alignment')) { + # Integer values + my $varname = $wholename; + $varname =~ s/\s//g; + my $regname = registered_name($name, $varname); + print $decl "static int $regname = -1;\n"; + print $reg "{ &$regname, { \"$wholename\", \"x11.glx.render.$name.$varname\", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }},\n"; + } + } + } + } + + # The image requests have a few implicit elements first: + if ($image) { + foreach my $wholename (('swap bytes', 'lsb first')) { + # Boolean values + my $varname = $wholename; + $varname =~ s/\s//g; + my $regname = registered_name($name, $varname); + print $impl " proto_tree_add_item(t, $regname, tvb, *offsetp, 1, little_endian);\n"; + print $impl " *offsetp += 1;\n"; + $length += 1; + } + print $impl " UNUSED(2);\n"; + $length += 2; + foreach my $wholename (('row length', 'skip rows', 'skip pixels', 'alignment')) { + # Integer values + my $varname = $wholename; + $varname =~ s/\s//g; + my $regname = registered_name($name, $varname); + print $impl " proto_tree_add_item(t, $regname, tvb, *offsetp, 4, little_endian);\n"; + print $impl " *offsetp += 4;\n"; + $length += 4; + } + } + + foreach my $e (@elements) { + my $type = $e->att('type'); + $type =~ s/^const //; + my $list; + $list = 1 if ($type =~ /\*$/); + $type =~ s/ \*$//; + + my $fieldname = $e->att('name'); + my $regname = registered_name($name, $fieldname); + + my $info = $gltype{$type}; + my $ft = $info->{'type'}; + my $base = $info->{'base'}; + + if (!$list) { + my $size = $info->{'size'}; + my $get = $info->{'get'}; + + if ($e->att('counter')) { + print $impl " $fieldname = $get(tvb, *offsetp);\n"; + } + print $impl " proto_tree_add_item(t, $regname, tvb, *offsetp, $size, little_endian);\n"; + print $impl " *offsetp += $size;\n"; + $length += $size; + } else { # list + # TODO: variable_param + my $list = $info->{'list'}; + my $count = $e->att('count'); + my $variable_param = $e->att('variable_param'); + + $regname .= ", $regname".'_item' if ($info->{'size'} > 1); + if (defined($count) && !defined($variable_param)) { + print $impl " $list(tvb, offsetp, t, $regname, $count, little_endian);\n"; + } else { + print $impl " $list(tvb, offsetp, t, $regname, (length - $length) / $gltype{$type}{'size'}, little_endian);\n"; + } + } + } + + print $impl "}\n\n"; + $t->purge; +} + +sub get_ref($$) +{ + my $elt = shift; + my $refref = shift; + my $rv; + + given($elt->name()) { + when ('fieldref') { + $rv = $elt->text(); + $refref->{$rv} = 1; + $rv = 'f_'.$rv; + } + when ('value') { $rv = $elt->text(); } + when ('op') { $rv = get_op($elt, $refref); } + default { die "Invalid op fragment: $_" } + } + return $rv; +} + +sub get_op($;$) { + my $op = shift; + my $refref = shift // {}; + + my @elements = $op->children(qr/fieldref|value|op/); + (@elements == 2) or die ("Wrong number of children for 'op'\n"); + my $left; + my $right; + + $left = get_ref($elements[0], $refref); + $right = get_ref($elements[1], $refref); + + return "($left " . $op->att('op') . " $right)"; +} + +sub register_element($$$;$) +{ + my $e = shift; + my $varpat = shift; + my $humanpat = shift; + my $indent = shift // ' ' x 4; + + return if ($e->name() eq 'pad'); + + # Register field with wireshark + + my $fieldname = $e->att('name'); + my $type = $e->att('type'); + $type =~ s/^.*://; + + my $regname = 'hf_x11_'.sprintf ($varpat, $fieldname); + my $humanname = 'x11.'.sprintf ($humanpat, $fieldname); + + my $info = $basictype{$type} // $simpletype{$type} // $struct{$type}; + my $ft = $info->{'type'} // 'FT_NONE'; + my $base = $info->{'base'} // 'BASE_NONE'; + + print $decl "static int $regname = -1;\n"; + if ($e->name() eq 'list' and $info->{'size'} > 1) { + print $reg "{ &$regname, { \"$fieldname\", \"$humanname\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n"; + $regname .= '_item'; + print $decl "static int $regname = -1;\n"; + } + print $reg "{ &$regname, { \"$fieldname\", \"$humanname\", $ft, $base, NULL, 0, NULL, HFILL }},\n"; + + if ($e->name() eq 'field') { + if ($basictype{$type} or $simpletype{$type}) { + # Pre-declare variable + print $impl $indent."int f_$fieldname;\n"; + } + } +} + +sub dissect_element($$$;$$) +{ + my $e = shift; + my $varpat = shift; + my $length = shift; + my $adjustlength = shift; + my $indent = shift // ' ' x 4; + + if ($e->name() eq 'pad') { + my $bytes = $e->att('bytes'); + print $impl $indent."UNUSED($bytes);\n"; + $length += $bytes; + } elsif ($e->name() eq 'field') { + my $fieldname = $e->att('name'); + my $regname = 'hf_x11_'.sprintf ($varpat, $fieldname); + my $type = $e->att('type'); + $type =~ s/^.*://; + + if ($basictype{$type} or $simpletype{$type}) { + my $info = $basictype{$type} // $simpletype{$type}; + my $size = $info->{'size'}; + my $get = $info->{'get'}; + + print $impl $indent."f_$fieldname = $get(tvb, *offsetp);\n"; + print $impl $indent."proto_tree_add_item(t, $regname, tvb, *offsetp, $size, little_endian);\n"; + print $impl $indent."*offsetp += $size;\n"; + $length += $size; + } elsif ($struct{$type}) { + # TODO: variable-lengths (when $info->{'size'} == 0 ) + my $info = $struct{$type}; + $length += $info->{'size'}; + print $impl $indent."struct_$type(tvb, offsetp, t, little_endian, 1);\n"; + } else { + die ("Unrecognized type: $type\n"); + } + } else { # list + my $fieldname = $e->att('name'); + my $regname = 'hf_x11_'.sprintf ($varpat, $fieldname); + my $type = $e->att('type'); + $type =~ s/^.*://; + + my $info = $basictype{$type} // $simpletype{$type} // $struct{$type}; + my $lencalc = "(length - $length) / $info->{'size'}"; + my $lentype = $e->first_child(); + if (defined $lentype) { + given ($lentype->name()) { + when ('value') { $lencalc = $lentype->text(); } + when ('fieldref') { $lencalc = 'f_'.$lentype->text(); } + when ('op') { $lencalc = get_op($lentype); } + } + } + + if ($basictype{$type} or $simpletype{$type}) { + my $list = $info->{'list'}; + $regname .= ", $regname".'_item' if ($info->{'size'} > 1); + print $impl $indent."$list(tvb, offsetp, t, $regname, $lencalc, little_endian);\n"; + } elsif ($struct{$type}) { + print $impl $indent."struct_$type(tvb, offsetp, t, little_endian, $lencalc);\n"; + } else { + die ("Unrecognized type: $type\n"); + } + + if ($adjustlength && defined($lentype)) { + # Some requests end with a list of unspecified length + # Adjust the length field here so that the next $lencalc will be accurate + say $impl $indent."length -= $lencalc * $info->{'size'};"; + } + } + return $length; +} + +sub struct { + my ($t, $elt) = @_; + my $name = $elt->att('name'); + + if (defined $struct{$name}) { + $t->purge; + return; + } + + my @elements = $elt->children(qr/pad|field|list/); + + print(" - Struct $name\n"); + + my %refs; + my $size = 0; + my $dynamic = 0; + my $needi = 0; + # Find struct size + foreach my $e (@elements) { + my $count; + $count = 1; + if ($e->name() eq 'pad') { + my $bytes = $e->att('bytes'); + $size += $bytes; + next; + } elsif ($e->name() eq 'list') { + my $type = $e->att('type'); + my $info = $basictype{$type} // $simpletype{$type} // $struct{$type}; + my $count; + + $needi = 1 if ($info->{'size'} == 0); + + if ($e->has_child('fieldref') || $e->has_child('op')) { + my $ref = $e->first_child('fieldref'); + if (defined $ref) { + $refs{$ref->text()} = 1; + } else { + get_op($e->first_child('op'), \%refs); + } + $count = 0; + $dynamic = 1; + } else { + $count = $e->first_child('value')->text(); + } + } # else 'field' + + my $type = $e->att('type'); + my $info = $basictype{$type} // $simpletype{$type} // $struct{$type}; + + $size += $info->{'size'} * $count; + } + + if ($dynamic) { + $size = 0; + print $impl <att('type') // ''; + my $info = $basictype{$type} // $simpletype{$type} // $struct{$type}; + + given ($e->name()) { + when ('pad') { + my $bytes = $e->att('bytes'); + $size += $bytes; + } + when ('list') { + my $len = $e->first_child(); + my $infosize = $info->{'size'}; + my $sizemul; + + given ($len->name()) { + when ('op') { $sizemul = get_op($len, \%refs); } + when ('fieldref') { $sizemul = 'f_'.$len->text(); } + when ('value') { + if ($infosize) { + $size += $infosize * $len->text(); + } else { + $sizemul = $len->text(); + } + } + default { die "Invalid list size: $_\n"; } + } + if (defined $sizemul) { + if ($infosize) { + say $impl " size += $sizemul * $infosize;"; + } else { + say $impl " for (i = 0; i < $sizemul; i++) {"; + say $impl " off = (*offsetp) + size + $size;"; + say $impl " size += struct_size_$type(tvb, &off, little_endian);"; + say $impl ' }'; + } + } + } + when ('field') { + my $fname = $e->att('name'); + if (defined($refs{$fname})) { + say $impl " f_$fname = $info->{'get'}(tvb, *offsetp + size + $size);"; + } + $size += $info->{'size'}; + } + } + } + say $impl " return size + $size;"; + say $impl '}'; + $size = 0; # 0 means "dynamic calcuation required" + } + + print $decl "static int hf_x11_struct_$name = -1;\n"; + print $reg "{ &hf_x11_struct_$name, { \"$name\", \"x11.struct.$name\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n"; + + print $impl < $size }; + $t->purge; +} + +sub union { + # TODO proper dissection + # + # Right now, the only extension to use a union is randr. + # for now, punt. + my ($t, $elt) = @_; + my $name = $elt->att('name'); + + if (defined $struct{$name}) { + $t->purge; + return; + } + + my @elements = $elt->children(qr/field/); + my @sizes; + + print(" - Union $name\n"); + + # Find union size + foreach my $e (@elements) { + my $type = $e->att('type'); + my $info = $basictype{$type} // $simpletype{$type} // $struct{$type}; + + $info->{'size'} > 0 or die ("Error: Union containing variable sized struct\n"); + push @sizes, $info->{'size'}; + } + @sizes = sort {$b <=> $a} @sizes; + my $size = $sizes[0]; + + print $decl "static int hf_x11_union_$name = -1;\n"; + print $reg "{ &hf_x11_union_$name, { \"$name\", \"x11.union.$name\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n"; + + print $impl < $size }; + $t->purge; +} + +sub request { + my ($t, $elt) = @_; + my $name = $elt->att('name'); + + print(" - Request $name\n"); + $request{$elt->att('opcode')} = $name; + + my $length = 4; + my @elements = $elt->children(qr/pad|field|list/); + + # Wireshark defines _U_ to mean "Unused" (compiler specific define) + if (!@elements) { + print $impl <name() eq 'list' && $name eq 'Render' && $e->att('name') eq 'data' && -e 'mesa/src/mesa/glapi/gl_API.xml') { + # Special case: Use mesa-generated dissector for 'data' + print $impl " dispatch_glx_render(tvb, pinfo, offsetp, t, little_endian, (length - $length));\n"; + } else { + $length = dissect_element($e, $varpat, $length, 1); + } + } + + say $impl '}'; + + my $reply = $elt->first_child('reply'); + if ($reply) { + $reply{$elt->att('opcode')} = $name; + + $varpat = $header.'_'.$name.'_reply_%s'; + $humanpat = "$header.$name.reply.%s"; + + @elements = $reply->children(qr/pad|field|list/); + + # Wireshark defines _U_ to mean "Unused" (compiler specific define) + if (!@elements) { + say $impl "static void $header$name"."_Reply(tvbuff_t *tvb _U_, packet_info *pinfo, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_)\n{"; + } else { + say $impl "static void $header$name"."_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian)\n{"; + } + say $impl ' int f_length, length, sequence_number;' if (@elements); + + foreach my $e (@elements) { + register_element($e, $varpat, $humanpat); + } + + say $impl ''; + say $impl ' col_append_fstr(pinfo->cinfo, COL_INFO, "-'.$name.'");'; + say $impl ''; + say $impl ' REPLY(reply);'; + + my $first = 1; + my $length = 1; + foreach my $e (@elements) { + $length = dissect_element($e, $varpat, $length); + if ($first) { + $first = 0; + say $impl ' sequence_number = VALUE16(tvb, *offsetp);'; + say $impl ' proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number,'; + say $impl ' "sequencenumber: %d ('.$header.'-'.$name.')", sequence_number);'; + say $impl ' *offsetp += 2;'; + + say $impl ' f_length = VALUE32(tvb, *offsetp);'; + say $impl ' length = f_length * 4 + 32;'; + say $impl ' proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian);'; + say $impl ' *offsetp += 4;'; + + $length += 6; + } + } + + say $impl '}'; + } + $t->purge; +} + +sub defxid(@) { + my $name; + while ($name = shift) { + $simpletype{$name} = { size => 4, type => 'FT_UINT32', base => 'BASE_HEX', get => 'VALUE32', list => 'listOfCard32', }; + } +} + +sub xidtype { + my ($t, $elt) = @_; + my $name = $elt->att('name'); + + defxid($name); + + $t->purge; +} + +sub typedef { + my ($t, $elt) = @_; + my $oldname = $elt->att('oldname'); + my $newname = $elt->att('newname'); + + # Duplicate the type + my $info = $basictype{$oldname} // $simpletype{$oldname}; + $simpletype{$newname} = $info; + + $t->purge; +} + +sub error { + my ($t, $elt) = @_; + + my $number = $elt->att('number'); + if ($number >= 0) { + my $name = $elt->att('name'); + print $error " \"$header-$name\",\n"; + } + + $t->purge; +} + +sub event { + my ($t, $elt) = @_; + + my $number = $elt->att('number'); + my $name = $elt->att('name'); + + $event{$elt->att('number')} = $name; + + my $length = 1; + my @elements = $elt->children(qr/pad|field|list/); + + # Wireshark defines _U_ to mean "Unused" (compiler specific define) + if (!@elements) { + print $impl <purge; +} + +sub include +{ + my ($t, $elt) = @_; + my $include = $elt->text(); + + print " - Import $include\n"; + my $xml = XML::Twig->new( + twig_roots => { + 'import' => \&include, + 'struct' => \&struct, + 'xidtype' => \&xidtype, + 'xidunion' => \&xidtype, + 'typedef' => \&typedef, + }); + $xml->parsefile("xcbproto/src/$include.xml") or die ("Cannot open $include.xml\n"); + + $t->purge; +} + + +sub xcb_start { + my ($t, $elt) = @_; + $header = $elt->att('header'); + $extname = ($elt->att('extension-name') or $header); + + print("Extension $extname\n"); + + $parentclass = 'XProto'; + undef %request; + undef %event; + undef %reply; + + %simpletype = (); + + print $error "const char *$header"."_errors[] = {\n"; +} + +sub xcb { + my ($t, $elt) = @_; + + my $xextname = $elt->att('extension-xname'); + my $lookup_name = $header . "_extension_minor"; + my $error_name = $header . "_errors"; + my $event_name = $header . "_events"; + my $reply_name = $header . "_replies"; + + print $decl "static int hf_x11_$lookup_name = -1;\n\n"; + + print $impl "static const value_string $lookup_name"."[] = {\n"; + foreach my $req (sort {$a <=> $b} keys %request) { + print $impl " { $req, \"$request{$req}\" },\n"; + } + print $impl " { 0, NULL }\n"; + print $impl "};\n"; + + say $impl "const x11_event_info $event_name".'[] = {'; + foreach my $e (sort {$a <=> $b} keys %event) { + say $impl " { \"$header-$event{$e}\", $header$event{$e} },"; + } + say $impl ' { NULL, NULL }'; + say $impl '};'; + + print $impl "static x11_reply_info $reply_name"."[] = {\n"; + foreach my $e (sort {$a <=> $b} keys %reply) { + print $impl " { $e, $header$reply{$e}_Reply },\n"; + } + print $impl " { 0, NULL }\n"; + print $impl "};\n"; + + print $reg "{ &hf_x11_$lookup_name, { \"extension-minor\", \"x11.extension-minor\", FT_UINT8, BASE_DEC, VALS($lookup_name), 0, \"minor opcode\", HFILL }},\n\n"; + + print $impl <cinfo, COL_INFO, "-%s", + val_to_str(minor, $lookup_name, + "")); + switch (minor) { +eot + ; + + foreach my $req (sort {$a <=> $b} keys %request) { + print $impl " case $req:\n"; + print $impl "\t$header$request{$req}(tvb, pinfo, offsetp, t, little_endian, length);\n"; + print $impl "\tbreak;\n"; + } + say $impl " /* No need for a default case here, since Unknown is printed above,"; + say $impl " and UNDECODED() is taken care of by dissect_x11_request */"; + print $impl " }\n}\n"; + print $impl < + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +eot + ; +} + +# initialize core X11 protocol +system('./process-x11-fields.pl < x11-fields'); + +# Extension implementation +$impl = new IO::File '> x11-extension-implementation.h' + or die ("Cannot open x11-extension-implementation.h for writing\n"); +$error = new IO::File '> x11-extension-errors.h' + or die ("Cannot open x11-extension-errors.h for writing\n"); + +add_generated_header($impl); +add_generated_header($error); + +# Open the files generated by process-x11-fields.pl for appending +$reg = new IO::File '>> x11-register-info.h' + or die ("Cannot open x11-register-info.h for appending\n"); +$decl = new IO::File '>> x11-declarations.h' + or die ("Cannot open x11-declarations.h for appending\n"); + +print $reg "\n/* Generated by $0 below this line */\n"; +print $decl "\n/* Generated by $0 below this line */\n"; + +# Mesa for glRender +if (-e 'mesa/src/mesa/glapi/gl_API.xml') { + $enum = new IO::File '> x11-glx-render-enum.h' + or die ("Cannot open x11-glx-render-enum.h for writing\n"); + add_generated_header($enum); + print $enum "static const value_string mesa_enum[] = {\n"; + print $impl '#include "x11-glx-render-enum.h"'."\n\n"; + + print("Mesa glRender:\n"); + $header = "glx_render"; + + my $xml = XML::Twig->new( + start_tag_handlers => { + 'category' => \&mesa_category_start, + }, + twig_roots => { + 'category' => \&mesa_category, + 'enum' => \&mesa_enum, + 'type' => \&mesa_type, + 'function' => \&mesa_function, + }); + $xml->parsefile('mesa/src/mesa/glapi/gl_API.xml') or die ("Cannot open gl_API\n"); + + print $enum " { 0, NULL }\n"; + print $enum "};\n"; + $enum->close(); + + print $decl "static int hf_x11_glx_render_op_name = -1;\n\n"; + + print $impl "static const value_string glx_render_op_name"."[] = {\n"; + foreach my $req (sort {$a <=> $b} keys %request) { + print $impl " { $req, \"gl$request{$req}\" },\n"; + } + print $impl " { 0, NULL }\n"; + print $impl "};\n"; + + print $reg "{ &hf_x11_glx_render_op_name, { \"render op\", \"x11.glx.render.op\", FT_UINT16, BASE_DEC, VALS(glx_render_op_name), 0, \"render op\", HFILL }},\n\n"; + +# Uses ett_x11_list_of_rectangle, since I am unable to see how the subtree type matters. + print $impl <= 4) { + guint32 op, len; + int next; + proto_item *ti; + proto_tree *tt; + + len = VALUE16(tvb, *offsetp); + + op = VALUE16(tvb, *offsetp + 2); + ti = proto_tree_add_uint(t, hf_x11_glx_render_op_name, tvb, *offsetp, len, op); + + tt = proto_item_add_subtree(ti, ett_x11_list_of_rectangle); + + ti = proto_tree_add_item(tt, hf_x11_request_length, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + proto_tree_add_item(tt, hf_x11_glx_render_op_name, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + + if (len < 4) { + expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR, "Invalid Length"); + /* Eat the rest of the packet, mark it undecoded */ + len = length; + op = -1; + } + len -= 4; + + next = *offsetp + len; + + switch (op) { +eot + ; + foreach my $req (sort {$a <=> $b} keys %request) { + print $impl "\tcase $req:\n"; + print $impl "\t mesa_$request{$req}(tvb, offsetp, tt, little_endian, len);\n"; + print $impl "\t break;\n"; + } + print $impl "\tdefault:\n"; + print $impl "\t proto_tree_add_item(tt, hf_x11_undecoded, tvb, *offsetp, len, little_endian);\n"; + print $impl "\t *offsetp += len;\n"; + + print $impl "\t}\n"; + print $impl "\tif (*offsetp < next) {\n"; + print $impl "\t proto_tree_add_item(tt, hf_x11_unused, tvb, *offsetp, next - *offsetp, little_endian);\n"; + print $impl "\t *offsetp = next;\n"; + print $impl "\t}\n"; + print $impl "\tlength -= (len + 4);\n"; + print $impl " }\n}\n"; +} + +# XCB +foreach my $ext (@reslist) { + my $xml = XML::Twig->new( + start_tag_handlers => { + 'xcb' => \&xcb_start, + }, + twig_roots => { + 'xcb' => \&xcb, + 'import' => \&include, + 'request' => \&request, + 'struct' => \&struct, + 'union' => \&union, + 'xidtype' => \&xidtype, + 'xidunion' => \&xidtype, + 'typedef' => \&typedef, + 'error' => \&error, + 'errorcopy' => \&error, + 'event' => \&event, + }); + $xml->parsefile($ext) or die ("Cannot open $ext\n"); +} + +print $impl "static void register_x11_extensions(void)\n{\n"; +foreach my $reg (@register) { + print $impl " register_$reg();\n"; +} +print $impl "}\n"; diff --git a/epan/dissectors/x11-declarations.h b/epan/dissectors/x11-declarations.h new file mode 100644 index 0000000000..2240b4ea4f --- /dev/null +++ b/epan/dissectors/x11-declarations.h @@ -0,0 +1,4118 @@ +/* Do not modify this file. */ +/* It was automatically generated by ./process-x11-fields.pl. */ +/* $Id$ */ + +/* + * Copyright 2000, Christophe Tronche + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +static int hf_x11_above_sibling = -1; +static int hf_x11_acceleration_denominator = -1; +static int hf_x11_acceleration_numerator = -1; +static int hf_x11_access_mode = -1; +static int hf_x11_address = -1; +static int hf_x11_ip_address = -1; +static int hf_x11_address_length = -1; +static int hf_x11_alloc = -1; +static int hf_x11_allow_events_mode = -1; +static int hf_x11_allow_exposures = -1; +static int hf_x11_arcs = -1; +static int hf_x11_arc = -1; +static int hf_x11_arc_x = -1; +static int hf_x11_arc_y = -1; +static int hf_x11_arc_width = -1; +static int hf_x11_arc_height = -1; +static int hf_x11_arc_angle1 = -1; +static int hf_x11_arc_angle2 = -1; +static int hf_x11_arc_mode = -1; +static int hf_x11_atom = -1; +static int hf_x11_authorization_protocol_name_length = -1; +static int hf_x11_authorization_protocol_name = -1; +static int hf_x11_authorization_protocol_data_length = -1; +static int hf_x11_authorization_protocol_data = -1; +static int hf_x11_auto_repeat_mode = -1; +static int hf_x11_bitmap_format_bit_order = -1; +static int hf_x11_bitmap_format_scanline_pad = -1; +static int hf_x11_bitmap_format_scanline_unit = -1; +static int hf_x11_bytes_after = -1; +static int hf_x11_back_blue = -1; +static int hf_x11_back_green = -1; +static int hf_x11_back_red = -1; +static int hf_x11_background = -1; +static int hf_x11_background_pixel = -1; +static int hf_x11_background_pixmap = -1; +static int hf_x11_backing_pixel = -1; +static int hf_x11_backing_planes = -1; +static int hf_x11_backing_store = -1; +static int hf_x11_bell_duration = -1; +static int hf_x11_bell_percent = -1; +static int hf_x11_bell_pitch = -1; +static int hf_x11_bit_gravity = -1; +static int hf_x11_bit_plane = -1; +static int hf_x11_blue = -1; +static int hf_x11_blues = -1; +static int hf_x11_border_pixel = -1; +static int hf_x11_border_pixmap = -1; +static int hf_x11_border_width = -1; +static int hf_x11_button = -1; +static int hf_x11_byte_order = -1; +static int hf_x11_childwindow = -1; +static int hf_x11_cap_style = -1; +static int hf_x11_change_host_mode = -1; +static int hf_x11_cid = -1; +static int hf_x11_class = -1; +static int hf_x11_clip_mask = -1; +static int hf_x11_clip_x_origin = -1; +static int hf_x11_clip_y_origin = -1; +static int hf_x11_close_down_mode = -1; +static int hf_x11_cmap = -1; +static int hf_x11_colormap = -1; +static int hf_x11_colormap_state = -1; +static int hf_x11_color_items = -1; +static int hf_x11_coloritem = -1; +static int hf_x11_coloritem_pixel = -1; +static int hf_x11_coloritem_red = -1; +static int hf_x11_coloritem_green = -1; +static int hf_x11_coloritem_blue = -1; +static int hf_x11_coloritem_flags = -1; +static int hf_x11_coloritem_flags_do_red = -1; +static int hf_x11_coloritem_flags_do_green = -1; +static int hf_x11_coloritem_flags_do_blue = -1; +static int hf_x11_coloritem_flags_unused = -1; +static int hf_x11_coloritem_unused = -1; +static int hf_x11_colors = -1; +static int hf_x11_configure_window_mask = -1; +static int hf_x11_configure_window_mask_x = -1; +static int hf_x11_configure_window_mask_y = -1; +static int hf_x11_configure_window_mask_width = -1; +static int hf_x11_configure_window_mask_height = -1; +static int hf_x11_configure_window_mask_border_width = -1; +static int hf_x11_configure_window_mask_sibling = -1; +static int hf_x11_configure_window_mask_stack_mode = -1; +static int hf_x11_confine_to = -1; +static int hf_x11_contiguous = -1; +static int hf_x11_coordinate_mode = -1; +static int hf_x11_count = -1; +static int hf_x11_cursor = -1; +static int hf_x11_dash_offset = -1; +static int hf_x11_dashes = -1; +static int hf_x11_dashes_length = -1; +static int hf_x11_do_acceleration = -1; +static int hf_x11_do_threshold = -1; +static int hf_x11_detail = -1; +static int hf_x11_do_not_propagate_mask = -1; +static int hf_x11_do_not_propagate_mask_KeyPress = -1; +static int hf_x11_do_not_propagate_mask_KeyRelease = -1; +static int hf_x11_do_not_propagate_mask_ButtonPress = -1; +static int hf_x11_do_not_propagate_mask_ButtonRelease = -1; +static int hf_x11_do_not_propagate_mask_PointerMotion = -1; +static int hf_x11_do_not_propagate_mask_Button1Motion = -1; +static int hf_x11_do_not_propagate_mask_Button2Motion = -1; +static int hf_x11_do_not_propagate_mask_Button3Motion = -1; +static int hf_x11_do_not_propagate_mask_Button4Motion = -1; +static int hf_x11_do_not_propagate_mask_Button5Motion = -1; +static int hf_x11_do_not_propagate_mask_ButtonMotion = -1; +static int hf_x11_do_not_propagate_mask_erroneous_bits = -1; +static int hf_x11_event_sequencenumber = -1; +static int hf_x11_error = -1; +static int hf_x11_error_badvalue = -1; +static int hf_x11_error_sequencenumber = -1; +static int hf_x11_errorcode = -1; +static int hf_x11_event_x = -1; +static int hf_x11_event_y = -1; +static int hf_x11_eventbutton = -1; +static int hf_x11_eventcode = -1; +static int hf_x11_eventwindow = -1; +static int hf_x11_first_event = -1; +static int hf_x11_first_error = -1; +static int hf_x11_gc_dashes = -1; +static int hf_x11_gc_value_mask = -1; +static int hf_x11_gc_value_mask_function = -1; +static int hf_x11_gc_value_mask_plane_mask = -1; +static int hf_x11_gc_value_mask_foreground = -1; +static int hf_x11_gc_value_mask_background = -1; +static int hf_x11_gc_value_mask_line_width = -1; +static int hf_x11_gc_value_mask_line_style = -1; +static int hf_x11_gc_value_mask_cap_style = -1; +static int hf_x11_gc_value_mask_join_style = -1; +static int hf_x11_gc_value_mask_fill_style = -1; +static int hf_x11_gc_value_mask_fill_rule = -1; +static int hf_x11_gc_value_mask_tile = -1; +static int hf_x11_gc_value_mask_stipple = -1; +static int hf_x11_gc_value_mask_tile_stipple_x_origin = -1; +static int hf_x11_gc_value_mask_tile_stipple_y_origin = -1; +static int hf_x11_gc_value_mask_font = -1; +static int hf_x11_gc_value_mask_subwindow_mode = -1; +static int hf_x11_gc_value_mask_graphics_exposures = -1; +static int hf_x11_gc_value_mask_clip_x_origin = -1; +static int hf_x11_gc_value_mask_clip_y_origin = -1; +static int hf_x11_gc_value_mask_clip_mask = -1; +static int hf_x11_gc_value_mask_dash_offset = -1; +static int hf_x11_gc_value_mask_gc_dashes = -1; +static int hf_x11_gc_value_mask_arc_mode = -1; +static int hf_x11_green = -1; +static int hf_x11_greens = -1; +static int hf_x11_data = -1; +static int hf_x11_data_length = -1; +static int hf_x11_delete = -1; +static int hf_x11_delta = -1; +static int hf_x11_depth = -1; +static int hf_x11_destination = -1; +static int hf_x11_direction = -1; +static int hf_x11_drawable = -1; +static int hf_x11_dst_drawable = -1; +static int hf_x11_dst_gc = -1; +static int hf_x11_dst_window = -1; +static int hf_x11_dst_x = -1; +static int hf_x11_dst_y = -1; +static int hf_x11_event_detail = -1; +static int hf_x11_event_mask = -1; +static int hf_x11_event_mask_KeyPress = -1; +static int hf_x11_event_mask_KeyRelease = -1; +static int hf_x11_event_mask_ButtonPress = -1; +static int hf_x11_event_mask_ButtonRelease = -1; +static int hf_x11_event_mask_EnterWindow = -1; +static int hf_x11_event_mask_LeaveWindow = -1; +static int hf_x11_event_mask_PointerMotion = -1; +static int hf_x11_event_mask_PointerMotionHint = -1; +static int hf_x11_event_mask_Button1Motion = -1; +static int hf_x11_event_mask_Button2Motion = -1; +static int hf_x11_event_mask_Button3Motion = -1; +static int hf_x11_event_mask_Button4Motion = -1; +static int hf_x11_event_mask_Button5Motion = -1; +static int hf_x11_event_mask_ButtonMotion = -1; +static int hf_x11_event_mask_KeymapState = -1; +static int hf_x11_event_mask_Exposure = -1; +static int hf_x11_event_mask_VisibilityChange = -1; +static int hf_x11_event_mask_StructureNotify = -1; +static int hf_x11_event_mask_ResizeRedirect = -1; +static int hf_x11_event_mask_SubstructureNotify = -1; +static int hf_x11_event_mask_SubstructureRedirect = -1; +static int hf_x11_event_mask_FocusChange = -1; +static int hf_x11_event_mask_PropertyChange = -1; +static int hf_x11_event_mask_ColormapChange = -1; +static int hf_x11_event_mask_OwnerGrabButton = -1; +static int hf_x11_event_mask_erroneous_bits = -1; +static int hf_x11_exact_blue = -1; +static int hf_x11_exact_green = -1; +static int hf_x11_exact_red = -1; +static int hf_x11_exposures = -1; +static int hf_x11_family = -1; +static int hf_x11_fid = -1; +static int hf_x11_fill_rule = -1; +static int hf_x11_fill_style = -1; +static int hf_x11_first_keycode = -1; +static int hf_x11_focus = -1; +static int hf_x11_focus_detail = -1; +static int hf_x11_focus_mode = -1; +static int hf_x11_font = -1; +static int hf_x11_fore_blue = -1; +static int hf_x11_fore_green = -1; +static int hf_x11_fore_red = -1; +static int hf_x11_foreground = -1; +static int hf_x11_format = -1; +static int hf_x11_from_configure = -1; +static int hf_x11_function = -1; +static int hf_x11_gc = -1; +static int hf_x11_get_property_type = -1; +static int hf_x11_grab_mode = -1; +static int hf_x11_grab_status = -1; +static int hf_x11_grab_window = -1; +static int hf_x11_graphics_exposures = -1; +static int hf_x11_height = -1; +static int hf_x11_image_byte_order = -1; +static int hf_x11_initial_connection = -1; +static int hf_x11_image_format = -1; +static int hf_x11_image_pixmap_format = -1; +static int hf_x11_interval = -1; +static int hf_x11_items = -1; +static int hf_x11_join_style = -1; +static int hf_x11_key = -1; +static int hf_x11_key_click_percent = -1; +static int hf_x11_keyboard_key = -1; +static int hf_x11_keyboard_mode = -1; +static int hf_x11_keybut_mask_erroneous_bits = -1; +static int hf_x11_keycode = -1; +static int hf_x11_keyboard_value_mask = -1; +static int hf_x11_keyboard_value_mask_key_click_percent = -1; +static int hf_x11_keyboard_value_mask_bell_percent = -1; +static int hf_x11_keyboard_value_mask_bell_pitch = -1; +static int hf_x11_keyboard_value_mask_bell_duration = -1; +static int hf_x11_keyboard_value_mask_led = -1; +static int hf_x11_keyboard_value_mask_led_mode = -1; +static int hf_x11_keyboard_value_mask_keyboard_key = -1; +static int hf_x11_keyboard_value_mask_auto_repeat_mode = -1; +static int hf_x11_keycode_count = -1; +static int hf_x11_keycodes = -1; +static int hf_x11_keycodes_item = -1; +static int hf_x11_keycodes_per_modifier = -1; +static int hf_x11_keys = -1; +static int hf_x11_keysyms = -1; +static int hf_x11_keysyms_item = -1; +static int hf_x11_keysyms_item_keysym = -1; +static int hf_x11_keysyms_per_keycode = -1; +static int hf_x11_length_of_reason = -1; +static int hf_x11_length_of_vendor = -1; +static int hf_x11_led = -1; +static int hf_x11_led_mode = -1; +static int hf_x11_left_pad = -1; +static int hf_x11_line_style = -1; +static int hf_x11_line_width = -1; +static int hf_x11_long_length = -1; +static int hf_x11_long_offset = -1; +static int hf_x11_map = -1; +static int hf_x11_map_length = -1; +static int hf_x11_mapping_request = -1; +static int hf_x11_mask = -1; +static int hf_x11_mask_char = -1; +static int hf_x11_mask_font = -1; +static int hf_x11_max_names = -1; +static int hf_x11_mid = -1; +static int hf_x11_mode = -1; +static int hf_x11_major_opcode = -1; +static int hf_x11_max_keycode = -1; +static int hf_x11_maximum_request_length = -1; +static int hf_x11_min_keycode = -1; +static int hf_x11_minor_opcode = -1; +static int hf_x11_modifiers_mask = -1; +static int hf_x11_modifiers_mask_Shift = -1; +static int hf_x11_modifiers_mask_Lock = -1; +static int hf_x11_modifiers_mask_Control = -1; +static int hf_x11_modifiers_mask_Mod1 = -1; +static int hf_x11_modifiers_mask_Mod2 = -1; +static int hf_x11_modifiers_mask_Mod3 = -1; +static int hf_x11_modifiers_mask_Mod4 = -1; +static int hf_x11_modifiers_mask_Mod5 = -1; +static int hf_x11_modifiers_mask_Button1 = -1; +static int hf_x11_modifiers_mask_Button2 = -1; +static int hf_x11_modifiers_mask_Button3 = -1; +static int hf_x11_modifiers_mask_Button4 = -1; +static int hf_x11_modifiers_mask_Button5 = -1; +static int hf_x11_modifiers_mask_AnyModifier = -1; +static int hf_x11_modifiers_mask_erroneous_bits = -1; +static int hf_x11_motion_buffer_size = -1; +static int hf_x11_new = -1; +static int hf_x11_number_of_formats_in_pixmap_formats = -1; +static int hf_x11_number_of_screens_in_roots = -1; +static int hf_x11_name = -1; +static int hf_x11_name_length = -1; +static int hf_x11_odd_length = -1; +static int hf_x11_only_if_exists = -1; +static int hf_x11_opcode = -1; +static int hf_x11_ordering = -1; +static int hf_x11_override_redirect = -1; +static int hf_x11_owner = -1; +static int hf_x11_owner_events = -1; +static int hf_x11_parent = -1; +static int hf_x11_path = -1; +static int hf_x11_path_string = -1; +static int hf_x11_pattern = -1; +static int hf_x11_pattern_length = -1; +static int hf_x11_percent = -1; +static int hf_x11_pid = -1; +static int hf_x11_pixel = -1; +static int hf_x11_pixels = -1; +static int hf_x11_pixels_item = -1; +static int hf_x11_pixmap = -1; +static int hf_x11_place = -1; +static int hf_x11_plane_mask = -1; +static int hf_x11_planes = -1; +static int hf_x11_point = -1; +static int hf_x11_points = -1; +static int hf_x11_point_x = -1; +static int hf_x11_point_y = -1; +static int hf_x11_pointer_event_mask = -1; +static int hf_x11_pointer_event_mask_ButtonPress = -1; +static int hf_x11_pointer_event_mask_ButtonRelease = -1; +static int hf_x11_pointer_event_mask_EnterWindow = -1; +static int hf_x11_pointer_event_mask_LeaveWindow = -1; +static int hf_x11_pointer_event_mask_PointerMotion = -1; +static int hf_x11_pointer_event_mask_PointerMotionHint = -1; +static int hf_x11_pointer_event_mask_Button1Motion = -1; +static int hf_x11_pointer_event_mask_Button2Motion = -1; +static int hf_x11_pointer_event_mask_Button3Motion = -1; +static int hf_x11_pointer_event_mask_Button4Motion = -1; +static int hf_x11_pointer_event_mask_Button5Motion = -1; +static int hf_x11_pointer_event_mask_ButtonMotion = -1; +static int hf_x11_pointer_event_mask_KeymapState = -1; +static int hf_x11_pointer_event_mask_erroneous_bits = -1; +static int hf_x11_pointer_mode = -1; +static int hf_x11_prefer_blanking = -1; +static int hf_x11_present = -1; +static int hf_x11_propagate = -1; +static int hf_x11_properties = -1; +static int hf_x11_properties_item = -1; +static int hf_x11_property = -1; +static int hf_x11_property_number = -1; +static int hf_x11_property_state = -1; +static int hf_x11_protocol_major_version = -1; +static int hf_x11_protocol_minor_version = -1; +static int hf_x11_reason = -1; +static int hf_x11_rectangle_height = -1; +static int hf_x11_rectangles = -1; +static int hf_x11_rectangle = -1; +static int hf_x11_rectangle_width = -1; +static int hf_x11_rectangle_x = -1; +static int hf_x11_rectangle_y = -1; +static int hf_x11_red = -1; +static int hf_x11_reds = -1; +static int hf_x11_request = -1; +static int hf_x11_requestor = -1; +static int hf_x11_request_length = -1; +static int hf_x11_resource = -1; +static int hf_x11_revert_to = -1; +static int hf_x11_release_number = -1; +static int hf_x11_reply = -1; +static int hf_x11_reply_sequencenumber = -1; +static int hf_x11_replylength = -1; +static int hf_x11_replyopcode = -1; +static int hf_x11_resource_id_base = -1; +static int hf_x11_resource_id_mask = -1; +static int hf_x11_root_x = -1; +static int hf_x11_root_y = -1; +static int hf_x11_rootwindow = -1; +static int hf_x11_same_screen = -1; +static int hf_x11_same_screen_focus_mask = -1; +static int hf_x11_same_screen_focus_mask_focus = -1; +static int hf_x11_same_screen_focus_mask_same_screen = -1; +static int hf_x11_success = -1; +static int hf_x11_save_set_mode = -1; +static int hf_x11_save_under = -1; +static int hf_x11_screen_saver_mode = -1; +static int hf_x11_segment = -1; +static int hf_x11_segments = -1; +static int hf_x11_segment_x1 = -1; +static int hf_x11_segment_x2 = -1; +static int hf_x11_segment_y1 = -1; +static int hf_x11_segment_y2 = -1; +static int hf_x11_selection = -1; +static int hf_x11_shape = -1; +static int hf_x11_sibling = -1; +static int hf_x11_source_pixmap = -1; +static int hf_x11_source_font = -1; +static int hf_x11_source_char = -1; +static int hf_x11_src_cmap = -1; +static int hf_x11_src_drawable = -1; +static int hf_x11_src_gc = -1; +static int hf_x11_src_height = -1; +static int hf_x11_src_width = -1; +static int hf_x11_src_window = -1; +static int hf_x11_src_x = -1; +static int hf_x11_src_y = -1; +static int hf_x11_start = -1; +static int hf_x11_stack_mode = -1; +static int hf_x11_stipple = -1; +static int hf_x11_stop = -1; +static int hf_x11_str_number_in_path = -1; +static int hf_x11_string = -1; +static int hf_x11_string16 = -1; +static int hf_x11_string16_bytes = -1; +static int hf_x11_string_length = -1; +static int hf_x11_subwindow_mode = -1; +static int hf_x11_target = -1; +static int hf_x11_textitem = -1; +static int hf_x11_textitem_font = -1; +static int hf_x11_textitem_string = -1; +static int hf_x11_textitem_string_delta = -1; +static int hf_x11_textitem_string_string8 = -1; +static int hf_x11_textitem_string_string16 = -1; +static int hf_x11_textitem_string_string16_bytes = -1; +static int hf_x11_threshold = -1; +static int hf_x11_tile = -1; +static int hf_x11_tile_stipple_x_origin = -1; +static int hf_x11_tile_stipple_y_origin = -1; +static int hf_x11_time = -1; +static int hf_x11_timeout = -1; +static int hf_x11_type = -1; +static int hf_x11_undecoded = -1; +static int hf_x11_unused = -1; +static int hf_x11_valuelength = -1; +static int hf_x11_vendor = -1; +static int hf_x11_visibility_state = -1; +static int hf_x11_visual = -1; +static int hf_x11_visual_blue = -1; +static int hf_x11_visual_green = -1; +static int hf_x11_visual_red = -1; +static int hf_x11_visualid = -1; +static int hf_x11_warp_pointer_dst_window = -1; +static int hf_x11_warp_pointer_src_window = -1; +static int hf_x11_wid = -1; +static int hf_x11_width = -1; +static int hf_x11_win_gravity = -1; +static int hf_x11_win_x = -1; +static int hf_x11_win_y = -1; +static int hf_x11_window = -1; +static int hf_x11_window_class = -1; +static int hf_x11_window_value_mask = -1; +static int hf_x11_window_value_mask_background_pixmap = -1; +static int hf_x11_window_value_mask_background_pixel = -1; +static int hf_x11_window_value_mask_border_pixmap = -1; +static int hf_x11_window_value_mask_border_pixel = -1; +static int hf_x11_window_value_mask_bit_gravity = -1; +static int hf_x11_window_value_mask_win_gravity = -1; +static int hf_x11_window_value_mask_backing_store = -1; +static int hf_x11_window_value_mask_backing_planes = -1; +static int hf_x11_window_value_mask_backing_pixel = -1; +static int hf_x11_window_value_mask_override_redirect = -1; +static int hf_x11_window_value_mask_save_under = -1; +static int hf_x11_window_value_mask_event_mask = -1; +static int hf_x11_window_value_mask_do_not_propagate_mask = -1; +static int hf_x11_window_value_mask_colormap = -1; +static int hf_x11_window_value_mask_cursor = -1; +static int hf_x11_x = -1; +static int hf_x11_y = -1; + +/* Generated by process-x11-xcb.pl below this line */ +static int hf_x11_glx_render_CallList_list = -1; +static int hf_x11_glx_render_CallLists_n = -1; +static int hf_x11_glx_render_CallLists_type = -1; +static int hf_x11_glx_render_CallLists_lists = -1; +static int hf_x11_glx_render_ListBase_base = -1; +static int hf_x11_glx_render_Begin_mode = -1; +static int hf_x11_glx_render_Bitmap_width = -1; +static int hf_x11_glx_render_Bitmap_height = -1; +static int hf_x11_glx_render_Bitmap_xorig = -1; +static int hf_x11_glx_render_Bitmap_yorig = -1; +static int hf_x11_glx_render_Bitmap_xmove = -1; +static int hf_x11_glx_render_Bitmap_ymove = -1; +static int hf_x11_glx_render_Bitmap_bitmap = -1; +static int hf_x11_glx_render_Bitmap_swapbytes = -1; +static int hf_x11_glx_render_Bitmap_lsbfirst = -1; +static int hf_x11_glx_render_Bitmap_rowlength = -1; +static int hf_x11_glx_render_Bitmap_skiprows = -1; +static int hf_x11_glx_render_Bitmap_skippixels = -1; +static int hf_x11_glx_render_Bitmap_alignment = -1; +static int hf_x11_glx_render_Color3bv_v = -1; +static int hf_x11_glx_render_Color3dv_v = -1; +static int hf_x11_glx_render_Color3dv_v_item = -1; +static int hf_x11_glx_render_Color3fv_v = -1; +static int hf_x11_glx_render_Color3fv_v_item = -1; +static int hf_x11_glx_render_Color3iv_v = -1; +static int hf_x11_glx_render_Color3iv_v_item = -1; +static int hf_x11_glx_render_Color3sv_v = -1; +static int hf_x11_glx_render_Color3sv_v_item = -1; +static int hf_x11_glx_render_Color3ubv_v = -1; +static int hf_x11_glx_render_Color3uiv_v = -1; +static int hf_x11_glx_render_Color3uiv_v_item = -1; +static int hf_x11_glx_render_Color3usv_v = -1; +static int hf_x11_glx_render_Color3usv_v_item = -1; +static int hf_x11_glx_render_Color4bv_v = -1; +static int hf_x11_glx_render_Color4dv_v = -1; +static int hf_x11_glx_render_Color4dv_v_item = -1; +static int hf_x11_glx_render_Color4fv_v = -1; +static int hf_x11_glx_render_Color4fv_v_item = -1; +static int hf_x11_glx_render_Color4iv_v = -1; +static int hf_x11_glx_render_Color4iv_v_item = -1; +static int hf_x11_glx_render_Color4sv_v = -1; +static int hf_x11_glx_render_Color4sv_v_item = -1; +static int hf_x11_glx_render_Color4ubv_v = -1; +static int hf_x11_glx_render_Color4uiv_v = -1; +static int hf_x11_glx_render_Color4uiv_v_item = -1; +static int hf_x11_glx_render_Color4usv_v = -1; +static int hf_x11_glx_render_Color4usv_v_item = -1; +static int hf_x11_glx_render_EdgeFlagv_flag = -1; +static int hf_x11_glx_render_Indexdv_c = -1; +static int hf_x11_glx_render_Indexdv_c_item = -1; +static int hf_x11_glx_render_Indexfv_c = -1; +static int hf_x11_glx_render_Indexfv_c_item = -1; +static int hf_x11_glx_render_Indexiv_c = -1; +static int hf_x11_glx_render_Indexiv_c_item = -1; +static int hf_x11_glx_render_Indexsv_c = -1; +static int hf_x11_glx_render_Indexsv_c_item = -1; +static int hf_x11_glx_render_Normal3bv_v = -1; +static int hf_x11_glx_render_Normal3dv_v = -1; +static int hf_x11_glx_render_Normal3dv_v_item = -1; +static int hf_x11_glx_render_Normal3fv_v = -1; +static int hf_x11_glx_render_Normal3fv_v_item = -1; +static int hf_x11_glx_render_Normal3iv_v = -1; +static int hf_x11_glx_render_Normal3iv_v_item = -1; +static int hf_x11_glx_render_Normal3sv_v = -1; +static int hf_x11_glx_render_Normal3sv_v_item = -1; +static int hf_x11_glx_render_RasterPos2dv_v = -1; +static int hf_x11_glx_render_RasterPos2dv_v_item = -1; +static int hf_x11_glx_render_RasterPos2fv_v = -1; +static int hf_x11_glx_render_RasterPos2fv_v_item = -1; +static int hf_x11_glx_render_RasterPos2iv_v = -1; +static int hf_x11_glx_render_RasterPos2iv_v_item = -1; +static int hf_x11_glx_render_RasterPos2sv_v = -1; +static int hf_x11_glx_render_RasterPos2sv_v_item = -1; +static int hf_x11_glx_render_RasterPos3dv_v = -1; +static int hf_x11_glx_render_RasterPos3dv_v_item = -1; +static int hf_x11_glx_render_RasterPos3fv_v = -1; +static int hf_x11_glx_render_RasterPos3fv_v_item = -1; +static int hf_x11_glx_render_RasterPos3iv_v = -1; +static int hf_x11_glx_render_RasterPos3iv_v_item = -1; +static int hf_x11_glx_render_RasterPos3sv_v = -1; +static int hf_x11_glx_render_RasterPos3sv_v_item = -1; +static int hf_x11_glx_render_RasterPos4dv_v = -1; +static int hf_x11_glx_render_RasterPos4dv_v_item = -1; +static int hf_x11_glx_render_RasterPos4fv_v = -1; +static int hf_x11_glx_render_RasterPos4fv_v_item = -1; +static int hf_x11_glx_render_RasterPos4iv_v = -1; +static int hf_x11_glx_render_RasterPos4iv_v_item = -1; +static int hf_x11_glx_render_RasterPos4sv_v = -1; +static int hf_x11_glx_render_RasterPos4sv_v_item = -1; +static int hf_x11_glx_render_Rectdv_v1 = -1; +static int hf_x11_glx_render_Rectdv_v1_item = -1; +static int hf_x11_glx_render_Rectdv_v2 = -1; +static int hf_x11_glx_render_Rectdv_v2_item = -1; +static int hf_x11_glx_render_Rectfv_v1 = -1; +static int hf_x11_glx_render_Rectfv_v1_item = -1; +static int hf_x11_glx_render_Rectfv_v2 = -1; +static int hf_x11_glx_render_Rectfv_v2_item = -1; +static int hf_x11_glx_render_Rectiv_v1 = -1; +static int hf_x11_glx_render_Rectiv_v1_item = -1; +static int hf_x11_glx_render_Rectiv_v2 = -1; +static int hf_x11_glx_render_Rectiv_v2_item = -1; +static int hf_x11_glx_render_Rectsv_v1 = -1; +static int hf_x11_glx_render_Rectsv_v1_item = -1; +static int hf_x11_glx_render_Rectsv_v2 = -1; +static int hf_x11_glx_render_Rectsv_v2_item = -1; +static int hf_x11_glx_render_TexCoord1dv_v = -1; +static int hf_x11_glx_render_TexCoord1dv_v_item = -1; +static int hf_x11_glx_render_TexCoord1fv_v = -1; +static int hf_x11_glx_render_TexCoord1fv_v_item = -1; +static int hf_x11_glx_render_TexCoord1iv_v = -1; +static int hf_x11_glx_render_TexCoord1iv_v_item = -1; +static int hf_x11_glx_render_TexCoord1sv_v = -1; +static int hf_x11_glx_render_TexCoord1sv_v_item = -1; +static int hf_x11_glx_render_TexCoord2dv_v = -1; +static int hf_x11_glx_render_TexCoord2dv_v_item = -1; +static int hf_x11_glx_render_TexCoord2fv_v = -1; +static int hf_x11_glx_render_TexCoord2fv_v_item = -1; +static int hf_x11_glx_render_TexCoord2iv_v = -1; +static int hf_x11_glx_render_TexCoord2iv_v_item = -1; +static int hf_x11_glx_render_TexCoord2sv_v = -1; +static int hf_x11_glx_render_TexCoord2sv_v_item = -1; +static int hf_x11_glx_render_TexCoord3dv_v = -1; +static int hf_x11_glx_render_TexCoord3dv_v_item = -1; +static int hf_x11_glx_render_TexCoord3fv_v = -1; +static int hf_x11_glx_render_TexCoord3fv_v_item = -1; +static int hf_x11_glx_render_TexCoord3iv_v = -1; +static int hf_x11_glx_render_TexCoord3iv_v_item = -1; +static int hf_x11_glx_render_TexCoord3sv_v = -1; +static int hf_x11_glx_render_TexCoord3sv_v_item = -1; +static int hf_x11_glx_render_TexCoord4dv_v = -1; +static int hf_x11_glx_render_TexCoord4dv_v_item = -1; +static int hf_x11_glx_render_TexCoord4fv_v = -1; +static int hf_x11_glx_render_TexCoord4fv_v_item = -1; +static int hf_x11_glx_render_TexCoord4iv_v = -1; +static int hf_x11_glx_render_TexCoord4iv_v_item = -1; +static int hf_x11_glx_render_TexCoord4sv_v = -1; +static int hf_x11_glx_render_TexCoord4sv_v_item = -1; +static int hf_x11_glx_render_Vertex2dv_v = -1; +static int hf_x11_glx_render_Vertex2dv_v_item = -1; +static int hf_x11_glx_render_Vertex2fv_v = -1; +static int hf_x11_glx_render_Vertex2fv_v_item = -1; +static int hf_x11_glx_render_Vertex2iv_v = -1; +static int hf_x11_glx_render_Vertex2iv_v_item = -1; +static int hf_x11_glx_render_Vertex2sv_v = -1; +static int hf_x11_glx_render_Vertex2sv_v_item = -1; +static int hf_x11_glx_render_Vertex3dv_v = -1; +static int hf_x11_glx_render_Vertex3dv_v_item = -1; +static int hf_x11_glx_render_Vertex3fv_v = -1; +static int hf_x11_glx_render_Vertex3fv_v_item = -1; +static int hf_x11_glx_render_Vertex3iv_v = -1; +static int hf_x11_glx_render_Vertex3iv_v_item = -1; +static int hf_x11_glx_render_Vertex3sv_v = -1; +static int hf_x11_glx_render_Vertex3sv_v_item = -1; +static int hf_x11_glx_render_Vertex4dv_v = -1; +static int hf_x11_glx_render_Vertex4dv_v_item = -1; +static int hf_x11_glx_render_Vertex4fv_v = -1; +static int hf_x11_glx_render_Vertex4fv_v_item = -1; +static int hf_x11_glx_render_Vertex4iv_v = -1; +static int hf_x11_glx_render_Vertex4iv_v_item = -1; +static int hf_x11_glx_render_Vertex4sv_v = -1; +static int hf_x11_glx_render_Vertex4sv_v_item = -1; +static int hf_x11_glx_render_ClipPlane_plane = -1; +static int hf_x11_glx_render_ClipPlane_equation = -1; +static int hf_x11_glx_render_ClipPlane_equation_item = -1; +static int hf_x11_glx_render_ColorMaterial_face = -1; +static int hf_x11_glx_render_ColorMaterial_mode = -1; +static int hf_x11_glx_render_CullFace_mode = -1; +static int hf_x11_glx_render_Fogf_pname = -1; +static int hf_x11_glx_render_Fogf_param = -1; +static int hf_x11_glx_render_Fogfv_pname = -1; +static int hf_x11_glx_render_Fogfv_params = -1; +static int hf_x11_glx_render_Fogfv_params_item = -1; +static int hf_x11_glx_render_Fogi_pname = -1; +static int hf_x11_glx_render_Fogi_param = -1; +static int hf_x11_glx_render_Fogiv_pname = -1; +static int hf_x11_glx_render_Fogiv_params = -1; +static int hf_x11_glx_render_Fogiv_params_item = -1; +static int hf_x11_glx_render_FrontFace_mode = -1; +static int hf_x11_glx_render_Hint_target = -1; +static int hf_x11_glx_render_Hint_mode = -1; +static int hf_x11_glx_render_Lightf_light = -1; +static int hf_x11_glx_render_Lightf_pname = -1; +static int hf_x11_glx_render_Lightf_param = -1; +static int hf_x11_glx_render_Lightfv_light = -1; +static int hf_x11_glx_render_Lightfv_pname = -1; +static int hf_x11_glx_render_Lightfv_params = -1; +static int hf_x11_glx_render_Lightfv_params_item = -1; +static int hf_x11_glx_render_Lighti_light = -1; +static int hf_x11_glx_render_Lighti_pname = -1; +static int hf_x11_glx_render_Lighti_param = -1; +static int hf_x11_glx_render_Lightiv_light = -1; +static int hf_x11_glx_render_Lightiv_pname = -1; +static int hf_x11_glx_render_Lightiv_params = -1; +static int hf_x11_glx_render_Lightiv_params_item = -1; +static int hf_x11_glx_render_LightModelf_pname = -1; +static int hf_x11_glx_render_LightModelf_param = -1; +static int hf_x11_glx_render_LightModelfv_pname = -1; +static int hf_x11_glx_render_LightModelfv_params = -1; +static int hf_x11_glx_render_LightModelfv_params_item = -1; +static int hf_x11_glx_render_LightModeli_pname = -1; +static int hf_x11_glx_render_LightModeli_param = -1; +static int hf_x11_glx_render_LightModeliv_pname = -1; +static int hf_x11_glx_render_LightModeliv_params = -1; +static int hf_x11_glx_render_LightModeliv_params_item = -1; +static int hf_x11_glx_render_LineStipple_factor = -1; +static int hf_x11_glx_render_LineStipple_pattern = -1; +static int hf_x11_glx_render_LineWidth_width = -1; +static int hf_x11_glx_render_Materialf_face = -1; +static int hf_x11_glx_render_Materialf_pname = -1; +static int hf_x11_glx_render_Materialf_param = -1; +static int hf_x11_glx_render_Materialfv_face = -1; +static int hf_x11_glx_render_Materialfv_pname = -1; +static int hf_x11_glx_render_Materialfv_params = -1; +static int hf_x11_glx_render_Materialfv_params_item = -1; +static int hf_x11_glx_render_Materiali_face = -1; +static int hf_x11_glx_render_Materiali_pname = -1; +static int hf_x11_glx_render_Materiali_param = -1; +static int hf_x11_glx_render_Materialiv_face = -1; +static int hf_x11_glx_render_Materialiv_pname = -1; +static int hf_x11_glx_render_Materialiv_params = -1; +static int hf_x11_glx_render_Materialiv_params_item = -1; +static int hf_x11_glx_render_PointSize_size = -1; +static int hf_x11_glx_render_PolygonMode_face = -1; +static int hf_x11_glx_render_PolygonMode_mode = -1; +static int hf_x11_glx_render_PolygonStipple_mask = -1; +static int hf_x11_glx_render_PolygonStipple_swapbytes = -1; +static int hf_x11_glx_render_PolygonStipple_lsbfirst = -1; +static int hf_x11_glx_render_PolygonStipple_rowlength = -1; +static int hf_x11_glx_render_PolygonStipple_skiprows = -1; +static int hf_x11_glx_render_PolygonStipple_skippixels = -1; +static int hf_x11_glx_render_PolygonStipple_alignment = -1; +static int hf_x11_glx_render_Scissor_x = -1; +static int hf_x11_glx_render_Scissor_y = -1; +static int hf_x11_glx_render_Scissor_width = -1; +static int hf_x11_glx_render_Scissor_height = -1; +static int hf_x11_glx_render_ShadeModel_mode = -1; +static int hf_x11_glx_render_TexParameterf_target = -1; +static int hf_x11_glx_render_TexParameterf_pname = -1; +static int hf_x11_glx_render_TexParameterf_param = -1; +static int hf_x11_glx_render_TexParameterfv_target = -1; +static int hf_x11_glx_render_TexParameterfv_pname = -1; +static int hf_x11_glx_render_TexParameterfv_params = -1; +static int hf_x11_glx_render_TexParameterfv_params_item = -1; +static int hf_x11_glx_render_TexParameteri_target = -1; +static int hf_x11_glx_render_TexParameteri_pname = -1; +static int hf_x11_glx_render_TexParameteri_param = -1; +static int hf_x11_glx_render_TexParameteriv_target = -1; +static int hf_x11_glx_render_TexParameteriv_pname = -1; +static int hf_x11_glx_render_TexParameteriv_params = -1; +static int hf_x11_glx_render_TexParameteriv_params_item = -1; +static int hf_x11_glx_render_TexImage1D_target = -1; +static int hf_x11_glx_render_TexImage1D_level = -1; +static int hf_x11_glx_render_TexImage1D_internalformat = -1; +static int hf_x11_glx_render_TexImage1D_width = -1; +static int hf_x11_glx_render_TexImage1D_border = -1; +static int hf_x11_glx_render_TexImage1D_format = -1; +static int hf_x11_glx_render_TexImage1D_type = -1; +static int hf_x11_glx_render_TexImage1D_pixels = -1; +static int hf_x11_glx_render_TexImage1D_swapbytes = -1; +static int hf_x11_glx_render_TexImage1D_lsbfirst = -1; +static int hf_x11_glx_render_TexImage1D_rowlength = -1; +static int hf_x11_glx_render_TexImage1D_skiprows = -1; +static int hf_x11_glx_render_TexImage1D_skippixels = -1; +static int hf_x11_glx_render_TexImage1D_alignment = -1; +static int hf_x11_glx_render_TexImage2D_target = -1; +static int hf_x11_glx_render_TexImage2D_level = -1; +static int hf_x11_glx_render_TexImage2D_internalformat = -1; +static int hf_x11_glx_render_TexImage2D_width = -1; +static int hf_x11_glx_render_TexImage2D_height = -1; +static int hf_x11_glx_render_TexImage2D_border = -1; +static int hf_x11_glx_render_TexImage2D_format = -1; +static int hf_x11_glx_render_TexImage2D_type = -1; +static int hf_x11_glx_render_TexImage2D_pixels = -1; +static int hf_x11_glx_render_TexImage2D_swapbytes = -1; +static int hf_x11_glx_render_TexImage2D_lsbfirst = -1; +static int hf_x11_glx_render_TexImage2D_rowlength = -1; +static int hf_x11_glx_render_TexImage2D_skiprows = -1; +static int hf_x11_glx_render_TexImage2D_skippixels = -1; +static int hf_x11_glx_render_TexImage2D_alignment = -1; +static int hf_x11_glx_render_TexEnvf_target = -1; +static int hf_x11_glx_render_TexEnvf_pname = -1; +static int hf_x11_glx_render_TexEnvf_param = -1; +static int hf_x11_glx_render_TexEnvfv_target = -1; +static int hf_x11_glx_render_TexEnvfv_pname = -1; +static int hf_x11_glx_render_TexEnvfv_params = -1; +static int hf_x11_glx_render_TexEnvfv_params_item = -1; +static int hf_x11_glx_render_TexEnvi_target = -1; +static int hf_x11_glx_render_TexEnvi_pname = -1; +static int hf_x11_glx_render_TexEnvi_param = -1; +static int hf_x11_glx_render_TexEnviv_target = -1; +static int hf_x11_glx_render_TexEnviv_pname = -1; +static int hf_x11_glx_render_TexEnviv_params = -1; +static int hf_x11_glx_render_TexEnviv_params_item = -1; +static int hf_x11_glx_render_TexGend_coord = -1; +static int hf_x11_glx_render_TexGend_pname = -1; +static int hf_x11_glx_render_TexGend_param = -1; +static int hf_x11_glx_render_TexGendv_coord = -1; +static int hf_x11_glx_render_TexGendv_pname = -1; +static int hf_x11_glx_render_TexGendv_params = -1; +static int hf_x11_glx_render_TexGendv_params_item = -1; +static int hf_x11_glx_render_TexGenf_coord = -1; +static int hf_x11_glx_render_TexGenf_pname = -1; +static int hf_x11_glx_render_TexGenf_param = -1; +static int hf_x11_glx_render_TexGenfv_coord = -1; +static int hf_x11_glx_render_TexGenfv_pname = -1; +static int hf_x11_glx_render_TexGenfv_params = -1; +static int hf_x11_glx_render_TexGenfv_params_item = -1; +static int hf_x11_glx_render_TexGeni_coord = -1; +static int hf_x11_glx_render_TexGeni_pname = -1; +static int hf_x11_glx_render_TexGeni_param = -1; +static int hf_x11_glx_render_TexGeniv_coord = -1; +static int hf_x11_glx_render_TexGeniv_pname = -1; +static int hf_x11_glx_render_TexGeniv_params = -1; +static int hf_x11_glx_render_TexGeniv_params_item = -1; +static int hf_x11_glx_render_LoadName_name = -1; +static int hf_x11_glx_render_PassThrough_token = -1; +static int hf_x11_glx_render_PushName_name = -1; +static int hf_x11_glx_render_DrawBuffer_mode = -1; +static int hf_x11_glx_render_Clear_mask = -1; +static int hf_x11_glx_render_ClearAccum_red = -1; +static int hf_x11_glx_render_ClearAccum_green = -1; +static int hf_x11_glx_render_ClearAccum_blue = -1; +static int hf_x11_glx_render_ClearAccum_alpha = -1; +static int hf_x11_glx_render_ClearIndex_c = -1; +static int hf_x11_glx_render_ClearColor_red = -1; +static int hf_x11_glx_render_ClearColor_green = -1; +static int hf_x11_glx_render_ClearColor_blue = -1; +static int hf_x11_glx_render_ClearColor_alpha = -1; +static int hf_x11_glx_render_ClearStencil_s = -1; +static int hf_x11_glx_render_ClearDepth_depth = -1; +static int hf_x11_glx_render_StencilMask_mask = -1; +static int hf_x11_glx_render_ColorMask_red = -1; +static int hf_x11_glx_render_ColorMask_green = -1; +static int hf_x11_glx_render_ColorMask_blue = -1; +static int hf_x11_glx_render_ColorMask_alpha = -1; +static int hf_x11_glx_render_DepthMask_flag = -1; +static int hf_x11_glx_render_IndexMask_mask = -1; +static int hf_x11_glx_render_Accum_op = -1; +static int hf_x11_glx_render_Accum_value = -1; +static int hf_x11_glx_render_Disable_cap = -1; +static int hf_x11_glx_render_Enable_cap = -1; +static int hf_x11_glx_render_PushAttrib_mask = -1; +static int hf_x11_glx_render_Map1d_target = -1; +static int hf_x11_glx_render_Map1d_u1 = -1; +static int hf_x11_glx_render_Map1d_u2 = -1; +static int hf_x11_glx_render_Map1d_stride = -1; +static int hf_x11_glx_render_Map1d_order = -1; +static int hf_x11_glx_render_Map1d_points = -1; +static int hf_x11_glx_render_Map1d_points_item = -1; +static int hf_x11_glx_render_Map1f_target = -1; +static int hf_x11_glx_render_Map1f_u1 = -1; +static int hf_x11_glx_render_Map1f_u2 = -1; +static int hf_x11_glx_render_Map1f_stride = -1; +static int hf_x11_glx_render_Map1f_order = -1; +static int hf_x11_glx_render_Map1f_points = -1; +static int hf_x11_glx_render_Map1f_points_item = -1; +static int hf_x11_glx_render_Map2d_target = -1; +static int hf_x11_glx_render_Map2d_u1 = -1; +static int hf_x11_glx_render_Map2d_u2 = -1; +static int hf_x11_glx_render_Map2d_ustride = -1; +static int hf_x11_glx_render_Map2d_uorder = -1; +static int hf_x11_glx_render_Map2d_v1 = -1; +static int hf_x11_glx_render_Map2d_v2 = -1; +static int hf_x11_glx_render_Map2d_vstride = -1; +static int hf_x11_glx_render_Map2d_vorder = -1; +static int hf_x11_glx_render_Map2d_points = -1; +static int hf_x11_glx_render_Map2d_points_item = -1; +static int hf_x11_glx_render_Map2f_target = -1; +static int hf_x11_glx_render_Map2f_u1 = -1; +static int hf_x11_glx_render_Map2f_u2 = -1; +static int hf_x11_glx_render_Map2f_ustride = -1; +static int hf_x11_glx_render_Map2f_uorder = -1; +static int hf_x11_glx_render_Map2f_v1 = -1; +static int hf_x11_glx_render_Map2f_v2 = -1; +static int hf_x11_glx_render_Map2f_vstride = -1; +static int hf_x11_glx_render_Map2f_vorder = -1; +static int hf_x11_glx_render_Map2f_points = -1; +static int hf_x11_glx_render_Map2f_points_item = -1; +static int hf_x11_glx_render_MapGrid1d_un = -1; +static int hf_x11_glx_render_MapGrid1d_u1 = -1; +static int hf_x11_glx_render_MapGrid1d_u2 = -1; +static int hf_x11_glx_render_MapGrid1f_un = -1; +static int hf_x11_glx_render_MapGrid1f_u1 = -1; +static int hf_x11_glx_render_MapGrid1f_u2 = -1; +static int hf_x11_glx_render_MapGrid2d_un = -1; +static int hf_x11_glx_render_MapGrid2d_u1 = -1; +static int hf_x11_glx_render_MapGrid2d_u2 = -1; +static int hf_x11_glx_render_MapGrid2d_vn = -1; +static int hf_x11_glx_render_MapGrid2d_v1 = -1; +static int hf_x11_glx_render_MapGrid2d_v2 = -1; +static int hf_x11_glx_render_MapGrid2f_un = -1; +static int hf_x11_glx_render_MapGrid2f_u1 = -1; +static int hf_x11_glx_render_MapGrid2f_u2 = -1; +static int hf_x11_glx_render_MapGrid2f_vn = -1; +static int hf_x11_glx_render_MapGrid2f_v1 = -1; +static int hf_x11_glx_render_MapGrid2f_v2 = -1; +static int hf_x11_glx_render_EvalCoord1dv_u = -1; +static int hf_x11_glx_render_EvalCoord1dv_u_item = -1; +static int hf_x11_glx_render_EvalCoord1fv_u = -1; +static int hf_x11_glx_render_EvalCoord1fv_u_item = -1; +static int hf_x11_glx_render_EvalCoord2dv_u = -1; +static int hf_x11_glx_render_EvalCoord2dv_u_item = -1; +static int hf_x11_glx_render_EvalCoord2fv_u = -1; +static int hf_x11_glx_render_EvalCoord2fv_u_item = -1; +static int hf_x11_glx_render_EvalMesh1_mode = -1; +static int hf_x11_glx_render_EvalMesh1_i1 = -1; +static int hf_x11_glx_render_EvalMesh1_i2 = -1; +static int hf_x11_glx_render_EvalPoint1_i = -1; +static int hf_x11_glx_render_EvalMesh2_mode = -1; +static int hf_x11_glx_render_EvalMesh2_i1 = -1; +static int hf_x11_glx_render_EvalMesh2_i2 = -1; +static int hf_x11_glx_render_EvalMesh2_j1 = -1; +static int hf_x11_glx_render_EvalMesh2_j2 = -1; +static int hf_x11_glx_render_EvalPoint2_i = -1; +static int hf_x11_glx_render_EvalPoint2_j = -1; +static int hf_x11_glx_render_AlphaFunc_func = -1; +static int hf_x11_glx_render_AlphaFunc_ref = -1; +static int hf_x11_glx_render_BlendFunc_sfactor = -1; +static int hf_x11_glx_render_BlendFunc_dfactor = -1; +static int hf_x11_glx_render_LogicOp_opcode = -1; +static int hf_x11_glx_render_StencilFunc_func = -1; +static int hf_x11_glx_render_StencilFunc_ref = -1; +static int hf_x11_glx_render_StencilFunc_mask = -1; +static int hf_x11_glx_render_StencilOp_fail = -1; +static int hf_x11_glx_render_StencilOp_zfail = -1; +static int hf_x11_glx_render_StencilOp_zpass = -1; +static int hf_x11_glx_render_DepthFunc_func = -1; +static int hf_x11_glx_render_PixelZoom_xfactor = -1; +static int hf_x11_glx_render_PixelZoom_yfactor = -1; +static int hf_x11_glx_render_PixelTransferf_pname = -1; +static int hf_x11_glx_render_PixelTransferf_param = -1; +static int hf_x11_glx_render_PixelTransferi_pname = -1; +static int hf_x11_glx_render_PixelTransferi_param = -1; +static int hf_x11_glx_render_PixelMapfv_map = -1; +static int hf_x11_glx_render_PixelMapfv_mapsize = -1; +static int hf_x11_glx_render_PixelMapfv_values = -1; +static int hf_x11_glx_render_PixelMapfv_values_item = -1; +static int hf_x11_glx_render_PixelMapuiv_map = -1; +static int hf_x11_glx_render_PixelMapuiv_mapsize = -1; +static int hf_x11_glx_render_PixelMapuiv_values = -1; +static int hf_x11_glx_render_PixelMapuiv_values_item = -1; +static int hf_x11_glx_render_PixelMapusv_map = -1; +static int hf_x11_glx_render_PixelMapusv_mapsize = -1; +static int hf_x11_glx_render_PixelMapusv_values = -1; +static int hf_x11_glx_render_PixelMapusv_values_item = -1; +static int hf_x11_glx_render_ReadBuffer_mode = -1; +static int hf_x11_glx_render_CopyPixels_x = -1; +static int hf_x11_glx_render_CopyPixels_y = -1; +static int hf_x11_glx_render_CopyPixels_width = -1; +static int hf_x11_glx_render_CopyPixels_height = -1; +static int hf_x11_glx_render_CopyPixels_type = -1; +static int hf_x11_glx_render_DrawPixels_width = -1; +static int hf_x11_glx_render_DrawPixels_height = -1; +static int hf_x11_glx_render_DrawPixels_format = -1; +static int hf_x11_glx_render_DrawPixels_type = -1; +static int hf_x11_glx_render_DrawPixels_pixels = -1; +static int hf_x11_glx_render_DrawPixels_swapbytes = -1; +static int hf_x11_glx_render_DrawPixels_lsbfirst = -1; +static int hf_x11_glx_render_DrawPixels_rowlength = -1; +static int hf_x11_glx_render_DrawPixels_skiprows = -1; +static int hf_x11_glx_render_DrawPixels_skippixels = -1; +static int hf_x11_glx_render_DrawPixels_alignment = -1; +static int hf_x11_glx_render_DepthRange_zNear = -1; +static int hf_x11_glx_render_DepthRange_zFar = -1; +static int hf_x11_glx_render_Frustum_left = -1; +static int hf_x11_glx_render_Frustum_right = -1; +static int hf_x11_glx_render_Frustum_bottom = -1; +static int hf_x11_glx_render_Frustum_top = -1; +static int hf_x11_glx_render_Frustum_zNear = -1; +static int hf_x11_glx_render_Frustum_zFar = -1; +static int hf_x11_glx_render_LoadMatrixf_m = -1; +static int hf_x11_glx_render_LoadMatrixf_m_item = -1; +static int hf_x11_glx_render_LoadMatrixd_m = -1; +static int hf_x11_glx_render_LoadMatrixd_m_item = -1; +static int hf_x11_glx_render_MatrixMode_mode = -1; +static int hf_x11_glx_render_MultMatrixf_m = -1; +static int hf_x11_glx_render_MultMatrixf_m_item = -1; +static int hf_x11_glx_render_MultMatrixd_m = -1; +static int hf_x11_glx_render_MultMatrixd_m_item = -1; +static int hf_x11_glx_render_Ortho_left = -1; +static int hf_x11_glx_render_Ortho_right = -1; +static int hf_x11_glx_render_Ortho_bottom = -1; +static int hf_x11_glx_render_Ortho_top = -1; +static int hf_x11_glx_render_Ortho_zNear = -1; +static int hf_x11_glx_render_Ortho_zFar = -1; +static int hf_x11_glx_render_Rotated_angle = -1; +static int hf_x11_glx_render_Rotated_x = -1; +static int hf_x11_glx_render_Rotated_y = -1; +static int hf_x11_glx_render_Rotated_z = -1; +static int hf_x11_glx_render_Rotatef_angle = -1; +static int hf_x11_glx_render_Rotatef_x = -1; +static int hf_x11_glx_render_Rotatef_y = -1; +static int hf_x11_glx_render_Rotatef_z = -1; +static int hf_x11_glx_render_Scaled_x = -1; +static int hf_x11_glx_render_Scaled_y = -1; +static int hf_x11_glx_render_Scaled_z = -1; +static int hf_x11_glx_render_Scalef_x = -1; +static int hf_x11_glx_render_Scalef_y = -1; +static int hf_x11_glx_render_Scalef_z = -1; +static int hf_x11_glx_render_Translated_x = -1; +static int hf_x11_glx_render_Translated_y = -1; +static int hf_x11_glx_render_Translated_z = -1; +static int hf_x11_glx_render_Translatef_x = -1; +static int hf_x11_glx_render_Translatef_y = -1; +static int hf_x11_glx_render_Translatef_z = -1; +static int hf_x11_glx_render_Viewport_x = -1; +static int hf_x11_glx_render_Viewport_y = -1; +static int hf_x11_glx_render_Viewport_width = -1; +static int hf_x11_glx_render_Viewport_height = -1; +static int hf_x11_glx_render_DrawArrays_mode = -1; +static int hf_x11_glx_render_DrawArrays_first = -1; +static int hf_x11_glx_render_DrawArrays_count = -1; +static int hf_x11_glx_render_PolygonOffset_factor = -1; +static int hf_x11_glx_render_PolygonOffset_units = -1; +static int hf_x11_glx_render_CopyTexImage1D_target = -1; +static int hf_x11_glx_render_CopyTexImage1D_level = -1; +static int hf_x11_glx_render_CopyTexImage1D_internalformat = -1; +static int hf_x11_glx_render_CopyTexImage1D_x = -1; +static int hf_x11_glx_render_CopyTexImage1D_y = -1; +static int hf_x11_glx_render_CopyTexImage1D_width = -1; +static int hf_x11_glx_render_CopyTexImage1D_border = -1; +static int hf_x11_glx_render_CopyTexImage2D_target = -1; +static int hf_x11_glx_render_CopyTexImage2D_level = -1; +static int hf_x11_glx_render_CopyTexImage2D_internalformat = -1; +static int hf_x11_glx_render_CopyTexImage2D_x = -1; +static int hf_x11_glx_render_CopyTexImage2D_y = -1; +static int hf_x11_glx_render_CopyTexImage2D_width = -1; +static int hf_x11_glx_render_CopyTexImage2D_height = -1; +static int hf_x11_glx_render_CopyTexImage2D_border = -1; +static int hf_x11_glx_render_CopyTexSubImage1D_target = -1; +static int hf_x11_glx_render_CopyTexSubImage1D_level = -1; +static int hf_x11_glx_render_CopyTexSubImage1D_xoffset = -1; +static int hf_x11_glx_render_CopyTexSubImage1D_x = -1; +static int hf_x11_glx_render_CopyTexSubImage1D_y = -1; +static int hf_x11_glx_render_CopyTexSubImage1D_width = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_target = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_level = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_xoffset = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_yoffset = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_x = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_y = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_width = -1; +static int hf_x11_glx_render_CopyTexSubImage2D_height = -1; +static int hf_x11_glx_render_TexSubImage1D_target = -1; +static int hf_x11_glx_render_TexSubImage1D_level = -1; +static int hf_x11_glx_render_TexSubImage1D_xoffset = -1; +static int hf_x11_glx_render_TexSubImage1D_width = -1; +static int hf_x11_glx_render_TexSubImage1D_format = -1; +static int hf_x11_glx_render_TexSubImage1D_type = -1; +static int hf_x11_glx_render_TexSubImage1D_UNUSED = -1; +static int hf_x11_glx_render_TexSubImage1D_pixels = -1; +static int hf_x11_glx_render_TexSubImage1D_swapbytes = -1; +static int hf_x11_glx_render_TexSubImage1D_lsbfirst = -1; +static int hf_x11_glx_render_TexSubImage1D_rowlength = -1; +static int hf_x11_glx_render_TexSubImage1D_skiprows = -1; +static int hf_x11_glx_render_TexSubImage1D_skippixels = -1; +static int hf_x11_glx_render_TexSubImage1D_alignment = -1; +static int hf_x11_glx_render_TexSubImage2D_target = -1; +static int hf_x11_glx_render_TexSubImage2D_level = -1; +static int hf_x11_glx_render_TexSubImage2D_xoffset = -1; +static int hf_x11_glx_render_TexSubImage2D_yoffset = -1; +static int hf_x11_glx_render_TexSubImage2D_width = -1; +static int hf_x11_glx_render_TexSubImage2D_height = -1; +static int hf_x11_glx_render_TexSubImage2D_format = -1; +static int hf_x11_glx_render_TexSubImage2D_type = -1; +static int hf_x11_glx_render_TexSubImage2D_UNUSED = -1; +static int hf_x11_glx_render_TexSubImage2D_pixels = -1; +static int hf_x11_glx_render_TexSubImage2D_swapbytes = -1; +static int hf_x11_glx_render_TexSubImage2D_lsbfirst = -1; +static int hf_x11_glx_render_TexSubImage2D_rowlength = -1; +static int hf_x11_glx_render_TexSubImage2D_skiprows = -1; +static int hf_x11_glx_render_TexSubImage2D_skippixels = -1; +static int hf_x11_glx_render_TexSubImage2D_alignment = -1; +static int hf_x11_glx_render_BindTexture_target = -1; +static int hf_x11_glx_render_BindTexture_texture = -1; +static int hf_x11_glx_render_PrioritizeTextures_n = -1; +static int hf_x11_glx_render_PrioritizeTextures_textures = -1; +static int hf_x11_glx_render_PrioritizeTextures_textures_item = -1; +static int hf_x11_glx_render_PrioritizeTextures_priorities = -1; +static int hf_x11_glx_render_PrioritizeTextures_priorities_item = -1; +static int hf_x11_glx_render_Indexubv_c = -1; +static int hf_x11_glx_render_BlendColor_red = -1; +static int hf_x11_glx_render_BlendColor_green = -1; +static int hf_x11_glx_render_BlendColor_blue = -1; +static int hf_x11_glx_render_BlendColor_alpha = -1; +static int hf_x11_glx_render_BlendEquation_mode = -1; +static int hf_x11_glx_render_ColorTable_target = -1; +static int hf_x11_glx_render_ColorTable_internalformat = -1; +static int hf_x11_glx_render_ColorTable_width = -1; +static int hf_x11_glx_render_ColorTable_format = -1; +static int hf_x11_glx_render_ColorTable_type = -1; +static int hf_x11_glx_render_ColorTable_table = -1; +static int hf_x11_glx_render_ColorTable_swapbytes = -1; +static int hf_x11_glx_render_ColorTable_lsbfirst = -1; +static int hf_x11_glx_render_ColorTable_rowlength = -1; +static int hf_x11_glx_render_ColorTable_skiprows = -1; +static int hf_x11_glx_render_ColorTable_skippixels = -1; +static int hf_x11_glx_render_ColorTable_alignment = -1; +static int hf_x11_glx_render_ColorTableParameterfv_target = -1; +static int hf_x11_glx_render_ColorTableParameterfv_pname = -1; +static int hf_x11_glx_render_ColorTableParameterfv_params = -1; +static int hf_x11_glx_render_ColorTableParameterfv_params_item = -1; +static int hf_x11_glx_render_ColorTableParameteriv_target = -1; +static int hf_x11_glx_render_ColorTableParameteriv_pname = -1; +static int hf_x11_glx_render_ColorTableParameteriv_params = -1; +static int hf_x11_glx_render_ColorTableParameteriv_params_item = -1; +static int hf_x11_glx_render_CopyColorTable_target = -1; +static int hf_x11_glx_render_CopyColorTable_internalformat = -1; +static int hf_x11_glx_render_CopyColorTable_x = -1; +static int hf_x11_glx_render_CopyColorTable_y = -1; +static int hf_x11_glx_render_CopyColorTable_width = -1; +static int hf_x11_glx_render_ColorSubTable_target = -1; +static int hf_x11_glx_render_ColorSubTable_start = -1; +static int hf_x11_glx_render_ColorSubTable_count = -1; +static int hf_x11_glx_render_ColorSubTable_format = -1; +static int hf_x11_glx_render_ColorSubTable_type = -1; +static int hf_x11_glx_render_ColorSubTable_data = -1; +static int hf_x11_glx_render_ColorSubTable_swapbytes = -1; +static int hf_x11_glx_render_ColorSubTable_lsbfirst = -1; +static int hf_x11_glx_render_ColorSubTable_rowlength = -1; +static int hf_x11_glx_render_ColorSubTable_skiprows = -1; +static int hf_x11_glx_render_ColorSubTable_skippixels = -1; +static int hf_x11_glx_render_ColorSubTable_alignment = -1; +static int hf_x11_glx_render_CopyColorSubTable_target = -1; +static int hf_x11_glx_render_CopyColorSubTable_start = -1; +static int hf_x11_glx_render_CopyColorSubTable_x = -1; +static int hf_x11_glx_render_CopyColorSubTable_y = -1; +static int hf_x11_glx_render_CopyColorSubTable_width = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_target = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_internalformat = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_width = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_format = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_type = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_image = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_swapbytes = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_lsbfirst = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_rowlength = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_skiprows = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_skippixels = -1; +static int hf_x11_glx_render_ConvolutionFilter1D_alignment = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_target = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_internalformat = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_width = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_height = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_format = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_type = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_image = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_swapbytes = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_lsbfirst = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_rowlength = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_skiprows = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_skippixels = -1; +static int hf_x11_glx_render_ConvolutionFilter2D_alignment = -1; +static int hf_x11_glx_render_ConvolutionParameterf_target = -1; +static int hf_x11_glx_render_ConvolutionParameterf_pname = -1; +static int hf_x11_glx_render_ConvolutionParameterf_params = -1; +static int hf_x11_glx_render_ConvolutionParameterfv_target = -1; +static int hf_x11_glx_render_ConvolutionParameterfv_pname = -1; +static int hf_x11_glx_render_ConvolutionParameterfv_params = -1; +static int hf_x11_glx_render_ConvolutionParameterfv_params_item = -1; +static int hf_x11_glx_render_ConvolutionParameteri_target = -1; +static int hf_x11_glx_render_ConvolutionParameteri_pname = -1; +static int hf_x11_glx_render_ConvolutionParameteri_params = -1; +static int hf_x11_glx_render_ConvolutionParameteriv_target = -1; +static int hf_x11_glx_render_ConvolutionParameteriv_pname = -1; +static int hf_x11_glx_render_ConvolutionParameteriv_params = -1; +static int hf_x11_glx_render_ConvolutionParameteriv_params_item = -1; +static int hf_x11_glx_render_CopyConvolutionFilter1D_target = -1; +static int hf_x11_glx_render_CopyConvolutionFilter1D_internalformat = -1; +static int hf_x11_glx_render_CopyConvolutionFilter1D_x = -1; +static int hf_x11_glx_render_CopyConvolutionFilter1D_y = -1; +static int hf_x11_glx_render_CopyConvolutionFilter1D_width = -1; +static int hf_x11_glx_render_CopyConvolutionFilter2D_target = -1; +static int hf_x11_glx_render_CopyConvolutionFilter2D_internalformat = -1; +static int hf_x11_glx_render_CopyConvolutionFilter2D_x = -1; +static int hf_x11_glx_render_CopyConvolutionFilter2D_y = -1; +static int hf_x11_glx_render_CopyConvolutionFilter2D_width = -1; +static int hf_x11_glx_render_CopyConvolutionFilter2D_height = -1; +static int hf_x11_glx_render_SeparableFilter2D_target = -1; +static int hf_x11_glx_render_SeparableFilter2D_internalformat = -1; +static int hf_x11_glx_render_SeparableFilter2D_width = -1; +static int hf_x11_glx_render_SeparableFilter2D_height = -1; +static int hf_x11_glx_render_SeparableFilter2D_format = -1; +static int hf_x11_glx_render_SeparableFilter2D_type = -1; +static int hf_x11_glx_render_SeparableFilter2D_row = -1; +static int hf_x11_glx_render_SeparableFilter2D_column = -1; +static int hf_x11_glx_render_Histogram_target = -1; +static int hf_x11_glx_render_Histogram_width = -1; +static int hf_x11_glx_render_Histogram_internalformat = -1; +static int hf_x11_glx_render_Histogram_sink = -1; +static int hf_x11_glx_render_Minmax_target = -1; +static int hf_x11_glx_render_Minmax_internalformat = -1; +static int hf_x11_glx_render_Minmax_sink = -1; +static int hf_x11_glx_render_ResetHistogram_target = -1; +static int hf_x11_glx_render_ResetMinmax_target = -1; +static int hf_x11_glx_render_TexImage3D_target = -1; +static int hf_x11_glx_render_TexImage3D_level = -1; +static int hf_x11_glx_render_TexImage3D_internalformat = -1; +static int hf_x11_glx_render_TexImage3D_width = -1; +static int hf_x11_glx_render_TexImage3D_height = -1; +static int hf_x11_glx_render_TexImage3D_depth = -1; +static int hf_x11_glx_render_TexImage3D_border = -1; +static int hf_x11_glx_render_TexImage3D_format = -1; +static int hf_x11_glx_render_TexImage3D_type = -1; +static int hf_x11_glx_render_TexImage3D_pixels = -1; +static int hf_x11_glx_render_TexImage3D_swapbytes = -1; +static int hf_x11_glx_render_TexImage3D_lsbfirst = -1; +static int hf_x11_glx_render_TexImage3D_rowlength = -1; +static int hf_x11_glx_render_TexImage3D_skiprows = -1; +static int hf_x11_glx_render_TexImage3D_skippixels = -1; +static int hf_x11_glx_render_TexImage3D_alignment = -1; +static int hf_x11_glx_render_TexSubImage3D_target = -1; +static int hf_x11_glx_render_TexSubImage3D_level = -1; +static int hf_x11_glx_render_TexSubImage3D_xoffset = -1; +static int hf_x11_glx_render_TexSubImage3D_yoffset = -1; +static int hf_x11_glx_render_TexSubImage3D_zoffset = -1; +static int hf_x11_glx_render_TexSubImage3D_width = -1; +static int hf_x11_glx_render_TexSubImage3D_height = -1; +static int hf_x11_glx_render_TexSubImage3D_depth = -1; +static int hf_x11_glx_render_TexSubImage3D_format = -1; +static int hf_x11_glx_render_TexSubImage3D_type = -1; +static int hf_x11_glx_render_TexSubImage3D_UNUSED = -1; +static int hf_x11_glx_render_TexSubImage3D_pixels = -1; +static int hf_x11_glx_render_TexSubImage3D_swapbytes = -1; +static int hf_x11_glx_render_TexSubImage3D_lsbfirst = -1; +static int hf_x11_glx_render_TexSubImage3D_rowlength = -1; +static int hf_x11_glx_render_TexSubImage3D_skiprows = -1; +static int hf_x11_glx_render_TexSubImage3D_skippixels = -1; +static int hf_x11_glx_render_TexSubImage3D_alignment = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_target = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_level = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_xoffset = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_yoffset = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_zoffset = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_x = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_y = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_width = -1; +static int hf_x11_glx_render_CopyTexSubImage3D_height = -1; +static int hf_x11_glx_render_ActiveTextureARB_texture = -1; +static int hf_x11_glx_render_MultiTexCoord1dvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord1dvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord1dvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord1fvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord1fvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord1fvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord1ivARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord1ivARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord1ivARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord1svARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord1svARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord1svARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord2dvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord2dvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord2dvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord2fvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord2fvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord2fvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord2ivARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord2ivARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord2ivARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord2svARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord2svARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord2svARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord3dvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord3dvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord3dvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord3fvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord3fvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord3fvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord3ivARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord3ivARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord3ivARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord3svARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord3svARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord3svARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord4dvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord4dvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord4dvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord4fvARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord4fvARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord4fvARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord4ivARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord4ivARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord4ivARB_v_item = -1; +static int hf_x11_glx_render_MultiTexCoord4svARB_target = -1; +static int hf_x11_glx_render_MultiTexCoord4svARB_v = -1; +static int hf_x11_glx_render_MultiTexCoord4svARB_v_item = -1; +static int hf_x11_glx_render_SampleCoverageARB_value = -1; +static int hf_x11_glx_render_SampleCoverageARB_invert = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_target = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_level = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_internalformat = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_width = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_height = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_depth = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_border = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_imageSize = -1; +static int hf_x11_glx_render_CompressedTexImage3DARB_data = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_target = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_level = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_internalformat = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_width = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_height = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_border = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_imageSize = -1; +static int hf_x11_glx_render_CompressedTexImage2DARB_data = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_target = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_level = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_internalformat = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_width = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_border = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_imageSize = -1; +static int hf_x11_glx_render_CompressedTexImage1DARB_data = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_target = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_level = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_xoffset = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_yoffset = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_zoffset = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_width = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_height = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_depth = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_format = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_imageSize = -1; +static int hf_x11_glx_render_CompressedTexSubImage3DARB_data = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_target = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_level = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_xoffset = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_yoffset = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_width = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_height = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_format = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_imageSize = -1; +static int hf_x11_glx_render_CompressedTexSubImage2DARB_data = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_target = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_level = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_xoffset = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_width = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_format = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_imageSize = -1; +static int hf_x11_glx_render_CompressedTexSubImage1DARB_data = -1; +static int hf_x11_glx_render_CurrentPaletteMatrixARB_index = -1; +static int hf_x11_glx_render_MatrixIndexubvARB_size = -1; +static int hf_x11_glx_render_MatrixIndexubvARB_indices = -1; +static int hf_x11_glx_render_MatrixIndexusvARB_size = -1; +static int hf_x11_glx_render_MatrixIndexusvARB_indices = -1; +static int hf_x11_glx_render_MatrixIndexusvARB_indices_item = -1; +static int hf_x11_glx_render_MatrixIndexuivARB_size = -1; +static int hf_x11_glx_render_MatrixIndexuivARB_indices = -1; +static int hf_x11_glx_render_MatrixIndexuivARB_indices_item = -1; +static int hf_x11_glx_render_VertexAttrib1dvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib1dvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib1dvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib1fvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib1fvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib1fvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib1svARB_index = -1; +static int hf_x11_glx_render_VertexAttrib1svARB_v = -1; +static int hf_x11_glx_render_VertexAttrib1svARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib2dvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib2dvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib2dvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib2fvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib2fvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib2fvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib2svARB_index = -1; +static int hf_x11_glx_render_VertexAttrib2svARB_v = -1; +static int hf_x11_glx_render_VertexAttrib2svARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib3dvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib3dvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib3dvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib3fvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib3fvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib3fvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib3svARB_index = -1; +static int hf_x11_glx_render_VertexAttrib3svARB_v = -1; +static int hf_x11_glx_render_VertexAttrib3svARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4dvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4dvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4dvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4fvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4fvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4fvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4svARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4svARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4svARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4NubvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4NubvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4bvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4bvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4ivARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4ivARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4ivARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4ubvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4ubvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4usvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4usvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4usvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4uivARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4uivARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4uivARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4NbvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4NbvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4NsvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4NsvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4NsvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4NivARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4NivARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4NivARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4NusvARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4NusvARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4NusvARB_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4NuivARB_index = -1; +static int hf_x11_glx_render_VertexAttrib4NuivARB_v = -1; +static int hf_x11_glx_render_VertexAttrib4NuivARB_v_item = -1; +static int hf_x11_glx_render_ProgramStringARB_target = -1; +static int hf_x11_glx_render_ProgramStringARB_format = -1; +static int hf_x11_glx_render_ProgramStringARB_len = -1; +static int hf_x11_glx_render_ProgramStringARB_string = -1; +static int hf_x11_glx_render_ProgramEnvParameter4dvARB_target = -1; +static int hf_x11_glx_render_ProgramEnvParameter4dvARB_index = -1; +static int hf_x11_glx_render_ProgramEnvParameter4dvARB_params = -1; +static int hf_x11_glx_render_ProgramEnvParameter4dvARB_params_item = -1; +static int hf_x11_glx_render_ProgramEnvParameter4fvARB_target = -1; +static int hf_x11_glx_render_ProgramEnvParameter4fvARB_index = -1; +static int hf_x11_glx_render_ProgramEnvParameter4fvARB_params = -1; +static int hf_x11_glx_render_ProgramEnvParameter4fvARB_params_item = -1; +static int hf_x11_glx_render_ProgramLocalParameter4dvARB_target = -1; +static int hf_x11_glx_render_ProgramLocalParameter4dvARB_index = -1; +static int hf_x11_glx_render_ProgramLocalParameter4dvARB_params = -1; +static int hf_x11_glx_render_ProgramLocalParameter4dvARB_params_item = -1; +static int hf_x11_glx_render_ProgramLocalParameter4fvARB_target = -1; +static int hf_x11_glx_render_ProgramLocalParameter4fvARB_index = -1; +static int hf_x11_glx_render_ProgramLocalParameter4fvARB_params = -1; +static int hf_x11_glx_render_ProgramLocalParameter4fvARB_params_item = -1; +static int hf_x11_glx_render_BeginQueryARB_target = -1; +static int hf_x11_glx_render_BeginQueryARB_id = -1; +static int hf_x11_glx_render_EndQueryARB_target = -1; +static int hf_x11_glx_render_DrawBuffersARB_n = -1; +static int hf_x11_glx_render_DrawBuffersARB_bufs = -1; +static int hf_x11_glx_render_DrawBuffersARB_bufs_item = -1; +static int hf_x11_glx_render_PolygonOffsetEXT_factor = -1; +static int hf_x11_glx_render_PolygonOffsetEXT_bias = -1; +static int hf_x11_glx_render_TexFilterFuncSGIS_target = -1; +static int hf_x11_glx_render_TexFilterFuncSGIS_filter = -1; +static int hf_x11_glx_render_TexFilterFuncSGIS_n = -1; +static int hf_x11_glx_render_TexFilterFuncSGIS_weights = -1; +static int hf_x11_glx_render_TexFilterFuncSGIS_weights_item = -1; +static int hf_x11_glx_render_TexImage4DSGIS_target = -1; +static int hf_x11_glx_render_TexImage4DSGIS_level = -1; +static int hf_x11_glx_render_TexImage4DSGIS_internalformat = -1; +static int hf_x11_glx_render_TexImage4DSGIS_width = -1; +static int hf_x11_glx_render_TexImage4DSGIS_height = -1; +static int hf_x11_glx_render_TexImage4DSGIS_depth = -1; +static int hf_x11_glx_render_TexImage4DSGIS_size4d = -1; +static int hf_x11_glx_render_TexImage4DSGIS_border = -1; +static int hf_x11_glx_render_TexImage4DSGIS_format = -1; +static int hf_x11_glx_render_TexImage4DSGIS_type = -1; +static int hf_x11_glx_render_TexImage4DSGIS_pixels = -1; +static int hf_x11_glx_render_TexImage4DSGIS_swapbytes = -1; +static int hf_x11_glx_render_TexImage4DSGIS_lsbfirst = -1; +static int hf_x11_glx_render_TexImage4DSGIS_rowlength = -1; +static int hf_x11_glx_render_TexImage4DSGIS_skiprows = -1; +static int hf_x11_glx_render_TexImage4DSGIS_skippixels = -1; +static int hf_x11_glx_render_TexImage4DSGIS_alignment = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_target = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_level = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_xoffset = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_yoffset = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_zoffset = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_woffset = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_width = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_height = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_depth = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_size4d = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_format = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_type = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_UNUSED = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_pixels = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_swapbytes = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_lsbfirst = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_rowlength = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_skiprows = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_skippixels = -1; +static int hf_x11_glx_render_TexSubImage4DSGIS_alignment = -1; +static int hf_x11_glx_render_DetailTexFuncSGIS_target = -1; +static int hf_x11_glx_render_DetailTexFuncSGIS_n = -1; +static int hf_x11_glx_render_DetailTexFuncSGIS_points = -1; +static int hf_x11_glx_render_DetailTexFuncSGIS_points_item = -1; +static int hf_x11_glx_render_SharpenTexFuncSGIS_target = -1; +static int hf_x11_glx_render_SharpenTexFuncSGIS_n = -1; +static int hf_x11_glx_render_SharpenTexFuncSGIS_points = -1; +static int hf_x11_glx_render_SharpenTexFuncSGIS_points_item = -1; +static int hf_x11_glx_render_SampleMaskSGIS_value = -1; +static int hf_x11_glx_render_SampleMaskSGIS_invert = -1; +static int hf_x11_glx_render_SamplePatternSGIS_pattern = -1; +static int hf_x11_glx_render_PointParameterfEXT_pname = -1; +static int hf_x11_glx_render_PointParameterfEXT_param = -1; +static int hf_x11_glx_render_PointParameterfvEXT_pname = -1; +static int hf_x11_glx_render_PointParameterfvEXT_params = -1; +static int hf_x11_glx_render_PointParameterfvEXT_params_item = -1; +static int hf_x11_glx_render_FrameZoomSGIX_factor = -1; +static int hf_x11_glx_render_ReferencePlaneSGIX_equation = -1; +static int hf_x11_glx_render_ReferencePlaneSGIX_equation_item = -1; +static int hf_x11_glx_render_FogFuncSGIS_n = -1; +static int hf_x11_glx_render_FogFuncSGIS_points = -1; +static int hf_x11_glx_render_FogFuncSGIS_points_item = -1; +static int hf_x11_glx_render_SecondaryColor3bvEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3dvEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3dvEXT_v_item = -1; +static int hf_x11_glx_render_SecondaryColor3fvEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3fvEXT_v_item = -1; +static int hf_x11_glx_render_SecondaryColor3ivEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3ivEXT_v_item = -1; +static int hf_x11_glx_render_SecondaryColor3svEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3svEXT_v_item = -1; +static int hf_x11_glx_render_SecondaryColor3ubvEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3uivEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3uivEXT_v_item = -1; +static int hf_x11_glx_render_SecondaryColor3usvEXT_v = -1; +static int hf_x11_glx_render_SecondaryColor3usvEXT_v_item = -1; +static int hf_x11_glx_render_FogCoordfvEXT_coord = -1; +static int hf_x11_glx_render_FogCoordfvEXT_coord_item = -1; +static int hf_x11_glx_render_FogCoorddvEXT_coord = -1; +static int hf_x11_glx_render_FogCoorddvEXT_coord_item = -1; +static int hf_x11_glx_render_PixelTexGenSGIX_mode = -1; +static int hf_x11_glx_render_BlendFuncSeparateEXT_sfactorRGB = -1; +static int hf_x11_glx_render_BlendFuncSeparateEXT_dfactorRGB = -1; +static int hf_x11_glx_render_BlendFuncSeparateEXT_sfactorAlpha = -1; +static int hf_x11_glx_render_BlendFuncSeparateEXT_dfactorAlpha = -1; +static int hf_x11_glx_render_VertexWeightfvEXT_weight = -1; +static int hf_x11_glx_render_VertexWeightfvEXT_weight_item = -1; +static int hf_x11_glx_render_CombinerParameterfvNV_pname = -1; +static int hf_x11_glx_render_CombinerParameterfvNV_params = -1; +static int hf_x11_glx_render_CombinerParameterfvNV_params_item = -1; +static int hf_x11_glx_render_CombinerParameterfNV_pname = -1; +static int hf_x11_glx_render_CombinerParameterfNV_param = -1; +static int hf_x11_glx_render_CombinerParameterivNV_pname = -1; +static int hf_x11_glx_render_CombinerParameterivNV_params = -1; +static int hf_x11_glx_render_CombinerParameterivNV_params_item = -1; +static int hf_x11_glx_render_CombinerParameteriNV_pname = -1; +static int hf_x11_glx_render_CombinerParameteriNV_param = -1; +static int hf_x11_glx_render_CombinerInputNV_stage = -1; +static int hf_x11_glx_render_CombinerInputNV_portion = -1; +static int hf_x11_glx_render_CombinerInputNV_variable = -1; +static int hf_x11_glx_render_CombinerInputNV_input = -1; +static int hf_x11_glx_render_CombinerInputNV_mapping = -1; +static int hf_x11_glx_render_CombinerInputNV_componentUsage = -1; +static int hf_x11_glx_render_CombinerOutputNV_stage = -1; +static int hf_x11_glx_render_CombinerOutputNV_portion = -1; +static int hf_x11_glx_render_CombinerOutputNV_abOutput = -1; +static int hf_x11_glx_render_CombinerOutputNV_cdOutput = -1; +static int hf_x11_glx_render_CombinerOutputNV_sumOutput = -1; +static int hf_x11_glx_render_CombinerOutputNV_scale = -1; +static int hf_x11_glx_render_CombinerOutputNV_bias = -1; +static int hf_x11_glx_render_CombinerOutputNV_abDotProduct = -1; +static int hf_x11_glx_render_CombinerOutputNV_cdDotProduct = -1; +static int hf_x11_glx_render_CombinerOutputNV_muxSum = -1; +static int hf_x11_glx_render_FinalCombinerInputNV_variable = -1; +static int hf_x11_glx_render_FinalCombinerInputNV_input = -1; +static int hf_x11_glx_render_FinalCombinerInputNV_mapping = -1; +static int hf_x11_glx_render_FinalCombinerInputNV_componentUsage = -1; +static int hf_x11_glx_render_WindowPos3fvMESA_v = -1; +static int hf_x11_glx_render_WindowPos3fvMESA_v_item = -1; +static int hf_x11_glx_render_TextureColorMaskSGIS_red = -1; +static int hf_x11_glx_render_TextureColorMaskSGIS_green = -1; +static int hf_x11_glx_render_TextureColorMaskSGIS_blue = -1; +static int hf_x11_glx_render_TextureColorMaskSGIS_alpha = -1; +static int hf_x11_glx_render_BindProgramNV_target = -1; +static int hf_x11_glx_render_BindProgramNV_program = -1; +static int hf_x11_glx_render_ExecuteProgramNV_target = -1; +static int hf_x11_glx_render_ExecuteProgramNV_id = -1; +static int hf_x11_glx_render_ExecuteProgramNV_params = -1; +static int hf_x11_glx_render_ExecuteProgramNV_params_item = -1; +static int hf_x11_glx_render_LoadProgramNV_target = -1; +static int hf_x11_glx_render_LoadProgramNV_id = -1; +static int hf_x11_glx_render_LoadProgramNV_len = -1; +static int hf_x11_glx_render_LoadProgramNV_program = -1; +static int hf_x11_glx_render_ProgramParameters4dvNV_target = -1; +static int hf_x11_glx_render_ProgramParameters4dvNV_index = -1; +static int hf_x11_glx_render_ProgramParameters4dvNV_num = -1; +static int hf_x11_glx_render_ProgramParameters4dvNV_params = -1; +static int hf_x11_glx_render_ProgramParameters4dvNV_params_item = -1; +static int hf_x11_glx_render_ProgramParameters4fvNV_target = -1; +static int hf_x11_glx_render_ProgramParameters4fvNV_index = -1; +static int hf_x11_glx_render_ProgramParameters4fvNV_num = -1; +static int hf_x11_glx_render_ProgramParameters4fvNV_params = -1; +static int hf_x11_glx_render_ProgramParameters4fvNV_params_item = -1; +static int hf_x11_glx_render_RequestResidentProgramsNV_n = -1; +static int hf_x11_glx_render_RequestResidentProgramsNV_ids = -1; +static int hf_x11_glx_render_RequestResidentProgramsNV_ids_item = -1; +static int hf_x11_glx_render_TrackMatrixNV_target = -1; +static int hf_x11_glx_render_TrackMatrixNV_address = -1; +static int hf_x11_glx_render_TrackMatrixNV_matrix = -1; +static int hf_x11_glx_render_TrackMatrixNV_transform = -1; +static int hf_x11_glx_render_VertexAttrib1svNV_index = -1; +static int hf_x11_glx_render_VertexAttrib1svNV_v = -1; +static int hf_x11_glx_render_VertexAttrib1svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib2svNV_index = -1; +static int hf_x11_glx_render_VertexAttrib2svNV_v = -1; +static int hf_x11_glx_render_VertexAttrib2svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib3svNV_index = -1; +static int hf_x11_glx_render_VertexAttrib3svNV_v = -1; +static int hf_x11_glx_render_VertexAttrib3svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4svNV_index = -1; +static int hf_x11_glx_render_VertexAttrib4svNV_v = -1; +static int hf_x11_glx_render_VertexAttrib4svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib1fvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib1fvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib1fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib2fvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib2fvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib2fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib3fvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib3fvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib3fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4fvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib4fvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib4fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib1dvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib1dvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib1dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib2dvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib2dvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib2dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib3dvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib3dvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib3dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4dvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib4dvNV_v = -1; +static int hf_x11_glx_render_VertexAttrib4dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttrib4ubvNV_index = -1; +static int hf_x11_glx_render_VertexAttrib4ubvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs1svNV_index = -1; +static int hf_x11_glx_render_VertexAttribs1svNV_n = -1; +static int hf_x11_glx_render_VertexAttribs1svNV_v = -1; +static int hf_x11_glx_render_VertexAttribs1svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs2svNV_index = -1; +static int hf_x11_glx_render_VertexAttribs2svNV_n = -1; +static int hf_x11_glx_render_VertexAttribs2svNV_v = -1; +static int hf_x11_glx_render_VertexAttribs2svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs3svNV_index = -1; +static int hf_x11_glx_render_VertexAttribs3svNV_n = -1; +static int hf_x11_glx_render_VertexAttribs3svNV_v = -1; +static int hf_x11_glx_render_VertexAttribs3svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs4svNV_index = -1; +static int hf_x11_glx_render_VertexAttribs4svNV_n = -1; +static int hf_x11_glx_render_VertexAttribs4svNV_v = -1; +static int hf_x11_glx_render_VertexAttribs4svNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs1fvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs1fvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs1fvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs1fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs2fvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs2fvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs2fvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs2fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs3fvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs3fvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs3fvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs3fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs4fvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs4fvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs4fvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs4fvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs1dvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs1dvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs1dvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs1dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs2dvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs2dvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs2dvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs2dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs3dvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs3dvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs3dvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs3dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs4dvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs4dvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs4dvNV_v = -1; +static int hf_x11_glx_render_VertexAttribs4dvNV_v_item = -1; +static int hf_x11_glx_render_VertexAttribs4ubvNV_index = -1; +static int hf_x11_glx_render_VertexAttribs4ubvNV_n = -1; +static int hf_x11_glx_render_VertexAttribs4ubvNV_v = -1; +static int hf_x11_glx_render_PointParameteriNV_pname = -1; +static int hf_x11_glx_render_PointParameteriNV_param = -1; +static int hf_x11_glx_render_PointParameterivNV_pname = -1; +static int hf_x11_glx_render_PointParameterivNV_params = -1; +static int hf_x11_glx_render_PointParameterivNV_params_item = -1; +static int hf_x11_glx_render_ActiveStencilFaceEXT_face = -1; +static int hf_x11_glx_render_ProgramNamedParameter4fvNV_id = -1; +static int hf_x11_glx_render_ProgramNamedParameter4fvNV_len = -1; +static int hf_x11_glx_render_ProgramNamedParameter4fvNV_name = -1; +static int hf_x11_glx_render_ProgramNamedParameter4fvNV_v = -1; +static int hf_x11_glx_render_ProgramNamedParameter4fvNV_v_item = -1; +static int hf_x11_glx_render_ProgramNamedParameter4dvNV_id = -1; +static int hf_x11_glx_render_ProgramNamedParameter4dvNV_len = -1; +static int hf_x11_glx_render_ProgramNamedParameter4dvNV_name = -1; +static int hf_x11_glx_render_ProgramNamedParameter4dvNV_v = -1; +static int hf_x11_glx_render_ProgramNamedParameter4dvNV_v_item = -1; +static int hf_x11_glx_render_DepthBoundsEXT_zmin = -1; +static int hf_x11_glx_render_DepthBoundsEXT_zmax = -1; +static int hf_x11_glx_render_BlendEquationSeparateEXT_modeRGB = -1; +static int hf_x11_glx_render_BlendEquationSeparateEXT_modeA = -1; +static int hf_x11_glx_render_op_name = -1; + +static int hf_x11_bigreq_Enable_reply_maximum_request_length = -1; +static int hf_x11_bigreq_extension_minor = -1; + +static int hf_x11_struct_RECTANGLE = -1; +static int hf_x11_struct_RECTANGLE_x = -1; +static int hf_x11_struct_RECTANGLE_y = -1; +static int hf_x11_struct_RECTANGLE_width = -1; +static int hf_x11_struct_RECTANGLE_height = -1; +static int hf_x11_struct_STR = -1; +static int hf_x11_struct_STR_name_len = -1; +static int hf_x11_struct_STR_name = -1; +static int hf_x11_struct_DIRECTFORMAT = -1; +static int hf_x11_struct_DIRECTFORMAT_red_shift = -1; +static int hf_x11_struct_DIRECTFORMAT_red_mask = -1; +static int hf_x11_struct_DIRECTFORMAT_green_shift = -1; +static int hf_x11_struct_DIRECTFORMAT_green_mask = -1; +static int hf_x11_struct_DIRECTFORMAT_blue_shift = -1; +static int hf_x11_struct_DIRECTFORMAT_blue_mask = -1; +static int hf_x11_struct_DIRECTFORMAT_alpha_shift = -1; +static int hf_x11_struct_DIRECTFORMAT_alpha_mask = -1; +static int hf_x11_struct_PICTFORMINFO = -1; +static int hf_x11_struct_PICTFORMINFO_id = -1; +static int hf_x11_struct_PICTFORMINFO_type = -1; +static int hf_x11_struct_PICTFORMINFO_depth = -1; +static int hf_x11_struct_PICTFORMINFO_direct = -1; +static int hf_x11_struct_PICTFORMINFO_colormap = -1; +static int hf_x11_struct_PICTVISUAL = -1; +static int hf_x11_struct_PICTVISUAL_visual = -1; +static int hf_x11_struct_PICTVISUAL_format = -1; +static int hf_x11_struct_PICTDEPTH = -1; +static int hf_x11_struct_PICTDEPTH_depth = -1; +static int hf_x11_struct_PICTDEPTH_num_visuals = -1; +static int hf_x11_struct_PICTDEPTH_visuals = -1; +static int hf_x11_struct_PICTDEPTH_visuals_item = -1; +static int hf_x11_struct_PICTSCREEN = -1; +static int hf_x11_struct_PICTSCREEN_num_depths = -1; +static int hf_x11_struct_PICTSCREEN_fallback = -1; +static int hf_x11_struct_PICTSCREEN_depths = -1; +static int hf_x11_struct_INDEXVALUE = -1; +static int hf_x11_struct_INDEXVALUE_pixel = -1; +static int hf_x11_struct_INDEXVALUE_red = -1; +static int hf_x11_struct_INDEXVALUE_green = -1; +static int hf_x11_struct_INDEXVALUE_blue = -1; +static int hf_x11_struct_INDEXVALUE_alpha = -1; +static int hf_x11_struct_COLOR = -1; +static int hf_x11_struct_COLOR_red = -1; +static int hf_x11_struct_COLOR_green = -1; +static int hf_x11_struct_COLOR_blue = -1; +static int hf_x11_struct_COLOR_alpha = -1; +static int hf_x11_struct_POINTFIX = -1; +static int hf_x11_struct_POINTFIX_x = -1; +static int hf_x11_struct_POINTFIX_y = -1; +static int hf_x11_struct_LINEFIX = -1; +static int hf_x11_struct_LINEFIX_p1 = -1; +static int hf_x11_struct_LINEFIX_p2 = -1; +static int hf_x11_struct_TRIANGLE = -1; +static int hf_x11_struct_TRIANGLE_p1 = -1; +static int hf_x11_struct_TRIANGLE_p2 = -1; +static int hf_x11_struct_TRIANGLE_p3 = -1; +static int hf_x11_struct_TRAPEZOID = -1; +static int hf_x11_struct_TRAPEZOID_top = -1; +static int hf_x11_struct_TRAPEZOID_bottom = -1; +static int hf_x11_struct_TRAPEZOID_left = -1; +static int hf_x11_struct_TRAPEZOID_right = -1; +static int hf_x11_struct_GLYPHINFO = -1; +static int hf_x11_struct_GLYPHINFO_width = -1; +static int hf_x11_struct_GLYPHINFO_height = -1; +static int hf_x11_struct_GLYPHINFO_x = -1; +static int hf_x11_struct_GLYPHINFO_y = -1; +static int hf_x11_struct_GLYPHINFO_x_off = -1; +static int hf_x11_struct_GLYPHINFO_y_off = -1; +static int hf_x11_struct_TRANSFORM = -1; +static int hf_x11_struct_TRANSFORM_matrix11 = -1; +static int hf_x11_struct_TRANSFORM_matrix12 = -1; +static int hf_x11_struct_TRANSFORM_matrix13 = -1; +static int hf_x11_struct_TRANSFORM_matrix21 = -1; +static int hf_x11_struct_TRANSFORM_matrix22 = -1; +static int hf_x11_struct_TRANSFORM_matrix23 = -1; +static int hf_x11_struct_TRANSFORM_matrix31 = -1; +static int hf_x11_struct_TRANSFORM_matrix32 = -1; +static int hf_x11_struct_TRANSFORM_matrix33 = -1; +static int hf_x11_struct_ANIMCURSORELT = -1; +static int hf_x11_struct_ANIMCURSORELT_cursor = -1; +static int hf_x11_struct_ANIMCURSORELT_delay = -1; +static int hf_x11_struct_SPANFIX = -1; +static int hf_x11_struct_SPANFIX_l = -1; +static int hf_x11_struct_SPANFIX_r = -1; +static int hf_x11_struct_SPANFIX_y = -1; +static int hf_x11_struct_TRAP = -1; +static int hf_x11_struct_TRAP_top = -1; +static int hf_x11_struct_TRAP_bot = -1; +static int hf_x11_composite_QueryVersion_client_major_version = -1; +static int hf_x11_composite_QueryVersion_client_minor_version = -1; +static int hf_x11_composite_QueryVersion_reply_major_version = -1; +static int hf_x11_composite_QueryVersion_reply_minor_version = -1; +static int hf_x11_composite_RedirectWindow_window = -1; +static int hf_x11_composite_RedirectWindow_update = -1; +static int hf_x11_composite_RedirectSubwindows_window = -1; +static int hf_x11_composite_RedirectSubwindows_update = -1; +static int hf_x11_composite_UnredirectWindow_window = -1; +static int hf_x11_composite_UnredirectWindow_update = -1; +static int hf_x11_composite_UnredirectSubwindows_window = -1; +static int hf_x11_composite_UnredirectSubwindows_update = -1; +static int hf_x11_composite_CreateRegionFromBorderClip_region = -1; +static int hf_x11_composite_CreateRegionFromBorderClip_window = -1; +static int hf_x11_composite_NameWindowPixmap_window = -1; +static int hf_x11_composite_NameWindowPixmap_pixmap = -1; +static int hf_x11_composite_GetOverlayWindow_window = -1; +static int hf_x11_composite_GetOverlayWindow_reply_overlay_win = -1; +static int hf_x11_composite_ReleaseOverlayWindow_window = -1; +static int hf_x11_composite_extension_minor = -1; + +static int hf_x11_damage_QueryVersion_client_major_version = -1; +static int hf_x11_damage_QueryVersion_client_minor_version = -1; +static int hf_x11_damage_QueryVersion_reply_major_version = -1; +static int hf_x11_damage_QueryVersion_reply_minor_version = -1; +static int hf_x11_damage_Create_damage = -1; +static int hf_x11_damage_Create_drawable = -1; +static int hf_x11_damage_Create_level = -1; +static int hf_x11_damage_Destroy_damage = -1; +static int hf_x11_damage_Subtract_damage = -1; +static int hf_x11_damage_Subtract_repair = -1; +static int hf_x11_damage_Subtract_parts = -1; +static int hf_x11_damage_Add_drawable = -1; +static int hf_x11_damage_Add_region = -1; +static int hf_x11_damage_Notify_level = -1; +static int hf_x11_damage_Notify_drawable = -1; +static int hf_x11_damage_Notify_damage = -1; +static int hf_x11_damage_Notify_timestamp = -1; +static int hf_x11_damage_Notify_area = -1; +static int hf_x11_damage_Notify_geometry = -1; +static int hf_x11_damage_extension_minor = -1; + +static int hf_x11_dpms_GetVersion_client_major_version = -1; +static int hf_x11_dpms_GetVersion_client_minor_version = -1; +static int hf_x11_dpms_GetVersion_reply_server_major_version = -1; +static int hf_x11_dpms_GetVersion_reply_server_minor_version = -1; +static int hf_x11_dpms_Capable_reply_capable = -1; +static int hf_x11_dpms_GetTimeouts_reply_standby_timeout = -1; +static int hf_x11_dpms_GetTimeouts_reply_suspend_timeout = -1; +static int hf_x11_dpms_GetTimeouts_reply_off_timeout = -1; +static int hf_x11_dpms_SetTimeouts_standby_timeout = -1; +static int hf_x11_dpms_SetTimeouts_suspend_timeout = -1; +static int hf_x11_dpms_SetTimeouts_off_timeout = -1; +static int hf_x11_dpms_ForceLevel_power_level = -1; +static int hf_x11_dpms_Info_reply_power_level = -1; +static int hf_x11_dpms_Info_reply_state = -1; +static int hf_x11_dpms_extension_minor = -1; + +static int hf_x11_ge_QueryVersion_client_major_version = -1; +static int hf_x11_ge_QueryVersion_client_minor_version = -1; +static int hf_x11_ge_QueryVersion_reply_major_version = -1; +static int hf_x11_ge_QueryVersion_reply_minor_version = -1; +static int hf_x11_ge_extension_minor = -1; + +static int hf_x11_glx_PbufferClobber_event_type = -1; +static int hf_x11_glx_PbufferClobber_draw_type = -1; +static int hf_x11_glx_PbufferClobber_drawable = -1; +static int hf_x11_glx_PbufferClobber_b_mask = -1; +static int hf_x11_glx_PbufferClobber_aux_buffer = -1; +static int hf_x11_glx_PbufferClobber_x = -1; +static int hf_x11_glx_PbufferClobber_y = -1; +static int hf_x11_glx_PbufferClobber_width = -1; +static int hf_x11_glx_PbufferClobber_height = -1; +static int hf_x11_glx_PbufferClobber_count = -1; +static int hf_x11_glx_Render_context_tag = -1; +static int hf_x11_glx_Render_data = -1; +static int hf_x11_glx_RenderLarge_context_tag = -1; +static int hf_x11_glx_RenderLarge_request_num = -1; +static int hf_x11_glx_RenderLarge_request_total = -1; +static int hf_x11_glx_RenderLarge_data_len = -1; +static int hf_x11_glx_RenderLarge_data = -1; +static int hf_x11_glx_CreateContext_context = -1; +static int hf_x11_glx_CreateContext_visual = -1; +static int hf_x11_glx_CreateContext_screen = -1; +static int hf_x11_glx_CreateContext_share_list = -1; +static int hf_x11_glx_CreateContext_is_direct = -1; +static int hf_x11_glx_DestroyContext_context = -1; +static int hf_x11_glx_MakeCurrent_drawable = -1; +static int hf_x11_glx_MakeCurrent_context = -1; +static int hf_x11_glx_MakeCurrent_old_context_tag = -1; +static int hf_x11_glx_MakeCurrent_reply_context_tag = -1; +static int hf_x11_glx_IsDirect_context = -1; +static int hf_x11_glx_IsDirect_reply_is_direct = -1; +static int hf_x11_glx_QueryVersion_major_version = -1; +static int hf_x11_glx_QueryVersion_minor_version = -1; +static int hf_x11_glx_QueryVersion_reply_major_version = -1; +static int hf_x11_glx_QueryVersion_reply_minor_version = -1; +static int hf_x11_glx_WaitGL_context_tag = -1; +static int hf_x11_glx_WaitX_context_tag = -1; +static int hf_x11_glx_CopyContext_src = -1; +static int hf_x11_glx_CopyContext_dest = -1; +static int hf_x11_glx_CopyContext_mask = -1; +static int hf_x11_glx_CopyContext_src_context_tag = -1; +static int hf_x11_glx_SwapBuffers_context_tag = -1; +static int hf_x11_glx_SwapBuffers_drawable = -1; +static int hf_x11_glx_UseXFont_context_tag = -1; +static int hf_x11_glx_UseXFont_font = -1; +static int hf_x11_glx_UseXFont_first = -1; +static int hf_x11_glx_UseXFont_count = -1; +static int hf_x11_glx_UseXFont_list_base = -1; +static int hf_x11_glx_CreateGLXPixmap_screen = -1; +static int hf_x11_glx_CreateGLXPixmap_visual = -1; +static int hf_x11_glx_CreateGLXPixmap_pixmap = -1; +static int hf_x11_glx_CreateGLXPixmap_glx_pixmap = -1; +static int hf_x11_glx_GetVisualConfigs_screen = -1; +static int hf_x11_glx_GetVisualConfigs_reply_num_visuals = -1; +static int hf_x11_glx_GetVisualConfigs_reply_num_properties = -1; +static int hf_x11_glx_GetVisualConfigs_reply_property_list = -1; +static int hf_x11_glx_GetVisualConfigs_reply_property_list_item = -1; +static int hf_x11_glx_DestroyGLXPixmap_glx_pixmap = -1; +static int hf_x11_glx_VendorPrivate_vendor_code = -1; +static int hf_x11_glx_VendorPrivate_context_tag = -1; +static int hf_x11_glx_VendorPrivate_data = -1; +static int hf_x11_glx_VendorPrivateWithReply_vendor_code = -1; +static int hf_x11_glx_VendorPrivateWithReply_context_tag = -1; +static int hf_x11_glx_VendorPrivateWithReply_data = -1; +static int hf_x11_glx_VendorPrivateWithReply_reply_retval = -1; +static int hf_x11_glx_VendorPrivateWithReply_reply_data1 = -1; +static int hf_x11_glx_VendorPrivateWithReply_reply_data2 = -1; +static int hf_x11_glx_QueryExtensionsString_screen = -1; +static int hf_x11_glx_QueryExtensionsString_reply_n = -1; +static int hf_x11_glx_QueryServerString_screen = -1; +static int hf_x11_glx_QueryServerString_name = -1; +static int hf_x11_glx_QueryServerString_reply_str_len = -1; +static int hf_x11_glx_QueryServerString_reply_string = -1; +static int hf_x11_glx_ClientInfo_major_version = -1; +static int hf_x11_glx_ClientInfo_minor_version = -1; +static int hf_x11_glx_ClientInfo_str_len = -1; +static int hf_x11_glx_ClientInfo_string = -1; +static int hf_x11_glx_GetFBConfigs_screen = -1; +static int hf_x11_glx_GetFBConfigs_reply_num_FB_configs = -1; +static int hf_x11_glx_GetFBConfigs_reply_num_properties = -1; +static int hf_x11_glx_GetFBConfigs_reply_property_list = -1; +static int hf_x11_glx_GetFBConfigs_reply_property_list_item = -1; +static int hf_x11_glx_CreatePixmap_screen = -1; +static int hf_x11_glx_CreatePixmap_fbconfig = -1; +static int hf_x11_glx_CreatePixmap_pixmap = -1; +static int hf_x11_glx_CreatePixmap_glx_pixmap = -1; +static int hf_x11_glx_CreatePixmap_num_attribs = -1; +static int hf_x11_glx_CreatePixmap_attribs = -1; +static int hf_x11_glx_CreatePixmap_attribs_item = -1; +static int hf_x11_glx_DestroyPixmap_glx_pixmap = -1; +static int hf_x11_glx_CreateNewContext_context = -1; +static int hf_x11_glx_CreateNewContext_fbconfig = -1; +static int hf_x11_glx_CreateNewContext_screen = -1; +static int hf_x11_glx_CreateNewContext_render_type = -1; +static int hf_x11_glx_CreateNewContext_share_list = -1; +static int hf_x11_glx_CreateNewContext_is_direct = -1; +static int hf_x11_glx_CreateNewContext_reserved1 = -1; +static int hf_x11_glx_CreateNewContext_reserved2 = -1; +static int hf_x11_glx_QueryContext_context = -1; +static int hf_x11_glx_QueryContext_reply_num_attribs = -1; +static int hf_x11_glx_QueryContext_reply_attribs = -1; +static int hf_x11_glx_QueryContext_reply_attribs_item = -1; +static int hf_x11_glx_MakeContextCurrent_old_context_tag = -1; +static int hf_x11_glx_MakeContextCurrent_drawable = -1; +static int hf_x11_glx_MakeContextCurrent_read_drawable = -1; +static int hf_x11_glx_MakeContextCurrent_context = -1; +static int hf_x11_glx_MakeContextCurrent_reply_context_tag = -1; +static int hf_x11_glx_CreatePbuffer_screen = -1; +static int hf_x11_glx_CreatePbuffer_fbconfig = -1; +static int hf_x11_glx_CreatePbuffer_pbuffer = -1; +static int hf_x11_glx_CreatePbuffer_num_attribs = -1; +static int hf_x11_glx_CreatePbuffer_attribs = -1; +static int hf_x11_glx_CreatePbuffer_attribs_item = -1; +static int hf_x11_glx_DestroyPbuffer_pbuffer = -1; +static int hf_x11_glx_GetDrawableAttributes_drawable = -1; +static int hf_x11_glx_GetDrawableAttributes_reply_num_attribs = -1; +static int hf_x11_glx_GetDrawableAttributes_reply_attribs = -1; +static int hf_x11_glx_GetDrawableAttributes_reply_attribs_item = -1; +static int hf_x11_glx_ChangeDrawableAttributes_drawable = -1; +static int hf_x11_glx_ChangeDrawableAttributes_num_attribs = -1; +static int hf_x11_glx_ChangeDrawableAttributes_attribs = -1; +static int hf_x11_glx_ChangeDrawableAttributes_attribs_item = -1; +static int hf_x11_glx_CreateWindow_screen = -1; +static int hf_x11_glx_CreateWindow_fbconfig = -1; +static int hf_x11_glx_CreateWindow_window = -1; +static int hf_x11_glx_CreateWindow_glx_window = -1; +static int hf_x11_glx_CreateWindow_num_attribs = -1; +static int hf_x11_glx_CreateWindow_attribs = -1; +static int hf_x11_glx_CreateWindow_attribs_item = -1; +static int hf_x11_glx_DeleteWindow_glxwindow = -1; +static int hf_x11_glx_NewList_context_tag = -1; +static int hf_x11_glx_NewList_list = -1; +static int hf_x11_glx_NewList_mode = -1; +static int hf_x11_glx_EndList_context_tag = -1; +static int hf_x11_glx_DeleteLists_context_tag = -1; +static int hf_x11_glx_DeleteLists_list = -1; +static int hf_x11_glx_DeleteLists_range = -1; +static int hf_x11_glx_GenLists_context_tag = -1; +static int hf_x11_glx_GenLists_range = -1; +static int hf_x11_glx_GenLists_reply_ret_val = -1; +static int hf_x11_glx_FeedbackBuffer_context_tag = -1; +static int hf_x11_glx_FeedbackBuffer_size = -1; +static int hf_x11_glx_FeedbackBuffer_type = -1; +static int hf_x11_glx_SelectBuffer_context_tag = -1; +static int hf_x11_glx_SelectBuffer_size = -1; +static int hf_x11_glx_RenderMode_context_tag = -1; +static int hf_x11_glx_RenderMode_mode = -1; +static int hf_x11_glx_RenderMode_reply_ret_val = -1; +static int hf_x11_glx_RenderMode_reply_n = -1; +static int hf_x11_glx_RenderMode_reply_new_mode = -1; +static int hf_x11_glx_RenderMode_reply_data = -1; +static int hf_x11_glx_RenderMode_reply_data_item = -1; +static int hf_x11_glx_Finish_context_tag = -1; +static int hf_x11_glx_PixelStoref_context_tag = -1; +static int hf_x11_glx_PixelStoref_pname = -1; +static int hf_x11_glx_PixelStoref_datum = -1; +static int hf_x11_glx_PixelStorei_context_tag = -1; +static int hf_x11_glx_PixelStorei_pname = -1; +static int hf_x11_glx_PixelStorei_datum = -1; +static int hf_x11_glx_ReadPixels_context_tag = -1; +static int hf_x11_glx_ReadPixels_x = -1; +static int hf_x11_glx_ReadPixels_y = -1; +static int hf_x11_glx_ReadPixels_width = -1; +static int hf_x11_glx_ReadPixels_height = -1; +static int hf_x11_glx_ReadPixels_format = -1; +static int hf_x11_glx_ReadPixels_type = -1; +static int hf_x11_glx_ReadPixels_swap_bytes = -1; +static int hf_x11_glx_ReadPixels_lsb_first = -1; +static int hf_x11_glx_ReadPixels_reply_data = -1; +static int hf_x11_glx_GetBooleanv_context_tag = -1; +static int hf_x11_glx_GetBooleanv_pname = -1; +static int hf_x11_glx_GetBooleanv_reply_n = -1; +static int hf_x11_glx_GetBooleanv_reply_datum = -1; +static int hf_x11_glx_GetBooleanv_reply_data = -1; +static int hf_x11_glx_GetClipPlane_context_tag = -1; +static int hf_x11_glx_GetClipPlane_plane = -1; +static int hf_x11_glx_GetClipPlane_reply_data = -1; +static int hf_x11_glx_GetClipPlane_reply_data_item = -1; +static int hf_x11_glx_GetDoublev_context_tag = -1; +static int hf_x11_glx_GetDoublev_pname = -1; +static int hf_x11_glx_GetDoublev_reply_n = -1; +static int hf_x11_glx_GetDoublev_reply_datum = -1; +static int hf_x11_glx_GetDoublev_reply_data = -1; +static int hf_x11_glx_GetDoublev_reply_data_item = -1; +static int hf_x11_glx_GetError_context_tag = -1; +static int hf_x11_glx_GetError_reply_error = -1; +static int hf_x11_glx_GetFloatv_context_tag = -1; +static int hf_x11_glx_GetFloatv_pname = -1; +static int hf_x11_glx_GetFloatv_reply_n = -1; +static int hf_x11_glx_GetFloatv_reply_datum = -1; +static int hf_x11_glx_GetFloatv_reply_data = -1; +static int hf_x11_glx_GetFloatv_reply_data_item = -1; +static int hf_x11_glx_GetIntegerv_context_tag = -1; +static int hf_x11_glx_GetIntegerv_pname = -1; +static int hf_x11_glx_GetIntegerv_reply_n = -1; +static int hf_x11_glx_GetIntegerv_reply_datum = -1; +static int hf_x11_glx_GetIntegerv_reply_data = -1; +static int hf_x11_glx_GetIntegerv_reply_data_item = -1; +static int hf_x11_glx_GetLightfv_context_tag = -1; +static int hf_x11_glx_GetLightfv_light = -1; +static int hf_x11_glx_GetLightfv_pname = -1; +static int hf_x11_glx_GetLightfv_reply_n = -1; +static int hf_x11_glx_GetLightfv_reply_datum = -1; +static int hf_x11_glx_GetLightfv_reply_data = -1; +static int hf_x11_glx_GetLightfv_reply_data_item = -1; +static int hf_x11_glx_GetLightiv_context_tag = -1; +static int hf_x11_glx_GetLightiv_light = -1; +static int hf_x11_glx_GetLightiv_pname = -1; +static int hf_x11_glx_GetLightiv_reply_n = -1; +static int hf_x11_glx_GetLightiv_reply_datum = -1; +static int hf_x11_glx_GetLightiv_reply_data = -1; +static int hf_x11_glx_GetLightiv_reply_data_item = -1; +static int hf_x11_glx_GetMapdv_context_tag = -1; +static int hf_x11_glx_GetMapdv_target = -1; +static int hf_x11_glx_GetMapdv_query = -1; +static int hf_x11_glx_GetMapdv_reply_n = -1; +static int hf_x11_glx_GetMapdv_reply_datum = -1; +static int hf_x11_glx_GetMapdv_reply_data = -1; +static int hf_x11_glx_GetMapdv_reply_data_item = -1; +static int hf_x11_glx_GetMapfv_context_tag = -1; +static int hf_x11_glx_GetMapfv_target = -1; +static int hf_x11_glx_GetMapfv_query = -1; +static int hf_x11_glx_GetMapfv_reply_n = -1; +static int hf_x11_glx_GetMapfv_reply_datum = -1; +static int hf_x11_glx_GetMapfv_reply_data = -1; +static int hf_x11_glx_GetMapfv_reply_data_item = -1; +static int hf_x11_glx_GetMapiv_context_tag = -1; +static int hf_x11_glx_GetMapiv_target = -1; +static int hf_x11_glx_GetMapiv_query = -1; +static int hf_x11_glx_GetMapiv_reply_n = -1; +static int hf_x11_glx_GetMapiv_reply_datum = -1; +static int hf_x11_glx_GetMapiv_reply_data = -1; +static int hf_x11_glx_GetMapiv_reply_data_item = -1; +static int hf_x11_glx_GetMaterialfv_context_tag = -1; +static int hf_x11_glx_GetMaterialfv_face = -1; +static int hf_x11_glx_GetMaterialfv_pname = -1; +static int hf_x11_glx_GetMaterialfv_reply_n = -1; +static int hf_x11_glx_GetMaterialfv_reply_datum = -1; +static int hf_x11_glx_GetMaterialfv_reply_data = -1; +static int hf_x11_glx_GetMaterialfv_reply_data_item = -1; +static int hf_x11_glx_GetMaterialiv_context_tag = -1; +static int hf_x11_glx_GetMaterialiv_face = -1; +static int hf_x11_glx_GetMaterialiv_pname = -1; +static int hf_x11_glx_GetMaterialiv_reply_n = -1; +static int hf_x11_glx_GetMaterialiv_reply_datum = -1; +static int hf_x11_glx_GetMaterialiv_reply_data = -1; +static int hf_x11_glx_GetMaterialiv_reply_data_item = -1; +static int hf_x11_glx_GetPixelMapfv_context_tag = -1; +static int hf_x11_glx_GetPixelMapfv_map = -1; +static int hf_x11_glx_GetPixelMapfv_reply_n = -1; +static int hf_x11_glx_GetPixelMapfv_reply_datum = -1; +static int hf_x11_glx_GetPixelMapfv_reply_data = -1; +static int hf_x11_glx_GetPixelMapfv_reply_data_item = -1; +static int hf_x11_glx_GetPixelMapuiv_context_tag = -1; +static int hf_x11_glx_GetPixelMapuiv_map = -1; +static int hf_x11_glx_GetPixelMapuiv_reply_n = -1; +static int hf_x11_glx_GetPixelMapuiv_reply_datum = -1; +static int hf_x11_glx_GetPixelMapuiv_reply_data = -1; +static int hf_x11_glx_GetPixelMapuiv_reply_data_item = -1; +static int hf_x11_glx_GetPixelMapusv_context_tag = -1; +static int hf_x11_glx_GetPixelMapusv_map = -1; +static int hf_x11_glx_GetPixelMapusv_reply_n = -1; +static int hf_x11_glx_GetPixelMapusv_reply_datum = -1; +static int hf_x11_glx_GetPixelMapusv_reply_data = -1; +static int hf_x11_glx_GetPixelMapusv_reply_data_item = -1; +static int hf_x11_glx_GetPolygonStipple_context_tag = -1; +static int hf_x11_glx_GetPolygonStipple_lsb_first = -1; +static int hf_x11_glx_GetPolygonStipple_reply_data = -1; +static int hf_x11_glx_GetString_context_tag = -1; +static int hf_x11_glx_GetString_name = -1; +static int hf_x11_glx_GetString_reply_n = -1; +static int hf_x11_glx_GetString_reply_string = -1; +static int hf_x11_glx_GetTexEnvfv_context_tag = -1; +static int hf_x11_glx_GetTexEnvfv_target = -1; +static int hf_x11_glx_GetTexEnvfv_pname = -1; +static int hf_x11_glx_GetTexEnvfv_reply_n = -1; +static int hf_x11_glx_GetTexEnvfv_reply_datum = -1; +static int hf_x11_glx_GetTexEnvfv_reply_data = -1; +static int hf_x11_glx_GetTexEnvfv_reply_data_item = -1; +static int hf_x11_glx_GetTexEnviv_context_tag = -1; +static int hf_x11_glx_GetTexEnviv_target = -1; +static int hf_x11_glx_GetTexEnviv_pname = -1; +static int hf_x11_glx_GetTexEnviv_reply_n = -1; +static int hf_x11_glx_GetTexEnviv_reply_datum = -1; +static int hf_x11_glx_GetTexEnviv_reply_data = -1; +static int hf_x11_glx_GetTexEnviv_reply_data_item = -1; +static int hf_x11_glx_GetTexGendv_context_tag = -1; +static int hf_x11_glx_GetTexGendv_coord = -1; +static int hf_x11_glx_GetTexGendv_pname = -1; +static int hf_x11_glx_GetTexGendv_reply_n = -1; +static int hf_x11_glx_GetTexGendv_reply_datum = -1; +static int hf_x11_glx_GetTexGendv_reply_data = -1; +static int hf_x11_glx_GetTexGendv_reply_data_item = -1; +static int hf_x11_glx_GetTexGenfv_context_tag = -1; +static int hf_x11_glx_GetTexGenfv_coord = -1; +static int hf_x11_glx_GetTexGenfv_pname = -1; +static int hf_x11_glx_GetTexGenfv_reply_n = -1; +static int hf_x11_glx_GetTexGenfv_reply_datum = -1; +static int hf_x11_glx_GetTexGenfv_reply_data = -1; +static int hf_x11_glx_GetTexGenfv_reply_data_item = -1; +static int hf_x11_glx_GetTexGeniv_context_tag = -1; +static int hf_x11_glx_GetTexGeniv_coord = -1; +static int hf_x11_glx_GetTexGeniv_pname = -1; +static int hf_x11_glx_GetTexGeniv_reply_n = -1; +static int hf_x11_glx_GetTexGeniv_reply_datum = -1; +static int hf_x11_glx_GetTexGeniv_reply_data = -1; +static int hf_x11_glx_GetTexGeniv_reply_data_item = -1; +static int hf_x11_glx_GetTexImage_context_tag = -1; +static int hf_x11_glx_GetTexImage_target = -1; +static int hf_x11_glx_GetTexImage_level = -1; +static int hf_x11_glx_GetTexImage_format = -1; +static int hf_x11_glx_GetTexImage_type = -1; +static int hf_x11_glx_GetTexImage_swap_bytes = -1; +static int hf_x11_glx_GetTexImage_reply_width = -1; +static int hf_x11_glx_GetTexImage_reply_height = -1; +static int hf_x11_glx_GetTexImage_reply_depth = -1; +static int hf_x11_glx_GetTexImage_reply_data = -1; +static int hf_x11_glx_GetTexParameterfv_context_tag = -1; +static int hf_x11_glx_GetTexParameterfv_target = -1; +static int hf_x11_glx_GetTexParameterfv_pname = -1; +static int hf_x11_glx_GetTexParameterfv_reply_n = -1; +static int hf_x11_glx_GetTexParameterfv_reply_datum = -1; +static int hf_x11_glx_GetTexParameterfv_reply_data = -1; +static int hf_x11_glx_GetTexParameterfv_reply_data_item = -1; +static int hf_x11_glx_GetTexParameteriv_context_tag = -1; +static int hf_x11_glx_GetTexParameteriv_target = -1; +static int hf_x11_glx_GetTexParameteriv_pname = -1; +static int hf_x11_glx_GetTexParameteriv_reply_n = -1; +static int hf_x11_glx_GetTexParameteriv_reply_datum = -1; +static int hf_x11_glx_GetTexParameteriv_reply_data = -1; +static int hf_x11_glx_GetTexParameteriv_reply_data_item = -1; +static int hf_x11_glx_GetTexLevelParameterfv_context_tag = -1; +static int hf_x11_glx_GetTexLevelParameterfv_target = -1; +static int hf_x11_glx_GetTexLevelParameterfv_level = -1; +static int hf_x11_glx_GetTexLevelParameterfv_pname = -1; +static int hf_x11_glx_GetTexLevelParameterfv_reply_n = -1; +static int hf_x11_glx_GetTexLevelParameterfv_reply_datum = -1; +static int hf_x11_glx_GetTexLevelParameterfv_reply_data = -1; +static int hf_x11_glx_GetTexLevelParameterfv_reply_data_item = -1; +static int hf_x11_glx_GetTexLevelParameteriv_context_tag = -1; +static int hf_x11_glx_GetTexLevelParameteriv_target = -1; +static int hf_x11_glx_GetTexLevelParameteriv_level = -1; +static int hf_x11_glx_GetTexLevelParameteriv_pname = -1; +static int hf_x11_glx_GetTexLevelParameteriv_reply_n = -1; +static int hf_x11_glx_GetTexLevelParameteriv_reply_datum = -1; +static int hf_x11_glx_GetTexLevelParameteriv_reply_data = -1; +static int hf_x11_glx_GetTexLevelParameteriv_reply_data_item = -1; +static int hf_x11_glx_IsList_context_tag = -1; +static int hf_x11_glx_IsList_list = -1; +static int hf_x11_glx_IsList_reply_ret_val = -1; +static int hf_x11_glx_Flush_context_tag = -1; +static int hf_x11_glx_AreTexturesResident_context_tag = -1; +static int hf_x11_glx_AreTexturesResident_n = -1; +static int hf_x11_glx_AreTexturesResident_textures = -1; +static int hf_x11_glx_AreTexturesResident_textures_item = -1; +static int hf_x11_glx_AreTexturesResident_reply_ret_val = -1; +static int hf_x11_glx_AreTexturesResident_reply_data = -1; +static int hf_x11_glx_DeleteTextures_context_tag = -1; +static int hf_x11_glx_DeleteTextures_n = -1; +static int hf_x11_glx_DeleteTextures_textures = -1; +static int hf_x11_glx_DeleteTextures_textures_item = -1; +static int hf_x11_glx_GenTextures_context_tag = -1; +static int hf_x11_glx_GenTextures_n = -1; +static int hf_x11_glx_GenTextures_reply_data = -1; +static int hf_x11_glx_GenTextures_reply_data_item = -1; +static int hf_x11_glx_IsTexture_context_tag = -1; +static int hf_x11_glx_IsTexture_texture = -1; +static int hf_x11_glx_IsTexture_reply_ret_val = -1; +static int hf_x11_glx_GetColorTable_context_tag = -1; +static int hf_x11_glx_GetColorTable_target = -1; +static int hf_x11_glx_GetColorTable_format = -1; +static int hf_x11_glx_GetColorTable_type = -1; +static int hf_x11_glx_GetColorTable_swap_bytes = -1; +static int hf_x11_glx_GetColorTable_reply_width = -1; +static int hf_x11_glx_GetColorTable_reply_data = -1; +static int hf_x11_glx_GetColorTableParameterfv_context_tag = -1; +static int hf_x11_glx_GetColorTableParameterfv_target = -1; +static int hf_x11_glx_GetColorTableParameterfv_pname = -1; +static int hf_x11_glx_GetColorTableParameterfv_reply_n = -1; +static int hf_x11_glx_GetColorTableParameterfv_reply_datum = -1; +static int hf_x11_glx_GetColorTableParameterfv_reply_data = -1; +static int hf_x11_glx_GetColorTableParameterfv_reply_data_item = -1; +static int hf_x11_glx_GetColorTableParameteriv_context_tag = -1; +static int hf_x11_glx_GetColorTableParameteriv_target = -1; +static int hf_x11_glx_GetColorTableParameteriv_pname = -1; +static int hf_x11_glx_GetColorTableParameteriv_reply_n = -1; +static int hf_x11_glx_GetColorTableParameteriv_reply_datum = -1; +static int hf_x11_glx_GetColorTableParameteriv_reply_data = -1; +static int hf_x11_glx_GetColorTableParameteriv_reply_data_item = -1; +static int hf_x11_glx_GetConvolutionFilter_context_tag = -1; +static int hf_x11_glx_GetConvolutionFilter_target = -1; +static int hf_x11_glx_GetConvolutionFilter_format = -1; +static int hf_x11_glx_GetConvolutionFilter_type = -1; +static int hf_x11_glx_GetConvolutionFilter_swap_bytes = -1; +static int hf_x11_glx_GetConvolutionFilter_reply_width = -1; +static int hf_x11_glx_GetConvolutionFilter_reply_height = -1; +static int hf_x11_glx_GetConvolutionFilter_reply_data = -1; +static int hf_x11_glx_GetConvolutionParameterfv_context_tag = -1; +static int hf_x11_glx_GetConvolutionParameterfv_target = -1; +static int hf_x11_glx_GetConvolutionParameterfv_pname = -1; +static int hf_x11_glx_GetConvolutionParameterfv_reply_n = -1; +static int hf_x11_glx_GetConvolutionParameterfv_reply_datum = -1; +static int hf_x11_glx_GetConvolutionParameterfv_reply_data = -1; +static int hf_x11_glx_GetConvolutionParameterfv_reply_data_item = -1; +static int hf_x11_glx_GetConvolutionParameteriv_context_tag = -1; +static int hf_x11_glx_GetConvolutionParameteriv_target = -1; +static int hf_x11_glx_GetConvolutionParameteriv_pname = -1; +static int hf_x11_glx_GetConvolutionParameteriv_reply_n = -1; +static int hf_x11_glx_GetConvolutionParameteriv_reply_datum = -1; +static int hf_x11_glx_GetConvolutionParameteriv_reply_data = -1; +static int hf_x11_glx_GetConvolutionParameteriv_reply_data_item = -1; +static int hf_x11_glx_GetSeparableFilter_context_tag = -1; +static int hf_x11_glx_GetSeparableFilter_target = -1; +static int hf_x11_glx_GetSeparableFilter_format = -1; +static int hf_x11_glx_GetSeparableFilter_type = -1; +static int hf_x11_glx_GetSeparableFilter_swap_bytes = -1; +static int hf_x11_glx_GetSeparableFilter_reply_row_w = -1; +static int hf_x11_glx_GetSeparableFilter_reply_col_h = -1; +static int hf_x11_glx_GetSeparableFilter_reply_rows_and_cols = -1; +static int hf_x11_glx_GetHistogram_context_tag = -1; +static int hf_x11_glx_GetHistogram_target = -1; +static int hf_x11_glx_GetHistogram_format = -1; +static int hf_x11_glx_GetHistogram_type = -1; +static int hf_x11_glx_GetHistogram_swap_bytes = -1; +static int hf_x11_glx_GetHistogram_reset = -1; +static int hf_x11_glx_GetHistogram_reply_width = -1; +static int hf_x11_glx_GetHistogram_reply_data = -1; +static int hf_x11_glx_GetHistogramParameterfv_context_tag = -1; +static int hf_x11_glx_GetHistogramParameterfv_target = -1; +static int hf_x11_glx_GetHistogramParameterfv_pname = -1; +static int hf_x11_glx_GetHistogramParameterfv_reply_n = -1; +static int hf_x11_glx_GetHistogramParameterfv_reply_datum = -1; +static int hf_x11_glx_GetHistogramParameterfv_reply_data = -1; +static int hf_x11_glx_GetHistogramParameterfv_reply_data_item = -1; +static int hf_x11_glx_GetHistogramParameteriv_context_tag = -1; +static int hf_x11_glx_GetHistogramParameteriv_target = -1; +static int hf_x11_glx_GetHistogramParameteriv_pname = -1; +static int hf_x11_glx_GetHistogramParameteriv_reply_n = -1; +static int hf_x11_glx_GetHistogramParameteriv_reply_datum = -1; +static int hf_x11_glx_GetHistogramParameteriv_reply_data = -1; +static int hf_x11_glx_GetHistogramParameteriv_reply_data_item = -1; +static int hf_x11_glx_GetMinmax_context_tag = -1; +static int hf_x11_glx_GetMinmax_target = -1; +static int hf_x11_glx_GetMinmax_format = -1; +static int hf_x11_glx_GetMinmax_type = -1; +static int hf_x11_glx_GetMinmax_swap_bytes = -1; +static int hf_x11_glx_GetMinmax_reset = -1; +static int hf_x11_glx_GetMinmax_reply_data = -1; +static int hf_x11_glx_GetMinmaxParameterfv_context_tag = -1; +static int hf_x11_glx_GetMinmaxParameterfv_target = -1; +static int hf_x11_glx_GetMinmaxParameterfv_pname = -1; +static int hf_x11_glx_GetMinmaxParameterfv_reply_n = -1; +static int hf_x11_glx_GetMinmaxParameterfv_reply_datum = -1; +static int hf_x11_glx_GetMinmaxParameterfv_reply_data = -1; +static int hf_x11_glx_GetMinmaxParameterfv_reply_data_item = -1; +static int hf_x11_glx_GetMinmaxParameteriv_context_tag = -1; +static int hf_x11_glx_GetMinmaxParameteriv_target = -1; +static int hf_x11_glx_GetMinmaxParameteriv_pname = -1; +static int hf_x11_glx_GetMinmaxParameteriv_reply_n = -1; +static int hf_x11_glx_GetMinmaxParameteriv_reply_datum = -1; +static int hf_x11_glx_GetMinmaxParameteriv_reply_data = -1; +static int hf_x11_glx_GetMinmaxParameteriv_reply_data_item = -1; +static int hf_x11_glx_GetCompressedTexImageARB_context_tag = -1; +static int hf_x11_glx_GetCompressedTexImageARB_target = -1; +static int hf_x11_glx_GetCompressedTexImageARB_level = -1; +static int hf_x11_glx_GetCompressedTexImageARB_reply_size = -1; +static int hf_x11_glx_GetCompressedTexImageARB_reply_data = -1; +static int hf_x11_glx_DeleteQueriesARB_context_tag = -1; +static int hf_x11_glx_DeleteQueriesARB_n = -1; +static int hf_x11_glx_DeleteQueriesARB_ids = -1; +static int hf_x11_glx_DeleteQueriesARB_ids_item = -1; +static int hf_x11_glx_GenQueriesARB_context_tag = -1; +static int hf_x11_glx_GenQueriesARB_n = -1; +static int hf_x11_glx_GenQueriesARB_reply_data = -1; +static int hf_x11_glx_GenQueriesARB_reply_data_item = -1; +static int hf_x11_glx_IsQueryARB_context_tag = -1; +static int hf_x11_glx_IsQueryARB_id = -1; +static int hf_x11_glx_IsQueryARB_reply_ret_val = -1; +static int hf_x11_glx_GetQueryivARB_context_tag = -1; +static int hf_x11_glx_GetQueryivARB_target = -1; +static int hf_x11_glx_GetQueryivARB_pname = -1; +static int hf_x11_glx_GetQueryivARB_reply_n = -1; +static int hf_x11_glx_GetQueryivARB_reply_datum = -1; +static int hf_x11_glx_GetQueryivARB_reply_data = -1; +static int hf_x11_glx_GetQueryivARB_reply_data_item = -1; +static int hf_x11_glx_GetQueryObjectivARB_context_tag = -1; +static int hf_x11_glx_GetQueryObjectivARB_id = -1; +static int hf_x11_glx_GetQueryObjectivARB_pname = -1; +static int hf_x11_glx_GetQueryObjectivARB_reply_n = -1; +static int hf_x11_glx_GetQueryObjectivARB_reply_datum = -1; +static int hf_x11_glx_GetQueryObjectivARB_reply_data = -1; +static int hf_x11_glx_GetQueryObjectivARB_reply_data_item = -1; +static int hf_x11_glx_GetQueryObjectuivARB_context_tag = -1; +static int hf_x11_glx_GetQueryObjectuivARB_id = -1; +static int hf_x11_glx_GetQueryObjectuivARB_pname = -1; +static int hf_x11_glx_GetQueryObjectuivARB_reply_n = -1; +static int hf_x11_glx_GetQueryObjectuivARB_reply_datum = -1; +static int hf_x11_glx_GetQueryObjectuivARB_reply_data = -1; +static int hf_x11_glx_GetQueryObjectuivARB_reply_data_item = -1; +static int hf_x11_glx_extension_minor = -1; + +static int hf_x11_struct_ScreenSize = -1; +static int hf_x11_struct_ScreenSize_width = -1; +static int hf_x11_struct_ScreenSize_height = -1; +static int hf_x11_struct_ScreenSize_mwidth = -1; +static int hf_x11_struct_ScreenSize_mheight = -1; +static int hf_x11_struct_RefreshRates = -1; +static int hf_x11_struct_RefreshRates_nRates = -1; +static int hf_x11_struct_RefreshRates_rates = -1; +static int hf_x11_struct_RefreshRates_rates_item = -1; +static int hf_x11_randr_QueryVersion_major_version = -1; +static int hf_x11_randr_QueryVersion_minor_version = -1; +static int hf_x11_randr_QueryVersion_reply_major_version = -1; +static int hf_x11_randr_QueryVersion_reply_minor_version = -1; +static int hf_x11_randr_SetScreenConfig_window = -1; +static int hf_x11_randr_SetScreenConfig_timestamp = -1; +static int hf_x11_randr_SetScreenConfig_config_timestamp = -1; +static int hf_x11_randr_SetScreenConfig_sizeID = -1; +static int hf_x11_randr_SetScreenConfig_rotation = -1; +static int hf_x11_randr_SetScreenConfig_rate = -1; +static int hf_x11_randr_SetScreenConfig_reply_status = -1; +static int hf_x11_randr_SetScreenConfig_reply_new_timestamp = -1; +static int hf_x11_randr_SetScreenConfig_reply_config_timestamp = -1; +static int hf_x11_randr_SetScreenConfig_reply_root = -1; +static int hf_x11_randr_SetScreenConfig_reply_subpixel_order = -1; +static int hf_x11_randr_SelectInput_window = -1; +static int hf_x11_randr_SelectInput_enable = -1; +static int hf_x11_randr_GetScreenInfo_window = -1; +static int hf_x11_randr_GetScreenInfo_reply_rotations = -1; +static int hf_x11_randr_GetScreenInfo_reply_root = -1; +static int hf_x11_randr_GetScreenInfo_reply_timestamp = -1; +static int hf_x11_randr_GetScreenInfo_reply_config_timestamp = -1; +static int hf_x11_randr_GetScreenInfo_reply_nSizes = -1; +static int hf_x11_randr_GetScreenInfo_reply_sizeID = -1; +static int hf_x11_randr_GetScreenInfo_reply_rotation = -1; +static int hf_x11_randr_GetScreenInfo_reply_rate = -1; +static int hf_x11_randr_GetScreenInfo_reply_nInfo = -1; +static int hf_x11_randr_GetScreenInfo_reply_sizes = -1; +static int hf_x11_randr_GetScreenInfo_reply_sizes_item = -1; +static int hf_x11_randr_GetScreenInfo_reply_rates = -1; +static int hf_x11_randr_GetScreenSizeRange_window = -1; +static int hf_x11_randr_GetScreenSizeRange_reply_min_width = -1; +static int hf_x11_randr_GetScreenSizeRange_reply_min_height = -1; +static int hf_x11_randr_GetScreenSizeRange_reply_max_width = -1; +static int hf_x11_randr_GetScreenSizeRange_reply_max_height = -1; +static int hf_x11_randr_SetScreenSize_window = -1; +static int hf_x11_randr_SetScreenSize_width = -1; +static int hf_x11_randr_SetScreenSize_height = -1; +static int hf_x11_randr_SetScreenSize_mm_width = -1; +static int hf_x11_randr_SetScreenSize_mm_height = -1; +static int hf_x11_struct_ModeInfo = -1; +static int hf_x11_struct_ModeInfo_id = -1; +static int hf_x11_struct_ModeInfo_width = -1; +static int hf_x11_struct_ModeInfo_height = -1; +static int hf_x11_struct_ModeInfo_dot_clock = -1; +static int hf_x11_struct_ModeInfo_hsync_start = -1; +static int hf_x11_struct_ModeInfo_hsync_end = -1; +static int hf_x11_struct_ModeInfo_htotal = -1; +static int hf_x11_struct_ModeInfo_hskew = -1; +static int hf_x11_struct_ModeInfo_vsync_start = -1; +static int hf_x11_struct_ModeInfo_vsync_end = -1; +static int hf_x11_struct_ModeInfo_vtotal = -1; +static int hf_x11_struct_ModeInfo_name_len = -1; +static int hf_x11_struct_ModeInfo_mode_flags = -1; +static int hf_x11_randr_GetScreenResources_window = -1; +static int hf_x11_randr_GetScreenResources_reply_timestamp = -1; +static int hf_x11_randr_GetScreenResources_reply_config_timestamp = -1; +static int hf_x11_randr_GetScreenResources_reply_num_crtcs = -1; +static int hf_x11_randr_GetScreenResources_reply_num_outputs = -1; +static int hf_x11_randr_GetScreenResources_reply_num_modes = -1; +static int hf_x11_randr_GetScreenResources_reply_names_len = -1; +static int hf_x11_randr_GetScreenResources_reply_crtcs = -1; +static int hf_x11_randr_GetScreenResources_reply_crtcs_item = -1; +static int hf_x11_randr_GetScreenResources_reply_outputs = -1; +static int hf_x11_randr_GetScreenResources_reply_outputs_item = -1; +static int hf_x11_randr_GetScreenResources_reply_modes = -1; +static int hf_x11_randr_GetScreenResources_reply_modes_item = -1; +static int hf_x11_randr_GetScreenResources_reply_names = -1; +static int hf_x11_randr_GetOutputInfo_output = -1; +static int hf_x11_randr_GetOutputInfo_config_timestamp = -1; +static int hf_x11_randr_GetOutputInfo_reply_status = -1; +static int hf_x11_randr_GetOutputInfo_reply_timestamp = -1; +static int hf_x11_randr_GetOutputInfo_reply_crtc = -1; +static int hf_x11_randr_GetOutputInfo_reply_mm_width = -1; +static int hf_x11_randr_GetOutputInfo_reply_mm_height = -1; +static int hf_x11_randr_GetOutputInfo_reply_connection = -1; +static int hf_x11_randr_GetOutputInfo_reply_subpixel_order = -1; +static int hf_x11_randr_GetOutputInfo_reply_num_crtcs = -1; +static int hf_x11_randr_GetOutputInfo_reply_num_modes = -1; +static int hf_x11_randr_GetOutputInfo_reply_num_preferred = -1; +static int hf_x11_randr_GetOutputInfo_reply_num_clones = -1; +static int hf_x11_randr_GetOutputInfo_reply_name_len = -1; +static int hf_x11_randr_GetOutputInfo_reply_crtcs = -1; +static int hf_x11_randr_GetOutputInfo_reply_crtcs_item = -1; +static int hf_x11_randr_GetOutputInfo_reply_modes = -1; +static int hf_x11_randr_GetOutputInfo_reply_modes_item = -1; +static int hf_x11_randr_GetOutputInfo_reply_clones = -1; +static int hf_x11_randr_GetOutputInfo_reply_clones_item = -1; +static int hf_x11_randr_GetOutputInfo_reply_name = -1; +static int hf_x11_randr_ListOutputProperties_output = -1; +static int hf_x11_randr_ListOutputProperties_reply_num_atoms = -1; +static int hf_x11_randr_ListOutputProperties_reply_atoms = -1; +static int hf_x11_randr_ListOutputProperties_reply_atoms_item = -1; +static int hf_x11_randr_QueryOutputProperty_output = -1; +static int hf_x11_randr_QueryOutputProperty_property = -1; +static int hf_x11_randr_QueryOutputProperty_reply_pending = -1; +static int hf_x11_randr_QueryOutputProperty_reply_range = -1; +static int hf_x11_randr_QueryOutputProperty_reply_immutable = -1; +static int hf_x11_randr_QueryOutputProperty_reply_validValues = -1; +static int hf_x11_randr_QueryOutputProperty_reply_validValues_item = -1; +static int hf_x11_randr_ConfigureOutputProperty_output = -1; +static int hf_x11_randr_ConfigureOutputProperty_property = -1; +static int hf_x11_randr_ConfigureOutputProperty_pending = -1; +static int hf_x11_randr_ConfigureOutputProperty_range = -1; +static int hf_x11_randr_ConfigureOutputProperty_values = -1; +static int hf_x11_randr_ConfigureOutputProperty_values_item = -1; +static int hf_x11_randr_ChangeOutputProperty_output = -1; +static int hf_x11_randr_ChangeOutputProperty_property = -1; +static int hf_x11_randr_ChangeOutputProperty_type = -1; +static int hf_x11_randr_ChangeOutputProperty_format = -1; +static int hf_x11_randr_ChangeOutputProperty_mode = -1; +static int hf_x11_randr_ChangeOutputProperty_num_units = -1; +static int hf_x11_randr_ChangeOutputProperty_data = -1; +static int hf_x11_randr_DeleteOutputProperty_output = -1; +static int hf_x11_randr_DeleteOutputProperty_property = -1; +static int hf_x11_randr_GetOutputProperty_output = -1; +static int hf_x11_randr_GetOutputProperty_property = -1; +static int hf_x11_randr_GetOutputProperty_type = -1; +static int hf_x11_randr_GetOutputProperty_long_offset = -1; +static int hf_x11_randr_GetOutputProperty_long_length = -1; +static int hf_x11_randr_GetOutputProperty_delete = -1; +static int hf_x11_randr_GetOutputProperty_pending = -1; +static int hf_x11_randr_GetOutputProperty_reply_format = -1; +static int hf_x11_randr_GetOutputProperty_reply_type = -1; +static int hf_x11_randr_GetOutputProperty_reply_bytes_after = -1; +static int hf_x11_randr_GetOutputProperty_reply_num_items = -1; +static int hf_x11_randr_GetOutputProperty_reply_data = -1; +static int hf_x11_randr_CreateMode_window = -1; +static int hf_x11_randr_CreateMode_mode_info = -1; +static int hf_x11_randr_CreateMode_name = -1; +static int hf_x11_randr_CreateMode_reply_mode = -1; +static int hf_x11_randr_DestroyMode_mode = -1; +static int hf_x11_randr_AddOutputMode_output = -1; +static int hf_x11_randr_AddOutputMode_mode = -1; +static int hf_x11_randr_DeleteOutputMode_output = -1; +static int hf_x11_randr_DeleteOutputMode_mode = -1; +static int hf_x11_randr_GetCrtcInfo_crtc = -1; +static int hf_x11_randr_GetCrtcInfo_config_timestamp = -1; +static int hf_x11_randr_GetCrtcInfo_reply_status = -1; +static int hf_x11_randr_GetCrtcInfo_reply_timestamp = -1; +static int hf_x11_randr_GetCrtcInfo_reply_x = -1; +static int hf_x11_randr_GetCrtcInfo_reply_y = -1; +static int hf_x11_randr_GetCrtcInfo_reply_width = -1; +static int hf_x11_randr_GetCrtcInfo_reply_height = -1; +static int hf_x11_randr_GetCrtcInfo_reply_mode = -1; +static int hf_x11_randr_GetCrtcInfo_reply_rotation = -1; +static int hf_x11_randr_GetCrtcInfo_reply_rotations = -1; +static int hf_x11_randr_GetCrtcInfo_reply_num_outputs = -1; +static int hf_x11_randr_GetCrtcInfo_reply_num_possible_outputs = -1; +static int hf_x11_randr_GetCrtcInfo_reply_outputs = -1; +static int hf_x11_randr_GetCrtcInfo_reply_outputs_item = -1; +static int hf_x11_randr_GetCrtcInfo_reply_possible = -1; +static int hf_x11_randr_GetCrtcInfo_reply_possible_item = -1; +static int hf_x11_randr_SetCrtcConfig_crtc = -1; +static int hf_x11_randr_SetCrtcConfig_timestamp = -1; +static int hf_x11_randr_SetCrtcConfig_config_timestamp = -1; +static int hf_x11_randr_SetCrtcConfig_x = -1; +static int hf_x11_randr_SetCrtcConfig_y = -1; +static int hf_x11_randr_SetCrtcConfig_mode = -1; +static int hf_x11_randr_SetCrtcConfig_rotation = -1; +static int hf_x11_randr_SetCrtcConfig_outputs = -1; +static int hf_x11_randr_SetCrtcConfig_outputs_item = -1; +static int hf_x11_randr_SetCrtcConfig_reply_status = -1; +static int hf_x11_randr_SetCrtcConfig_reply_timestamp = -1; +static int hf_x11_randr_GetCrtcGammaSize_crtc = -1; +static int hf_x11_randr_GetCrtcGammaSize_reply_size = -1; +static int hf_x11_randr_GetCrtcGamma_crtc = -1; +static int hf_x11_randr_GetCrtcGamma_reply_size = -1; +static int hf_x11_randr_GetCrtcGamma_reply_red = -1; +static int hf_x11_randr_GetCrtcGamma_reply_red_item = -1; +static int hf_x11_randr_GetCrtcGamma_reply_green = -1; +static int hf_x11_randr_GetCrtcGamma_reply_green_item = -1; +static int hf_x11_randr_GetCrtcGamma_reply_blue = -1; +static int hf_x11_randr_GetCrtcGamma_reply_blue_item = -1; +static int hf_x11_randr_SetCrtcGamma_crtc = -1; +static int hf_x11_randr_SetCrtcGamma_size = -1; +static int hf_x11_randr_SetCrtcGamma_red = -1; +static int hf_x11_randr_SetCrtcGamma_red_item = -1; +static int hf_x11_randr_SetCrtcGamma_green = -1; +static int hf_x11_randr_SetCrtcGamma_green_item = -1; +static int hf_x11_randr_SetCrtcGamma_blue = -1; +static int hf_x11_randr_SetCrtcGamma_blue_item = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_window = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_timestamp = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_config_timestamp = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_num_crtcs = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_num_outputs = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_num_modes = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_names_len = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs_item = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_outputs = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_outputs_item = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_modes = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_modes_item = -1; +static int hf_x11_randr_GetScreenResourcesCurrent_reply_names = -1; +static int hf_x11_randr_SetCrtcTransform_crtc = -1; +static int hf_x11_randr_SetCrtcTransform_transform = -1; +static int hf_x11_randr_SetCrtcTransform_filter_len = -1; +static int hf_x11_randr_SetCrtcTransform_filter_name = -1; +static int hf_x11_randr_SetCrtcTransform_filter_params = -1; +static int hf_x11_randr_SetCrtcTransform_filter_params_item = -1; +static int hf_x11_randr_GetCrtcTransform_crtc = -1; +static int hf_x11_randr_GetCrtcTransform_reply_pending_transform = -1; +static int hf_x11_randr_GetCrtcTransform_reply_has_transforms = -1; +static int hf_x11_randr_GetCrtcTransform_reply_current_transform = -1; +static int hf_x11_randr_GetCrtcTransform_reply_pending_len = -1; +static int hf_x11_randr_GetCrtcTransform_reply_pending_nparams = -1; +static int hf_x11_randr_GetCrtcTransform_reply_current_len = -1; +static int hf_x11_randr_GetCrtcTransform_reply_current_nparams = -1; +static int hf_x11_randr_GetCrtcTransform_reply_pending_filter_name = -1; +static int hf_x11_randr_GetCrtcTransform_reply_pending_params = -1; +static int hf_x11_randr_GetCrtcTransform_reply_pending_params_item = -1; +static int hf_x11_randr_GetCrtcTransform_reply_current_filter_name = -1; +static int hf_x11_randr_GetCrtcTransform_reply_current_params = -1; +static int hf_x11_randr_GetCrtcTransform_reply_current_params_item = -1; +static int hf_x11_randr_GetPanning_crtc = -1; +static int hf_x11_randr_GetPanning_reply_status = -1; +static int hf_x11_randr_GetPanning_reply_timestamp = -1; +static int hf_x11_randr_GetPanning_reply_left = -1; +static int hf_x11_randr_GetPanning_reply_top = -1; +static int hf_x11_randr_GetPanning_reply_width = -1; +static int hf_x11_randr_GetPanning_reply_height = -1; +static int hf_x11_randr_GetPanning_reply_track_left = -1; +static int hf_x11_randr_GetPanning_reply_track_top = -1; +static int hf_x11_randr_GetPanning_reply_track_width = -1; +static int hf_x11_randr_GetPanning_reply_track_height = -1; +static int hf_x11_randr_GetPanning_reply_border_left = -1; +static int hf_x11_randr_GetPanning_reply_border_top = -1; +static int hf_x11_randr_GetPanning_reply_border_right = -1; +static int hf_x11_randr_GetPanning_reply_border_bottom = -1; +static int hf_x11_randr_SetPanning_crtc = -1; +static int hf_x11_randr_SetPanning_timestamp = -1; +static int hf_x11_randr_SetPanning_left = -1; +static int hf_x11_randr_SetPanning_top = -1; +static int hf_x11_randr_SetPanning_width = -1; +static int hf_x11_randr_SetPanning_height = -1; +static int hf_x11_randr_SetPanning_track_left = -1; +static int hf_x11_randr_SetPanning_track_top = -1; +static int hf_x11_randr_SetPanning_track_width = -1; +static int hf_x11_randr_SetPanning_track_height = -1; +static int hf_x11_randr_SetPanning_border_left = -1; +static int hf_x11_randr_SetPanning_border_top = -1; +static int hf_x11_randr_SetPanning_border_right = -1; +static int hf_x11_randr_SetPanning_border_bottom = -1; +static int hf_x11_randr_SetPanning_reply_status = -1; +static int hf_x11_randr_SetPanning_reply_timestamp = -1; +static int hf_x11_randr_SetOutputPrimary_window = -1; +static int hf_x11_randr_SetOutputPrimary_output = -1; +static int hf_x11_randr_GetOutputPrimary_window = -1; +static int hf_x11_randr_GetOutputPrimary_reply_output = -1; +static int hf_x11_randr_ScreenChangeNotify_rotation = -1; +static int hf_x11_randr_ScreenChangeNotify_timestamp = -1; +static int hf_x11_randr_ScreenChangeNotify_config_timestamp = -1; +static int hf_x11_randr_ScreenChangeNotify_root = -1; +static int hf_x11_randr_ScreenChangeNotify_request_window = -1; +static int hf_x11_randr_ScreenChangeNotify_sizeID = -1; +static int hf_x11_randr_ScreenChangeNotify_subpixel_order = -1; +static int hf_x11_randr_ScreenChangeNotify_width = -1; +static int hf_x11_randr_ScreenChangeNotify_height = -1; +static int hf_x11_randr_ScreenChangeNotify_mwidth = -1; +static int hf_x11_randr_ScreenChangeNotify_mheight = -1; +static int hf_x11_struct_CrtcChange = -1; +static int hf_x11_struct_CrtcChange_timestamp = -1; +static int hf_x11_struct_CrtcChange_window = -1; +static int hf_x11_struct_CrtcChange_crtc = -1; +static int hf_x11_struct_CrtcChange_mode = -1; +static int hf_x11_struct_CrtcChange_rotation = -1; +static int hf_x11_struct_CrtcChange_x = -1; +static int hf_x11_struct_CrtcChange_y = -1; +static int hf_x11_struct_CrtcChange_width = -1; +static int hf_x11_struct_CrtcChange_height = -1; +static int hf_x11_struct_OutputChange = -1; +static int hf_x11_struct_OutputChange_timestamp = -1; +static int hf_x11_struct_OutputChange_config_timestamp = -1; +static int hf_x11_struct_OutputChange_window = -1; +static int hf_x11_struct_OutputChange_output = -1; +static int hf_x11_struct_OutputChange_crtc = -1; +static int hf_x11_struct_OutputChange_mode = -1; +static int hf_x11_struct_OutputChange_rotation = -1; +static int hf_x11_struct_OutputChange_connection = -1; +static int hf_x11_struct_OutputChange_subpixel_order = -1; +static int hf_x11_struct_OutputProperty = -1; +static int hf_x11_struct_OutputProperty_window = -1; +static int hf_x11_struct_OutputProperty_output = -1; +static int hf_x11_struct_OutputProperty_atom = -1; +static int hf_x11_struct_OutputProperty_timestamp = -1; +static int hf_x11_struct_OutputProperty_status = -1; +static int hf_x11_union_NotifyData = -1; +static int hf_x11_randr_Notify_subCode = -1; +static int hf_x11_randr_Notify_u = -1; +static int hf_x11_randr_extension_minor = -1; + +static int hf_x11_struct_Range8 = -1; +static int hf_x11_struct_Range8_first = -1; +static int hf_x11_struct_Range8_last = -1; +static int hf_x11_struct_Range16 = -1; +static int hf_x11_struct_Range16_first = -1; +static int hf_x11_struct_Range16_last = -1; +static int hf_x11_struct_ExtRange = -1; +static int hf_x11_struct_ExtRange_major = -1; +static int hf_x11_struct_ExtRange_minor = -1; +static int hf_x11_struct_Range = -1; +static int hf_x11_struct_Range_core_requests = -1; +static int hf_x11_struct_Range_core_replies = -1; +static int hf_x11_struct_Range_ext_requests = -1; +static int hf_x11_struct_Range_ext_replies = -1; +static int hf_x11_struct_Range_delivered_events = -1; +static int hf_x11_struct_Range_device_events = -1; +static int hf_x11_struct_Range_errors = -1; +static int hf_x11_struct_Range_client_started = -1; +static int hf_x11_struct_Range_client_died = -1; +static int hf_x11_struct_ClientInfo = -1; +static int hf_x11_struct_ClientInfo_client_resource = -1; +static int hf_x11_struct_ClientInfo_num_ranges = -1; +static int hf_x11_struct_ClientInfo_ranges = -1; +static int hf_x11_struct_ClientInfo_ranges_item = -1; +static int hf_x11_record_QueryVersion_major_version = -1; +static int hf_x11_record_QueryVersion_minor_version = -1; +static int hf_x11_record_QueryVersion_reply_major_version = -1; +static int hf_x11_record_QueryVersion_reply_minor_version = -1; +static int hf_x11_record_CreateContext_context = -1; +static int hf_x11_record_CreateContext_element_header = -1; +static int hf_x11_record_CreateContext_num_client_specs = -1; +static int hf_x11_record_CreateContext_num_ranges = -1; +static int hf_x11_record_CreateContext_client_specs = -1; +static int hf_x11_record_CreateContext_client_specs_item = -1; +static int hf_x11_record_CreateContext_ranges = -1; +static int hf_x11_record_CreateContext_ranges_item = -1; +static int hf_x11_record_RegisterClients_context = -1; +static int hf_x11_record_RegisterClients_element_header = -1; +static int hf_x11_record_RegisterClients_num_client_specs = -1; +static int hf_x11_record_RegisterClients_num_ranges = -1; +static int hf_x11_record_RegisterClients_client_specs = -1; +static int hf_x11_record_RegisterClients_client_specs_item = -1; +static int hf_x11_record_RegisterClients_ranges = -1; +static int hf_x11_record_RegisterClients_ranges_item = -1; +static int hf_x11_record_UnregisterClients_context = -1; +static int hf_x11_record_UnregisterClients_num_client_specs = -1; +static int hf_x11_record_UnregisterClients_client_specs = -1; +static int hf_x11_record_UnregisterClients_client_specs_item = -1; +static int hf_x11_record_GetContext_context = -1; +static int hf_x11_record_GetContext_reply_enabled = -1; +static int hf_x11_record_GetContext_reply_element_header = -1; +static int hf_x11_record_GetContext_reply_num_intercepted_clients = -1; +static int hf_x11_record_GetContext_reply_intercepted_clients = -1; +static int hf_x11_record_EnableContext_context = -1; +static int hf_x11_record_EnableContext_reply_category = -1; +static int hf_x11_record_EnableContext_reply_element_header = -1; +static int hf_x11_record_EnableContext_reply_client_swapped = -1; +static int hf_x11_record_EnableContext_reply_xid_base = -1; +static int hf_x11_record_EnableContext_reply_server_time = -1; +static int hf_x11_record_EnableContext_reply_rec_sequence_num = -1; +static int hf_x11_record_EnableContext_reply_data = -1; +static int hf_x11_record_DisableContext_context = -1; +static int hf_x11_record_FreeContext_context = -1; +static int hf_x11_record_extension_minor = -1; + +static int hf_x11_render_QueryVersion_client_major_version = -1; +static int hf_x11_render_QueryVersion_client_minor_version = -1; +static int hf_x11_render_QueryVersion_reply_major_version = -1; +static int hf_x11_render_QueryVersion_reply_minor_version = -1; +static int hf_x11_render_QueryPictFormats_reply_num_formats = -1; +static int hf_x11_render_QueryPictFormats_reply_num_screens = -1; +static int hf_x11_render_QueryPictFormats_reply_num_depths = -1; +static int hf_x11_render_QueryPictFormats_reply_num_visuals = -1; +static int hf_x11_render_QueryPictFormats_reply_num_subpixel = -1; +static int hf_x11_render_QueryPictFormats_reply_formats = -1; +static int hf_x11_render_QueryPictFormats_reply_formats_item = -1; +static int hf_x11_render_QueryPictFormats_reply_screens = -1; +static int hf_x11_render_QueryPictFormats_reply_subpixels = -1; +static int hf_x11_render_QueryPictFormats_reply_subpixels_item = -1; +static int hf_x11_render_QueryPictIndexValues_format = -1; +static int hf_x11_render_QueryPictIndexValues_reply_num_values = -1; +static int hf_x11_render_QueryPictIndexValues_reply_values = -1; +static int hf_x11_render_QueryPictIndexValues_reply_values_item = -1; +static int hf_x11_render_CreatePicture_pid = -1; +static int hf_x11_render_CreatePicture_drawable = -1; +static int hf_x11_render_CreatePicture_format = -1; +static int hf_x11_render_ChangePicture_picture = -1; +static int hf_x11_render_SetPictureClipRectangles_picture = -1; +static int hf_x11_render_SetPictureClipRectangles_clip_x_origin = -1; +static int hf_x11_render_SetPictureClipRectangles_clip_y_origin = -1; +static int hf_x11_render_SetPictureClipRectangles_rectangles = -1; +static int hf_x11_render_SetPictureClipRectangles_rectangles_item = -1; +static int hf_x11_render_FreePicture_picture = -1; +static int hf_x11_render_Composite_op = -1; +static int hf_x11_render_Composite_src = -1; +static int hf_x11_render_Composite_mask = -1; +static int hf_x11_render_Composite_dst = -1; +static int hf_x11_render_Composite_src_x = -1; +static int hf_x11_render_Composite_src_y = -1; +static int hf_x11_render_Composite_mask_x = -1; +static int hf_x11_render_Composite_mask_y = -1; +static int hf_x11_render_Composite_dst_x = -1; +static int hf_x11_render_Composite_dst_y = -1; +static int hf_x11_render_Composite_width = -1; +static int hf_x11_render_Composite_height = -1; +static int hf_x11_render_Trapezoids_op = -1; +static int hf_x11_render_Trapezoids_src = -1; +static int hf_x11_render_Trapezoids_dst = -1; +static int hf_x11_render_Trapezoids_mask_format = -1; +static int hf_x11_render_Trapezoids_src_x = -1; +static int hf_x11_render_Trapezoids_src_y = -1; +static int hf_x11_render_Trapezoids_traps = -1; +static int hf_x11_render_Trapezoids_traps_item = -1; +static int hf_x11_render_Triangles_op = -1; +static int hf_x11_render_Triangles_src = -1; +static int hf_x11_render_Triangles_dst = -1; +static int hf_x11_render_Triangles_mask_format = -1; +static int hf_x11_render_Triangles_src_x = -1; +static int hf_x11_render_Triangles_src_y = -1; +static int hf_x11_render_Triangles_triangles = -1; +static int hf_x11_render_Triangles_triangles_item = -1; +static int hf_x11_render_TriStrip_op = -1; +static int hf_x11_render_TriStrip_src = -1; +static int hf_x11_render_TriStrip_dst = -1; +static int hf_x11_render_TriStrip_mask_format = -1; +static int hf_x11_render_TriStrip_src_x = -1; +static int hf_x11_render_TriStrip_src_y = -1; +static int hf_x11_render_TriStrip_points = -1; +static int hf_x11_render_TriStrip_points_item = -1; +static int hf_x11_render_TriFan_op = -1; +static int hf_x11_render_TriFan_src = -1; +static int hf_x11_render_TriFan_dst = -1; +static int hf_x11_render_TriFan_mask_format = -1; +static int hf_x11_render_TriFan_src_x = -1; +static int hf_x11_render_TriFan_src_y = -1; +static int hf_x11_render_TriFan_points = -1; +static int hf_x11_render_TriFan_points_item = -1; +static int hf_x11_render_CreateGlyphSet_gsid = -1; +static int hf_x11_render_CreateGlyphSet_format = -1; +static int hf_x11_render_ReferenceGlyphSet_gsid = -1; +static int hf_x11_render_ReferenceGlyphSet_existing = -1; +static int hf_x11_render_FreeGlyphSet_glyphset = -1; +static int hf_x11_render_AddGlyphs_glyphset = -1; +static int hf_x11_render_AddGlyphs_glyphs_len = -1; +static int hf_x11_render_AddGlyphs_glyphids = -1; +static int hf_x11_render_AddGlyphs_glyphids_item = -1; +static int hf_x11_render_AddGlyphs_glyphs = -1; +static int hf_x11_render_AddGlyphs_glyphs_item = -1; +static int hf_x11_render_AddGlyphs_data = -1; +static int hf_x11_render_FreeGlyphs_glyphset = -1; +static int hf_x11_render_FreeGlyphs_glyphs = -1; +static int hf_x11_render_FreeGlyphs_glyphs_item = -1; +static int hf_x11_render_CompositeGlyphs8_op = -1; +static int hf_x11_render_CompositeGlyphs8_src = -1; +static int hf_x11_render_CompositeGlyphs8_dst = -1; +static int hf_x11_render_CompositeGlyphs8_mask_format = -1; +static int hf_x11_render_CompositeGlyphs8_glyphset = -1; +static int hf_x11_render_CompositeGlyphs8_src_x = -1; +static int hf_x11_render_CompositeGlyphs8_src_y = -1; +static int hf_x11_render_CompositeGlyphs8_glyphcmds = -1; +static int hf_x11_render_CompositeGlyphs16_op = -1; +static int hf_x11_render_CompositeGlyphs16_src = -1; +static int hf_x11_render_CompositeGlyphs16_dst = -1; +static int hf_x11_render_CompositeGlyphs16_mask_format = -1; +static int hf_x11_render_CompositeGlyphs16_glyphset = -1; +static int hf_x11_render_CompositeGlyphs16_src_x = -1; +static int hf_x11_render_CompositeGlyphs16_src_y = -1; +static int hf_x11_render_CompositeGlyphs16_glyphcmds = -1; +static int hf_x11_render_CompositeGlyphs32_op = -1; +static int hf_x11_render_CompositeGlyphs32_src = -1; +static int hf_x11_render_CompositeGlyphs32_dst = -1; +static int hf_x11_render_CompositeGlyphs32_mask_format = -1; +static int hf_x11_render_CompositeGlyphs32_glyphset = -1; +static int hf_x11_render_CompositeGlyphs32_src_x = -1; +static int hf_x11_render_CompositeGlyphs32_src_y = -1; +static int hf_x11_render_CompositeGlyphs32_glyphcmds = -1; +static int hf_x11_render_FillRectangles_op = -1; +static int hf_x11_render_FillRectangles_dst = -1; +static int hf_x11_render_FillRectangles_color = -1; +static int hf_x11_render_FillRectangles_rects = -1; +static int hf_x11_render_FillRectangles_rects_item = -1; +static int hf_x11_render_CreateCursor_cid = -1; +static int hf_x11_render_CreateCursor_source = -1; +static int hf_x11_render_CreateCursor_x = -1; +static int hf_x11_render_CreateCursor_y = -1; +static int hf_x11_render_SetPictureTransform_picture = -1; +static int hf_x11_render_SetPictureTransform_transform = -1; +static int hf_x11_render_QueryFilters_drawable = -1; +static int hf_x11_render_QueryFilters_reply_num_aliases = -1; +static int hf_x11_render_QueryFilters_reply_num_filters = -1; +static int hf_x11_render_QueryFilters_reply_aliases = -1; +static int hf_x11_render_QueryFilters_reply_aliases_item = -1; +static int hf_x11_render_QueryFilters_reply_filters = -1; +static int hf_x11_render_SetPictureFilter_picture = -1; +static int hf_x11_render_SetPictureFilter_filter_len = -1; +static int hf_x11_render_SetPictureFilter_filter = -1; +static int hf_x11_render_SetPictureFilter_values = -1; +static int hf_x11_render_SetPictureFilter_values_item = -1; +static int hf_x11_render_CreateAnimCursor_cid = -1; +static int hf_x11_render_CreateAnimCursor_cursors = -1; +static int hf_x11_render_CreateAnimCursor_cursors_item = -1; +static int hf_x11_render_AddTraps_picture = -1; +static int hf_x11_render_AddTraps_x_off = -1; +static int hf_x11_render_AddTraps_y_off = -1; +static int hf_x11_render_AddTraps_traps = -1; +static int hf_x11_render_AddTraps_traps_item = -1; +static int hf_x11_render_CreateSolidFill_picture = -1; +static int hf_x11_render_CreateSolidFill_color = -1; +static int hf_x11_render_CreateLinearGradient_picture = -1; +static int hf_x11_render_CreateLinearGradient_p1 = -1; +static int hf_x11_render_CreateLinearGradient_p2 = -1; +static int hf_x11_render_CreateLinearGradient_num_stops = -1; +static int hf_x11_render_CreateLinearGradient_stops = -1; +static int hf_x11_render_CreateLinearGradient_stops_item = -1; +static int hf_x11_render_CreateLinearGradient_colors = -1; +static int hf_x11_render_CreateLinearGradient_colors_item = -1; +static int hf_x11_render_CreateRadialGradient_picture = -1; +static int hf_x11_render_CreateRadialGradient_inner = -1; +static int hf_x11_render_CreateRadialGradient_outer = -1; +static int hf_x11_render_CreateRadialGradient_inner_radius = -1; +static int hf_x11_render_CreateRadialGradient_outer_radius = -1; +static int hf_x11_render_CreateRadialGradient_num_stops = -1; +static int hf_x11_render_CreateRadialGradient_stops = -1; +static int hf_x11_render_CreateRadialGradient_stops_item = -1; +static int hf_x11_render_CreateRadialGradient_colors = -1; +static int hf_x11_render_CreateRadialGradient_colors_item = -1; +static int hf_x11_render_CreateConicalGradient_picture = -1; +static int hf_x11_render_CreateConicalGradient_center = -1; +static int hf_x11_render_CreateConicalGradient_angle = -1; +static int hf_x11_render_CreateConicalGradient_num_stops = -1; +static int hf_x11_render_CreateConicalGradient_stops = -1; +static int hf_x11_render_CreateConicalGradient_stops_item = -1; +static int hf_x11_render_CreateConicalGradient_colors = -1; +static int hf_x11_render_CreateConicalGradient_colors_item = -1; +static int hf_x11_render_extension_minor = -1; + +static int hf_x11_struct_Client = -1; +static int hf_x11_struct_Client_resource_base = -1; +static int hf_x11_struct_Client_resource_mask = -1; +static int hf_x11_struct_Type = -1; +static int hf_x11_struct_Type_resource_type = -1; +static int hf_x11_struct_Type_count = -1; +static int hf_x11_res_QueryVersion_client_major = -1; +static int hf_x11_res_QueryVersion_client_minor = -1; +static int hf_x11_res_QueryVersion_reply_server_major = -1; +static int hf_x11_res_QueryVersion_reply_server_minor = -1; +static int hf_x11_res_QueryClients_reply_num_clients = -1; +static int hf_x11_res_QueryClients_reply_clients = -1; +static int hf_x11_res_QueryClients_reply_clients_item = -1; +static int hf_x11_res_QueryClientResources_xid = -1; +static int hf_x11_res_QueryClientResources_reply_num_types = -1; +static int hf_x11_res_QueryClientResources_reply_types = -1; +static int hf_x11_res_QueryClientResources_reply_types_item = -1; +static int hf_x11_res_QueryClientPixmapBytes_xid = -1; +static int hf_x11_res_QueryClientPixmapBytes_reply_bytes = -1; +static int hf_x11_res_QueryClientPixmapBytes_reply_bytes_overflow = -1; +static int hf_x11_res_extension_minor = -1; + +static int hf_x11_screensaver_QueryVersion_client_major_version = -1; +static int hf_x11_screensaver_QueryVersion_client_minor_version = -1; +static int hf_x11_screensaver_QueryVersion_reply_server_major_version = -1; +static int hf_x11_screensaver_QueryVersion_reply_server_minor_version = -1; +static int hf_x11_screensaver_QueryInfo_drawable = -1; +static int hf_x11_screensaver_QueryInfo_reply_state = -1; +static int hf_x11_screensaver_QueryInfo_reply_saver_window = -1; +static int hf_x11_screensaver_QueryInfo_reply_ms_until_server = -1; +static int hf_x11_screensaver_QueryInfo_reply_ms_since_user_input = -1; +static int hf_x11_screensaver_QueryInfo_reply_event_mask = -1; +static int hf_x11_screensaver_QueryInfo_reply_kind = -1; +static int hf_x11_screensaver_SelectInput_drawable = -1; +static int hf_x11_screensaver_SelectInput_event_mask = -1; +static int hf_x11_screensaver_SetAttributes_drawable = -1; +static int hf_x11_screensaver_SetAttributes_x = -1; +static int hf_x11_screensaver_SetAttributes_y = -1; +static int hf_x11_screensaver_SetAttributes_width = -1; +static int hf_x11_screensaver_SetAttributes_height = -1; +static int hf_x11_screensaver_SetAttributes_border_width = -1; +static int hf_x11_screensaver_SetAttributes_class = -1; +static int hf_x11_screensaver_SetAttributes_depth = -1; +static int hf_x11_screensaver_SetAttributes_visual = -1; +static int hf_x11_screensaver_UnsetAttributes_drawable = -1; +static int hf_x11_screensaver_Suspend_suspend = -1; +static int hf_x11_screensaver_Notify_code = -1; +static int hf_x11_screensaver_Notify_state = -1; +static int hf_x11_screensaver_Notify_sequence_number = -1; +static int hf_x11_screensaver_Notify_time = -1; +static int hf_x11_screensaver_Notify_root = -1; +static int hf_x11_screensaver_Notify_window = -1; +static int hf_x11_screensaver_Notify_kind = -1; +static int hf_x11_screensaver_Notify_forced = -1; +static int hf_x11_screensaver_extension_minor = -1; + +static int hf_x11_shape_Notify_shape_kind = -1; +static int hf_x11_shape_Notify_affected_window = -1; +static int hf_x11_shape_Notify_extents_x = -1; +static int hf_x11_shape_Notify_extents_y = -1; +static int hf_x11_shape_Notify_extents_width = -1; +static int hf_x11_shape_Notify_extents_height = -1; +static int hf_x11_shape_Notify_server_time = -1; +static int hf_x11_shape_Notify_shaped = -1; +static int hf_x11_shape_QueryVersion_reply_major_version = -1; +static int hf_x11_shape_QueryVersion_reply_minor_version = -1; +static int hf_x11_shape_Rectangles_operation = -1; +static int hf_x11_shape_Rectangles_destination_kind = -1; +static int hf_x11_shape_Rectangles_ordering = -1; +static int hf_x11_shape_Rectangles_destination_window = -1; +static int hf_x11_shape_Rectangles_x_offset = -1; +static int hf_x11_shape_Rectangles_y_offset = -1; +static int hf_x11_shape_Rectangles_rectangles = -1; +static int hf_x11_shape_Rectangles_rectangles_item = -1; +static int hf_x11_shape_Mask_operation = -1; +static int hf_x11_shape_Mask_destination_kind = -1; +static int hf_x11_shape_Mask_destination_window = -1; +static int hf_x11_shape_Mask_x_offset = -1; +static int hf_x11_shape_Mask_y_offset = -1; +static int hf_x11_shape_Mask_source_bitmap = -1; +static int hf_x11_shape_Combine_operation = -1; +static int hf_x11_shape_Combine_destination_kind = -1; +static int hf_x11_shape_Combine_source_kind = -1; +static int hf_x11_shape_Combine_destination_window = -1; +static int hf_x11_shape_Combine_x_offset = -1; +static int hf_x11_shape_Combine_y_offset = -1; +static int hf_x11_shape_Combine_source_window = -1; +static int hf_x11_shape_Offset_destination_kind = -1; +static int hf_x11_shape_Offset_destination_window = -1; +static int hf_x11_shape_Offset_x_offset = -1; +static int hf_x11_shape_Offset_y_offset = -1; +static int hf_x11_shape_QueryExtents_destination_window = -1; +static int hf_x11_shape_QueryExtents_reply_bounding_shaped = -1; +static int hf_x11_shape_QueryExtents_reply_clip_shaped = -1; +static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_x = -1; +static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_y = -1; +static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_width = -1; +static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_height = -1; +static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_x = -1; +static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_y = -1; +static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_width = -1; +static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_height = -1; +static int hf_x11_shape_SelectInput_destination_window = -1; +static int hf_x11_shape_SelectInput_enable = -1; +static int hf_x11_shape_InputSelected_destination_window = -1; +static int hf_x11_shape_InputSelected_reply_enabled = -1; +static int hf_x11_shape_GetRectangles_window = -1; +static int hf_x11_shape_GetRectangles_source_kind = -1; +static int hf_x11_shape_GetRectangles_reply_ordering = -1; +static int hf_x11_shape_GetRectangles_reply_rectangles_len = -1; +static int hf_x11_shape_GetRectangles_reply_rectangles = -1; +static int hf_x11_shape_GetRectangles_reply_rectangles_item = -1; +static int hf_x11_shape_extension_minor = -1; + +static int hf_x11_shm_Completion_drawable = -1; +static int hf_x11_shm_Completion_minor_event = -1; +static int hf_x11_shm_Completion_major_event = -1; +static int hf_x11_shm_Completion_shmseg = -1; +static int hf_x11_shm_Completion_offset = -1; +static int hf_x11_shm_QueryVersion_reply_shared_pixmaps = -1; +static int hf_x11_shm_QueryVersion_reply_major_version = -1; +static int hf_x11_shm_QueryVersion_reply_minor_version = -1; +static int hf_x11_shm_QueryVersion_reply_uid = -1; +static int hf_x11_shm_QueryVersion_reply_gid = -1; +static int hf_x11_shm_QueryVersion_reply_pixmap_format = -1; +static int hf_x11_shm_Attach_shmseg = -1; +static int hf_x11_shm_Attach_shmid = -1; +static int hf_x11_shm_Attach_read_only = -1; +static int hf_x11_shm_Detach_shmseg = -1; +static int hf_x11_shm_PutImage_drawable = -1; +static int hf_x11_shm_PutImage_gc = -1; +static int hf_x11_shm_PutImage_total_width = -1; +static int hf_x11_shm_PutImage_total_height = -1; +static int hf_x11_shm_PutImage_src_x = -1; +static int hf_x11_shm_PutImage_src_y = -1; +static int hf_x11_shm_PutImage_src_width = -1; +static int hf_x11_shm_PutImage_src_height = -1; +static int hf_x11_shm_PutImage_dst_x = -1; +static int hf_x11_shm_PutImage_dst_y = -1; +static int hf_x11_shm_PutImage_depth = -1; +static int hf_x11_shm_PutImage_format = -1; +static int hf_x11_shm_PutImage_send_event = -1; +static int hf_x11_shm_PutImage_shmseg = -1; +static int hf_x11_shm_PutImage_offset = -1; +static int hf_x11_shm_GetImage_drawable = -1; +static int hf_x11_shm_GetImage_x = -1; +static int hf_x11_shm_GetImage_y = -1; +static int hf_x11_shm_GetImage_width = -1; +static int hf_x11_shm_GetImage_height = -1; +static int hf_x11_shm_GetImage_plane_mask = -1; +static int hf_x11_shm_GetImage_format = -1; +static int hf_x11_shm_GetImage_shmseg = -1; +static int hf_x11_shm_GetImage_offset = -1; +static int hf_x11_shm_GetImage_reply_depth = -1; +static int hf_x11_shm_GetImage_reply_visual = -1; +static int hf_x11_shm_GetImage_reply_size = -1; +static int hf_x11_shm_CreatePixmap_pid = -1; +static int hf_x11_shm_CreatePixmap_drawable = -1; +static int hf_x11_shm_CreatePixmap_width = -1; +static int hf_x11_shm_CreatePixmap_height = -1; +static int hf_x11_shm_CreatePixmap_depth = -1; +static int hf_x11_shm_CreatePixmap_shmseg = -1; +static int hf_x11_shm_CreatePixmap_offset = -1; +static int hf_x11_shm_extension_minor = -1; + +static int hf_x11_struct_INT64 = -1; +static int hf_x11_struct_INT64_hi = -1; +static int hf_x11_struct_INT64_lo = -1; +static int hf_x11_struct_SYSTEMCOUNTER = -1; +static int hf_x11_struct_SYSTEMCOUNTER_counter = -1; +static int hf_x11_struct_SYSTEMCOUNTER_resolution = -1; +static int hf_x11_struct_SYSTEMCOUNTER_name_len = -1; +static int hf_x11_struct_SYSTEMCOUNTER_name = -1; +static int hf_x11_struct_TRIGGER = -1; +static int hf_x11_struct_TRIGGER_counter = -1; +static int hf_x11_struct_TRIGGER_wait_type = -1; +static int hf_x11_struct_TRIGGER_wait_value = -1; +static int hf_x11_struct_TRIGGER_test_type = -1; +static int hf_x11_struct_WAITCONDITION = -1; +static int hf_x11_struct_WAITCONDITION_trigger = -1; +static int hf_x11_struct_WAITCONDITION_event_threshold = -1; +static int hf_x11_sync_Initialize_desired_major_version = -1; +static int hf_x11_sync_Initialize_desired_minor_version = -1; +static int hf_x11_sync_Initialize_reply_major_version = -1; +static int hf_x11_sync_Initialize_reply_minor_version = -1; +static int hf_x11_sync_ListSystemCounters_reply_counters_len = -1; +static int hf_x11_sync_ListSystemCounters_reply_counters = -1; +static int hf_x11_sync_CreateCounter_id = -1; +static int hf_x11_sync_CreateCounter_initial_value = -1; +static int hf_x11_sync_DestroyCounter_counter = -1; +static int hf_x11_sync_QueryCounter_counter = -1; +static int hf_x11_sync_QueryCounter_reply_counter_value = -1; +static int hf_x11_sync_Await_wait_list = -1; +static int hf_x11_sync_Await_wait_list_item = -1; +static int hf_x11_sync_ChangeCounter_counter = -1; +static int hf_x11_sync_ChangeCounter_amount = -1; +static int hf_x11_sync_SetCounter_counter = -1; +static int hf_x11_sync_SetCounter_value = -1; +static int hf_x11_sync_CreateAlarm_id = -1; +static int hf_x11_sync_ChangeAlarm_id = -1; +static int hf_x11_sync_DestroyAlarm_alarm = -1; +static int hf_x11_sync_QueryAlarm_alarm = -1; +static int hf_x11_sync_QueryAlarm_reply_trigger = -1; +static int hf_x11_sync_QueryAlarm_reply_delta = -1; +static int hf_x11_sync_QueryAlarm_reply_events = -1; +static int hf_x11_sync_QueryAlarm_reply_state = -1; +static int hf_x11_sync_SetPriority_id = -1; +static int hf_x11_sync_SetPriority_priority = -1; +static int hf_x11_sync_GetPriority_id = -1; +static int hf_x11_sync_GetPriority_reply_priority = -1; +static int hf_x11_sync_CounterNotify_kind = -1; +static int hf_x11_sync_CounterNotify_counter = -1; +static int hf_x11_sync_CounterNotify_wait_value = -1; +static int hf_x11_sync_CounterNotify_counter_value = -1; +static int hf_x11_sync_CounterNotify_timestamp = -1; +static int hf_x11_sync_CounterNotify_count = -1; +static int hf_x11_sync_CounterNotify_destroyed = -1; +static int hf_x11_sync_AlarmNotify_kind = -1; +static int hf_x11_sync_AlarmNotify_alarm = -1; +static int hf_x11_sync_AlarmNotify_counter_value = -1; +static int hf_x11_sync_AlarmNotify_alarm_value = -1; +static int hf_x11_sync_AlarmNotify_timestamp = -1; +static int hf_x11_sync_AlarmNotify_state = -1; +static int hf_x11_sync_extension_minor = -1; + +static int hf_x11_xc_misc_GetVersion_client_major_version = -1; +static int hf_x11_xc_misc_GetVersion_client_minor_version = -1; +static int hf_x11_xc_misc_GetVersion_reply_server_major_version = -1; +static int hf_x11_xc_misc_GetVersion_reply_server_minor_version = -1; +static int hf_x11_xc_misc_GetXIDRange_reply_start_id = -1; +static int hf_x11_xc_misc_GetXIDRange_reply_count = -1; +static int hf_x11_xc_misc_GetXIDList_count = -1; +static int hf_x11_xc_misc_GetXIDList_reply_ids_len = -1; +static int hf_x11_xc_misc_GetXIDList_reply_ids = -1; +static int hf_x11_xc_misc_GetXIDList_reply_ids_item = -1; +static int hf_x11_xc_misc_extension_minor = -1; + +static int hf_x11_xevie_QueryVersion_client_major_version = -1; +static int hf_x11_xevie_QueryVersion_client_minor_version = -1; +static int hf_x11_xevie_QueryVersion_reply_server_major_version = -1; +static int hf_x11_xevie_QueryVersion_reply_server_minor_version = -1; +static int hf_x11_xevie_Start_screen = -1; +static int hf_x11_xevie_End_cmap = -1; +static int hf_x11_struct_Event = -1; +static int hf_x11_xevie_Send_event = -1; +static int hf_x11_xevie_Send_data_type = -1; +static int hf_x11_xevie_SelectInput_event_mask = -1; +static int hf_x11_xevie_extension_minor = -1; + +static int hf_x11_struct_DrmClipRect = -1; +static int hf_x11_struct_DrmClipRect_x1 = -1; +static int hf_x11_struct_DrmClipRect_y1 = -1; +static int hf_x11_struct_DrmClipRect_x2 = -1; +static int hf_x11_struct_DrmClipRect_x3 = -1; +static int hf_x11_xf86dri_QueryVersion_reply_dri_major_version = -1; +static int hf_x11_xf86dri_QueryVersion_reply_dri_minor_version = -1; +static int hf_x11_xf86dri_QueryVersion_reply_dri_minor_patch = -1; +static int hf_x11_xf86dri_QueryDirectRenderingCapable_screen = -1; +static int hf_x11_xf86dri_QueryDirectRenderingCapable_reply_is_capable = -1; +static int hf_x11_xf86dri_OpenConnection_screen = -1; +static int hf_x11_xf86dri_OpenConnection_reply_drm_client_key_low = -1; +static int hf_x11_xf86dri_OpenConnection_reply_drm_client_key_high = -1; +static int hf_x11_xf86dri_OpenConnection_reply_sarea_handle_low = -1; +static int hf_x11_xf86dri_OpenConnection_reply_sarea_handle_high = -1; +static int hf_x11_xf86dri_OpenConnection_reply_bus_id_len = -1; +static int hf_x11_xf86dri_OpenConnection_reply_bus_id = -1; +static int hf_x11_xf86dri_CloseConnection_screen = -1; +static int hf_x11_xf86dri_GetClientDriverName_screen = -1; +static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_major_version = -1; +static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_minor_version = -1; +static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_patch_version = -1; +static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name_len = -1; +static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name = -1; +static int hf_x11_xf86dri_CreateContext_visual = -1; +static int hf_x11_xf86dri_CreateContext_screen = -1; +static int hf_x11_xf86dri_CreateContext_context = -1; +static int hf_x11_xf86dri_CreateContext_reply_hw_context = -1; +static int hf_x11_xf86dri_DestroyContext_screen = -1; +static int hf_x11_xf86dri_DestroyContext_context = -1; +static int hf_x11_xf86dri_CreateDrawable_screen = -1; +static int hf_x11_xf86dri_CreateDrawable_drawable = -1; +static int hf_x11_xf86dri_CreateDrawable_reply_hw_drawable_handle = -1; +static int hf_x11_xf86dri_DestroyDrawable_screen = -1; +static int hf_x11_xf86dri_DestroyDrawable_drawable = -1; +static int hf_x11_xf86dri_GetDrawableInfo_screen = -1; +static int hf_x11_xf86dri_GetDrawableInfo_drawable = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_index = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_stamp = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_X = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_Y = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_W = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_H = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_num_clip_rects = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_clip_rects = -1; +static int hf_x11_xf86dri_GetDrawableInfo_reply_clip_rects_item = -1; +static int hf_x11_xf86dri_GetDeviceInfo_screen = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_low = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_high = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_origin_offset = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_size = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_stride = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_device_private_size = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_device_private = -1; +static int hf_x11_xf86dri_GetDeviceInfo_reply_device_private_item = -1; +static int hf_x11_xf86dri_AuthConnection_screen = -1; +static int hf_x11_xf86dri_AuthConnection_magic = -1; +static int hf_x11_xf86dri_AuthConnection_reply_authenticated = -1; +static int hf_x11_xf86dri_extension_minor = -1; + +static int hf_x11_xf86vidmode_QueryVersion_reply_major_version = -1; +static int hf_x11_xf86vidmode_QueryVersion_reply_minor_version = -1; +static int hf_x11_xf86vidmode_GetModeLine_screen = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_dotclock = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_hdisplay = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_hsyncstart = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_hsyncend = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_htotal = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_hskew = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_vdisplay = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_vsyncstart = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_vsyncend = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_vtotal = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_flags = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_privsize = -1; +static int hf_x11_xf86vidmode_GetModeLine_reply_private = -1; +static int hf_x11_xf86vidmode_ModModeLine_screen = -1; +static int hf_x11_xf86vidmode_ModModeLine_hdisplay = -1; +static int hf_x11_xf86vidmode_ModModeLine_hsyncstart = -1; +static int hf_x11_xf86vidmode_ModModeLine_hsyncend = -1; +static int hf_x11_xf86vidmode_ModModeLine_htotal = -1; +static int hf_x11_xf86vidmode_ModModeLine_hskew = -1; +static int hf_x11_xf86vidmode_ModModeLine_vdisplay = -1; +static int hf_x11_xf86vidmode_ModModeLine_vsyncstart = -1; +static int hf_x11_xf86vidmode_ModModeLine_vsyncend = -1; +static int hf_x11_xf86vidmode_ModModeLine_vtotal = -1; +static int hf_x11_xf86vidmode_ModModeLine_flags = -1; +static int hf_x11_xf86vidmode_ModModeLine_privsize = -1; +static int hf_x11_xf86vidmode_ModModeLine_private = -1; +static int hf_x11_xf86vidmode_SwitchMode_screen = -1; +static int hf_x11_xf86vidmode_SwitchMode_zoom = -1; +static int hf_x11_xf86vidmode_GetMonitor_screen = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_vendor_length = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_model_length = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_num_hsync = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_num_vsync = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_hsync = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_hsync_item = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_vsync = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_vsync_item = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_vendor = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_alignment_pad = -1; +static int hf_x11_xf86vidmode_GetMonitor_reply_model = -1; +static int hf_x11_xf86vidmode_LockModeSwitch_screen = -1; +static int hf_x11_xf86vidmode_LockModeSwitch_lock = -1; +static int hf_x11_xf86vidmode_GetAllModeLines_screen = -1; +static int hf_x11_xf86vidmode_GetAllModeLines_reply_modecount = -1; +static int hf_x11_xf86vidmode_GetAllModeLines_reply_modeinfo = -1; +static int hf_x11_xf86vidmode_GetAllModeLines_reply_modeinfo_item = -1; +static int hf_x11_xf86vidmode_AddModeLine_screen = -1; +static int hf_x11_xf86vidmode_AddModeLine_dotclock = -1; +static int hf_x11_xf86vidmode_AddModeLine_hdisplay = -1; +static int hf_x11_xf86vidmode_AddModeLine_hsyncstart = -1; +static int hf_x11_xf86vidmode_AddModeLine_hsyncend = -1; +static int hf_x11_xf86vidmode_AddModeLine_htotal = -1; +static int hf_x11_xf86vidmode_AddModeLine_hskew = -1; +static int hf_x11_xf86vidmode_AddModeLine_vdisplay = -1; +static int hf_x11_xf86vidmode_AddModeLine_vsyncstart = -1; +static int hf_x11_xf86vidmode_AddModeLine_vsyncend = -1; +static int hf_x11_xf86vidmode_AddModeLine_vtotal = -1; +static int hf_x11_xf86vidmode_AddModeLine_flags = -1; +static int hf_x11_xf86vidmode_AddModeLine_privsize = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_dotclock = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_hdisplay = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_hsyncstart = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_hsyncend = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_htotal = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_hskew = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_vdisplay = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_vsyncstart = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_vsyncend = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_vtotal = -1; +static int hf_x11_xf86vidmode_AddModeLine_after_flags = -1; +static int hf_x11_xf86vidmode_AddModeLine_private = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_screen = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_dotclock = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_hdisplay = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_hsyncstart = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_hsyncend = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_htotal = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_hskew = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_vdisplay = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_vsyncstart = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_vsyncend = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_vtotal = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_flags = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_privsize = -1; +static int hf_x11_xf86vidmode_DeleteModeLine_private = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_screen = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_dotclock = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_hdisplay = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_hsyncstart = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_hsyncend = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_htotal = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_hskew = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_vdisplay = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_vsyncstart = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_vsyncend = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_vtotal = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_flags = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_privsize = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_private = -1; +static int hf_x11_xf86vidmode_ValidateModeLine_reply_status = -1; +static int hf_x11_xf86vidmode_SwitchToMode_screen = -1; +static int hf_x11_xf86vidmode_SwitchToMode_dotclock = -1; +static int hf_x11_xf86vidmode_SwitchToMode_hdisplay = -1; +static int hf_x11_xf86vidmode_SwitchToMode_hsyncstart = -1; +static int hf_x11_xf86vidmode_SwitchToMode_hsyncend = -1; +static int hf_x11_xf86vidmode_SwitchToMode_htotal = -1; +static int hf_x11_xf86vidmode_SwitchToMode_hskew = -1; +static int hf_x11_xf86vidmode_SwitchToMode_vdisplay = -1; +static int hf_x11_xf86vidmode_SwitchToMode_vsyncstart = -1; +static int hf_x11_xf86vidmode_SwitchToMode_vsyncend = -1; +static int hf_x11_xf86vidmode_SwitchToMode_vtotal = -1; +static int hf_x11_xf86vidmode_SwitchToMode_flags = -1; +static int hf_x11_xf86vidmode_SwitchToMode_privsize = -1; +static int hf_x11_xf86vidmode_SwitchToMode_private = -1; +static int hf_x11_xf86vidmode_GetViewPort_screen = -1; +static int hf_x11_xf86vidmode_GetViewPort_reply_x = -1; +static int hf_x11_xf86vidmode_GetViewPort_reply_y = -1; +static int hf_x11_xf86vidmode_SetViewPort_screen = -1; +static int hf_x11_xf86vidmode_SetViewPort_x = -1; +static int hf_x11_xf86vidmode_SetViewPort_y = -1; +static int hf_x11_xf86vidmode_GetDotClocks_screen = -1; +static int hf_x11_xf86vidmode_GetDotClocks_reply_flags = -1; +static int hf_x11_xf86vidmode_GetDotClocks_reply_clocks = -1; +static int hf_x11_xf86vidmode_GetDotClocks_reply_maxclocks = -1; +static int hf_x11_xf86vidmode_GetDotClocks_reply_clock = -1; +static int hf_x11_xf86vidmode_GetDotClocks_reply_clock_item = -1; +static int hf_x11_xf86vidmode_SetClientVersion_major = -1; +static int hf_x11_xf86vidmode_SetClientVersion_minor = -1; +static int hf_x11_xf86vidmode_SetGamma_screen = -1; +static int hf_x11_xf86vidmode_SetGamma_red = -1; +static int hf_x11_xf86vidmode_SetGamma_green = -1; +static int hf_x11_xf86vidmode_SetGamma_blue = -1; +static int hf_x11_xf86vidmode_GetGamma_screen = -1; +static int hf_x11_xf86vidmode_GetGamma_reply_red = -1; +static int hf_x11_xf86vidmode_GetGamma_reply_green = -1; +static int hf_x11_xf86vidmode_GetGamma_reply_blue = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_screen = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_size = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_size = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_red = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_red_item = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_green = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_green_item = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_blue = -1; +static int hf_x11_xf86vidmode_GetGammaRamp_reply_blue_item = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_screen = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_size = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_red = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_red_item = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_green = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_green_item = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_blue = -1; +static int hf_x11_xf86vidmode_SetGammaRamp_blue_item = -1; +static int hf_x11_xf86vidmode_GetGammaRampSize_screen = -1; +static int hf_x11_xf86vidmode_GetGammaRampSize_reply_size = -1; +static int hf_x11_xf86vidmode_GetPermissions_screen = -1; +static int hf_x11_xf86vidmode_GetPermissions_reply_permissions = -1; +static int hf_x11_xf86vidmode_extension_minor = -1; + +static int hf_x11_xfixes_QueryVersion_client_major_version = -1; +static int hf_x11_xfixes_QueryVersion_client_minor_version = -1; +static int hf_x11_xfixes_QueryVersion_reply_major_version = -1; +static int hf_x11_xfixes_QueryVersion_reply_minor_version = -1; +static int hf_x11_xfixes_ChangeSaveSet_mode = -1; +static int hf_x11_xfixes_ChangeSaveSet_target = -1; +static int hf_x11_xfixes_ChangeSaveSet_map = -1; +static int hf_x11_xfixes_ChangeSaveSet_window = -1; +static int hf_x11_xfixes_SelectionNotify_subtype = -1; +static int hf_x11_xfixes_SelectionNotify_window = -1; +static int hf_x11_xfixes_SelectionNotify_owner = -1; +static int hf_x11_xfixes_SelectionNotify_selection = -1; +static int hf_x11_xfixes_SelectionNotify_timestamp = -1; +static int hf_x11_xfixes_SelectionNotify_selection_timestamp = -1; +static int hf_x11_xfixes_SelectSelectionInput_window = -1; +static int hf_x11_xfixes_SelectSelectionInput_selection = -1; +static int hf_x11_xfixes_SelectSelectionInput_event_mask = -1; +static int hf_x11_xfixes_CursorNotify_subtype = -1; +static int hf_x11_xfixes_CursorNotify_window = -1; +static int hf_x11_xfixes_CursorNotify_cursor_serial = -1; +static int hf_x11_xfixes_CursorNotify_timestamp = -1; +static int hf_x11_xfixes_CursorNotify_name = -1; +static int hf_x11_xfixes_SelectCursorInput_window = -1; +static int hf_x11_xfixes_SelectCursorInput_event_mask = -1; +static int hf_x11_xfixes_GetCursorImage_reply_x = -1; +static int hf_x11_xfixes_GetCursorImage_reply_y = -1; +static int hf_x11_xfixes_GetCursorImage_reply_width = -1; +static int hf_x11_xfixes_GetCursorImage_reply_height = -1; +static int hf_x11_xfixes_GetCursorImage_reply_xhot = -1; +static int hf_x11_xfixes_GetCursorImage_reply_yhot = -1; +static int hf_x11_xfixes_GetCursorImage_reply_cursor_serial = -1; +static int hf_x11_xfixes_GetCursorImage_reply_cursor_image = -1; +static int hf_x11_xfixes_GetCursorImage_reply_cursor_image_item = -1; +static int hf_x11_xfixes_CreateRegion_region = -1; +static int hf_x11_xfixes_CreateRegion_rectangles = -1; +static int hf_x11_xfixes_CreateRegion_rectangles_item = -1; +static int hf_x11_xfixes_CreateRegionFromBitmap_region = -1; +static int hf_x11_xfixes_CreateRegionFromBitmap_bitmap = -1; +static int hf_x11_xfixes_CreateRegionFromWindow_region = -1; +static int hf_x11_xfixes_CreateRegionFromWindow_window = -1; +static int hf_x11_xfixes_CreateRegionFromWindow_kind = -1; +static int hf_x11_xfixes_CreateRegionFromGC_region = -1; +static int hf_x11_xfixes_CreateRegionFromGC_gc = -1; +static int hf_x11_xfixes_CreateRegionFromPicture_region = -1; +static int hf_x11_xfixes_CreateRegionFromPicture_picture = -1; +static int hf_x11_xfixes_DestroyRegion_region = -1; +static int hf_x11_xfixes_SetRegion_region = -1; +static int hf_x11_xfixes_SetRegion_rectangles = -1; +static int hf_x11_xfixes_SetRegion_rectangles_item = -1; +static int hf_x11_xfixes_CopyRegion_source = -1; +static int hf_x11_xfixes_CopyRegion_destination = -1; +static int hf_x11_xfixes_UnionRegion_source1 = -1; +static int hf_x11_xfixes_UnionRegion_source2 = -1; +static int hf_x11_xfixes_UnionRegion_destination = -1; +static int hf_x11_xfixes_IntersectRegion_source1 = -1; +static int hf_x11_xfixes_IntersectRegion_source2 = -1; +static int hf_x11_xfixes_IntersectRegion_destination = -1; +static int hf_x11_xfixes_SubtractRegion_source1 = -1; +static int hf_x11_xfixes_SubtractRegion_source2 = -1; +static int hf_x11_xfixes_SubtractRegion_destination = -1; +static int hf_x11_xfixes_InvertRegion_source = -1; +static int hf_x11_xfixes_InvertRegion_bounds = -1; +static int hf_x11_xfixes_InvertRegion_destination = -1; +static int hf_x11_xfixes_TranslateRegion_region = -1; +static int hf_x11_xfixes_TranslateRegion_dx = -1; +static int hf_x11_xfixes_TranslateRegion_dy = -1; +static int hf_x11_xfixes_RegionExtents_source = -1; +static int hf_x11_xfixes_RegionExtents_destination = -1; +static int hf_x11_xfixes_FetchRegion_region = -1; +static int hf_x11_xfixes_FetchRegion_reply_extents = -1; +static int hf_x11_xfixes_FetchRegion_reply_rectangles = -1; +static int hf_x11_xfixes_FetchRegion_reply_rectangles_item = -1; +static int hf_x11_xfixes_SetGCClipRegion_gc = -1; +static int hf_x11_xfixes_SetGCClipRegion_region = -1; +static int hf_x11_xfixes_SetGCClipRegion_x_origin = -1; +static int hf_x11_xfixes_SetGCClipRegion_y_origin = -1; +static int hf_x11_xfixes_SetWindowShapeRegion_dest = -1; +static int hf_x11_xfixes_SetWindowShapeRegion_dest_kind = -1; +static int hf_x11_xfixes_SetWindowShapeRegion_x_offset = -1; +static int hf_x11_xfixes_SetWindowShapeRegion_y_offset = -1; +static int hf_x11_xfixes_SetWindowShapeRegion_region = -1; +static int hf_x11_xfixes_SetPictureClipRegion_picture = -1; +static int hf_x11_xfixes_SetPictureClipRegion_region = -1; +static int hf_x11_xfixes_SetPictureClipRegion_x_origin = -1; +static int hf_x11_xfixes_SetPictureClipRegion_y_origin = -1; +static int hf_x11_xfixes_SetCursorName_cursor = -1; +static int hf_x11_xfixes_SetCursorName_nbytes = -1; +static int hf_x11_xfixes_SetCursorName_name = -1; +static int hf_x11_xfixes_GetCursorName_cursor = -1; +static int hf_x11_xfixes_GetCursorName_reply_atom = -1; +static int hf_x11_xfixes_GetCursorName_reply_nbytes = -1; +static int hf_x11_xfixes_GetCursorName_reply_name = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_x = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_y = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_width = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_height = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_xhot = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_yhot = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_serial = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_atom = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_nbytes = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_name = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image = -1; +static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image_item = -1; +static int hf_x11_xfixes_ChangeCursor_source = -1; +static int hf_x11_xfixes_ChangeCursor_destination = -1; +static int hf_x11_xfixes_ChangeCursorByName_src = -1; +static int hf_x11_xfixes_ChangeCursorByName_nbytes = -1; +static int hf_x11_xfixes_ChangeCursorByName_name = -1; +static int hf_x11_xfixes_ExpandRegion_source = -1; +static int hf_x11_xfixes_ExpandRegion_destination = -1; +static int hf_x11_xfixes_ExpandRegion_left = -1; +static int hf_x11_xfixes_ExpandRegion_right = -1; +static int hf_x11_xfixes_ExpandRegion_top = -1; +static int hf_x11_xfixes_ExpandRegion_bottom = -1; +static int hf_x11_xfixes_HideCursor_window = -1; +static int hf_x11_xfixes_ShowCursor_window = -1; +static int hf_x11_xfixes_extension_minor = -1; + +static int hf_x11_struct_ScreenInfo = -1; +static int hf_x11_struct_ScreenInfo_x_org = -1; +static int hf_x11_struct_ScreenInfo_y_org = -1; +static int hf_x11_struct_ScreenInfo_width = -1; +static int hf_x11_struct_ScreenInfo_height = -1; +static int hf_x11_xinerama_QueryVersion_major = -1; +static int hf_x11_xinerama_QueryVersion_minor = -1; +static int hf_x11_xinerama_QueryVersion_reply_major = -1; +static int hf_x11_xinerama_QueryVersion_reply_minor = -1; +static int hf_x11_xinerama_GetState_window = -1; +static int hf_x11_xinerama_GetState_reply_state = -1; +static int hf_x11_xinerama_GetState_reply_window = -1; +static int hf_x11_xinerama_GetScreenCount_window = -1; +static int hf_x11_xinerama_GetScreenCount_reply_screen_count = -1; +static int hf_x11_xinerama_GetScreenCount_reply_window = -1; +static int hf_x11_xinerama_GetScreenSize_window = -1; +static int hf_x11_xinerama_GetScreenSize_screen = -1; +static int hf_x11_xinerama_GetScreenSize_reply_width = -1; +static int hf_x11_xinerama_GetScreenSize_reply_height = -1; +static int hf_x11_xinerama_GetScreenSize_reply_window = -1; +static int hf_x11_xinerama_GetScreenSize_reply_screen = -1; +static int hf_x11_xinerama_IsActive_reply_state = -1; +static int hf_x11_xinerama_QueryScreens_reply_number = -1; +static int hf_x11_xinerama_QueryScreens_reply_screen_info = -1; +static int hf_x11_xinerama_QueryScreens_reply_screen_info_item = -1; +static int hf_x11_xinerama_extension_minor = -1; + +static int hf_x11_xinput_GetExtensionVersion_name_len = -1; +static int hf_x11_xinput_GetExtensionVersion_name = -1; +static int hf_x11_xinput_GetExtensionVersion_reply_server_major = -1; +static int hf_x11_xinput_GetExtensionVersion_reply_server_minor = -1; +static int hf_x11_xinput_GetExtensionVersion_reply_present = -1; +static int hf_x11_struct_DeviceInfo = -1; +static int hf_x11_struct_DeviceInfo_device_type = -1; +static int hf_x11_struct_DeviceInfo_device_id = -1; +static int hf_x11_struct_DeviceInfo_num_class_info = -1; +static int hf_x11_struct_DeviceInfo_device_use = -1; +static int hf_x11_xinput_ListInputDevices_reply_devices_len = -1; +static int hf_x11_xinput_ListInputDevices_reply_devices = -1; +static int hf_x11_xinput_ListInputDevices_reply_devices_item = -1; +static int hf_x11_struct_InputClassInfo = -1; +static int hf_x11_struct_InputClassInfo_class_id = -1; +static int hf_x11_struct_InputClassInfo_event_type_base = -1; +static int hf_x11_xinput_OpenDevice_device_id = -1; +static int hf_x11_xinput_OpenDevice_reply_num_classes = -1; +static int hf_x11_xinput_OpenDevice_reply_class_info = -1; +static int hf_x11_xinput_OpenDevice_reply_class_info_item = -1; +static int hf_x11_xinput_CloseDevice_device_id = -1; +static int hf_x11_xinput_SetDeviceMode_device_id = -1; +static int hf_x11_xinput_SetDeviceMode_mode = -1; +static int hf_x11_xinput_SetDeviceMode_reply_status = -1; +static int hf_x11_xinput_SelectExtensionEvent_window = -1; +static int hf_x11_xinput_SelectExtensionEvent_num_classes = -1; +static int hf_x11_xinput_SelectExtensionEvent_classes = -1; +static int hf_x11_xinput_SelectExtensionEvent_classes_item = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_window = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_reply_num_this_classes = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_reply_num_all_classes = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes_item = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes = -1; +static int hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes_item = -1; +static int hf_x11_xinput_ChangeDeviceDontPropagateList_window = -1; +static int hf_x11_xinput_ChangeDeviceDontPropagateList_num_classes = -1; +static int hf_x11_xinput_ChangeDeviceDontPropagateList_mode = -1; +static int hf_x11_xinput_ChangeDeviceDontPropagateList_classes = -1; +static int hf_x11_xinput_ChangeDeviceDontPropagateList_classes_item = -1; +static int hf_x11_xinput_GetDeviceDontPropagateList_window = -1; +static int hf_x11_xinput_GetDeviceDontPropagateList_reply_num_classes = -1; +static int hf_x11_xinput_GetDeviceDontPropagateList_reply_classes = -1; +static int hf_x11_xinput_GetDeviceDontPropagateList_reply_classes_item = -1; +static int hf_x11_xinput_GetDeviceMotionEvents_start = -1; +static int hf_x11_xinput_GetDeviceMotionEvents_stop = -1; +static int hf_x11_xinput_GetDeviceMotionEvents_device_id = -1; +static int hf_x11_xinput_GetDeviceMotionEvents_reply_num_coords = -1; +static int hf_x11_xinput_GetDeviceMotionEvents_reply_num_axes = -1; +static int hf_x11_xinput_GetDeviceMotionEvents_reply_device_mode = -1; +static int hf_x11_xinput_ChangeKeyboardDevice_device_id = -1; +static int hf_x11_xinput_ChangeKeyboardDevice_reply_status = -1; +static int hf_x11_xinput_ChangePointerDevice_x_axis = -1; +static int hf_x11_xinput_ChangePointerDevice_y_axis = -1; +static int hf_x11_xinput_ChangePointerDevice_device_id = -1; +static int hf_x11_xinput_ChangePointerDevice_reply_status = -1; +static int hf_x11_xinput_GrabDevice_grab_window = -1; +static int hf_x11_xinput_GrabDevice_time = -1; +static int hf_x11_xinput_GrabDevice_num_classes = -1; +static int hf_x11_xinput_GrabDevice_this_device_mode = -1; +static int hf_x11_xinput_GrabDevice_other_device_mode = -1; +static int hf_x11_xinput_GrabDevice_owner_events = -1; +static int hf_x11_xinput_GrabDevice_device_id = -1; +static int hf_x11_xinput_GrabDevice_classes = -1; +static int hf_x11_xinput_GrabDevice_classes_item = -1; +static int hf_x11_xinput_GrabDevice_reply_status = -1; +static int hf_x11_xinput_UngrabDevice_time = -1; +static int hf_x11_xinput_UngrabDevice_device_id = -1; +static int hf_x11_xinput_GrabDeviceKey_grab_window = -1; +static int hf_x11_xinput_GrabDeviceKey_num_classes = -1; +static int hf_x11_xinput_GrabDeviceKey_modifiers = -1; +static int hf_x11_xinput_GrabDeviceKey_modifier_device = -1; +static int hf_x11_xinput_GrabDeviceKey_grabbed_device = -1; +static int hf_x11_xinput_GrabDeviceKey_key = -1; +static int hf_x11_xinput_GrabDeviceKey_this_device_mode = -1; +static int hf_x11_xinput_GrabDeviceKey_other_device_mode = -1; +static int hf_x11_xinput_GrabDeviceKey_owner_events = -1; +static int hf_x11_xinput_GrabDeviceKey_classes = -1; +static int hf_x11_xinput_GrabDeviceKey_classes_item = -1; +static int hf_x11_xinput_UngrabDeviceKey_grabWindow = -1; +static int hf_x11_xinput_UngrabDeviceKey_modifiers = -1; +static int hf_x11_xinput_UngrabDeviceKey_modifier_device = -1; +static int hf_x11_xinput_UngrabDeviceKey_key = -1; +static int hf_x11_xinput_UngrabDeviceKey_grabbed_device = -1; +static int hf_x11_xinput_GrabDeviceButton_grab_window = -1; +static int hf_x11_xinput_GrabDeviceButton_grabbed_device = -1; +static int hf_x11_xinput_GrabDeviceButton_modifier_device = -1; +static int hf_x11_xinput_GrabDeviceButton_num_classes = -1; +static int hf_x11_xinput_GrabDeviceButton_modifiers = -1; +static int hf_x11_xinput_GrabDeviceButton_this_device_mode = -1; +static int hf_x11_xinput_GrabDeviceButton_other_device_mode = -1; +static int hf_x11_xinput_GrabDeviceButton_button = -1; +static int hf_x11_xinput_GrabDeviceButton_owner_events = -1; +static int hf_x11_xinput_GrabDeviceButton_classes = -1; +static int hf_x11_xinput_GrabDeviceButton_classes_item = -1; +static int hf_x11_xinput_UngrabDeviceButton_grab_window = -1; +static int hf_x11_xinput_UngrabDeviceButton_modifiers = -1; +static int hf_x11_xinput_UngrabDeviceButton_modifier_device = -1; +static int hf_x11_xinput_UngrabDeviceButton_button = -1; +static int hf_x11_xinput_UngrabDeviceButton_grabbed_device = -1; +static int hf_x11_xinput_AllowDeviceEvents_time = -1; +static int hf_x11_xinput_AllowDeviceEvents_mode = -1; +static int hf_x11_xinput_AllowDeviceEvents_device_id = -1; +static int hf_x11_xinput_GetDeviceFocus_device_id = -1; +static int hf_x11_xinput_GetDeviceFocus_reply_focus = -1; +static int hf_x11_xinput_GetDeviceFocus_reply_time = -1; +static int hf_x11_xinput_GetDeviceFocus_reply_revert_to = -1; +static int hf_x11_xinput_SetDeviceFocus_focus = -1; +static int hf_x11_xinput_SetDeviceFocus_time = -1; +static int hf_x11_xinput_SetDeviceFocus_revert_to = -1; +static int hf_x11_xinput_SetDeviceFocus_device_id = -1; +static int hf_x11_xinput_GetFeedbackControl_device_id = -1; +static int hf_x11_xinput_GetFeedbackControl_reply_num_feedback = -1; +static int hf_x11_xinput_GetDeviceKeyMapping_device_id = -1; +static int hf_x11_xinput_GetDeviceKeyMapping_first_keycode = -1; +static int hf_x11_xinput_GetDeviceKeyMapping_count = -1; +static int hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_per_keycode = -1; +static int hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms = -1; +static int hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_item = -1; +static int hf_x11_xinput_ChangeDeviceKeyMapping_device_id = -1; +static int hf_x11_xinput_ChangeDeviceKeyMapping_first_keycode = -1; +static int hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_per_keycode = -1; +static int hf_x11_xinput_ChangeDeviceKeyMapping_keycode_count = -1; +static int hf_x11_xinput_ChangeDeviceKeyMapping_keysyms = -1; +static int hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_item = -1; +static int hf_x11_xinput_GetDeviceModifierMapping_device_id = -1; +static int hf_x11_xinput_GetDeviceModifierMapping_reply_keycodes_per_modifier = -1; +static int hf_x11_xinput_GetDeviceModifierMapping_reply_keymaps = -1; +static int hf_x11_xinput_SetDeviceModifierMapping_device_id = -1; +static int hf_x11_xinput_SetDeviceModifierMapping_keycodes_per_modifier = -1; +static int hf_x11_xinput_SetDeviceModifierMapping_keymaps = -1; +static int hf_x11_xinput_SetDeviceModifierMapping_reply_status = -1; +static int hf_x11_xinput_GetDeviceButtonMapping_device_id = -1; +static int hf_x11_xinput_GetDeviceButtonMapping_reply_map_size = -1; +static int hf_x11_xinput_GetDeviceButtonMapping_reply_map = -1; +static int hf_x11_xinput_SetDeviceButtonMapping_device_id = -1; +static int hf_x11_xinput_SetDeviceButtonMapping_map_size = -1; +static int hf_x11_xinput_SetDeviceButtonMapping_map = -1; +static int hf_x11_xinput_SetDeviceButtonMapping_reply_status = -1; +static int hf_x11_xinput_QueryDeviceState_device_id = -1; +static int hf_x11_xinput_QueryDeviceState_reply_num_classes = -1; +static int hf_x11_xinput_SendExtensionEvent_destination = -1; +static int hf_x11_xinput_SendExtensionEvent_device_id = -1; +static int hf_x11_xinput_SendExtensionEvent_propagate = -1; +static int hf_x11_xinput_SendExtensionEvent_num_classes = -1; +static int hf_x11_xinput_SendExtensionEvent_num_events = -1; +static int hf_x11_xinput_SendExtensionEvent_events = -1; +static int hf_x11_xinput_SendExtensionEvent_classes = -1; +static int hf_x11_xinput_SendExtensionEvent_classes_item = -1; +static int hf_x11_xinput_DeviceBell_device_id = -1; +static int hf_x11_xinput_DeviceBell_feedback_id = -1; +static int hf_x11_xinput_DeviceBell_feedback_class = -1; +static int hf_x11_xinput_DeviceBell_percent = -1; +static int hf_x11_xinput_SetDeviceValuators_device_id = -1; +static int hf_x11_xinput_SetDeviceValuators_first_valuator = -1; +static int hf_x11_xinput_SetDeviceValuators_num_valuators = -1; +static int hf_x11_xinput_SetDeviceValuators_valuators = -1; +static int hf_x11_xinput_SetDeviceValuators_valuators_item = -1; +static int hf_x11_xinput_SetDeviceValuators_reply_status = -1; +static int hf_x11_xinput_GetDeviceControl_control_id = -1; +static int hf_x11_xinput_GetDeviceControl_device_id = -1; +static int hf_x11_xinput_GetDeviceControl_reply_status = -1; +static int hf_x11_xinput_DeviceValuator_device_id = -1; +static int hf_x11_xinput_DeviceValuator_device_state = -1; +static int hf_x11_xinput_DeviceValuator_num_valuators = -1; +static int hf_x11_xinput_DeviceValuator_first_valuator = -1; +static int hf_x11_xinput_DeviceValuator_valuators = -1; +static int hf_x11_xinput_DeviceValuator_valuators_item = -1; +static int hf_x11_xinput_DeviceKeyPress_detail = -1; +static int hf_x11_xinput_DeviceKeyPress_time = -1; +static int hf_x11_xinput_DeviceKeyPress_root = -1; +static int hf_x11_xinput_DeviceKeyPress_event = -1; +static int hf_x11_xinput_DeviceKeyPress_child = -1; +static int hf_x11_xinput_DeviceKeyPress_root_x = -1; +static int hf_x11_xinput_DeviceKeyPress_root_y = -1; +static int hf_x11_xinput_DeviceKeyPress_event_x = -1; +static int hf_x11_xinput_DeviceKeyPress_event_y = -1; +static int hf_x11_xinput_DeviceKeyPress_state = -1; +static int hf_x11_xinput_DeviceKeyPress_same_screen = -1; +static int hf_x11_xinput_DeviceKeyPress_device_id = -1; +static int hf_x11_xinput_FocusIn_detail = -1; +static int hf_x11_xinput_FocusIn_time = -1; +static int hf_x11_xinput_FocusIn_window = -1; +static int hf_x11_xinput_FocusIn_mode = -1; +static int hf_x11_xinput_FocusIn_device_id = -1; +static int hf_x11_xinput_DeviceStateNotify_device_id = -1; +static int hf_x11_xinput_DeviceStateNotify_time = -1; +static int hf_x11_xinput_DeviceStateNotify_num_keys = -1; +static int hf_x11_xinput_DeviceStateNotify_num_buttons = -1; +static int hf_x11_xinput_DeviceStateNotify_num_valuators = -1; +static int hf_x11_xinput_DeviceStateNotify_classes_reported = -1; +static int hf_x11_xinput_DeviceStateNotify_buttons = -1; +static int hf_x11_xinput_DeviceStateNotify_keys = -1; +static int hf_x11_xinput_DeviceStateNotify_valuators = -1; +static int hf_x11_xinput_DeviceStateNotify_valuators_item = -1; +static int hf_x11_xinput_DeviceMappingNotify_device_id = -1; +static int hf_x11_xinput_DeviceMappingNotify_request = -1; +static int hf_x11_xinput_DeviceMappingNotify_first_keycode = -1; +static int hf_x11_xinput_DeviceMappingNotify_count = -1; +static int hf_x11_xinput_DeviceMappingNotify_time = -1; +static int hf_x11_xinput_ChangeDeviceNotify_device_id = -1; +static int hf_x11_xinput_ChangeDeviceNotify_time = -1; +static int hf_x11_xinput_ChangeDeviceNotify_request = -1; +static int hf_x11_xinput_DeviceKeyStateNotify_device_id = -1; +static int hf_x11_xinput_DeviceKeyStateNotify_keys = -1; +static int hf_x11_xinput_DeviceButtonStateNotify_device_id = -1; +static int hf_x11_xinput_DeviceButtonStateNotify_buttons = -1; +static int hf_x11_xinput_DevicePresenceNotify_time = -1; +static int hf_x11_xinput_DevicePresenceNotify_devchange = -1; +static int hf_x11_xinput_DevicePresenceNotify_device_id = -1; +static int hf_x11_xinput_DevicePresenceNotify_control = -1; +static int hf_x11_xinput_extension_minor = -1; + +static int hf_x11_struct_PRINTER = -1; +static int hf_x11_struct_PRINTER_nameLen = -1; +static int hf_x11_struct_PRINTER_name = -1; +static int hf_x11_struct_PRINTER_descLen = -1; +static int hf_x11_struct_PRINTER_description = -1; +static int hf_x11_xprint_PrintQueryVersion_reply_major_version = -1; +static int hf_x11_xprint_PrintQueryVersion_reply_minor_version = -1; +static int hf_x11_xprint_PrintGetPrinterList_printerNameLen = -1; +static int hf_x11_xprint_PrintGetPrinterList_localeLen = -1; +static int hf_x11_xprint_PrintGetPrinterList_printer_name = -1; +static int hf_x11_xprint_PrintGetPrinterList_locale = -1; +static int hf_x11_xprint_PrintGetPrinterList_reply_listCount = -1; +static int hf_x11_xprint_PrintGetPrinterList_reply_printers = -1; +static int hf_x11_xprint_CreateContext_context_id = -1; +static int hf_x11_xprint_CreateContext_printerNameLen = -1; +static int hf_x11_xprint_CreateContext_localeLen = -1; +static int hf_x11_xprint_CreateContext_printerName = -1; +static int hf_x11_xprint_CreateContext_locale = -1; +static int hf_x11_xprint_PrintSetContext_context = -1; +static int hf_x11_xprint_PrintGetContext_reply_context = -1; +static int hf_x11_xprint_PrintDestroyContext_context = -1; +static int hf_x11_xprint_PrintGetScreenOfContext_reply_root = -1; +static int hf_x11_xprint_PrintStartJob_output_mode = -1; +static int hf_x11_xprint_PrintEndJob_cancel = -1; +static int hf_x11_xprint_PrintStartDoc_driver_mode = -1; +static int hf_x11_xprint_PrintEndDoc_cancel = -1; +static int hf_x11_xprint_PrintPutDocumentData_drawable = -1; +static int hf_x11_xprint_PrintPutDocumentData_len_data = -1; +static int hf_x11_xprint_PrintPutDocumentData_len_fmt = -1; +static int hf_x11_xprint_PrintPutDocumentData_len_options = -1; +static int hf_x11_xprint_PrintPutDocumentData_data = -1; +static int hf_x11_xprint_PrintPutDocumentData_doc_format = -1; +static int hf_x11_xprint_PrintPutDocumentData_options = -1; +static int hf_x11_xprint_PrintGetDocumentData_context = -1; +static int hf_x11_xprint_PrintGetDocumentData_max_bytes = -1; +static int hf_x11_xprint_PrintGetDocumentData_reply_status_code = -1; +static int hf_x11_xprint_PrintGetDocumentData_reply_finished_flag = -1; +static int hf_x11_xprint_PrintGetDocumentData_reply_dataLen = -1; +static int hf_x11_xprint_PrintGetDocumentData_reply_data = -1; +static int hf_x11_xprint_PrintStartPage_window = -1; +static int hf_x11_xprint_PrintEndPage_cancel = -1; +static int hf_x11_xprint_PrintSelectInput_context = -1; +static int hf_x11_xprint_PrintInputSelected_context = -1; +static int hf_x11_xprint_PrintGetAttributes_context = -1; +static int hf_x11_xprint_PrintGetAttributes_pool = -1; +static int hf_x11_xprint_PrintGetAttributes_reply_stringLen = -1; +static int hf_x11_xprint_PrintGetAttributes_reply_attributes = -1; +static int hf_x11_xprint_PrintGetOneAttributes_context = -1; +static int hf_x11_xprint_PrintGetOneAttributes_nameLen = -1; +static int hf_x11_xprint_PrintGetOneAttributes_pool = -1; +static int hf_x11_xprint_PrintGetOneAttributes_name = -1; +static int hf_x11_xprint_PrintGetOneAttributes_reply_valueLen = -1; +static int hf_x11_xprint_PrintGetOneAttributes_reply_value = -1; +static int hf_x11_xprint_PrintSetAttributes_context = -1; +static int hf_x11_xprint_PrintSetAttributes_stringLen = -1; +static int hf_x11_xprint_PrintSetAttributes_pool = -1; +static int hf_x11_xprint_PrintSetAttributes_rule = -1; +static int hf_x11_xprint_PrintSetAttributes_attributes = -1; +static int hf_x11_xprint_PrintGetPageDimensions_context = -1; +static int hf_x11_xprint_PrintGetPageDimensions_reply_width = -1; +static int hf_x11_xprint_PrintGetPageDimensions_reply_height = -1; +static int hf_x11_xprint_PrintGetPageDimensions_reply_offset_x = -1; +static int hf_x11_xprint_PrintGetPageDimensions_reply_offset_y = -1; +static int hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_width = -1; +static int hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_height = -1; +static int hf_x11_xprint_PrintQueryScreens_reply_listCount = -1; +static int hf_x11_xprint_PrintQueryScreens_reply_roots = -1; +static int hf_x11_xprint_PrintQueryScreens_reply_roots_item = -1; +static int hf_x11_xprint_PrintSetImageResolution_context = -1; +static int hf_x11_xprint_PrintSetImageResolution_image_resolution = -1; +static int hf_x11_xprint_PrintSetImageResolution_reply_status = -1; +static int hf_x11_xprint_PrintSetImageResolution_reply_previous_resolutions = -1; +static int hf_x11_xprint_PrintGetImageResolution_context = -1; +static int hf_x11_xprint_PrintGetImageResolution_reply_image_resolution = -1; +static int hf_x11_xprint_Notify_detail = -1; +static int hf_x11_xprint_Notify_context = -1; +static int hf_x11_xprint_Notify_cancel = -1; +static int hf_x11_xprint_AttributNotify_detail = -1; +static int hf_x11_xprint_AttributNotify_context = -1; +static int hf_x11_xprint_extension_minor = -1; + +static int hf_x11_xselinux_QueryVersion_client_major = -1; +static int hf_x11_xselinux_QueryVersion_client_minor = -1; +static int hf_x11_xselinux_QueryVersion_reply_server_major = -1; +static int hf_x11_xselinux_QueryVersion_reply_server_minor = -1; +static int hf_x11_xselinux_SetDeviceCreateContext_context_len = -1; +static int hf_x11_xselinux_SetDeviceCreateContext_context = -1; +static int hf_x11_xselinux_GetDeviceCreateContext_reply_context_len = -1; +static int hf_x11_xselinux_GetDeviceCreateContext_reply_context = -1; +static int hf_x11_xselinux_SetDeviceContext_device = -1; +static int hf_x11_xselinux_SetDeviceContext_context_len = -1; +static int hf_x11_xselinux_SetDeviceContext_context = -1; +static int hf_x11_xselinux_GetDeviceContext_device = -1; +static int hf_x11_xselinux_GetDeviceContext_reply_context_len = -1; +static int hf_x11_xselinux_GetDeviceContext_reply_context = -1; +static int hf_x11_xselinux_SetWindowCreateContext_context_len = -1; +static int hf_x11_xselinux_SetWindowCreateContext_context = -1; +static int hf_x11_xselinux_GetWindowCreateContext_reply_context_len = -1; +static int hf_x11_xselinux_GetWindowCreateContext_reply_context = -1; +static int hf_x11_xselinux_GetWindowContext_window = -1; +static int hf_x11_xselinux_GetWindowContext_reply_context_len = -1; +static int hf_x11_xselinux_GetWindowContext_reply_context = -1; +static int hf_x11_struct_ListItem = -1; +static int hf_x11_struct_ListItem_name = -1; +static int hf_x11_struct_ListItem_object_context_len = -1; +static int hf_x11_struct_ListItem_data_context_len = -1; +static int hf_x11_struct_ListItem_object_context = -1; +static int hf_x11_struct_ListItem_data_context = -1; +static int hf_x11_xselinux_SetPropertyCreateContext_context_len = -1; +static int hf_x11_xselinux_SetPropertyCreateContext_context = -1; +static int hf_x11_xselinux_GetPropertyCreateContext_reply_context_len = -1; +static int hf_x11_xselinux_GetPropertyCreateContext_reply_context = -1; +static int hf_x11_xselinux_SetPropertyUseContext_context_len = -1; +static int hf_x11_xselinux_SetPropertyUseContext_context = -1; +static int hf_x11_xselinux_GetPropertyUseContext_reply_context_len = -1; +static int hf_x11_xselinux_GetPropertyUseContext_reply_context = -1; +static int hf_x11_xselinux_GetPropertyContext_window = -1; +static int hf_x11_xselinux_GetPropertyContext_property = -1; +static int hf_x11_xselinux_GetPropertyContext_reply_context_len = -1; +static int hf_x11_xselinux_GetPropertyContext_reply_context = -1; +static int hf_x11_xselinux_GetPropertyDataContext_window = -1; +static int hf_x11_xselinux_GetPropertyDataContext_property = -1; +static int hf_x11_xselinux_GetPropertyDataContext_reply_context_len = -1; +static int hf_x11_xselinux_GetPropertyDataContext_reply_context = -1; +static int hf_x11_xselinux_ListProperties_window = -1; +static int hf_x11_xselinux_ListProperties_reply_properties_len = -1; +static int hf_x11_xselinux_ListProperties_reply_properties = -1; +static int hf_x11_xselinux_SetSelectionCreateContext_context_len = -1; +static int hf_x11_xselinux_SetSelectionCreateContext_context = -1; +static int hf_x11_xselinux_GetSelectionCreateContext_reply_context_len = -1; +static int hf_x11_xselinux_GetSelectionCreateContext_reply_context = -1; +static int hf_x11_xselinux_SetSelectionUseContext_context_len = -1; +static int hf_x11_xselinux_SetSelectionUseContext_context = -1; +static int hf_x11_xselinux_GetSelectionUseContext_reply_context_len = -1; +static int hf_x11_xselinux_GetSelectionUseContext_reply_context = -1; +static int hf_x11_xselinux_GetSelectionContext_selection = -1; +static int hf_x11_xselinux_GetSelectionContext_reply_context_len = -1; +static int hf_x11_xselinux_GetSelectionContext_reply_context = -1; +static int hf_x11_xselinux_GetSelectionDataContext_selection = -1; +static int hf_x11_xselinux_GetSelectionDataContext_reply_context_len = -1; +static int hf_x11_xselinux_GetSelectionDataContext_reply_context = -1; +static int hf_x11_xselinux_ListSelections_reply_selections_len = -1; +static int hf_x11_xselinux_ListSelections_reply_selections = -1; +static int hf_x11_xselinux_GetClientContext_resource = -1; +static int hf_x11_xselinux_GetClientContext_reply_context_len = -1; +static int hf_x11_xselinux_GetClientContext_reply_context = -1; +static int hf_x11_xselinux_extension_minor = -1; + +static int hf_x11_xtest_GetVersion_major_version = -1; +static int hf_x11_xtest_GetVersion_minor_version = -1; +static int hf_x11_xtest_GetVersion_reply_major_version = -1; +static int hf_x11_xtest_GetVersion_reply_minor_version = -1; +static int hf_x11_xtest_CompareCursor_window = -1; +static int hf_x11_xtest_CompareCursor_cursor = -1; +static int hf_x11_xtest_CompareCursor_reply_same = -1; +static int hf_x11_xtest_FakeInput_type = -1; +static int hf_x11_xtest_FakeInput_detail = -1; +static int hf_x11_xtest_FakeInput_time = -1; +static int hf_x11_xtest_FakeInput_root = -1; +static int hf_x11_xtest_FakeInput_rootX = -1; +static int hf_x11_xtest_FakeInput_rootY = -1; +static int hf_x11_xtest_FakeInput_deviceid = -1; +static int hf_x11_xtest_GrabControl_impervious = -1; +static int hf_x11_xtest_extension_minor = -1; + +static int hf_x11_struct_Rational = -1; +static int hf_x11_struct_Rational_numerator = -1; +static int hf_x11_struct_Rational_denominator = -1; +static int hf_x11_struct_Format = -1; +static int hf_x11_struct_Format_visual = -1; +static int hf_x11_struct_Format_depth = -1; +static int hf_x11_struct_AdaptorInfo = -1; +static int hf_x11_struct_AdaptorInfo_base_id = -1; +static int hf_x11_struct_AdaptorInfo_name_size = -1; +static int hf_x11_struct_AdaptorInfo_num_ports = -1; +static int hf_x11_struct_AdaptorInfo_num_formats = -1; +static int hf_x11_struct_AdaptorInfo_type = -1; +static int hf_x11_struct_AdaptorInfo_name = -1; +static int hf_x11_struct_AdaptorInfo_formats = -1; +static int hf_x11_struct_AdaptorInfo_formats_item = -1; +static int hf_x11_struct_EncodingInfo = -1; +static int hf_x11_struct_EncodingInfo_encoding = -1; +static int hf_x11_struct_EncodingInfo_name_size = -1; +static int hf_x11_struct_EncodingInfo_width = -1; +static int hf_x11_struct_EncodingInfo_height = -1; +static int hf_x11_struct_EncodingInfo_rate = -1; +static int hf_x11_struct_EncodingInfo_name = -1; +static int hf_x11_struct_AttributeInfo = -1; +static int hf_x11_struct_AttributeInfo_flags = -1; +static int hf_x11_struct_AttributeInfo_min = -1; +static int hf_x11_struct_AttributeInfo_max = -1; +static int hf_x11_struct_AttributeInfo_size = -1; +static int hf_x11_struct_AttributeInfo_name = -1; +static int hf_x11_struct_ImageFormatInfo = -1; +static int hf_x11_struct_ImageFormatInfo_id = -1; +static int hf_x11_struct_ImageFormatInfo_type = -1; +static int hf_x11_struct_ImageFormatInfo_byte_order = -1; +static int hf_x11_struct_ImageFormatInfo_guid = -1; +static int hf_x11_struct_ImageFormatInfo_bpp = -1; +static int hf_x11_struct_ImageFormatInfo_num_planes = -1; +static int hf_x11_struct_ImageFormatInfo_depth = -1; +static int hf_x11_struct_ImageFormatInfo_red_mask = -1; +static int hf_x11_struct_ImageFormatInfo_green_mask = -1; +static int hf_x11_struct_ImageFormatInfo_blue_mask = -1; +static int hf_x11_struct_ImageFormatInfo_format = -1; +static int hf_x11_struct_ImageFormatInfo_y_sample_bits = -1; +static int hf_x11_struct_ImageFormatInfo_u_sample_bits = -1; +static int hf_x11_struct_ImageFormatInfo_v_sample_bits = -1; +static int hf_x11_struct_ImageFormatInfo_vhorz_y_period = -1; +static int hf_x11_struct_ImageFormatInfo_vhorz_u_period = -1; +static int hf_x11_struct_ImageFormatInfo_vhorz_v_period = -1; +static int hf_x11_struct_ImageFormatInfo_vvert_y_period = -1; +static int hf_x11_struct_ImageFormatInfo_vvert_u_period = -1; +static int hf_x11_struct_ImageFormatInfo_vvert_v_period = -1; +static int hf_x11_struct_ImageFormatInfo_vcomp_order = -1; +static int hf_x11_struct_ImageFormatInfo_vscanline_order = -1; +static int hf_x11_xv_VideoNotify_reason = -1; +static int hf_x11_xv_VideoNotify_time = -1; +static int hf_x11_xv_VideoNotify_drawable = -1; +static int hf_x11_xv_VideoNotify_port = -1; +static int hf_x11_xv_PortNotify_time = -1; +static int hf_x11_xv_PortNotify_port = -1; +static int hf_x11_xv_PortNotify_attribute = -1; +static int hf_x11_xv_PortNotify_value = -1; +static int hf_x11_xv_QueryExtension_reply_major = -1; +static int hf_x11_xv_QueryExtension_reply_minor = -1; +static int hf_x11_xv_QueryAdaptors_window = -1; +static int hf_x11_xv_QueryAdaptors_reply_num_adaptors = -1; +static int hf_x11_xv_QueryAdaptors_reply_info = -1; +static int hf_x11_xv_QueryEncodings_port = -1; +static int hf_x11_xv_QueryEncodings_reply_num_encodings = -1; +static int hf_x11_xv_QueryEncodings_reply_info = -1; +static int hf_x11_xv_GrabPort_port = -1; +static int hf_x11_xv_GrabPort_time = -1; +static int hf_x11_xv_GrabPort_reply_result = -1; +static int hf_x11_xv_UngrabPort_port = -1; +static int hf_x11_xv_UngrabPort_time = -1; +static int hf_x11_xv_PutVideo_port = -1; +static int hf_x11_xv_PutVideo_drawable = -1; +static int hf_x11_xv_PutVideo_gc = -1; +static int hf_x11_xv_PutVideo_vid_x = -1; +static int hf_x11_xv_PutVideo_vid_y = -1; +static int hf_x11_xv_PutVideo_vid_w = -1; +static int hf_x11_xv_PutVideo_vid_h = -1; +static int hf_x11_xv_PutVideo_drw_x = -1; +static int hf_x11_xv_PutVideo_drw_y = -1; +static int hf_x11_xv_PutVideo_drw_w = -1; +static int hf_x11_xv_PutVideo_drw_h = -1; +static int hf_x11_xv_PutStill_port = -1; +static int hf_x11_xv_PutStill_drawable = -1; +static int hf_x11_xv_PutStill_gc = -1; +static int hf_x11_xv_PutStill_vid_x = -1; +static int hf_x11_xv_PutStill_vid_y = -1; +static int hf_x11_xv_PutStill_vid_w = -1; +static int hf_x11_xv_PutStill_vid_h = -1; +static int hf_x11_xv_PutStill_drw_x = -1; +static int hf_x11_xv_PutStill_drw_y = -1; +static int hf_x11_xv_PutStill_drw_w = -1; +static int hf_x11_xv_PutStill_drw_h = -1; +static int hf_x11_xv_GetVideo_port = -1; +static int hf_x11_xv_GetVideo_drawable = -1; +static int hf_x11_xv_GetVideo_gc = -1; +static int hf_x11_xv_GetVideo_vid_x = -1; +static int hf_x11_xv_GetVideo_vid_y = -1; +static int hf_x11_xv_GetVideo_vid_w = -1; +static int hf_x11_xv_GetVideo_vid_h = -1; +static int hf_x11_xv_GetVideo_drw_x = -1; +static int hf_x11_xv_GetVideo_drw_y = -1; +static int hf_x11_xv_GetVideo_drw_w = -1; +static int hf_x11_xv_GetVideo_drw_h = -1; +static int hf_x11_xv_GetStill_port = -1; +static int hf_x11_xv_GetStill_drawable = -1; +static int hf_x11_xv_GetStill_gc = -1; +static int hf_x11_xv_GetStill_vid_x = -1; +static int hf_x11_xv_GetStill_vid_y = -1; +static int hf_x11_xv_GetStill_vid_w = -1; +static int hf_x11_xv_GetStill_vid_h = -1; +static int hf_x11_xv_GetStill_drw_x = -1; +static int hf_x11_xv_GetStill_drw_y = -1; +static int hf_x11_xv_GetStill_drw_w = -1; +static int hf_x11_xv_GetStill_drw_h = -1; +static int hf_x11_xv_StopVideo_port = -1; +static int hf_x11_xv_StopVideo_drawable = -1; +static int hf_x11_xv_SelectVideoNotify_drawable = -1; +static int hf_x11_xv_SelectVideoNotify_onoff = -1; +static int hf_x11_xv_SelectPortNotify_port = -1; +static int hf_x11_xv_SelectPortNotify_onoff = -1; +static int hf_x11_xv_QueryBestSize_port = -1; +static int hf_x11_xv_QueryBestSize_vid_w = -1; +static int hf_x11_xv_QueryBestSize_vid_h = -1; +static int hf_x11_xv_QueryBestSize_drw_w = -1; +static int hf_x11_xv_QueryBestSize_drw_h = -1; +static int hf_x11_xv_QueryBestSize_motion = -1; +static int hf_x11_xv_QueryBestSize_reply_actual_width = -1; +static int hf_x11_xv_QueryBestSize_reply_actual_height = -1; +static int hf_x11_xv_SetPortAttribute_port = -1; +static int hf_x11_xv_SetPortAttribute_attribute = -1; +static int hf_x11_xv_SetPortAttribute_value = -1; +static int hf_x11_xv_GetPortAttribute_port = -1; +static int hf_x11_xv_GetPortAttribute_attribute = -1; +static int hf_x11_xv_GetPortAttribute_reply_value = -1; +static int hf_x11_xv_QueryPortAttributes_port = -1; +static int hf_x11_xv_QueryPortAttributes_reply_num_attributes = -1; +static int hf_x11_xv_QueryPortAttributes_reply_text_size = -1; +static int hf_x11_xv_QueryPortAttributes_reply_attributes = -1; +static int hf_x11_xv_ListImageFormats_port = -1; +static int hf_x11_xv_ListImageFormats_reply_num_formats = -1; +static int hf_x11_xv_ListImageFormats_reply_format = -1; +static int hf_x11_xv_ListImageFormats_reply_format_item = -1; +static int hf_x11_xv_QueryImageAttributes_port = -1; +static int hf_x11_xv_QueryImageAttributes_id = -1; +static int hf_x11_xv_QueryImageAttributes_width = -1; +static int hf_x11_xv_QueryImageAttributes_height = -1; +static int hf_x11_xv_QueryImageAttributes_reply_num_planes = -1; +static int hf_x11_xv_QueryImageAttributes_reply_data_size = -1; +static int hf_x11_xv_QueryImageAttributes_reply_width = -1; +static int hf_x11_xv_QueryImageAttributes_reply_height = -1; +static int hf_x11_xv_QueryImageAttributes_reply_pitches = -1; +static int hf_x11_xv_QueryImageAttributes_reply_pitches_item = -1; +static int hf_x11_xv_QueryImageAttributes_reply_offsets = -1; +static int hf_x11_xv_QueryImageAttributes_reply_offsets_item = -1; +static int hf_x11_xv_PutImage_port = -1; +static int hf_x11_xv_PutImage_drawable = -1; +static int hf_x11_xv_PutImage_gc = -1; +static int hf_x11_xv_PutImage_id = -1; +static int hf_x11_xv_PutImage_src_x = -1; +static int hf_x11_xv_PutImage_src_y = -1; +static int hf_x11_xv_PutImage_src_w = -1; +static int hf_x11_xv_PutImage_src_h = -1; +static int hf_x11_xv_PutImage_drw_x = -1; +static int hf_x11_xv_PutImage_drw_y = -1; +static int hf_x11_xv_PutImage_drw_w = -1; +static int hf_x11_xv_PutImage_drw_h = -1; +static int hf_x11_xv_PutImage_width = -1; +static int hf_x11_xv_PutImage_height = -1; +static int hf_x11_xv_PutImage_data = -1; +static int hf_x11_xv_ShmPutImage_port = -1; +static int hf_x11_xv_ShmPutImage_drawable = -1; +static int hf_x11_xv_ShmPutImage_gc = -1; +static int hf_x11_xv_ShmPutImage_shmseg = -1; +static int hf_x11_xv_ShmPutImage_id = -1; +static int hf_x11_xv_ShmPutImage_offset = -1; +static int hf_x11_xv_ShmPutImage_src_x = -1; +static int hf_x11_xv_ShmPutImage_src_y = -1; +static int hf_x11_xv_ShmPutImage_src_w = -1; +static int hf_x11_xv_ShmPutImage_src_h = -1; +static int hf_x11_xv_ShmPutImage_drw_x = -1; +static int hf_x11_xv_ShmPutImage_drw_y = -1; +static int hf_x11_xv_ShmPutImage_drw_w = -1; +static int hf_x11_xv_ShmPutImage_drw_h = -1; +static int hf_x11_xv_ShmPutImage_width = -1; +static int hf_x11_xv_ShmPutImage_height = -1; +static int hf_x11_xv_ShmPutImage_send_event = -1; +static int hf_x11_xv_extension_minor = -1; + +static int hf_x11_struct_SurfaceInfo = -1; +static int hf_x11_struct_SurfaceInfo_id = -1; +static int hf_x11_struct_SurfaceInfo_chroma_format = -1; +static int hf_x11_struct_SurfaceInfo_pad0 = -1; +static int hf_x11_struct_SurfaceInfo_max_width = -1; +static int hf_x11_struct_SurfaceInfo_max_height = -1; +static int hf_x11_struct_SurfaceInfo_subpicture_max_width = -1; +static int hf_x11_struct_SurfaceInfo_subpicture_max_height = -1; +static int hf_x11_struct_SurfaceInfo_mc_type = -1; +static int hf_x11_struct_SurfaceInfo_flags = -1; +static int hf_x11_xvmc_QueryVersion_reply_major = -1; +static int hf_x11_xvmc_QueryVersion_reply_minor = -1; +static int hf_x11_xvmc_ListSurfaceTypes_port_id = -1; +static int hf_x11_xvmc_ListSurfaceTypes_reply_num = -1; +static int hf_x11_xvmc_ListSurfaceTypes_reply_surfaces = -1; +static int hf_x11_xvmc_ListSurfaceTypes_reply_surfaces_item = -1; +static int hf_x11_xvmc_CreateContext_context_id = -1; +static int hf_x11_xvmc_CreateContext_port_id = -1; +static int hf_x11_xvmc_CreateContext_surface_id = -1; +static int hf_x11_xvmc_CreateContext_width = -1; +static int hf_x11_xvmc_CreateContext_height = -1; +static int hf_x11_xvmc_CreateContext_flags = -1; +static int hf_x11_xvmc_CreateContext_reply_width_actual = -1; +static int hf_x11_xvmc_CreateContext_reply_height_actual = -1; +static int hf_x11_xvmc_CreateContext_reply_flags_return = -1; +static int hf_x11_xvmc_CreateContext_reply_priv_data = -1; +static int hf_x11_xvmc_CreateContext_reply_priv_data_item = -1; +static int hf_x11_xvmc_DestroyContext_context_id = -1; +static int hf_x11_xvmc_CreateSurface_surface_id = -1; +static int hf_x11_xvmc_CreateSurface_context_id = -1; +static int hf_x11_xvmc_CreateSurface_reply_priv_data = -1; +static int hf_x11_xvmc_CreateSurface_reply_priv_data_item = -1; +static int hf_x11_xvmc_DestroySurface_surface_id = -1; +static int hf_x11_xvmc_CreateSubpicture_subpicture_id = -1; +static int hf_x11_xvmc_CreateSubpicture_context = -1; +static int hf_x11_xvmc_CreateSubpicture_xvimage_id = -1; +static int hf_x11_xvmc_CreateSubpicture_width = -1; +static int hf_x11_xvmc_CreateSubpicture_height = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_width_actual = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_height_actual = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_num_palette_entries = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_entry_bytes = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_component_order = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_priv_data = -1; +static int hf_x11_xvmc_CreateSubpicture_reply_priv_data_item = -1; +static int hf_x11_xvmc_DestroySubpicture_subpicture_id = -1; +static int hf_x11_xvmc_ListSubpictureTypes_port_id = -1; +static int hf_x11_xvmc_ListSubpictureTypes_surface_id = -1; +static int hf_x11_xvmc_ListSubpictureTypes_reply_num = -1; +static int hf_x11_xvmc_ListSubpictureTypes_reply_types = -1; +static int hf_x11_xvmc_ListSubpictureTypes_reply_types_item = -1; +static int hf_x11_xvmc_extension_minor = -1; + diff --git a/epan/dissectors/x11-extension-errors.h b/epan/dissectors/x11-extension-errors.h new file mode 100644 index 0000000000..5e64537cc6 --- /dev/null +++ b/epan/dissectors/x11-extension-errors.h @@ -0,0 +1,174 @@ +/* Do not modify this file. */ +/* It was automatically generated by process-x11-xcb.pl. */ +/* $Id$ */ + +/* + * Copyright 2008, 2009 Open Text Corporation + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +const char *bigreq_errors[] = { + NULL +}; + +const char *composite_errors[] = { + NULL +}; + +const char *damage_errors[] = { + "damage-BadDamage", + NULL +}; + +const char *dpms_errors[] = { + NULL +}; + +const char *ge_errors[] = { + NULL +}; + +const char *glx_errors[] = { + "glx-BadContext", + "glx-BadContextState", + "glx-BadDrawable", + "glx-BadPixmap", + "glx-BadContextTag", + "glx-BadCurrentWindow", + "glx-BadRenderRequest", + "glx-BadLargeRequest", + "glx-UnsupportedPrivateRequest", + "glx-BadFBConfig", + "glx-BadPbuffer", + "glx-BadCurrentDrawable", + "glx-BadWindow", + NULL +}; + +const char *randr_errors[] = { + "randr-BadOutput", + "randr-BadCrtc", + "randr-BadMode", + NULL +}; + +const char *record_errors[] = { + "record-BadContext", + NULL +}; + +const char *render_errors[] = { + "render-PictFormat", + "render-Picture", + "render-PictOp", + "render-GlyphSet", + "render-Glyph", + NULL +}; + +const char *res_errors[] = { + NULL +}; + +const char *screensaver_errors[] = { + NULL +}; + +const char *shape_errors[] = { + NULL +}; + +const char *shm_errors[] = { + "shm-BadSeg", + NULL +}; + +const char *sync_errors[] = { + "sync-Counter", + "sync-Alarm", + NULL +}; + +const char *xc_misc_errors[] = { + NULL +}; + +const char *xevie_errors[] = { + NULL +}; + +const char *xf86dri_errors[] = { + NULL +}; + +const char *xf86vidmode_errors[] = { + "xf86vidmode-BadClock", + "xf86vidmode-BadHTimings", + "xf86vidmode-BadVTimings", + "xf86vidmode-ModeUnsuitable", + "xf86vidmode-ExtensionDisabled", + "xf86vidmode-ClientNotLocal", + "xf86vidmode-ZoomLocked", + NULL +}; + +const char *xfixes_errors[] = { + "xfixes-BadRegion", + NULL +}; + +const char *xinerama_errors[] = { + NULL +}; + +const char *xinput_errors[] = { + "xinput-Device", + "xinput-Event", + "xinput-Mode", + "xinput-DeviceBusy", + "xinput-Class", + NULL +}; + +const char *xprint_errors[] = { + "xprint-BadContext", + "xprint-BadSequence", + NULL +}; + +const char *xselinux_errors[] = { + NULL +}; + +const char *xtest_errors[] = { + NULL +}; + +const char *xv_errors[] = { + "xv-BadPort", + "xv-BadEncoding", + "xv-BadControl", + NULL +}; + +const char *xvmc_errors[] = { + NULL +}; + diff --git a/epan/dissectors/x11-extension-implementation.h b/epan/dissectors/x11-extension-implementation.h new file mode 100644 index 0000000000..323c629d7a --- /dev/null +++ b/epan/dissectors/x11-extension-implementation.h @@ -0,0 +1,21965 @@ +/* Do not modify this file. */ +/* It was automatically generated by process-x11-xcb.pl. */ +/* $Id$ */ + +/* + * Copyright 2008, 2009 Open Text Corporation + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "x11-glx-render-enum.h" + +static void mesa_CallList(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CallList_list, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CallLists(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CallLists_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CallLists_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CallLists_lists, (length - 8) / 1, little_endian); +} + +static void mesa_ListBase(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ListBase_base, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Begin(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Begin_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Bitmap(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_xorig, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_yorig, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_xmove, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Bitmap_ymove, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Bitmap_bitmap, (length - 44) / 1, little_endian); +} + +static void mesa_Color3bv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color3bv_v, 3, little_endian); +} + +static void mesa_Color3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Color3dv_v, hf_x11_glx_render_Color3dv_v_item, 3, little_endian); +} + +static void mesa_Color3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Color3fv_v, hf_x11_glx_render_Color3fv_v_item, 3, little_endian); +} + +static void mesa_Color3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Color3iv_v, hf_x11_glx_render_Color3iv_v_item, 3, little_endian); +} + +static void mesa_Color3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Color3sv_v, hf_x11_glx_render_Color3sv_v_item, 3, little_endian); +} + +static void mesa_Color3ubv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color3ubv_v, 3, little_endian); +} + +static void mesa_Color3uiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_Color3uiv_v, hf_x11_glx_render_Color3uiv_v_item, 3, little_endian); +} + +static void mesa_Color3usv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_Color3usv_v, hf_x11_glx_render_Color3usv_v_item, 3, little_endian); +} + +static void mesa_Color4bv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color4bv_v, 4, little_endian); +} + +static void mesa_Color4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Color4dv_v, hf_x11_glx_render_Color4dv_v_item, 4, little_endian); +} + +static void mesa_Color4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Color4fv_v, hf_x11_glx_render_Color4fv_v_item, 4, little_endian); +} + +static void mesa_Color4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Color4iv_v, hf_x11_glx_render_Color4iv_v_item, 4, little_endian); +} + +static void mesa_Color4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Color4sv_v, hf_x11_glx_render_Color4sv_v_item, 4, little_endian); +} + +static void mesa_Color4ubv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color4ubv_v, 4, little_endian); +} + +static void mesa_Color4uiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_Color4uiv_v, hf_x11_glx_render_Color4uiv_v_item, 4, little_endian); +} + +static void mesa_Color4usv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_Color4usv_v, hf_x11_glx_render_Color4usv_v_item, 4, little_endian); +} + +static void mesa_EdgeFlagv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_EdgeFlagv_flag, 1, little_endian); +} + +static void mesa_End(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_Indexdv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Indexdv_c, hf_x11_glx_render_Indexdv_c_item, 1, little_endian); +} + +static void mesa_Indexfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Indexfv_c, hf_x11_glx_render_Indexfv_c_item, 1, little_endian); +} + +static void mesa_Indexiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Indexiv_c, hf_x11_glx_render_Indexiv_c_item, 1, little_endian); +} + +static void mesa_Indexsv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Indexsv_c, hf_x11_glx_render_Indexsv_c_item, 1, little_endian); +} + +static void mesa_Normal3bv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Normal3bv_v, 3, little_endian); +} + +static void mesa_Normal3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Normal3dv_v, hf_x11_glx_render_Normal3dv_v_item, 3, little_endian); +} + +static void mesa_Normal3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Normal3fv_v, hf_x11_glx_render_Normal3fv_v_item, 3, little_endian); +} + +static void mesa_Normal3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Normal3iv_v, hf_x11_glx_render_Normal3iv_v_item, 3, little_endian); +} + +static void mesa_Normal3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Normal3sv_v, hf_x11_glx_render_Normal3sv_v_item, 3, little_endian); +} + +static void mesa_RasterPos2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_RasterPos2dv_v, hf_x11_glx_render_RasterPos2dv_v_item, 2, little_endian); +} + +static void mesa_RasterPos2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_RasterPos2fv_v, hf_x11_glx_render_RasterPos2fv_v_item, 2, little_endian); +} + +static void mesa_RasterPos2iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_RasterPos2iv_v, hf_x11_glx_render_RasterPos2iv_v_item, 2, little_endian); +} + +static void mesa_RasterPos2sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_RasterPos2sv_v, hf_x11_glx_render_RasterPos2sv_v_item, 2, little_endian); +} + +static void mesa_RasterPos3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_RasterPos3dv_v, hf_x11_glx_render_RasterPos3dv_v_item, 3, little_endian); +} + +static void mesa_RasterPos3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_RasterPos3fv_v, hf_x11_glx_render_RasterPos3fv_v_item, 3, little_endian); +} + +static void mesa_RasterPos3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_RasterPos3iv_v, hf_x11_glx_render_RasterPos3iv_v_item, 3, little_endian); +} + +static void mesa_RasterPos3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_RasterPos3sv_v, hf_x11_glx_render_RasterPos3sv_v_item, 3, little_endian); +} + +static void mesa_RasterPos4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_RasterPos4dv_v, hf_x11_glx_render_RasterPos4dv_v_item, 4, little_endian); +} + +static void mesa_RasterPos4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_RasterPos4fv_v, hf_x11_glx_render_RasterPos4fv_v_item, 4, little_endian); +} + +static void mesa_RasterPos4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_RasterPos4iv_v, hf_x11_glx_render_RasterPos4iv_v_item, 4, little_endian); +} + +static void mesa_RasterPos4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_RasterPos4sv_v, hf_x11_glx_render_RasterPos4sv_v_item, 4, little_endian); +} + +static void mesa_Rectdv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Rectdv_v1, hf_x11_glx_render_Rectdv_v1_item, 2, little_endian); + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Rectdv_v2, hf_x11_glx_render_Rectdv_v2_item, 2, little_endian); +} + +static void mesa_Rectfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Rectfv_v1, hf_x11_glx_render_Rectfv_v1_item, 2, little_endian); + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Rectfv_v2, hf_x11_glx_render_Rectfv_v2_item, 2, little_endian); +} + +static void mesa_Rectiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Rectiv_v1, hf_x11_glx_render_Rectiv_v1_item, 2, little_endian); + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Rectiv_v2, hf_x11_glx_render_Rectiv_v2_item, 2, little_endian); +} + +static void mesa_Rectsv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Rectsv_v1, hf_x11_glx_render_Rectsv_v1_item, 2, little_endian); + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Rectsv_v2, hf_x11_glx_render_Rectsv_v2_item, 2, little_endian); +} + +static void mesa_TexCoord1dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord1dv_v, hf_x11_glx_render_TexCoord1dv_v_item, 1, little_endian); +} + +static void mesa_TexCoord1fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord1fv_v, hf_x11_glx_render_TexCoord1fv_v_item, 1, little_endian); +} + +static void mesa_TexCoord1iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord1iv_v, hf_x11_glx_render_TexCoord1iv_v_item, 1, little_endian); +} + +static void mesa_TexCoord1sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord1sv_v, hf_x11_glx_render_TexCoord1sv_v_item, 1, little_endian); +} + +static void mesa_TexCoord2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord2dv_v, hf_x11_glx_render_TexCoord2dv_v_item, 2, little_endian); +} + +static void mesa_TexCoord2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord2fv_v, hf_x11_glx_render_TexCoord2fv_v_item, 2, little_endian); +} + +static void mesa_TexCoord2iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord2iv_v, hf_x11_glx_render_TexCoord2iv_v_item, 2, little_endian); +} + +static void mesa_TexCoord2sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord2sv_v, hf_x11_glx_render_TexCoord2sv_v_item, 2, little_endian); +} + +static void mesa_TexCoord3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord3dv_v, hf_x11_glx_render_TexCoord3dv_v_item, 3, little_endian); +} + +static void mesa_TexCoord3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord3fv_v, hf_x11_glx_render_TexCoord3fv_v_item, 3, little_endian); +} + +static void mesa_TexCoord3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord3iv_v, hf_x11_glx_render_TexCoord3iv_v_item, 3, little_endian); +} + +static void mesa_TexCoord3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord3sv_v, hf_x11_glx_render_TexCoord3sv_v_item, 3, little_endian); +} + +static void mesa_TexCoord4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord4dv_v, hf_x11_glx_render_TexCoord4dv_v_item, 4, little_endian); +} + +static void mesa_TexCoord4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord4fv_v, hf_x11_glx_render_TexCoord4fv_v_item, 4, little_endian); +} + +static void mesa_TexCoord4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord4iv_v, hf_x11_glx_render_TexCoord4iv_v_item, 4, little_endian); +} + +static void mesa_TexCoord4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord4sv_v, hf_x11_glx_render_TexCoord4sv_v_item, 4, little_endian); +} + +static void mesa_Vertex2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Vertex2dv_v, hf_x11_glx_render_Vertex2dv_v_item, 2, little_endian); +} + +static void mesa_Vertex2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Vertex2fv_v, hf_x11_glx_render_Vertex2fv_v_item, 2, little_endian); +} + +static void mesa_Vertex2iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Vertex2iv_v, hf_x11_glx_render_Vertex2iv_v_item, 2, little_endian); +} + +static void mesa_Vertex2sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Vertex2sv_v, hf_x11_glx_render_Vertex2sv_v_item, 2, little_endian); +} + +static void mesa_Vertex3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Vertex3dv_v, hf_x11_glx_render_Vertex3dv_v_item, 3, little_endian); +} + +static void mesa_Vertex3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Vertex3fv_v, hf_x11_glx_render_Vertex3fv_v_item, 3, little_endian); +} + +static void mesa_Vertex3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Vertex3iv_v, hf_x11_glx_render_Vertex3iv_v_item, 3, little_endian); +} + +static void mesa_Vertex3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Vertex3sv_v, hf_x11_glx_render_Vertex3sv_v_item, 3, little_endian); +} + +static void mesa_Vertex4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Vertex4dv_v, hf_x11_glx_render_Vertex4dv_v_item, 4, little_endian); +} + +static void mesa_Vertex4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Vertex4fv_v, hf_x11_glx_render_Vertex4fv_v_item, 4, little_endian); +} + +static void mesa_Vertex4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Vertex4iv_v, hf_x11_glx_render_Vertex4iv_v_item, 4, little_endian); +} + +static void mesa_Vertex4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Vertex4sv_v, hf_x11_glx_render_Vertex4sv_v_item, 4, little_endian); +} + +static void mesa_ClipPlane(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ClipPlane_plane, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ClipPlane_equation, hf_x11_glx_render_ClipPlane_equation_item, 4, little_endian); +} + +static void mesa_ColorMaterial(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ColorMaterial_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorMaterial_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CullFace(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CullFace_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Fogf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Fogf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Fogf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Fogfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Fogfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Fogfv_params, hf_x11_glx_render_Fogfv_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_Fogi(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Fogi_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Fogi_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Fogiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Fogiv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Fogiv_params, hf_x11_glx_render_Fogiv_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_FrontFace(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_FrontFace_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Hint(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Hint_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Hint_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Lightf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Lightf_light, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Lightf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Lightf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Lightfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Lightfv_light, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Lightfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Lightfv_params, hf_x11_glx_render_Lightfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_Lighti(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Lighti_light, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Lighti_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Lighti_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Lightiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Lightiv_light, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Lightiv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Lightiv_params, hf_x11_glx_render_Lightiv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_LightModelf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LightModelf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_LightModelf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_LightModelfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LightModelfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_LightModelfv_params, hf_x11_glx_render_LightModelfv_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_LightModeli(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LightModeli_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_LightModeli_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_LightModeliv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LightModeliv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_LightModeliv_params, hf_x11_glx_render_LightModeliv_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_LineStipple(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LineStipple_factor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_LineStipple_pattern, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void mesa_LineWidth(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LineWidth_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Materialf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Materialf_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Materialf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Materialf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Materialfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Materialfv_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Materialfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Materialfv_params, hf_x11_glx_render_Materialfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_Materiali(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Materiali_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Materiali_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Materiali_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Materialiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Materialiv_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Materialiv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Materialiv_params, hf_x11_glx_render_Materialiv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_PointSize(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PointSize_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PolygonMode(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PolygonMode_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PolygonMode_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PolygonStipple(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_PolygonStipple_mask, (length - 20) / 1, little_endian); +} + +static void mesa_Scissor(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Scissor_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Scissor_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Scissor_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Scissor_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ShadeModel(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ShadeModel_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexParameterf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexParameterf_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexParameterf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexParameterf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexParameterfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexParameterfv_params, hf_x11_glx_render_TexParameterfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_TexParameteri(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexParameteri_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexParameteri_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexParameteri_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexParameteriv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexParameteriv_params, hf_x11_glx_render_TexParameteriv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_TexImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage1D_pixels, (length - 48) / 1, little_endian); +} + +static void mesa_TexImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage2D_pixels, (length - 52) / 1, little_endian); +} + +static void mesa_TexEnvf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexEnvf_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexEnvf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexEnvf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexEnvfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexEnvfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexEnvfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexEnvfv_params, hf_x11_glx_render_TexEnvfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_TexEnvi(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexEnvi_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexEnvi_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexEnvi_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexEnviv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexEnviv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexEnviv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexEnviv_params, hf_x11_glx_render_TexEnviv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_TexGend(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexGend_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGend_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGend_param, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_TexGendv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexGendv_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGendv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexGendv_params, hf_x11_glx_render_TexGendv_params_item, (length - 8) / 8, little_endian); +} + +static void mesa_TexGenf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexGenf_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGenf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGenf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexGenfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexGenfv_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGenfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexGenfv_params, hf_x11_glx_render_TexGenfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_TexGeni(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexGeni_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGeni_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGeni_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexGeniv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexGeniv_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexGeniv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexGeniv_params, hf_x11_glx_render_TexGeniv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_InitNames(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_LoadName(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LoadName_name, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PassThrough(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PassThrough_token, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PopName(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_PushName(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PushName_name, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_DrawBuffer(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DrawBuffer_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Clear(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Clear_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ClearAccum(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_red, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_green, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_blue, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_alpha, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ClearIndex(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ClearIndex_c, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ClearColor(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ClearColor_red, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ClearColor_green, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ClearColor_blue, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ClearColor_alpha, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ClearStencil(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ClearStencil_s, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ClearDepth(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ClearDepth_depth, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_StencilMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_StencilMask_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ColorMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ColorMask_red, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ColorMask_green, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ColorMask_blue, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ColorMask_alpha, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_DepthMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DepthMask_flag, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_IndexMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_IndexMask_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Accum(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Accum_op, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Accum_value, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Disable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Disable_cap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Enable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Enable_cap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PopAttrib(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_PushAttrib(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PushAttrib_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Map1d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Map1d_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map1d_u1, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Map1d_u2, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Map1d_stride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map1d_order, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Map1d_points, hf_x11_glx_render_Map1d_points_item, (length - 28) / 8, little_endian); +} + +static void mesa_Map1f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Map1f_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map1f_u1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map1f_u2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map1f_stride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map1f_order, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Map1f_points, hf_x11_glx_render_Map1f_points_item, (length - 20) / 4, little_endian); +} + +static void mesa_Map2d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Map2d_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_u1, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_u2, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_ustride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_uorder, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_v1, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_v2, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_vstride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2d_vorder, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Map2d_points, hf_x11_glx_render_Map2d_points_item, (length - 52) / 8, little_endian); +} + +static void mesa_Map2f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Map2f_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_u1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_u2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_ustride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_uorder, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_v1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_v2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_vstride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Map2f_vorder, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Map2f_points, hf_x11_glx_render_Map2f_points_item, (length - 36) / 4, little_endian); +} + +static void mesa_MapGrid1d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MapGrid1d_un, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid1d_u1, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid1d_u2, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_MapGrid1f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MapGrid1f_un, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid1f_u1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid1f_u2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_MapGrid2d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_un, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_u1, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_u2, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_vn, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_v1, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_v2, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_MapGrid2f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_un, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_u1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_u2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_vn, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_v1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_v2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_EvalCoord1dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_EvalCoord1dv_u, hf_x11_glx_render_EvalCoord1dv_u_item, 1, little_endian); +} + +static void mesa_EvalCoord1fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_EvalCoord1fv_u, hf_x11_glx_render_EvalCoord1fv_u_item, 1, little_endian); +} + +static void mesa_EvalCoord2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_EvalCoord2dv_u, hf_x11_glx_render_EvalCoord2dv_u_item, 2, little_endian); +} + +static void mesa_EvalCoord2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_EvalCoord2fv_u, hf_x11_glx_render_EvalCoord2fv_u_item, 2, little_endian); +} + +static void mesa_EvalMesh1(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh1_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh1_i1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh1_i2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_EvalPoint1(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_EvalPoint1_i, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_EvalMesh2(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_i1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_i2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_j1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_j2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_EvalPoint2(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_EvalPoint2_i, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_EvalPoint2_j, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_AlphaFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_AlphaFunc_func, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_AlphaFunc_ref, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_BlendFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BlendFunc_sfactor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendFunc_dfactor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_LogicOp(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_LogicOp_opcode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_StencilFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_StencilFunc_func, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_StencilFunc_ref, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_StencilFunc_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_StencilOp(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_StencilOp_fail, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_StencilOp_zfail, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_StencilOp_zpass, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_DepthFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DepthFunc_func, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PixelZoom(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PixelZoom_xfactor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PixelZoom_yfactor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PixelTransferf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PixelTransferf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PixelTransferf_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PixelTransferi(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PixelTransferi_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PixelTransferi_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PixelMapfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int mapsize; + proto_tree_add_item(t, hf_x11_glx_render_PixelMapfv_map, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + mapsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_PixelMapfv_mapsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_PixelMapfv_values, hf_x11_glx_render_PixelMapfv_values_item, mapsize, little_endian); +} + +static void mesa_PixelMapuiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int mapsize; + proto_tree_add_item(t, hf_x11_glx_render_PixelMapuiv_map, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + mapsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_PixelMapuiv_mapsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_PixelMapuiv_values, hf_x11_glx_render_PixelMapuiv_values_item, mapsize, little_endian); +} + +static void mesa_PixelMapusv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int mapsize; + proto_tree_add_item(t, hf_x11_glx_render_PixelMapusv_map, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + mapsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_PixelMapusv_mapsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_PixelMapusv_values, hf_x11_glx_render_PixelMapusv_values_item, mapsize, little_endian); +} + +static void mesa_ReadBuffer(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ReadBuffer_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CopyPixels(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_DrawPixels(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_DrawPixels_pixels, (length - 36) / 1, little_endian); +} + +static void mesa_DepthRange(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DepthRange_zNear, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_DepthRange_zFar, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_Frustum(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Frustum_left, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Frustum_right, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Frustum_bottom, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Frustum_top, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Frustum_zNear, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Frustum_zFar, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_LoadIdentity(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_LoadMatrixf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_LoadMatrixf_m, hf_x11_glx_render_LoadMatrixf_m_item, 16, little_endian); +} + +static void mesa_LoadMatrixd(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_LoadMatrixd_m, hf_x11_glx_render_LoadMatrixd_m_item, 16, little_endian); +} + +static void mesa_MatrixMode(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MatrixMode_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_MultMatrixf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultMatrixf_m, hf_x11_glx_render_MultMatrixf_m_item, 16, little_endian); +} + +static void mesa_MultMatrixd(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultMatrixd_m, hf_x11_glx_render_MultMatrixd_m_item, 16, little_endian); +} + +static void mesa_Ortho(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Ortho_left, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Ortho_right, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Ortho_bottom, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Ortho_top, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Ortho_zNear, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Ortho_zFar, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_PopMatrix(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_PushMatrix(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_Rotated(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Rotated_angle, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Rotated_x, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Rotated_y, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Rotated_z, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_Rotatef(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Rotatef_angle, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Rotatef_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Rotatef_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Rotatef_z, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Scaled(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Scaled_x, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Scaled_y, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Scaled_z, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_Scalef(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Scalef_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Scalef_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Scalef_z, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Translated(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Translated_x, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Translated_y, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_Translated_z, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_Translatef(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Translatef_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Translatef_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Translatef_z, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_Viewport(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Viewport_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Viewport_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Viewport_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Viewport_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_DrawArrays(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DrawArrays_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawArrays_first, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_DrawArrays_count, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PolygonOffset(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PolygonOffset_factor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PolygonOffset_units, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CopyTexImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CopyTexImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CopyTexSubImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CopyTexSubImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexSubImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_UNUSED, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage1D_pixels, (length - 48) / 1, little_endian); +} + +static void mesa_TexSubImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_UNUSED, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage2D_pixels, (length - 56) / 1, little_endian); +} + +static void mesa_BindTexture(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BindTexture_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BindTexture_texture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PrioritizeTextures(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_PrioritizeTextures_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_PrioritizeTextures_textures, hf_x11_glx_render_PrioritizeTextures_textures_item, n, little_endian); + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_PrioritizeTextures_priorities, hf_x11_glx_render_PrioritizeTextures_priorities_item, n, little_endian); +} + +static void mesa_Indexubv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_Indexubv_c, 1, little_endian); +} + +static void mesa_BlendColor(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BlendColor_red, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendColor_green, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendColor_blue, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendColor_alpha, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_BlendEquation(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BlendEquation_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ColorTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTable_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ColorTable_table, (length - 40) / 1, little_endian); +} + +static void mesa_ColorTableParameterfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ColorTableParameterfv_params, hf_x11_glx_render_ColorTableParameterfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_ColorTableParameteriv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_ColorTableParameteriv_params, hf_x11_glx_render_ColorTableParameteriv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_CopyColorTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ColorSubTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_start, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_count, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ColorSubTable_data, (length - 40) / 1, little_endian); +} + +static void mesa_CopyColorSubTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_start, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ConvolutionFilter1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ConvolutionFilter1D_image, (length - 40) / 1, little_endian); +} + +static void mesa_ConvolutionFilter2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ConvolutionFilter2D_image, (length - 44) / 1, little_endian); +} + +static void mesa_ConvolutionParameterf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterf_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterf_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterf_params, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ConvolutionParameterfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ConvolutionParameterfv_params, hf_x11_glx_render_ConvolutionParameterfv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_ConvolutionParameteri(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteri_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteri_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteri_params, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ConvolutionParameteriv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_ConvolutionParameteriv_params, hf_x11_glx_render_ConvolutionParameteriv_params_item, (length - 8) / 4, little_endian); +} + +static void mesa_CopyConvolutionFilter1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CopyConvolutionFilter2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_SeparableFilter2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_SeparableFilter2D_row, (length - 24) / 1, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_glx_render_SeparableFilter2D_column, (length - 24) / 1, little_endian); +} + +static void mesa_Histogram(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Histogram_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Histogram_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Histogram_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Histogram_sink, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_Minmax(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_Minmax_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Minmax_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_Minmax_sink, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_ResetHistogram(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ResetHistogram_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ResetMinmax(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ResetMinmax_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexImage3D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage3D_pixels, (length - 56) / 1, little_endian); +} + +static void mesa_TexSubImage3D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_zoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_UNUSED, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage3D_pixels, (length - 64) / 1, little_endian); +} + +static void mesa_CopyTexSubImage3D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_zoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ActiveTextureARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ActiveTextureARB_texture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_MultiTexCoord1dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1dvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1dvARB_v, hf_x11_glx_render_MultiTexCoord1dvARB_v_item, 1, little_endian); +} + +static void mesa_MultiTexCoord1fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1fvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1fvARB_v, hf_x11_glx_render_MultiTexCoord1fvARB_v_item, 1, little_endian); +} + +static void mesa_MultiTexCoord1ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1ivARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1ivARB_v, hf_x11_glx_render_MultiTexCoord1ivARB_v_item, 1, little_endian); +} + +static void mesa_MultiTexCoord1svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1svARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1svARB_v, hf_x11_glx_render_MultiTexCoord1svARB_v_item, 1, little_endian); +} + +static void mesa_MultiTexCoord2dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2dvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2dvARB_v, hf_x11_glx_render_MultiTexCoord2dvARB_v_item, 2, little_endian); +} + +static void mesa_MultiTexCoord2fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2fvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2fvARB_v, hf_x11_glx_render_MultiTexCoord2fvARB_v_item, 2, little_endian); +} + +static void mesa_MultiTexCoord2ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2ivARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2ivARB_v, hf_x11_glx_render_MultiTexCoord2ivARB_v_item, 2, little_endian); +} + +static void mesa_MultiTexCoord2svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2svARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2svARB_v, hf_x11_glx_render_MultiTexCoord2svARB_v_item, 2, little_endian); +} + +static void mesa_MultiTexCoord3dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3dvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3dvARB_v, hf_x11_glx_render_MultiTexCoord3dvARB_v_item, 3, little_endian); +} + +static void mesa_MultiTexCoord3fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3fvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3fvARB_v, hf_x11_glx_render_MultiTexCoord3fvARB_v_item, 3, little_endian); +} + +static void mesa_MultiTexCoord3ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3ivARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3ivARB_v, hf_x11_glx_render_MultiTexCoord3ivARB_v_item, 3, little_endian); +} + +static void mesa_MultiTexCoord3svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3svARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3svARB_v, hf_x11_glx_render_MultiTexCoord3svARB_v_item, 3, little_endian); +} + +static void mesa_MultiTexCoord4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4dvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4dvARB_v, hf_x11_glx_render_MultiTexCoord4dvARB_v_item, 4, little_endian); +} + +static void mesa_MultiTexCoord4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4fvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4fvARB_v, hf_x11_glx_render_MultiTexCoord4fvARB_v_item, 4, little_endian); +} + +static void mesa_MultiTexCoord4ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4ivARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4ivARB_v, hf_x11_glx_render_MultiTexCoord4ivARB_v_item, 4, little_endian); +} + +static void mesa_MultiTexCoord4svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4svARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4svARB_v, hf_x11_glx_render_MultiTexCoord4svARB_v_item, 4, little_endian); +} + +static void mesa_SampleCoverageARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_SampleCoverageARB_value, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SampleCoverageARB_invert, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_CompressedTexImage3DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int imageSize; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + imageSize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_imageSize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexImage3DARB_data, imageSize, little_endian); +} + +static void mesa_CompressedTexImage2DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int imageSize; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + imageSize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_imageSize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexImage2DARB_data, imageSize, little_endian); +} + +static void mesa_CompressedTexImage1DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int imageSize; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + imageSize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_imageSize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexImage1DARB_data, imageSize, little_endian); +} + +static void mesa_CompressedTexSubImage3DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int imageSize; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_zoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + imageSize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_imageSize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexSubImage3DARB_data, imageSize, little_endian); +} + +static void mesa_CompressedTexSubImage2DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int imageSize; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + imageSize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_imageSize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexSubImage2DARB_data, imageSize, little_endian); +} + +static void mesa_CompressedTexSubImage1DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int imageSize; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + imageSize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_imageSize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexSubImage1DARB_data, imageSize, little_endian); +} + +static void mesa_CurrentPaletteMatrixARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CurrentPaletteMatrixARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_MatrixIndexubvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int size; + size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_MatrixIndexubvARB_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_MatrixIndexubvARB_indices, size, little_endian); +} + +static void mesa_MatrixIndexusvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int size; + size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_MatrixIndexusvARB_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_MatrixIndexusvARB_indices, hf_x11_glx_render_MatrixIndexusvARB_indices_item, size, little_endian); +} + +static void mesa_MatrixIndexuivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int size; + size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_MatrixIndexuivARB_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_MatrixIndexuivARB_indices, hf_x11_glx_render_MatrixIndexuivARB_indices_item, size, little_endian); +} + +static void mesa_VertexAttrib1dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1dvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1dvARB_v, hf_x11_glx_render_VertexAttrib1dvARB_v_item, 1, little_endian); +} + +static void mesa_VertexAttrib1fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1fvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1fvARB_v, hf_x11_glx_render_VertexAttrib1fvARB_v_item, 1, little_endian); +} + +static void mesa_VertexAttrib1svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1svARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1svARB_v, hf_x11_glx_render_VertexAttrib1svARB_v_item, 1, little_endian); +} + +static void mesa_VertexAttrib2dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2dvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2dvARB_v, hf_x11_glx_render_VertexAttrib2dvARB_v_item, 2, little_endian); +} + +static void mesa_VertexAttrib2fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2fvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2fvARB_v, hf_x11_glx_render_VertexAttrib2fvARB_v_item, 2, little_endian); +} + +static void mesa_VertexAttrib2svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2svARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2svARB_v, hf_x11_glx_render_VertexAttrib2svARB_v_item, 2, little_endian); +} + +static void mesa_VertexAttrib3dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3dvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3dvARB_v, hf_x11_glx_render_VertexAttrib3dvARB_v_item, 3, little_endian); +} + +static void mesa_VertexAttrib3fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3fvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3fvARB_v, hf_x11_glx_render_VertexAttrib3fvARB_v_item, 3, little_endian); +} + +static void mesa_VertexAttrib3svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3svARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3svARB_v, hf_x11_glx_render_VertexAttrib3svARB_v_item, 3, little_endian); +} + +static void mesa_VertexAttrib4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4dvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4dvARB_v, hf_x11_glx_render_VertexAttrib4dvARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4fvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4fvARB_v, hf_x11_glx_render_VertexAttrib4fvARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4svARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4svARB_v, hf_x11_glx_render_VertexAttrib4svARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4NubvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NubvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NubvARB_v, 4, little_endian); +} + +static void mesa_VertexAttrib4bvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4bvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4bvARB_v, 4, little_endian); +} + +static void mesa_VertexAttrib4ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4ivARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4ivARB_v, hf_x11_glx_render_VertexAttrib4ivARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4ubvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4ubvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4ubvARB_v, 4, little_endian); +} + +static void mesa_VertexAttrib4usvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4usvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4usvARB_v, hf_x11_glx_render_VertexAttrib4usvARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4uivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4uivARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4uivARB_v, hf_x11_glx_render_VertexAttrib4uivARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4NbvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NbvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NbvARB_v, 4, little_endian); +} + +static void mesa_VertexAttrib4NsvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NsvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NsvARB_v, hf_x11_glx_render_VertexAttrib4NsvARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4NivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NivARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NivARB_v, hf_x11_glx_render_VertexAttrib4NivARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4NusvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NusvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NusvARB_v, hf_x11_glx_render_VertexAttrib4NusvARB_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4NuivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NuivARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NuivARB_v, hf_x11_glx_render_VertexAttrib4NuivARB_v_item, 4, little_endian); +} + +static void mesa_ProgramStringARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int len; + proto_tree_add_item(t, hf_x11_glx_render_ProgramStringARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramStringARB_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_ProgramStringARB_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ProgramStringARB_string, len, little_endian); +} + +static void mesa_ProgramEnvParameter4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4dvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4dvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramEnvParameter4dvARB_params, hf_x11_glx_render_ProgramEnvParameter4dvARB_params_item, 4, little_endian); +} + +static void mesa_ProgramEnvParameter4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4fvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4fvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramEnvParameter4fvARB_params, hf_x11_glx_render_ProgramEnvParameter4fvARB_params_item, 4, little_endian); +} + +static void mesa_ProgramLocalParameter4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4dvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4dvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramLocalParameter4dvARB_params, hf_x11_glx_render_ProgramLocalParameter4dvARB_params_item, 4, little_endian); +} + +static void mesa_ProgramLocalParameter4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4fvARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4fvARB_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramLocalParameter4fvARB_params, hf_x11_glx_render_ProgramLocalParameter4fvARB_params_item, 4, little_endian); +} + +static void mesa_BeginQueryARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BeginQueryARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BeginQueryARB_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_EndQueryARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_EndQueryARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_DrawBuffersARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_DrawBuffersARB_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_DrawBuffersARB_bufs, hf_x11_glx_render_DrawBuffersARB_bufs_item, n, little_endian); +} + +static void mesa_PolygonOffsetEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PolygonOffsetEXT_factor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PolygonOffsetEXT_bias, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TexFilterFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_TexFilterFuncSGIS_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexFilterFuncSGIS_filter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_TexFilterFuncSGIS_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexFilterFuncSGIS_weights, hf_x11_glx_render_TexFilterFuncSGIS_weights_item, n, little_endian); +} + +static void mesa_TexImage4DSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_internalformat, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_size4d, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_border, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage4DSGIS_pixels, (length - 60) / 1, little_endian); +} + +static void mesa_TexSubImage4DSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_swapbytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_lsbfirst, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_rowlength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_skiprows, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_skippixels, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_alignment, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_xoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_yoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_zoffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_woffset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_size4d, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_UNUSED, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage4DSGIS_pixels, (length - 72) / 1, little_endian); +} + +static void mesa_DetailTexFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_DetailTexFuncSGIS_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_DetailTexFuncSGIS_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_DetailTexFuncSGIS_points, hf_x11_glx_render_DetailTexFuncSGIS_points_item, n, little_endian); +} + +static void mesa_SharpenTexFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_SharpenTexFuncSGIS_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_SharpenTexFuncSGIS_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_SharpenTexFuncSGIS_points, hf_x11_glx_render_SharpenTexFuncSGIS_points_item, n, little_endian); +} + +static void mesa_SampleMaskSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_SampleMaskSGIS_value, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_SampleMaskSGIS_invert, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_SamplePatternSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_SamplePatternSGIS_pattern, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PointParameterfEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PointParameterfEXT_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PointParameterfEXT_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PointParameterfvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PointParameterfvEXT_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_PointParameterfvEXT_params, hf_x11_glx_render_PointParameterfvEXT_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_FrameZoomSGIX(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_FrameZoomSGIX_factor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_TagSampleBufferSGIX(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void mesa_ReferencePlaneSGIX(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ReferencePlaneSGIX_equation, hf_x11_glx_render_ReferencePlaneSGIX_equation_item, 4, little_endian); +} + +static void mesa_FogFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_FogFuncSGIS_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_FogFuncSGIS_points, hf_x11_glx_render_FogFuncSGIS_points_item, n, little_endian); +} + +static void mesa_SecondaryColor3bvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3bvEXT_v, 3, little_endian); +} + +static void mesa_SecondaryColor3dvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3dvEXT_v, hf_x11_glx_render_SecondaryColor3dvEXT_v_item, 3, little_endian); +} + +static void mesa_SecondaryColor3fvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3fvEXT_v, hf_x11_glx_render_SecondaryColor3fvEXT_v_item, 3, little_endian); +} + +static void mesa_SecondaryColor3ivEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3ivEXT_v, hf_x11_glx_render_SecondaryColor3ivEXT_v_item, 3, little_endian); +} + +static void mesa_SecondaryColor3svEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3svEXT_v, hf_x11_glx_render_SecondaryColor3svEXT_v_item, 3, little_endian); +} + +static void mesa_SecondaryColor3ubvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfByte(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3ubvEXT_v, 3, little_endian); +} + +static void mesa_SecondaryColor3uivEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3uivEXT_v, hf_x11_glx_render_SecondaryColor3uivEXT_v_item, 3, little_endian); +} + +static void mesa_SecondaryColor3usvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfCard16(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3usvEXT_v, hf_x11_glx_render_SecondaryColor3usvEXT_v_item, 3, little_endian); +} + +static void mesa_FogCoordfvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_FogCoordfvEXT_coord, hf_x11_glx_render_FogCoordfvEXT_coord_item, 1, little_endian); +} + +static void mesa_FogCoorddvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_FogCoorddvEXT_coord, hf_x11_glx_render_FogCoorddvEXT_coord_item, 1, little_endian); +} + +static void mesa_PixelTexGenSGIX(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PixelTexGenSGIX_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_BlendFuncSeparateEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_sfactorRGB, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_dfactorRGB, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_sfactorAlpha, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_dfactorAlpha, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_VertexWeightfvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexWeightfvEXT_weight, hf_x11_glx_render_VertexWeightfvEXT_weight_item, 1, little_endian); +} + +static void mesa_CombinerParameterfvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterfvNV_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_CombinerParameterfvNV_params, hf_x11_glx_render_CombinerParameterfvNV_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_CombinerParameterfNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterfNV_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterfNV_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CombinerParameterivNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterivNV_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_CombinerParameterivNV_params, hf_x11_glx_render_CombinerParameterivNV_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_CombinerParameteriNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CombinerParameteriNV_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerParameteriNV_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CombinerInputNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_stage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_portion, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_variable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_input, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_mapping, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_componentUsage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_CombinerOutputNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_stage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_portion, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_abOutput, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_cdOutput, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_sumOutput, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_scale, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_bias, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_abDotProduct, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_cdDotProduct, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_muxSum, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_FinalCombinerInputNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_variable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_input, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_mapping, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_componentUsage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_WindowPos3fvMESA(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_WindowPos3fvMESA_v, hf_x11_glx_render_WindowPos3fvMESA_v_item, 3, little_endian); +} + +static void mesa_TextureColorMaskSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_red, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_green, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_blue, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_alpha, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void mesa_BindProgramNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BindProgramNV_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BindProgramNV_program, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ExecuteProgramNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ExecuteProgramNV_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ExecuteProgramNV_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ExecuteProgramNV_params, hf_x11_glx_render_ExecuteProgramNV_params_item, 4, little_endian); +} + +static void mesa_LoadProgramNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int len; + proto_tree_add_item(t, hf_x11_glx_render_LoadProgramNV_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_LoadProgramNV_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_LoadProgramNV_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_LoadProgramNV_program, len, little_endian); +} + +static void mesa_ProgramParameters4dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int num; + proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4dvNV_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + num = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4dvNV_num, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramParameters4dvNV_params, hf_x11_glx_render_ProgramParameters4dvNV_params_item, num, little_endian); +} + +static void mesa_ProgramParameters4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int num; + proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4fvNV_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + num = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4fvNV_num, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramParameters4fvNV_params, hf_x11_glx_render_ProgramParameters4fvNV_params_item, num, little_endian); +} + +static void mesa_RequestResidentProgramsNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_RequestResidentProgramsNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_render_RequestResidentProgramsNV_ids, hf_x11_glx_render_RequestResidentProgramsNV_ids_item, n, little_endian); +} + +static void mesa_TrackMatrixNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_address, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_matrix, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_transform, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_VertexAttrib1svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1svNV_v, hf_x11_glx_render_VertexAttrib1svNV_v_item, 1, little_endian); +} + +static void mesa_VertexAttrib2svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2svNV_v, hf_x11_glx_render_VertexAttrib2svNV_v_item, 2, little_endian); +} + +static void mesa_VertexAttrib3svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3svNV_v, hf_x11_glx_render_VertexAttrib3svNV_v_item, 3, little_endian); +} + +static void mesa_VertexAttrib4svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4svNV_v, hf_x11_glx_render_VertexAttrib4svNV_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib1fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1fvNV_v, hf_x11_glx_render_VertexAttrib1fvNV_v_item, 1, little_endian); +} + +static void mesa_VertexAttrib2fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2fvNV_v, hf_x11_glx_render_VertexAttrib2fvNV_v_item, 2, little_endian); +} + +static void mesa_VertexAttrib3fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3fvNV_v, hf_x11_glx_render_VertexAttrib3fvNV_v_item, 3, little_endian); +} + +static void mesa_VertexAttrib4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4fvNV_v, hf_x11_glx_render_VertexAttrib4fvNV_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib1dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1dvNV_v, hf_x11_glx_render_VertexAttrib1dvNV_v_item, 1, little_endian); +} + +static void mesa_VertexAttrib2dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2dvNV_v, hf_x11_glx_render_VertexAttrib2dvNV_v_item, 2, little_endian); +} + +static void mesa_VertexAttrib3dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3dvNV_v, hf_x11_glx_render_VertexAttrib3dvNV_v_item, 3, little_endian); +} + +static void mesa_VertexAttrib4dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4dvNV_v, hf_x11_glx_render_VertexAttrib4dvNV_v_item, 4, little_endian); +} + +static void mesa_VertexAttrib4ubvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4ubvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4ubvNV_v, 4, little_endian); +} + +static void mesa_VertexAttribs1svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1svNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs1svNV_v, hf_x11_glx_render_VertexAttribs1svNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs2svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2svNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs2svNV_v, hf_x11_glx_render_VertexAttribs2svNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs3svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3svNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs3svNV_v, hf_x11_glx_render_VertexAttribs3svNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs4svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4svNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4svNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs4svNV_v, hf_x11_glx_render_VertexAttribs4svNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs1fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1fvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs1fvNV_v, hf_x11_glx_render_VertexAttribs1fvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs2fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2fvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs2fvNV_v, hf_x11_glx_render_VertexAttribs2fvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs3fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3fvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs3fvNV_v, hf_x11_glx_render_VertexAttribs3fvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4fvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4fvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs4fvNV_v, hf_x11_glx_render_VertexAttribs4fvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs1dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1dvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs1dvNV_v, hf_x11_glx_render_VertexAttribs1dvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs2dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2dvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs2dvNV_v, hf_x11_glx_render_VertexAttribs2dvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs3dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3dvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs3dvNV_v, hf_x11_glx_render_VertexAttribs3dvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs4dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4dvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4dvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs4dvNV_v, hf_x11_glx_render_VertexAttribs4dvNV_v_item, n, little_endian); +} + +static void mesa_VertexAttribs4ubvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int n; + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4ubvNV_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4ubvNV_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs4ubvNV_v, n, little_endian); +} + +static void mesa_PointParameteriNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PointParameteriNV_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_PointParameteriNV_param, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_PointParameterivNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_PointParameterivNV_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_glx_render_PointParameterivNV_params, hf_x11_glx_render_PointParameterivNV_params_item, (length - 4) / 4, little_endian); +} + +static void mesa_ActiveStencilFaceEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_ActiveStencilFaceEXT_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void mesa_ProgramNamedParameter4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int len; + proto_tree_add_item(t, hf_x11_glx_render_ProgramNamedParameter4fvNV_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_ProgramNamedParameter4fvNV_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ProgramNamedParameter4fvNV_name, len, little_endian); + listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramNamedParameter4fvNV_v, hf_x11_glx_render_ProgramNamedParameter4fvNV_v_item, 4, little_endian); +} + +static void mesa_ProgramNamedParameter4dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int len; + proto_tree_add_item(t, hf_x11_glx_render_ProgramNamedParameter4dvNV_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_render_ProgramNamedParameter4dvNV_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_render_ProgramNamedParameter4dvNV_name, len, little_endian); + listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramNamedParameter4dvNV_v, hf_x11_glx_render_ProgramNamedParameter4dvNV_v_item, 4, little_endian); +} + +static void mesa_DepthBoundsEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_DepthBoundsEXT_zmin, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + proto_tree_add_item(t, hf_x11_glx_render_DepthBoundsEXT_zmax, tvb, *offsetp, 8, little_endian); + *offsetp += 8; +} + +static void mesa_BlendEquationSeparateEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + proto_tree_add_item(t, hf_x11_glx_render_BlendEquationSeparateEXT_modeRGB, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + proto_tree_add_item(t, hf_x11_glx_render_BlendEquationSeparateEXT_modeA, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static const value_string glx_render_op_name[] = { + { 1, "glCallList" }, + { 2, "glCallLists" }, + { 3, "glListBase" }, + { 4, "glBegin" }, + { 5, "glBitmap" }, + { 6, "glColor3bv" }, + { 7, "glColor3dv" }, + { 8, "glColor3fv" }, + { 9, "glColor3iv" }, + { 10, "glColor3sv" }, + { 11, "glColor3ubv" }, + { 12, "glColor3uiv" }, + { 13, "glColor3usv" }, + { 14, "glColor4bv" }, + { 15, "glColor4dv" }, + { 16, "glColor4fv" }, + { 17, "glColor4iv" }, + { 18, "glColor4sv" }, + { 19, "glColor4ubv" }, + { 20, "glColor4uiv" }, + { 21, "glColor4usv" }, + { 22, "glEdgeFlagv" }, + { 23, "glEnd" }, + { 24, "glIndexdv" }, + { 25, "glIndexfv" }, + { 26, "glIndexiv" }, + { 27, "glIndexsv" }, + { 28, "glNormal3bv" }, + { 29, "glNormal3dv" }, + { 30, "glNormal3fv" }, + { 31, "glNormal3iv" }, + { 32, "glNormal3sv" }, + { 33, "glRasterPos2dv" }, + { 34, "glRasterPos2fv" }, + { 35, "glRasterPos2iv" }, + { 36, "glRasterPos2sv" }, + { 37, "glRasterPos3dv" }, + { 38, "glRasterPos3fv" }, + { 39, "glRasterPos3iv" }, + { 40, "glRasterPos3sv" }, + { 41, "glRasterPos4dv" }, + { 42, "glRasterPos4fv" }, + { 43, "glRasterPos4iv" }, + { 44, "glRasterPos4sv" }, + { 45, "glRectdv" }, + { 46, "glRectfv" }, + { 47, "glRectiv" }, + { 48, "glRectsv" }, + { 49, "glTexCoord1dv" }, + { 50, "glTexCoord1fv" }, + { 51, "glTexCoord1iv" }, + { 52, "glTexCoord1sv" }, + { 53, "glTexCoord2dv" }, + { 54, "glTexCoord2fv" }, + { 55, "glTexCoord2iv" }, + { 56, "glTexCoord2sv" }, + { 57, "glTexCoord3dv" }, + { 58, "glTexCoord3fv" }, + { 59, "glTexCoord3iv" }, + { 60, "glTexCoord3sv" }, + { 61, "glTexCoord4dv" }, + { 62, "glTexCoord4fv" }, + { 63, "glTexCoord4iv" }, + { 64, "glTexCoord4sv" }, + { 65, "glVertex2dv" }, + { 66, "glVertex2fv" }, + { 67, "glVertex2iv" }, + { 68, "glVertex2sv" }, + { 69, "glVertex3dv" }, + { 70, "glVertex3fv" }, + { 71, "glVertex3iv" }, + { 72, "glVertex3sv" }, + { 73, "glVertex4dv" }, + { 74, "glVertex4fv" }, + { 75, "glVertex4iv" }, + { 76, "glVertex4sv" }, + { 77, "glClipPlane" }, + { 78, "glColorMaterial" }, + { 79, "glCullFace" }, + { 80, "glFogf" }, + { 81, "glFogfv" }, + { 82, "glFogi" }, + { 83, "glFogiv" }, + { 84, "glFrontFace" }, + { 85, "glHint" }, + { 86, "glLightf" }, + { 87, "glLightfv" }, + { 88, "glLighti" }, + { 89, "glLightiv" }, + { 90, "glLightModelf" }, + { 91, "glLightModelfv" }, + { 92, "glLightModeli" }, + { 93, "glLightModeliv" }, + { 94, "glLineStipple" }, + { 95, "glLineWidth" }, + { 96, "glMaterialf" }, + { 97, "glMaterialfv" }, + { 98, "glMateriali" }, + { 99, "glMaterialiv" }, + { 100, "glPointSize" }, + { 101, "glPolygonMode" }, + { 102, "glPolygonStipple" }, + { 103, "glScissor" }, + { 104, "glShadeModel" }, + { 105, "glTexParameterf" }, + { 106, "glTexParameterfv" }, + { 107, "glTexParameteri" }, + { 108, "glTexParameteriv" }, + { 109, "glTexImage1D" }, + { 110, "glTexImage2D" }, + { 111, "glTexEnvf" }, + { 112, "glTexEnvfv" }, + { 113, "glTexEnvi" }, + { 114, "glTexEnviv" }, + { 115, "glTexGend" }, + { 116, "glTexGendv" }, + { 117, "glTexGenf" }, + { 118, "glTexGenfv" }, + { 119, "glTexGeni" }, + { 120, "glTexGeniv" }, + { 121, "glInitNames" }, + { 122, "glLoadName" }, + { 123, "glPassThrough" }, + { 124, "glPopName" }, + { 125, "glPushName" }, + { 126, "glDrawBuffer" }, + { 127, "glClear" }, + { 128, "glClearAccum" }, + { 129, "glClearIndex" }, + { 130, "glClearColor" }, + { 131, "glClearStencil" }, + { 132, "glClearDepth" }, + { 133, "glStencilMask" }, + { 134, "glColorMask" }, + { 135, "glDepthMask" }, + { 136, "glIndexMask" }, + { 137, "glAccum" }, + { 138, "glDisable" }, + { 139, "glEnable" }, + { 141, "glPopAttrib" }, + { 142, "glPushAttrib" }, + { 143, "glMap1d" }, + { 144, "glMap1f" }, + { 145, "glMap2d" }, + { 146, "glMap2f" }, + { 147, "glMapGrid1d" }, + { 148, "glMapGrid1f" }, + { 149, "glMapGrid2d" }, + { 150, "glMapGrid2f" }, + { 151, "glEvalCoord1dv" }, + { 152, "glEvalCoord1fv" }, + { 153, "glEvalCoord2dv" }, + { 154, "glEvalCoord2fv" }, + { 155, "glEvalMesh1" }, + { 156, "glEvalPoint1" }, + { 157, "glEvalMesh2" }, + { 158, "glEvalPoint2" }, + { 159, "glAlphaFunc" }, + { 160, "glBlendFunc" }, + { 161, "glLogicOp" }, + { 162, "glStencilFunc" }, + { 163, "glStencilOp" }, + { 164, "glDepthFunc" }, + { 165, "glPixelZoom" }, + { 166, "glPixelTransferf" }, + { 167, "glPixelTransferi" }, + { 168, "glPixelMapfv" }, + { 169, "glPixelMapuiv" }, + { 170, "glPixelMapusv" }, + { 171, "glReadBuffer" }, + { 172, "glCopyPixels" }, + { 173, "glDrawPixels" }, + { 174, "glDepthRange" }, + { 175, "glFrustum" }, + { 176, "glLoadIdentity" }, + { 177, "glLoadMatrixf" }, + { 178, "glLoadMatrixd" }, + { 179, "glMatrixMode" }, + { 180, "glMultMatrixf" }, + { 181, "glMultMatrixd" }, + { 182, "glOrtho" }, + { 183, "glPopMatrix" }, + { 184, "glPushMatrix" }, + { 185, "glRotated" }, + { 186, "glRotatef" }, + { 187, "glScaled" }, + { 188, "glScalef" }, + { 189, "glTranslated" }, + { 190, "glTranslatef" }, + { 191, "glViewport" }, + { 192, "glPolygonOffset" }, + { 193, "glDrawArrays" }, + { 194, "glIndexubv" }, + { 195, "glColorSubTable" }, + { 196, "glCopyColorSubTable" }, + { 197, "glActiveTextureARB" }, + { 198, "glMultiTexCoord1dvARB" }, + { 199, "glMultiTexCoord1fvARB" }, + { 200, "glMultiTexCoord1ivARB" }, + { 201, "glMultiTexCoord1svARB" }, + { 202, "glMultiTexCoord2dvARB" }, + { 203, "glMultiTexCoord2fvARB" }, + { 204, "glMultiTexCoord2ivARB" }, + { 205, "glMultiTexCoord2svARB" }, + { 206, "glMultiTexCoord3dvARB" }, + { 207, "glMultiTexCoord3fvARB" }, + { 208, "glMultiTexCoord3ivARB" }, + { 209, "glMultiTexCoord3svARB" }, + { 210, "glMultiTexCoord4dvARB" }, + { 211, "glMultiTexCoord4fvARB" }, + { 212, "glMultiTexCoord4ivARB" }, + { 213, "glMultiTexCoord4svARB" }, + { 214, "glCompressedTexImage1DARB" }, + { 215, "glCompressedTexImage2DARB" }, + { 216, "glCompressedTexImage3DARB" }, + { 217, "glCompressedTexSubImage1DARB" }, + { 218, "glCompressedTexSubImage2DARB" }, + { 219, "glCompressedTexSubImage3DARB" }, + { 229, "glSampleCoverageARB" }, + { 230, "glWindowPos3fvMESA" }, + { 231, "glBeginQueryARB" }, + { 232, "glEndQueryARB" }, + { 233, "glDrawBuffersARB" }, + { 2048, "glSampleMaskSGIS" }, + { 2049, "glSamplePatternSGIS" }, + { 2050, "glTagSampleBufferSGIX" }, + { 2051, "glDetailTexFuncSGIS" }, + { 2052, "glSharpenTexFuncSGIS" }, + { 2053, "glColorTable" }, + { 2054, "glColorTableParameterfv" }, + { 2055, "glColorTableParameteriv" }, + { 2056, "glCopyColorTable" }, + { 2057, "glTexImage4DSGIS" }, + { 2058, "glTexSubImage4DSGIS" }, + { 2059, "glPixelTexGenSGIX" }, + { 2064, "glTexFilterFuncSGIS" }, + { 2065, "glPointParameterfEXT" }, + { 2066, "glPointParameterfvEXT" }, + { 2067, "glFogFuncSGIS" }, + { 2071, "glReferencePlaneSGIX" }, + { 2072, "glFrameZoomSGIX" }, + { 2082, "glTextureColorMaskSGIS" }, + { 4096, "glBlendColor" }, + { 4097, "glBlendEquation" }, + { 4098, "glPolygonOffsetEXT" }, + { 4099, "glTexSubImage1D" }, + { 4100, "glTexSubImage2D" }, + { 4101, "glConvolutionFilter1D" }, + { 4102, "glConvolutionFilter2D" }, + { 4103, "glConvolutionParameterf" }, + { 4104, "glConvolutionParameterfv" }, + { 4105, "glConvolutionParameteri" }, + { 4106, "glConvolutionParameteriv" }, + { 4107, "glCopyConvolutionFilter1D" }, + { 4108, "glCopyConvolutionFilter2D" }, + { 4109, "glSeparableFilter2D" }, + { 4110, "glHistogram" }, + { 4111, "glMinmax" }, + { 4112, "glResetHistogram" }, + { 4113, "glResetMinmax" }, + { 4114, "glTexImage3D" }, + { 4115, "glTexSubImage3D" }, + { 4117, "glBindTexture" }, + { 4118, "glPrioritizeTextures" }, + { 4119, "glCopyTexImage1D" }, + { 4120, "glCopyTexImage2D" }, + { 4121, "glCopyTexSubImage1D" }, + { 4122, "glCopyTexSubImage2D" }, + { 4123, "glCopyTexSubImage3D" }, + { 4124, "glFogCoordfvEXT" }, + { 4125, "glFogCoorddvEXT" }, + { 4126, "glSecondaryColor3bvEXT" }, + { 4127, "glSecondaryColor3svEXT" }, + { 4128, "glSecondaryColor3ivEXT" }, + { 4129, "glSecondaryColor3fvEXT" }, + { 4130, "glSecondaryColor3dvEXT" }, + { 4131, "glSecondaryColor3ubvEXT" }, + { 4132, "glSecondaryColor3usvEXT" }, + { 4133, "glSecondaryColor3uivEXT" }, + { 4134, "glBlendFuncSeparateEXT" }, + { 4135, "glVertexWeightfvEXT" }, + { 4136, "glCombinerParameterfNV" }, + { 4137, "glCombinerParameterfvNV" }, + { 4138, "glCombinerParameteriNV" }, + { 4139, "glCombinerParameterivNV" }, + { 4140, "glCombinerInputNV" }, + { 4141, "glCombinerOutputNV" }, + { 4142, "glFinalCombinerInputNV" }, + { 4180, "glBindProgramNV" }, + { 4181, "glExecuteProgramNV" }, + { 4182, "glRequestResidentProgramsNV" }, + { 4183, "glLoadProgramNV" }, + { 4184, "glProgramEnvParameter4fvARB" }, + { 4185, "glProgramEnvParameter4dvARB" }, + { 4186, "glProgramParameters4fvNV" }, + { 4187, "glProgramParameters4dvNV" }, + { 4188, "glTrackMatrixNV" }, + { 4189, "glVertexAttrib1svARB" }, + { 4190, "glVertexAttrib2svARB" }, + { 4191, "glVertexAttrib3svARB" }, + { 4192, "glVertexAttrib4svARB" }, + { 4193, "glVertexAttrib1fvARB" }, + { 4194, "glVertexAttrib2fvARB" }, + { 4195, "glVertexAttrib3fvARB" }, + { 4196, "glVertexAttrib4fvARB" }, + { 4197, "glVertexAttrib1dvARB" }, + { 4198, "glVertexAttrib2dvARB" }, + { 4199, "glVertexAttrib3dvARB" }, + { 4200, "glVertexAttrib4dvARB" }, + { 4201, "glVertexAttrib4NubvARB" }, + { 4202, "glVertexAttribs1svNV" }, + { 4203, "glVertexAttribs2svNV" }, + { 4204, "glVertexAttribs3svNV" }, + { 4205, "glVertexAttribs4svNV" }, + { 4206, "glVertexAttribs1fvNV" }, + { 4207, "glVertexAttribs2fvNV" }, + { 4208, "glVertexAttribs3fvNV" }, + { 4209, "glVertexAttribs4fvNV" }, + { 4210, "glVertexAttribs1dvNV" }, + { 4211, "glVertexAttribs2dvNV" }, + { 4212, "glVertexAttribs3dvNV" }, + { 4213, "glVertexAttribs4dvNV" }, + { 4214, "glVertexAttribs4ubvNV" }, + { 4215, "glProgramLocalParameter4fvARB" }, + { 4216, "glProgramLocalParameter4dvARB" }, + { 4217, "glProgramStringARB" }, + { 4218, "glProgramNamedParameter4fvNV" }, + { 4219, "glProgramNamedParameter4dvNV" }, + { 4220, "glActiveStencilFaceEXT" }, + { 4221, "glPointParameteriNV" }, + { 4222, "glPointParameterivNV" }, + { 4228, "glBlendEquationSeparateEXT" }, + { 4229, "glDepthBoundsEXT" }, + { 4230, "glVertexAttrib4bvARB" }, + { 4231, "glVertexAttrib4ivARB" }, + { 4232, "glVertexAttrib4ubvARB" }, + { 4233, "glVertexAttrib4usvARB" }, + { 4234, "glVertexAttrib4uivARB" }, + { 4235, "glVertexAttrib4NbvARB" }, + { 4236, "glVertexAttrib4NsvARB" }, + { 4237, "glVertexAttrib4NivARB" }, + { 4238, "glVertexAttrib4NusvARB" }, + { 4239, "glVertexAttrib4NuivARB" }, + { 4265, "glVertexAttrib1svNV" }, + { 4266, "glVertexAttrib2svNV" }, + { 4267, "glVertexAttrib3svNV" }, + { 4268, "glVertexAttrib4svNV" }, + { 4269, "glVertexAttrib1fvNV" }, + { 4270, "glVertexAttrib2fvNV" }, + { 4271, "glVertexAttrib3fvNV" }, + { 4272, "glVertexAttrib4fvNV" }, + { 4273, "glVertexAttrib1dvNV" }, + { 4274, "glVertexAttrib2dvNV" }, + { 4275, "glVertexAttrib3dvNV" }, + { 4276, "glVertexAttrib4dvNV" }, + { 4277, "glVertexAttrib4ubvNV" }, + { 4326, "glMatrixIndexubvARB" }, + { 4327, "glMatrixIndexusvARB" }, + { 4328, "glMatrixIndexuivARB" }, + { 4329, "glCurrentPaletteMatrixARB" }, + { 0, NULL } +}; + +static void dispatch_glx_render(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian, int length) +{ + while (length >= 4) { + guint32 op, len; + int next; + proto_item *ti; + proto_tree *tt; + + len = VALUE16(tvb, *offsetp); + + op = VALUE16(tvb, *offsetp + 2); + ti = proto_tree_add_uint(t, hf_x11_glx_render_op_name, tvb, *offsetp, len, op); + + tt = proto_item_add_subtree(ti, ett_x11_list_of_rectangle); + + ti = proto_tree_add_item(tt, hf_x11_request_length, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + proto_tree_add_item(tt, hf_x11_glx_render_op_name, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + + if (len < 4) { + expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR, "Invalid Length"); + /* Eat the rest of the packet, mark it undecoded */ + len = length; + op = -1; + } + len -= 4; + + next = *offsetp + len; + + switch (op) { + case 1: + mesa_CallList(tvb, offsetp, tt, little_endian, len); + break; + case 2: + mesa_CallLists(tvb, offsetp, tt, little_endian, len); + break; + case 3: + mesa_ListBase(tvb, offsetp, tt, little_endian, len); + break; + case 4: + mesa_Begin(tvb, offsetp, tt, little_endian, len); + break; + case 5: + mesa_Bitmap(tvb, offsetp, tt, little_endian, len); + break; + case 6: + mesa_Color3bv(tvb, offsetp, tt, little_endian, len); + break; + case 7: + mesa_Color3dv(tvb, offsetp, tt, little_endian, len); + break; + case 8: + mesa_Color3fv(tvb, offsetp, tt, little_endian, len); + break; + case 9: + mesa_Color3iv(tvb, offsetp, tt, little_endian, len); + break; + case 10: + mesa_Color3sv(tvb, offsetp, tt, little_endian, len); + break; + case 11: + mesa_Color3ubv(tvb, offsetp, tt, little_endian, len); + break; + case 12: + mesa_Color3uiv(tvb, offsetp, tt, little_endian, len); + break; + case 13: + mesa_Color3usv(tvb, offsetp, tt, little_endian, len); + break; + case 14: + mesa_Color4bv(tvb, offsetp, tt, little_endian, len); + break; + case 15: + mesa_Color4dv(tvb, offsetp, tt, little_endian, len); + break; + case 16: + mesa_Color4fv(tvb, offsetp, tt, little_endian, len); + break; + case 17: + mesa_Color4iv(tvb, offsetp, tt, little_endian, len); + break; + case 18: + mesa_Color4sv(tvb, offsetp, tt, little_endian, len); + break; + case 19: + mesa_Color4ubv(tvb, offsetp, tt, little_endian, len); + break; + case 20: + mesa_Color4uiv(tvb, offsetp, tt, little_endian, len); + break; + case 21: + mesa_Color4usv(tvb, offsetp, tt, little_endian, len); + break; + case 22: + mesa_EdgeFlagv(tvb, offsetp, tt, little_endian, len); + break; + case 23: + mesa_End(tvb, offsetp, tt, little_endian, len); + break; + case 24: + mesa_Indexdv(tvb, offsetp, tt, little_endian, len); + break; + case 25: + mesa_Indexfv(tvb, offsetp, tt, little_endian, len); + break; + case 26: + mesa_Indexiv(tvb, offsetp, tt, little_endian, len); + break; + case 27: + mesa_Indexsv(tvb, offsetp, tt, little_endian, len); + break; + case 28: + mesa_Normal3bv(tvb, offsetp, tt, little_endian, len); + break; + case 29: + mesa_Normal3dv(tvb, offsetp, tt, little_endian, len); + break; + case 30: + mesa_Normal3fv(tvb, offsetp, tt, little_endian, len); + break; + case 31: + mesa_Normal3iv(tvb, offsetp, tt, little_endian, len); + break; + case 32: + mesa_Normal3sv(tvb, offsetp, tt, little_endian, len); + break; + case 33: + mesa_RasterPos2dv(tvb, offsetp, tt, little_endian, len); + break; + case 34: + mesa_RasterPos2fv(tvb, offsetp, tt, little_endian, len); + break; + case 35: + mesa_RasterPos2iv(tvb, offsetp, tt, little_endian, len); + break; + case 36: + mesa_RasterPos2sv(tvb, offsetp, tt, little_endian, len); + break; + case 37: + mesa_RasterPos3dv(tvb, offsetp, tt, little_endian, len); + break; + case 38: + mesa_RasterPos3fv(tvb, offsetp, tt, little_endian, len); + break; + case 39: + mesa_RasterPos3iv(tvb, offsetp, tt, little_endian, len); + break; + case 40: + mesa_RasterPos3sv(tvb, offsetp, tt, little_endian, len); + break; + case 41: + mesa_RasterPos4dv(tvb, offsetp, tt, little_endian, len); + break; + case 42: + mesa_RasterPos4fv(tvb, offsetp, tt, little_endian, len); + break; + case 43: + mesa_RasterPos4iv(tvb, offsetp, tt, little_endian, len); + break; + case 44: + mesa_RasterPos4sv(tvb, offsetp, tt, little_endian, len); + break; + case 45: + mesa_Rectdv(tvb, offsetp, tt, little_endian, len); + break; + case 46: + mesa_Rectfv(tvb, offsetp, tt, little_endian, len); + break; + case 47: + mesa_Rectiv(tvb, offsetp, tt, little_endian, len); + break; + case 48: + mesa_Rectsv(tvb, offsetp, tt, little_endian, len); + break; + case 49: + mesa_TexCoord1dv(tvb, offsetp, tt, little_endian, len); + break; + case 50: + mesa_TexCoord1fv(tvb, offsetp, tt, little_endian, len); + break; + case 51: + mesa_TexCoord1iv(tvb, offsetp, tt, little_endian, len); + break; + case 52: + mesa_TexCoord1sv(tvb, offsetp, tt, little_endian, len); + break; + case 53: + mesa_TexCoord2dv(tvb, offsetp, tt, little_endian, len); + break; + case 54: + mesa_TexCoord2fv(tvb, offsetp, tt, little_endian, len); + break; + case 55: + mesa_TexCoord2iv(tvb, offsetp, tt, little_endian, len); + break; + case 56: + mesa_TexCoord2sv(tvb, offsetp, tt, little_endian, len); + break; + case 57: + mesa_TexCoord3dv(tvb, offsetp, tt, little_endian, len); + break; + case 58: + mesa_TexCoord3fv(tvb, offsetp, tt, little_endian, len); + break; + case 59: + mesa_TexCoord3iv(tvb, offsetp, tt, little_endian, len); + break; + case 60: + mesa_TexCoord3sv(tvb, offsetp, tt, little_endian, len); + break; + case 61: + mesa_TexCoord4dv(tvb, offsetp, tt, little_endian, len); + break; + case 62: + mesa_TexCoord4fv(tvb, offsetp, tt, little_endian, len); + break; + case 63: + mesa_TexCoord4iv(tvb, offsetp, tt, little_endian, len); + break; + case 64: + mesa_TexCoord4sv(tvb, offsetp, tt, little_endian, len); + break; + case 65: + mesa_Vertex2dv(tvb, offsetp, tt, little_endian, len); + break; + case 66: + mesa_Vertex2fv(tvb, offsetp, tt, little_endian, len); + break; + case 67: + mesa_Vertex2iv(tvb, offsetp, tt, little_endian, len); + break; + case 68: + mesa_Vertex2sv(tvb, offsetp, tt, little_endian, len); + break; + case 69: + mesa_Vertex3dv(tvb, offsetp, tt, little_endian, len); + break; + case 70: + mesa_Vertex3fv(tvb, offsetp, tt, little_endian, len); + break; + case 71: + mesa_Vertex3iv(tvb, offsetp, tt, little_endian, len); + break; + case 72: + mesa_Vertex3sv(tvb, offsetp, tt, little_endian, len); + break; + case 73: + mesa_Vertex4dv(tvb, offsetp, tt, little_endian, len); + break; + case 74: + mesa_Vertex4fv(tvb, offsetp, tt, little_endian, len); + break; + case 75: + mesa_Vertex4iv(tvb, offsetp, tt, little_endian, len); + break; + case 76: + mesa_Vertex4sv(tvb, offsetp, tt, little_endian, len); + break; + case 77: + mesa_ClipPlane(tvb, offsetp, tt, little_endian, len); + break; + case 78: + mesa_ColorMaterial(tvb, offsetp, tt, little_endian, len); + break; + case 79: + mesa_CullFace(tvb, offsetp, tt, little_endian, len); + break; + case 80: + mesa_Fogf(tvb, offsetp, tt, little_endian, len); + break; + case 81: + mesa_Fogfv(tvb, offsetp, tt, little_endian, len); + break; + case 82: + mesa_Fogi(tvb, offsetp, tt, little_endian, len); + break; + case 83: + mesa_Fogiv(tvb, offsetp, tt, little_endian, len); + break; + case 84: + mesa_FrontFace(tvb, offsetp, tt, little_endian, len); + break; + case 85: + mesa_Hint(tvb, offsetp, tt, little_endian, len); + break; + case 86: + mesa_Lightf(tvb, offsetp, tt, little_endian, len); + break; + case 87: + mesa_Lightfv(tvb, offsetp, tt, little_endian, len); + break; + case 88: + mesa_Lighti(tvb, offsetp, tt, little_endian, len); + break; + case 89: + mesa_Lightiv(tvb, offsetp, tt, little_endian, len); + break; + case 90: + mesa_LightModelf(tvb, offsetp, tt, little_endian, len); + break; + case 91: + mesa_LightModelfv(tvb, offsetp, tt, little_endian, len); + break; + case 92: + mesa_LightModeli(tvb, offsetp, tt, little_endian, len); + break; + case 93: + mesa_LightModeliv(tvb, offsetp, tt, little_endian, len); + break; + case 94: + mesa_LineStipple(tvb, offsetp, tt, little_endian, len); + break; + case 95: + mesa_LineWidth(tvb, offsetp, tt, little_endian, len); + break; + case 96: + mesa_Materialf(tvb, offsetp, tt, little_endian, len); + break; + case 97: + mesa_Materialfv(tvb, offsetp, tt, little_endian, len); + break; + case 98: + mesa_Materiali(tvb, offsetp, tt, little_endian, len); + break; + case 99: + mesa_Materialiv(tvb, offsetp, tt, little_endian, len); + break; + case 100: + mesa_PointSize(tvb, offsetp, tt, little_endian, len); + break; + case 101: + mesa_PolygonMode(tvb, offsetp, tt, little_endian, len); + break; + case 102: + mesa_PolygonStipple(tvb, offsetp, tt, little_endian, len); + break; + case 103: + mesa_Scissor(tvb, offsetp, tt, little_endian, len); + break; + case 104: + mesa_ShadeModel(tvb, offsetp, tt, little_endian, len); + break; + case 105: + mesa_TexParameterf(tvb, offsetp, tt, little_endian, len); + break; + case 106: + mesa_TexParameterfv(tvb, offsetp, tt, little_endian, len); + break; + case 107: + mesa_TexParameteri(tvb, offsetp, tt, little_endian, len); + break; + case 108: + mesa_TexParameteriv(tvb, offsetp, tt, little_endian, len); + break; + case 109: + mesa_TexImage1D(tvb, offsetp, tt, little_endian, len); + break; + case 110: + mesa_TexImage2D(tvb, offsetp, tt, little_endian, len); + break; + case 111: + mesa_TexEnvf(tvb, offsetp, tt, little_endian, len); + break; + case 112: + mesa_TexEnvfv(tvb, offsetp, tt, little_endian, len); + break; + case 113: + mesa_TexEnvi(tvb, offsetp, tt, little_endian, len); + break; + case 114: + mesa_TexEnviv(tvb, offsetp, tt, little_endian, len); + break; + case 115: + mesa_TexGend(tvb, offsetp, tt, little_endian, len); + break; + case 116: + mesa_TexGendv(tvb, offsetp, tt, little_endian, len); + break; + case 117: + mesa_TexGenf(tvb, offsetp, tt, little_endian, len); + break; + case 118: + mesa_TexGenfv(tvb, offsetp, tt, little_endian, len); + break; + case 119: + mesa_TexGeni(tvb, offsetp, tt, little_endian, len); + break; + case 120: + mesa_TexGeniv(tvb, offsetp, tt, little_endian, len); + break; + case 121: + mesa_InitNames(tvb, offsetp, tt, little_endian, len); + break; + case 122: + mesa_LoadName(tvb, offsetp, tt, little_endian, len); + break; + case 123: + mesa_PassThrough(tvb, offsetp, tt, little_endian, len); + break; + case 124: + mesa_PopName(tvb, offsetp, tt, little_endian, len); + break; + case 125: + mesa_PushName(tvb, offsetp, tt, little_endian, len); + break; + case 126: + mesa_DrawBuffer(tvb, offsetp, tt, little_endian, len); + break; + case 127: + mesa_Clear(tvb, offsetp, tt, little_endian, len); + break; + case 128: + mesa_ClearAccum(tvb, offsetp, tt, little_endian, len); + break; + case 129: + mesa_ClearIndex(tvb, offsetp, tt, little_endian, len); + break; + case 130: + mesa_ClearColor(tvb, offsetp, tt, little_endian, len); + break; + case 131: + mesa_ClearStencil(tvb, offsetp, tt, little_endian, len); + break; + case 132: + mesa_ClearDepth(tvb, offsetp, tt, little_endian, len); + break; + case 133: + mesa_StencilMask(tvb, offsetp, tt, little_endian, len); + break; + case 134: + mesa_ColorMask(tvb, offsetp, tt, little_endian, len); + break; + case 135: + mesa_DepthMask(tvb, offsetp, tt, little_endian, len); + break; + case 136: + mesa_IndexMask(tvb, offsetp, tt, little_endian, len); + break; + case 137: + mesa_Accum(tvb, offsetp, tt, little_endian, len); + break; + case 138: + mesa_Disable(tvb, offsetp, tt, little_endian, len); + break; + case 139: + mesa_Enable(tvb, offsetp, tt, little_endian, len); + break; + case 141: + mesa_PopAttrib(tvb, offsetp, tt, little_endian, len); + break; + case 142: + mesa_PushAttrib(tvb, offsetp, tt, little_endian, len); + break; + case 143: + mesa_Map1d(tvb, offsetp, tt, little_endian, len); + break; + case 144: + mesa_Map1f(tvb, offsetp, tt, little_endian, len); + break; + case 145: + mesa_Map2d(tvb, offsetp, tt, little_endian, len); + break; + case 146: + mesa_Map2f(tvb, offsetp, tt, little_endian, len); + break; + case 147: + mesa_MapGrid1d(tvb, offsetp, tt, little_endian, len); + break; + case 148: + mesa_MapGrid1f(tvb, offsetp, tt, little_endian, len); + break; + case 149: + mesa_MapGrid2d(tvb, offsetp, tt, little_endian, len); + break; + case 150: + mesa_MapGrid2f(tvb, offsetp, tt, little_endian, len); + break; + case 151: + mesa_EvalCoord1dv(tvb, offsetp, tt, little_endian, len); + break; + case 152: + mesa_EvalCoord1fv(tvb, offsetp, tt, little_endian, len); + break; + case 153: + mesa_EvalCoord2dv(tvb, offsetp, tt, little_endian, len); + break; + case 154: + mesa_EvalCoord2fv(tvb, offsetp, tt, little_endian, len); + break; + case 155: + mesa_EvalMesh1(tvb, offsetp, tt, little_endian, len); + break; + case 156: + mesa_EvalPoint1(tvb, offsetp, tt, little_endian, len); + break; + case 157: + mesa_EvalMesh2(tvb, offsetp, tt, little_endian, len); + break; + case 158: + mesa_EvalPoint2(tvb, offsetp, tt, little_endian, len); + break; + case 159: + mesa_AlphaFunc(tvb, offsetp, tt, little_endian, len); + break; + case 160: + mesa_BlendFunc(tvb, offsetp, tt, little_endian, len); + break; + case 161: + mesa_LogicOp(tvb, offsetp, tt, little_endian, len); + break; + case 162: + mesa_StencilFunc(tvb, offsetp, tt, little_endian, len); + break; + case 163: + mesa_StencilOp(tvb, offsetp, tt, little_endian, len); + break; + case 164: + mesa_DepthFunc(tvb, offsetp, tt, little_endian, len); + break; + case 165: + mesa_PixelZoom(tvb, offsetp, tt, little_endian, len); + break; + case 166: + mesa_PixelTransferf(tvb, offsetp, tt, little_endian, len); + break; + case 167: + mesa_PixelTransferi(tvb, offsetp, tt, little_endian, len); + break; + case 168: + mesa_PixelMapfv(tvb, offsetp, tt, little_endian, len); + break; + case 169: + mesa_PixelMapuiv(tvb, offsetp, tt, little_endian, len); + break; + case 170: + mesa_PixelMapusv(tvb, offsetp, tt, little_endian, len); + break; + case 171: + mesa_ReadBuffer(tvb, offsetp, tt, little_endian, len); + break; + case 172: + mesa_CopyPixels(tvb, offsetp, tt, little_endian, len); + break; + case 173: + mesa_DrawPixels(tvb, offsetp, tt, little_endian, len); + break; + case 174: + mesa_DepthRange(tvb, offsetp, tt, little_endian, len); + break; + case 175: + mesa_Frustum(tvb, offsetp, tt, little_endian, len); + break; + case 176: + mesa_LoadIdentity(tvb, offsetp, tt, little_endian, len); + break; + case 177: + mesa_LoadMatrixf(tvb, offsetp, tt, little_endian, len); + break; + case 178: + mesa_LoadMatrixd(tvb, offsetp, tt, little_endian, len); + break; + case 179: + mesa_MatrixMode(tvb, offsetp, tt, little_endian, len); + break; + case 180: + mesa_MultMatrixf(tvb, offsetp, tt, little_endian, len); + break; + case 181: + mesa_MultMatrixd(tvb, offsetp, tt, little_endian, len); + break; + case 182: + mesa_Ortho(tvb, offsetp, tt, little_endian, len); + break; + case 183: + mesa_PopMatrix(tvb, offsetp, tt, little_endian, len); + break; + case 184: + mesa_PushMatrix(tvb, offsetp, tt, little_endian, len); + break; + case 185: + mesa_Rotated(tvb, offsetp, tt, little_endian, len); + break; + case 186: + mesa_Rotatef(tvb, offsetp, tt, little_endian, len); + break; + case 187: + mesa_Scaled(tvb, offsetp, tt, little_endian, len); + break; + case 188: + mesa_Scalef(tvb, offsetp, tt, little_endian, len); + break; + case 189: + mesa_Translated(tvb, offsetp, tt, little_endian, len); + break; + case 190: + mesa_Translatef(tvb, offsetp, tt, little_endian, len); + break; + case 191: + mesa_Viewport(tvb, offsetp, tt, little_endian, len); + break; + case 192: + mesa_PolygonOffset(tvb, offsetp, tt, little_endian, len); + break; + case 193: + mesa_DrawArrays(tvb, offsetp, tt, little_endian, len); + break; + case 194: + mesa_Indexubv(tvb, offsetp, tt, little_endian, len); + break; + case 195: + mesa_ColorSubTable(tvb, offsetp, tt, little_endian, len); + break; + case 196: + mesa_CopyColorSubTable(tvb, offsetp, tt, little_endian, len); + break; + case 197: + mesa_ActiveTextureARB(tvb, offsetp, tt, little_endian, len); + break; + case 198: + mesa_MultiTexCoord1dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 199: + mesa_MultiTexCoord1fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 200: + mesa_MultiTexCoord1ivARB(tvb, offsetp, tt, little_endian, len); + break; + case 201: + mesa_MultiTexCoord1svARB(tvb, offsetp, tt, little_endian, len); + break; + case 202: + mesa_MultiTexCoord2dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 203: + mesa_MultiTexCoord2fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 204: + mesa_MultiTexCoord2ivARB(tvb, offsetp, tt, little_endian, len); + break; + case 205: + mesa_MultiTexCoord2svARB(tvb, offsetp, tt, little_endian, len); + break; + case 206: + mesa_MultiTexCoord3dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 207: + mesa_MultiTexCoord3fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 208: + mesa_MultiTexCoord3ivARB(tvb, offsetp, tt, little_endian, len); + break; + case 209: + mesa_MultiTexCoord3svARB(tvb, offsetp, tt, little_endian, len); + break; + case 210: + mesa_MultiTexCoord4dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 211: + mesa_MultiTexCoord4fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 212: + mesa_MultiTexCoord4ivARB(tvb, offsetp, tt, little_endian, len); + break; + case 213: + mesa_MultiTexCoord4svARB(tvb, offsetp, tt, little_endian, len); + break; + case 214: + mesa_CompressedTexImage1DARB(tvb, offsetp, tt, little_endian, len); + break; + case 215: + mesa_CompressedTexImage2DARB(tvb, offsetp, tt, little_endian, len); + break; + case 216: + mesa_CompressedTexImage3DARB(tvb, offsetp, tt, little_endian, len); + break; + case 217: + mesa_CompressedTexSubImage1DARB(tvb, offsetp, tt, little_endian, len); + break; + case 218: + mesa_CompressedTexSubImage2DARB(tvb, offsetp, tt, little_endian, len); + break; + case 219: + mesa_CompressedTexSubImage3DARB(tvb, offsetp, tt, little_endian, len); + break; + case 229: + mesa_SampleCoverageARB(tvb, offsetp, tt, little_endian, len); + break; + case 230: + mesa_WindowPos3fvMESA(tvb, offsetp, tt, little_endian, len); + break; + case 231: + mesa_BeginQueryARB(tvb, offsetp, tt, little_endian, len); + break; + case 232: + mesa_EndQueryARB(tvb, offsetp, tt, little_endian, len); + break; + case 233: + mesa_DrawBuffersARB(tvb, offsetp, tt, little_endian, len); + break; + case 2048: + mesa_SampleMaskSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2049: + mesa_SamplePatternSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2050: + mesa_TagSampleBufferSGIX(tvb, offsetp, tt, little_endian, len); + break; + case 2051: + mesa_DetailTexFuncSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2052: + mesa_SharpenTexFuncSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2053: + mesa_ColorTable(tvb, offsetp, tt, little_endian, len); + break; + case 2054: + mesa_ColorTableParameterfv(tvb, offsetp, tt, little_endian, len); + break; + case 2055: + mesa_ColorTableParameteriv(tvb, offsetp, tt, little_endian, len); + break; + case 2056: + mesa_CopyColorTable(tvb, offsetp, tt, little_endian, len); + break; + case 2057: + mesa_TexImage4DSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2058: + mesa_TexSubImage4DSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2059: + mesa_PixelTexGenSGIX(tvb, offsetp, tt, little_endian, len); + break; + case 2064: + mesa_TexFilterFuncSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2065: + mesa_PointParameterfEXT(tvb, offsetp, tt, little_endian, len); + break; + case 2066: + mesa_PointParameterfvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 2067: + mesa_FogFuncSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 2071: + mesa_ReferencePlaneSGIX(tvb, offsetp, tt, little_endian, len); + break; + case 2072: + mesa_FrameZoomSGIX(tvb, offsetp, tt, little_endian, len); + break; + case 2082: + mesa_TextureColorMaskSGIS(tvb, offsetp, tt, little_endian, len); + break; + case 4096: + mesa_BlendColor(tvb, offsetp, tt, little_endian, len); + break; + case 4097: + mesa_BlendEquation(tvb, offsetp, tt, little_endian, len); + break; + case 4098: + mesa_PolygonOffsetEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4099: + mesa_TexSubImage1D(tvb, offsetp, tt, little_endian, len); + break; + case 4100: + mesa_TexSubImage2D(tvb, offsetp, tt, little_endian, len); + break; + case 4101: + mesa_ConvolutionFilter1D(tvb, offsetp, tt, little_endian, len); + break; + case 4102: + mesa_ConvolutionFilter2D(tvb, offsetp, tt, little_endian, len); + break; + case 4103: + mesa_ConvolutionParameterf(tvb, offsetp, tt, little_endian, len); + break; + case 4104: + mesa_ConvolutionParameterfv(tvb, offsetp, tt, little_endian, len); + break; + case 4105: + mesa_ConvolutionParameteri(tvb, offsetp, tt, little_endian, len); + break; + case 4106: + mesa_ConvolutionParameteriv(tvb, offsetp, tt, little_endian, len); + break; + case 4107: + mesa_CopyConvolutionFilter1D(tvb, offsetp, tt, little_endian, len); + break; + case 4108: + mesa_CopyConvolutionFilter2D(tvb, offsetp, tt, little_endian, len); + break; + case 4109: + mesa_SeparableFilter2D(tvb, offsetp, tt, little_endian, len); + break; + case 4110: + mesa_Histogram(tvb, offsetp, tt, little_endian, len); + break; + case 4111: + mesa_Minmax(tvb, offsetp, tt, little_endian, len); + break; + case 4112: + mesa_ResetHistogram(tvb, offsetp, tt, little_endian, len); + break; + case 4113: + mesa_ResetMinmax(tvb, offsetp, tt, little_endian, len); + break; + case 4114: + mesa_TexImage3D(tvb, offsetp, tt, little_endian, len); + break; + case 4115: + mesa_TexSubImage3D(tvb, offsetp, tt, little_endian, len); + break; + case 4117: + mesa_BindTexture(tvb, offsetp, tt, little_endian, len); + break; + case 4118: + mesa_PrioritizeTextures(tvb, offsetp, tt, little_endian, len); + break; + case 4119: + mesa_CopyTexImage1D(tvb, offsetp, tt, little_endian, len); + break; + case 4120: + mesa_CopyTexImage2D(tvb, offsetp, tt, little_endian, len); + break; + case 4121: + mesa_CopyTexSubImage1D(tvb, offsetp, tt, little_endian, len); + break; + case 4122: + mesa_CopyTexSubImage2D(tvb, offsetp, tt, little_endian, len); + break; + case 4123: + mesa_CopyTexSubImage3D(tvb, offsetp, tt, little_endian, len); + break; + case 4124: + mesa_FogCoordfvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4125: + mesa_FogCoorddvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4126: + mesa_SecondaryColor3bvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4127: + mesa_SecondaryColor3svEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4128: + mesa_SecondaryColor3ivEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4129: + mesa_SecondaryColor3fvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4130: + mesa_SecondaryColor3dvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4131: + mesa_SecondaryColor3ubvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4132: + mesa_SecondaryColor3usvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4133: + mesa_SecondaryColor3uivEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4134: + mesa_BlendFuncSeparateEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4135: + mesa_VertexWeightfvEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4136: + mesa_CombinerParameterfNV(tvb, offsetp, tt, little_endian, len); + break; + case 4137: + mesa_CombinerParameterfvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4138: + mesa_CombinerParameteriNV(tvb, offsetp, tt, little_endian, len); + break; + case 4139: + mesa_CombinerParameterivNV(tvb, offsetp, tt, little_endian, len); + break; + case 4140: + mesa_CombinerInputNV(tvb, offsetp, tt, little_endian, len); + break; + case 4141: + mesa_CombinerOutputNV(tvb, offsetp, tt, little_endian, len); + break; + case 4142: + mesa_FinalCombinerInputNV(tvb, offsetp, tt, little_endian, len); + break; + case 4180: + mesa_BindProgramNV(tvb, offsetp, tt, little_endian, len); + break; + case 4181: + mesa_ExecuteProgramNV(tvb, offsetp, tt, little_endian, len); + break; + case 4182: + mesa_RequestResidentProgramsNV(tvb, offsetp, tt, little_endian, len); + break; + case 4183: + mesa_LoadProgramNV(tvb, offsetp, tt, little_endian, len); + break; + case 4184: + mesa_ProgramEnvParameter4fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4185: + mesa_ProgramEnvParameter4dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4186: + mesa_ProgramParameters4fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4187: + mesa_ProgramParameters4dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4188: + mesa_TrackMatrixNV(tvb, offsetp, tt, little_endian, len); + break; + case 4189: + mesa_VertexAttrib1svARB(tvb, offsetp, tt, little_endian, len); + break; + case 4190: + mesa_VertexAttrib2svARB(tvb, offsetp, tt, little_endian, len); + break; + case 4191: + mesa_VertexAttrib3svARB(tvb, offsetp, tt, little_endian, len); + break; + case 4192: + mesa_VertexAttrib4svARB(tvb, offsetp, tt, little_endian, len); + break; + case 4193: + mesa_VertexAttrib1fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4194: + mesa_VertexAttrib2fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4195: + mesa_VertexAttrib3fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4196: + mesa_VertexAttrib4fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4197: + mesa_VertexAttrib1dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4198: + mesa_VertexAttrib2dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4199: + mesa_VertexAttrib3dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4200: + mesa_VertexAttrib4dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4201: + mesa_VertexAttrib4NubvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4202: + mesa_VertexAttribs1svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4203: + mesa_VertexAttribs2svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4204: + mesa_VertexAttribs3svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4205: + mesa_VertexAttribs4svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4206: + mesa_VertexAttribs1fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4207: + mesa_VertexAttribs2fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4208: + mesa_VertexAttribs3fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4209: + mesa_VertexAttribs4fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4210: + mesa_VertexAttribs1dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4211: + mesa_VertexAttribs2dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4212: + mesa_VertexAttribs3dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4213: + mesa_VertexAttribs4dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4214: + mesa_VertexAttribs4ubvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4215: + mesa_ProgramLocalParameter4fvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4216: + mesa_ProgramLocalParameter4dvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4217: + mesa_ProgramStringARB(tvb, offsetp, tt, little_endian, len); + break; + case 4218: + mesa_ProgramNamedParameter4fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4219: + mesa_ProgramNamedParameter4dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4220: + mesa_ActiveStencilFaceEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4221: + mesa_PointParameteriNV(tvb, offsetp, tt, little_endian, len); + break; + case 4222: + mesa_PointParameterivNV(tvb, offsetp, tt, little_endian, len); + break; + case 4228: + mesa_BlendEquationSeparateEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4229: + mesa_DepthBoundsEXT(tvb, offsetp, tt, little_endian, len); + break; + case 4230: + mesa_VertexAttrib4bvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4231: + mesa_VertexAttrib4ivARB(tvb, offsetp, tt, little_endian, len); + break; + case 4232: + mesa_VertexAttrib4ubvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4233: + mesa_VertexAttrib4usvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4234: + mesa_VertexAttrib4uivARB(tvb, offsetp, tt, little_endian, len); + break; + case 4235: + mesa_VertexAttrib4NbvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4236: + mesa_VertexAttrib4NsvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4237: + mesa_VertexAttrib4NivARB(tvb, offsetp, tt, little_endian, len); + break; + case 4238: + mesa_VertexAttrib4NusvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4239: + mesa_VertexAttrib4NuivARB(tvb, offsetp, tt, little_endian, len); + break; + case 4265: + mesa_VertexAttrib1svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4266: + mesa_VertexAttrib2svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4267: + mesa_VertexAttrib3svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4268: + mesa_VertexAttrib4svNV(tvb, offsetp, tt, little_endian, len); + break; + case 4269: + mesa_VertexAttrib1fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4270: + mesa_VertexAttrib2fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4271: + mesa_VertexAttrib3fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4272: + mesa_VertexAttrib4fvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4273: + mesa_VertexAttrib1dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4274: + mesa_VertexAttrib2dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4275: + mesa_VertexAttrib3dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4276: + mesa_VertexAttrib4dvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4277: + mesa_VertexAttrib4ubvNV(tvb, offsetp, tt, little_endian, len); + break; + case 4326: + mesa_MatrixIndexubvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4327: + mesa_MatrixIndexusvARB(tvb, offsetp, tt, little_endian, len); + break; + case 4328: + mesa_MatrixIndexuivARB(tvb, offsetp, tt, little_endian, len); + break; + case 4329: + mesa_CurrentPaletteMatrixARB(tvb, offsetp, tt, little_endian, len); + break; + default: + proto_tree_add_item(tt, hf_x11_undecoded, tvb, *offsetp, len, little_endian); + *offsetp += len; + } + if (*offsetp < next) { + proto_tree_add_item(tt, hf_x11_unused, tvb, *offsetp, next - *offsetp, little_endian); + *offsetp = next; + } + length -= (len + 4); + } +} + +static void bigreqEnable(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void bigreqEnable_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_maximum_request_length; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Enable"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (bigreq-Enable)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_maximum_request_length = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_bigreq_Enable_reply_maximum_request_length, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string bigreq_extension_minor[] = { + { 0, "Enable" }, + { 0, NULL } +}; +const x11_event_info bigreq_events[] = { + { NULL, NULL } +}; +static x11_reply_info bigreq_replies[] = { + { 0, bigreqEnable_Reply }, + { 0, NULL } +}; + +static void dispatch_bigreq(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(bigreq_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, bigreq_extension_minor, + "")); + switch (minor) { + case 0: + bigreqEnable(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_bigreq(void) +{ + set_handler("BIG-REQUESTS", dispatch_bigreq, bigreq_errors, bigreq_events, bigreq_replies); +} + +static void struct_RECTANGLE(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_x; + int f_y; + int f_width; + int f_height; + + item = proto_tree_add_item(root, hf_x11_struct_RECTANGLE, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_RECTANGLE_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_RECTANGLE_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_RECTANGLE_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_RECTANGLE_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static int struct_size_STR(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_name_len; + f_name_len = VALUE8(tvb, *offsetp + size + 0); + size += f_name_len * 1; + return size + 1; +} + +static void struct_STR(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_name_len; + + item = proto_tree_add_item(root, hf_x11_struct_STR, tvb, *offsetp, struct_size_STR(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_name_len = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_STR_name_len, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + listOfByte(tvb, offsetp, t, hf_x11_struct_STR_name, f_name_len, little_endian); + } +} + +static void struct_DIRECTFORMAT(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_red_shift; + int f_red_mask; + int f_green_shift; + int f_green_mask; + int f_blue_shift; + int f_blue_mask; + int f_alpha_shift; + int f_alpha_mask; + + item = proto_tree_add_item(root, hf_x11_struct_DIRECTFORMAT, tvb, *offsetp, 16, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_red_shift = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_red_shift, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_red_mask = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_red_mask, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_green_shift = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_green_shift, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_green_mask = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_green_mask, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_blue_shift = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_blue_shift, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_blue_mask = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_blue_mask, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_alpha_shift = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_alpha_shift, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_alpha_mask = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DIRECTFORMAT_alpha_mask, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void struct_PICTFORMINFO(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_id; + int f_type; + int f_depth; + int f_colormap; + + item = proto_tree_add_item(root, hf_x11_struct_PICTFORMINFO, tvb, *offsetp, 28, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTFORMINFO_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTFORMINFO_type, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTFORMINFO_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + struct_DIRECTFORMAT(tvb, offsetp, t, little_endian, 1); + f_colormap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTFORMINFO_colormap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_PICTVISUAL(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_visual; + int f_format; + + item = proto_tree_add_item(root, hf_x11_struct_PICTVISUAL, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTVISUAL_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTVISUAL_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static int struct_size_PICTDEPTH(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_num_visuals; + f_num_visuals = VALUE16(tvb, *offsetp + size + 2); + size += f_num_visuals * 8; + return size + 8; +} + +static void struct_PICTDEPTH(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_depth; + int f_num_visuals; + + item = proto_tree_add_item(root, hf_x11_struct_PICTDEPTH, tvb, *offsetp, struct_size_PICTDEPTH(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTDEPTH_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_num_visuals = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTDEPTH_num_visuals, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(4); + struct_PICTVISUAL(tvb, offsetp, t, little_endian, f_num_visuals); + } +} + +static int struct_size_PICTSCREEN(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int i, off; + int f_num_depths; + f_num_depths = VALUE32(tvb, *offsetp + size + 0); + for (i = 0; i < f_num_depths; i++) { + off = (*offsetp) + size + 8; + size += struct_size_PICTDEPTH(tvb, &off, little_endian); + } + return size + 8; +} + +static void struct_PICTSCREEN(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_num_depths; + int f_fallback; + + item = proto_tree_add_item(root, hf_x11_struct_PICTSCREEN, tvb, *offsetp, struct_size_PICTSCREEN(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_num_depths = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTSCREEN_num_depths, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_fallback = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PICTSCREEN_fallback, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_PICTDEPTH(tvb, offsetp, t, little_endian, f_num_depths); + } +} + +static void struct_INDEXVALUE(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_pixel; + int f_red; + int f_green; + int f_blue; + int f_alpha; + + item = proto_tree_add_item(root, hf_x11_struct_INDEXVALUE, tvb, *offsetp, 12, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_pixel = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INDEXVALUE_pixel, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_red = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INDEXVALUE_red, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_green = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INDEXVALUE_green, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_blue = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INDEXVALUE_blue, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_alpha = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INDEXVALUE_alpha, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void struct_COLOR(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_red; + int f_green; + int f_blue; + int f_alpha; + + item = proto_tree_add_item(root, hf_x11_struct_COLOR, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_red = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_COLOR_red, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_green = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_COLOR_green, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_blue = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_COLOR_blue, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_alpha = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_COLOR_alpha, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void struct_POINTFIX(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_x; + int f_y; + + item = proto_tree_add_item(root, hf_x11_struct_POINTFIX, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_x = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_POINTFIX_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_y = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_POINTFIX_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_LINEFIX(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_struct_LINEFIX, tvb, *offsetp, 16, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + } +} + +static void struct_TRIANGLE(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_struct_TRIANGLE, tvb, *offsetp, 24, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + } +} + +static void struct_TRAPEZOID(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_top; + int f_bottom; + + item = proto_tree_add_item(root, hf_x11_struct_TRAPEZOID, tvb, *offsetp, 40, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_top = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRAPEZOID_top, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bottom = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRAPEZOID_bottom, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_LINEFIX(tvb, offsetp, t, little_endian, 1); + struct_LINEFIX(tvb, offsetp, t, little_endian, 1); + } +} + +static void struct_GLYPHINFO(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_width; + int f_height; + int f_x; + int f_y; + int f_x_off; + int f_y_off; + + item = proto_tree_add_item(root, hf_x11_struct_GLYPHINFO, tvb, *offsetp, 12, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_GLYPHINFO_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_GLYPHINFO_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_GLYPHINFO_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_GLYPHINFO_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_x_off = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_GLYPHINFO_x_off, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_off = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_GLYPHINFO_y_off, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void struct_TRANSFORM(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_matrix11; + int f_matrix12; + int f_matrix13; + int f_matrix21; + int f_matrix22; + int f_matrix23; + int f_matrix31; + int f_matrix32; + int f_matrix33; + + item = proto_tree_add_item(root, hf_x11_struct_TRANSFORM, tvb, *offsetp, 36, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_matrix11 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix11, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix12 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix12, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix13 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix13, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix21 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix21, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix22 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix22, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix23 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix23, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix31 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix31, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix32 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix32, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_matrix33 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRANSFORM_matrix33, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_ANIMCURSORELT(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_cursor; + int f_delay; + + item = proto_tree_add_item(root, hf_x11_struct_ANIMCURSORELT, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_cursor = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ANIMCURSORELT_cursor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_delay = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ANIMCURSORELT_delay, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_SPANFIX(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_l; + int f_r; + int f_y; + + item = proto_tree_add_item(root, hf_x11_struct_SPANFIX, tvb, *offsetp, 12, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_l = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SPANFIX_l, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_r = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SPANFIX_r, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_y = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SPANFIX_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_TRAP(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_struct_TRAP, tvb, *offsetp, 24, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + struct_SPANFIX(tvb, offsetp, t, little_endian, 1); + struct_SPANFIX(tvb, offsetp, t, little_endian, 1); + } +} + +static void compositeQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_QueryVersion_client_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_QueryVersion_client_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void compositeQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (composite-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_QueryVersion_reply_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_QueryVersion_reply_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void compositeRedirectWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_update; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_RedirectWindow_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_update = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_RedirectWindow_update, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void compositeRedirectSubwindows(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_update; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_RedirectSubwindows_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_update = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_RedirectSubwindows_update, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void compositeUnredirectWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_update; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_UnredirectWindow_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_update = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_UnredirectWindow_update, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void compositeUnredirectSubwindows(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_update; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_UnredirectSubwindows_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_update = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_UnredirectSubwindows_update, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void compositeCreateRegionFromBorderClip(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + int f_window; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_CreateRegionFromBorderClip_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_CreateRegionFromBorderClip_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void compositeNameWindowPixmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_pixmap; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_NameWindowPixmap_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_NameWindowPixmap_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void compositeGetOverlayWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_GetOverlayWindow_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void compositeGetOverlayWindow_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_overlay_win; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetOverlayWindow"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (composite-GetOverlayWindow)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_overlay_win = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_GetOverlayWindow_reply_overlay_win, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void compositeReleaseOverlayWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_composite_ReleaseOverlayWindow_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string composite_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "RedirectWindow" }, + { 2, "RedirectSubwindows" }, + { 3, "UnredirectWindow" }, + { 4, "UnredirectSubwindows" }, + { 5, "CreateRegionFromBorderClip" }, + { 6, "NameWindowPixmap" }, + { 7, "GetOverlayWindow" }, + { 8, "ReleaseOverlayWindow" }, + { 0, NULL } +}; +const x11_event_info composite_events[] = { + { NULL, NULL } +}; +static x11_reply_info composite_replies[] = { + { 0, compositeQueryVersion_Reply }, + { 7, compositeGetOverlayWindow_Reply }, + { 0, NULL } +}; + +static void dispatch_composite(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(composite_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, composite_extension_minor, + "")); + switch (minor) { + case 0: + compositeQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + compositeRedirectWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + compositeRedirectSubwindows(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + compositeUnredirectWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + compositeUnredirectSubwindows(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + compositeCreateRegionFromBorderClip(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + compositeNameWindowPixmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + compositeGetOverlayWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + compositeReleaseOverlayWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_composite(void) +{ + set_handler("Composite", dispatch_composite, composite_errors, composite_events, composite_replies); +} + +static void damageQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_QueryVersion_client_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_QueryVersion_client_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void damageQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (damage-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_QueryVersion_reply_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_QueryVersion_reply_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void damageCreate(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_damage; + int f_drawable; + int f_level; + f_damage = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Create_damage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Create_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_level = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Create_level, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void damageDestroy(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_damage; + f_damage = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Destroy_damage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void damageSubtract(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_damage; + int f_repair; + int f_parts; + f_damage = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Subtract_damage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_repair = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Subtract_repair, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_parts = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Subtract_parts, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void damageAdd(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_region; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Add_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Add_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void damageNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_level; + int f_drawable; + int f_damage; + int f_timestamp; + f_level = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Notify_level, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Notify_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_damage = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Notify_damage, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_damage_Notify_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_RECTANGLE(tvb, offsetp, t, little_endian, 1); + struct_RECTANGLE(tvb, offsetp, t, little_endian, 1); +} +static const value_string damage_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "Create" }, + { 2, "Destroy" }, + { 3, "Subtract" }, + { 4, "Add" }, + { 0, NULL } +}; +const x11_event_info damage_events[] = { + { "damage-Notify", damageNotify }, + { NULL, NULL } +}; +static x11_reply_info damage_replies[] = { + { 0, damageQueryVersion_Reply }, + { 0, NULL } +}; + +static void dispatch_damage(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(damage_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, damage_extension_minor, + "")); + switch (minor) { + case 0: + damageQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + damageCreate(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + damageDestroy(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + damageSubtract(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + damageAdd(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_damage(void) +{ + set_handler("DAMAGE", dispatch_damage, damage_errors, damage_events, damage_replies); +} + +static void dpmsGetVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetVersion_client_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_client_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetVersion_client_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void dpmsGetVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major_version; + int f_server_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (dpms-GetVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetVersion_reply_server_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetVersion_reply_server_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void dpmsCapable(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void dpmsCapable_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_capable; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Capable"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (dpms-Capable)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_capable = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_Capable_reply_capable, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void dpmsGetTimeouts(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void dpmsGetTimeouts_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_standby_timeout; + int f_suspend_timeout; + int f_off_timeout; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTimeouts"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (dpms-GetTimeouts)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_standby_timeout = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetTimeouts_reply_standby_timeout, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_suspend_timeout = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetTimeouts_reply_suspend_timeout, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_off_timeout = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_GetTimeouts_reply_off_timeout, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(18); +} + +static void dpmsSetTimeouts(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_standby_timeout; + int f_suspend_timeout; + int f_off_timeout; + f_standby_timeout = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_SetTimeouts_standby_timeout, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_suspend_timeout = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_SetTimeouts_suspend_timeout, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_off_timeout = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_SetTimeouts_off_timeout, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void dpmsEnable(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void dpmsDisable(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void dpmsForceLevel(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_power_level; + f_power_level = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_ForceLevel_power_level, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void dpmsInfo(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void dpmsInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_power_level; + int f_state; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Info"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (dpms-Info)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_power_level = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_Info_reply_power_level, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_state = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_dpms_Info_reply_state, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(21); +} +static const value_string dpms_extension_minor[] = { + { 0, "GetVersion" }, + { 1, "Capable" }, + { 2, "GetTimeouts" }, + { 3, "SetTimeouts" }, + { 4, "Enable" }, + { 5, "Disable" }, + { 6, "ForceLevel" }, + { 7, "Info" }, + { 0, NULL } +}; +const x11_event_info dpms_events[] = { + { NULL, NULL } +}; +static x11_reply_info dpms_replies[] = { + { 0, dpmsGetVersion_Reply }, + { 1, dpmsCapable_Reply }, + { 2, dpmsGetTimeouts_Reply }, + { 7, dpmsInfo_Reply }, + { 0, NULL } +}; + +static void dispatch_dpms(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(dpms_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, dpms_extension_minor, + "")); + switch (minor) { + case 0: + dpmsGetVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + dpmsCapable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + dpmsGetTimeouts(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + dpmsSetTimeouts(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + dpmsEnable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + dpmsDisable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + dpmsForceLevel(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + dpmsInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_dpms(void) +{ + set_handler("DPMS", dispatch_dpms, dpms_errors, dpms_events, dpms_replies); +} + +static void geQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_ge_QueryVersion_client_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_client_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_ge_QueryVersion_client_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void geQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (ge-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_ge_QueryVersion_reply_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_ge_QueryVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(20); +} +static const value_string ge_extension_minor[] = { + { 0, "QueryVersion" }, + { 0, NULL } +}; +const x11_event_info ge_events[] = { + { NULL, NULL } +}; +static x11_reply_info ge_replies[] = { + { 0, geQueryVersion_Reply }, + { 0, NULL } +}; + +static void dispatch_ge(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(ge_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, ge_extension_minor, + "")); + switch (minor) { + case 0: + geQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_ge(void) +{ + set_handler("Generic Event Extension", dispatch_ge, ge_errors, ge_events, ge_replies); +} + +static void glxPbufferClobber(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_event_type; + int f_draw_type; + int f_drawable; + int f_b_mask; + int f_aux_buffer; + int f_x; + int f_y; + int f_width; + int f_height; + int f_count; + UNUSED(1); + CARD16(event_sequencenumber); + f_event_type = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_event_type, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_draw_type = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_draw_type, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_b_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_b_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_aux_buffer = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_aux_buffer, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_count = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PbufferClobber_count, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(4); +} + +static void glxRender(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_Render_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + dispatch_glx_render(tvb, pinfo, offsetp, t, little_endian, (length - 8)); +} + +static void glxRenderLarge(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_request_num; + int f_request_total; + int f_data_len; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderLarge_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_request_num = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderLarge_request_num, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_request_total = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderLarge_request_total, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_data_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderLarge_data_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_RenderLarge_data, f_data_len, little_endian); + length -= f_data_len * 1; +} + +static void glxCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_visual; + int f_screen; + int f_share_list; + int f_is_direct; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateContext_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateContext_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_share_list = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateContext_share_list, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_is_direct = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateContext_is_direct, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void glxDestroyContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DestroyContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxMakeCurrent(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_context; + int f_old_context_tag; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeCurrent_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeCurrent_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_old_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeCurrent_old_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxMakeCurrent_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_tag; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-MakeCurrent"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-MakeCurrent)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeCurrent_reply_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void glxIsDirect(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsDirect_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxIsDirect_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_is_direct; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-IsDirect"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-IsDirect)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_is_direct = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsDirect_reply_is_direct, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void glxQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major_version; + int f_minor_version; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryVersion_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryVersion_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryVersion_reply_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryVersion_reply_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void glxWaitGL(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_WaitGL_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxWaitX(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_WaitX_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxCopyContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_src; + int f_dest; + int f_mask; + int f_src_context_tag; + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CopyContext_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dest = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CopyContext_dest, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CopyContext_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CopyContext_src_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxSwapBuffers(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_drawable; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_SwapBuffers_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_SwapBuffers_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxUseXFont(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_font; + int f_first; + int f_count; + int f_list_base; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_UseXFont_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_font = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_UseXFont_font, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_first = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_UseXFont_first, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_count = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_UseXFont_count, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_list_base = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_UseXFont_list_base, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxCreateGLXPixmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_visual; + int f_pixmap; + int f_glx_pixmap; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateGLXPixmap_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateGLXPixmap_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateGLXPixmap_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glx_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateGLXPixmap_glx_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxGetVisualConfigs(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetVisualConfigs_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetVisualConfigs_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_visuals; + int f_num_properties; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetVisualConfigs"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetVisualConfigs)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_visuals = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetVisualConfigs_reply_num_visuals, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_properties = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetVisualConfigs_reply_num_properties, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GetVisualConfigs_reply_property_list, hf_x11_glx_GetVisualConfigs_reply_property_list_item, f_length, little_endian); +} + +static void glxDestroyGLXPixmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_glx_pixmap; + f_glx_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DestroyGLXPixmap_glx_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxVendorPrivate(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_vendor_code; + int f_context_tag; + f_vendor_code = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_VendorPrivate_vendor_code, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_VendorPrivate_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_VendorPrivate_data, (length - 12) / 1, little_endian); +} + +static void glxVendorPrivateWithReply(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_vendor_code; + int f_context_tag; + f_vendor_code = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_VendorPrivateWithReply_vendor_code, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_VendorPrivateWithReply_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_VendorPrivateWithReply_data, (length - 12) / 1, little_endian); +} +static void glxVendorPrivateWithReply_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_retval; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-VendorPrivateWithReply"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-VendorPrivateWithReply)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_retval = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_VendorPrivateWithReply_reply_retval, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_VendorPrivateWithReply_reply_data1, 24, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_glx_VendorPrivateWithReply_reply_data2, (f_length * 4), little_endian); +} + +static void glxQueryExtensionsString(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryExtensionsString_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxQueryExtensionsString_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryExtensionsString"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-QueryExtensionsString)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryExtensionsString_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void glxQueryServerString(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_name; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryServerString_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_name = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryServerString_name, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxQueryServerString_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_str_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryServerString"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-QueryServerString)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_str_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryServerString_reply_str_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + listOfByte(tvb, offsetp, t, hf_x11_glx_QueryServerString_reply_string, f_str_len, little_endian); +} + +static void glxClientInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major_version; + int f_minor_version; + int f_str_len; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ClientInfo_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ClientInfo_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_str_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ClientInfo_str_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_glx_ClientInfo_string, f_str_len, little_endian); + length -= f_str_len * 1; +} + +static void glxGetFBConfigs(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFBConfigs_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetFBConfigs_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_FB_configs; + int f_num_properties; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetFBConfigs"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetFBConfigs)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_FB_configs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFBConfigs_reply_num_FB_configs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_properties = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFBConfigs_reply_num_properties, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GetFBConfigs_reply_property_list, hf_x11_glx_GetFBConfigs_reply_property_list_item, f_length, little_endian); +} + +static void glxCreatePixmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_fbconfig; + int f_pixmap; + int f_glx_pixmap; + int f_num_attribs; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePixmap_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_fbconfig = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePixmap_fbconfig, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePixmap_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glx_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePixmap_glx_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attribs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePixmap_num_attribs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_CreatePixmap_attribs, hf_x11_glx_CreatePixmap_attribs_item, (f_num_attribs * 2), little_endian); + length -= (f_num_attribs * 2) * 4; +} + +static void glxDestroyPixmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_glx_pixmap; + f_glx_pixmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DestroyPixmap_glx_pixmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxCreateNewContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_fbconfig; + int f_screen; + int f_render_type; + int f_share_list; + int f_is_direct; + int f_reserved1; + int f_reserved2; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_fbconfig = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_fbconfig, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_render_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_render_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_share_list = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_share_list, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_is_direct = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_is_direct, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_reserved1 = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_reserved1, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_reserved2 = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateNewContext_reserved2, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void glxQueryContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxQueryContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_attribs; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-QueryContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attribs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_QueryContext_reply_num_attribs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_glx_QueryContext_reply_attribs, hf_x11_glx_QueryContext_reply_attribs_item, (f_num_attribs * 2), little_endian); +} + +static void glxMakeContextCurrent(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_old_context_tag; + int f_drawable; + int f_read_drawable; + int f_context; + f_old_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeContextCurrent_old_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeContextCurrent_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_read_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeContextCurrent_read_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeContextCurrent_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxMakeContextCurrent_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_tag; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-MakeContextCurrent"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-MakeContextCurrent)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_MakeContextCurrent_reply_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void glxCreatePbuffer(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_fbconfig; + int f_pbuffer; + int f_num_attribs; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePbuffer_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_fbconfig = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePbuffer_fbconfig, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pbuffer = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePbuffer_pbuffer, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attribs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreatePbuffer_num_attribs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_CreatePbuffer_attribs, hf_x11_glx_CreatePbuffer_attribs_item, (f_num_attribs * 2), little_endian); + length -= (f_num_attribs * 2) * 4; +} + +static void glxDestroyPbuffer(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_pbuffer; + f_pbuffer = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DestroyPbuffer_pbuffer, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxGetDrawableAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetDrawableAttributes_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetDrawableAttributes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_attribs; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDrawableAttributes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetDrawableAttributes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attribs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetDrawableAttributes_reply_num_attribs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GetDrawableAttributes_reply_attribs, hf_x11_glx_GetDrawableAttributes_reply_attribs_item, (f_num_attribs * 2), little_endian); +} + +static void glxChangeDrawableAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_num_attribs; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ChangeDrawableAttributes_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attribs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ChangeDrawableAttributes_num_attribs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_ChangeDrawableAttributes_attribs, hf_x11_glx_ChangeDrawableAttributes_attribs_item, (f_num_attribs * 2), little_endian); + length -= (f_num_attribs * 2) * 4; +} + +static void glxCreateWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_fbconfig; + int f_window; + int f_glx_window; + int f_num_attribs; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateWindow_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_fbconfig = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateWindow_fbconfig, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateWindow_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glx_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateWindow_glx_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attribs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_CreateWindow_num_attribs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_CreateWindow_attribs, hf_x11_glx_CreateWindow_attribs_item, (f_num_attribs * 2), little_endian); + length -= (f_num_attribs * 2) * 4; +} + +static void glxDeleteWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_glxwindow; + f_glxwindow = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteWindow_glxwindow, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxNewList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_list; + int f_mode; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_NewList_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_list = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_NewList_list, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_NewList_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxEndList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_EndList_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxDeleteLists(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_list; + int f_range; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteLists_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_list = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteLists_list, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_range = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteLists_range, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxGenLists(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_range; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenLists_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_range = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenLists_range, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGenLists_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ret_val; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GenLists"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GenLists)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ret_val = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenLists_reply_ret_val, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxFeedbackBuffer(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_size; + int f_type; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_FeedbackBuffer_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_FeedbackBuffer_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_FeedbackBuffer_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxSelectBuffer(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_size; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_SelectBuffer_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_SelectBuffer_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxRenderMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_mode; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderMode_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderMode_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxRenderMode_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ret_val; + int f_n; + int f_new_mode; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-RenderMode"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-RenderMode)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ret_val = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderMode_reply_ret_val, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderMode_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_new_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_RenderMode_reply_new_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfCard32(tvb, offsetp, t, hf_x11_glx_RenderMode_reply_data, hf_x11_glx_RenderMode_reply_data_item, f_n, little_endian); +} + +static void glxFinish(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_Finish_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxFinish_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Finish"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-Finish)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxPixelStoref(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_pname; + int f_datum; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PixelStoref_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PixelStoref_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PixelStoref_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxPixelStorei(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_pname; + int f_datum; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PixelStorei_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PixelStorei_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_PixelStorei_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxReadPixels(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_x; + int f_y; + int f_width; + int f_height; + int f_format; + int f_type; + int f_swap_bytes; + int f_lsb_first; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_y = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_height = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_lsb_first = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_ReadPixels_lsb_first, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxReadPixels_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ReadPixels"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-ReadPixels)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfByte(tvb, offsetp, t, hf_x11_glx_ReadPixels_reply_data, (f_length * 4), little_endian); +} + +static void glxGetBooleanv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetBooleanv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetBooleanv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetBooleanv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetBooleanv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetBooleanv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetBooleanv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetBooleanv_reply_datum, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(15); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetBooleanv_reply_data, f_n, little_endian); +} + +static void glxGetClipPlane(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_plane; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetClipPlane_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_plane = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetClipPlane_plane, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetClipPlane_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetClipPlane"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetClipPlane)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfDouble(tvb, offsetp, t, hf_x11_glx_GetClipPlane_reply_data, hf_x11_glx_GetClipPlane_reply_data_item, (f_length / 2), little_endian); +} + +static void glxGetDoublev(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetDoublev_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetDoublev_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetDoublev_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDoublev"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetDoublev)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetDoublev_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = DOUBLE(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetDoublev_reply_datum, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + UNUSED(8); + listOfDouble(tvb, offsetp, t, hf_x11_glx_GetDoublev_reply_data, hf_x11_glx_GetDoublev_reply_data_item, f_n, little_endian); +} + +static void glxGetError(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetError_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetError_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_error; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetError"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetError)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_error = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetError_reply_error, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxGetFloatv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFloatv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFloatv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetFloatv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetFloatv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetFloatv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFloatv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetFloatv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetFloatv_reply_data, hf_x11_glx_GetFloatv_reply_data_item, f_n, little_endian); +} + +static void glxGetIntegerv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetIntegerv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetIntegerv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetIntegerv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetIntegerv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetIntegerv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetIntegerv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetIntegerv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetIntegerv_reply_data, hf_x11_glx_GetIntegerv_reply_data_item, f_n, little_endian); +} + +static void glxGetLightfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_light; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_light = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightfv_light, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetLightfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetLightfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetLightfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetLightfv_reply_data, hf_x11_glx_GetLightfv_reply_data_item, f_n, little_endian); +} + +static void glxGetLightiv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_light; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightiv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_light = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightiv_light, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightiv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetLightiv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetLightiv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetLightiv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightiv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetLightiv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetLightiv_reply_data, hf_x11_glx_GetLightiv_reply_data_item, f_n, little_endian); +} + +static void glxGetMapdv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_query; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapdv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapdv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_query = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapdv_query, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMapdv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMapdv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMapdv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapdv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = DOUBLE(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapdv_reply_datum, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + UNUSED(8); + listOfDouble(tvb, offsetp, t, hf_x11_glx_GetMapdv_reply_data, hf_x11_glx_GetMapdv_reply_data_item, f_n, little_endian); +} + +static void glxGetMapfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_query; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_query = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapfv_query, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMapfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMapfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMapfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetMapfv_reply_data, hf_x11_glx_GetMapfv_reply_data_item, f_n, little_endian); +} + +static void glxGetMapiv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_query; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapiv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapiv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_query = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapiv_query, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMapiv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMapiv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMapiv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapiv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMapiv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetMapiv_reply_data, hf_x11_glx_GetMapiv_reply_data_item, f_n, little_endian); +} + +static void glxGetMaterialfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_face; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_face = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialfv_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMaterialfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMaterialfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMaterialfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetMaterialfv_reply_data, hf_x11_glx_GetMaterialfv_reply_data_item, f_n, little_endian); +} + +static void glxGetMaterialiv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_face; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialiv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_face = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialiv_face, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialiv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMaterialiv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMaterialiv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMaterialiv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialiv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMaterialiv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetMaterialiv_reply_data, hf_x11_glx_GetMaterialiv_reply_data_item, f_n, little_endian); +} + +static void glxGetPixelMapfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_map; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_map = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapfv_map, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetPixelMapfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPixelMapfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetPixelMapfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetPixelMapfv_reply_data, hf_x11_glx_GetPixelMapfv_reply_data_item, f_n, little_endian); +} + +static void glxGetPixelMapuiv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_map; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapuiv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_map = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapuiv_map, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetPixelMapuiv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPixelMapuiv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetPixelMapuiv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapuiv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapuiv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GetPixelMapuiv_reply_data, hf_x11_glx_GetPixelMapuiv_reply_data_item, f_n, little_endian); +} + +static void glxGetPixelMapusv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_map; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapusv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_map = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapusv_map, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetPixelMapusv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPixelMapusv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetPixelMapusv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapusv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPixelMapusv_reply_datum, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(16); + listOfCard16(tvb, offsetp, t, hf_x11_glx_GetPixelMapusv_reply_data, hf_x11_glx_GetPixelMapusv_reply_data_item, f_n, little_endian); +} + +static void glxGetPolygonStipple(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_lsb_first; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPolygonStipple_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_lsb_first = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetPolygonStipple_lsb_first, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetPolygonStipple_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPolygonStipple"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetPolygonStipple)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetPolygonStipple_reply_data, (f_length * 4), little_endian); +} + +static void glxGetString(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_name; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetString_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_name = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetString_name, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetString_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetString"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetString)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetString_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetString_reply_string, f_n, little_endian); +} + +static void glxGetTexEnvfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnvfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnvfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnvfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexEnvfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexEnvfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexEnvfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnvfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnvfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetTexEnvfv_reply_data, hf_x11_glx_GetTexEnvfv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexEnviv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnviv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnviv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnviv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexEnviv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexEnviv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexEnviv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnviv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexEnviv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetTexEnviv_reply_data, hf_x11_glx_GetTexEnviv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexGendv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_coord; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGendv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_coord = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGendv_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGendv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexGendv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexGendv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexGendv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGendv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = DOUBLE(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGendv_reply_datum, tvb, *offsetp, 8, little_endian); + *offsetp += 8; + UNUSED(8); + listOfDouble(tvb, offsetp, t, hf_x11_glx_GetTexGendv_reply_data, hf_x11_glx_GetTexGendv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexGenfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_coord; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGenfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_coord = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGenfv_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGenfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexGenfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexGenfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexGenfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGenfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGenfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetTexGenfv_reply_data, hf_x11_glx_GetTexGenfv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexGeniv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_coord; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGeniv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_coord = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGeniv_coord, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGeniv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexGeniv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexGeniv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexGeniv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGeniv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexGeniv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetTexGeniv_reply_data, hf_x11_glx_GetTexGeniv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexImage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_level; + int f_format; + int f_type; + int f_swap_bytes; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_level = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetTexImage_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width; + int f_height; + int f_depth; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexImage"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexImage)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_reply_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_height = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_reply_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_depth = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexImage_reply_depth, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetTexImage_reply_data, (f_length * 4), little_endian); +} + +static void glxGetTexParameterfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameterfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexParameterfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexParameterfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexParameterfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameterfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameterfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetTexParameterfv_reply_data, hf_x11_glx_GetTexParameterfv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexParameteriv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameteriv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexParameteriv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexParameteriv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexParameteriv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameteriv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexParameteriv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetTexParameteriv_reply_data, hf_x11_glx_GetTexParameteriv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexLevelParameterfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_level; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameterfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_level = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameterfv_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexLevelParameterfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexLevelParameterfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexLevelParameterfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameterfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameterfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetTexLevelParameterfv_reply_data, hf_x11_glx_GetTexLevelParameterfv_reply_data_item, f_n, little_endian); +} + +static void glxGetTexLevelParameteriv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_level; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameteriv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_level = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameteriv_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetTexLevelParameteriv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetTexLevelParameteriv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetTexLevelParameteriv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameteriv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetTexLevelParameteriv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetTexLevelParameteriv_reply_data, hf_x11_glx_GetTexLevelParameteriv_reply_data_item, f_n, little_endian); +} + +static void glxIsList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_list; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsList_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_list = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsList_list, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxIsList_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ret_val; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-IsList"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-IsList)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ret_val = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsList_reply_ret_val, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxFlush(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_Flush_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxAreTexturesResident(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_n; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_AreTexturesResident_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_AreTexturesResident_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_AreTexturesResident_textures, hf_x11_glx_AreTexturesResident_textures_item, f_n, little_endian); + length -= f_n * 4; +} +static void glxAreTexturesResident_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ret_val; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-AreTexturesResident"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-AreTexturesResident)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ret_val = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_AreTexturesResident_reply_ret_val, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_glx_AreTexturesResident_reply_data, (f_length * 4), little_endian); +} + +static void glxDeleteTextures(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_n; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteTextures_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteTextures_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_DeleteTextures_textures, hf_x11_glx_DeleteTextures_textures_item, f_n, little_endian); + length -= f_n * 4; +} + +static void glxGenTextures(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_n; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenTextures_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenTextures_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGenTextures_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GenTextures"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GenTextures)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GenTextures_reply_data, hf_x11_glx_GenTextures_reply_data_item, f_length, little_endian); +} + +static void glxIsTexture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_texture; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsTexture_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_texture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsTexture_texture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxIsTexture_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ret_val; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-IsTexture"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-IsTexture)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ret_val = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsTexture_reply_ret_val, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxGetColorTable(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_format; + int f_type; + int f_swap_bytes; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTable_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTable_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTable_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTable_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTable_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetColorTable_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetColorTable"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetColorTable)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTable_reply_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetColorTable_reply_data, (f_length * 4), little_endian); +} + +static void glxGetColorTableParameterfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameterfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetColorTableParameterfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetColorTableParameterfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetColorTableParameterfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameterfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameterfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetColorTableParameterfv_reply_data, hf_x11_glx_GetColorTableParameterfv_reply_data_item, f_n, little_endian); +} + +static void glxGetColorTableParameteriv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameteriv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetColorTableParameteriv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetColorTableParameteriv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetColorTableParameteriv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameteriv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetColorTableParameteriv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetColorTableParameteriv_reply_data, hf_x11_glx_GetColorTableParameteriv_reply_data_item, f_n, little_endian); +} + +static void glxGetConvolutionFilter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_format; + int f_type; + int f_swap_bytes; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetConvolutionFilter_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width; + int f_height; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetConvolutionFilter"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetConvolutionFilter)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_reply_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_height = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionFilter_reply_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetConvolutionFilter_reply_data, (f_length * 4), little_endian); +} + +static void glxGetConvolutionParameterfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameterfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetConvolutionParameterfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetConvolutionParameterfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetConvolutionParameterfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameterfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameterfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetConvolutionParameterfv_reply_data, hf_x11_glx_GetConvolutionParameterfv_reply_data_item, f_n, little_endian); +} + +static void glxGetConvolutionParameteriv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameteriv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetConvolutionParameteriv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetConvolutionParameteriv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetConvolutionParameteriv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameteriv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetConvolutionParameteriv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetConvolutionParameteriv_reply_data, hf_x11_glx_GetConvolutionParameteriv_reply_data_item, f_n, little_endian); +} + +static void glxGetSeparableFilter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_format; + int f_type; + int f_swap_bytes; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetSeparableFilter_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_row_w; + int f_col_h; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetSeparableFilter"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetSeparableFilter)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_row_w = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_reply_row_w, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_col_h = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetSeparableFilter_reply_col_h, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetSeparableFilter_reply_rows_and_cols, (f_length * 4), little_endian); +} + +static void glxGetHistogram(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_format; + int f_type; + int f_swap_bytes; + int f_reset; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_reset = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_reset, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetHistogram_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetHistogram"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetHistogram)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogram_reply_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetHistogram_reply_data, (f_length * 4), little_endian); +} + +static void glxGetHistogramParameterfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameterfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetHistogramParameterfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetHistogramParameterfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetHistogramParameterfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameterfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameterfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetHistogramParameterfv_reply_data, hf_x11_glx_GetHistogramParameterfv_reply_data_item, f_n, little_endian); +} + +static void glxGetHistogramParameteriv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameteriv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetHistogramParameteriv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetHistogramParameteriv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetHistogramParameteriv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameteriv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetHistogramParameteriv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetHistogramParameteriv_reply_data, hf_x11_glx_GetHistogramParameteriv_reply_data_item, f_n, little_endian); +} + +static void glxGetMinmax(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_format; + int f_type; + int f_swap_bytes; + int f_reset; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmax_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmax_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmax_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmax_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_swap_bytes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmax_swap_bytes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_reset = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmax_reset, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void glxGetMinmax_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMinmax"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMinmax)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetMinmax_reply_data, (f_length * 4), little_endian); +} + +static void glxGetMinmaxParameterfv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameterfv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameterfv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameterfv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMinmaxParameterfv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMinmaxParameterfv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMinmaxParameterfv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameterfv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = FLOAT(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameterfv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfFloat(tvb, offsetp, t, hf_x11_glx_GetMinmaxParameterfv_reply_data, hf_x11_glx_GetMinmaxParameterfv_reply_data_item, f_n, little_endian); +} + +static void glxGetMinmaxParameteriv(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameteriv_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameteriv_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameteriv_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetMinmaxParameteriv_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMinmaxParameteriv"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetMinmaxParameteriv)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameteriv_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetMinmaxParameteriv_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetMinmaxParameteriv_reply_data, hf_x11_glx_GetMinmaxParameteriv_reply_data_item, f_n, little_endian); +} + +static void glxGetCompressedTexImageARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_level; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetCompressedTexImageARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetCompressedTexImageARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_level = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetCompressedTexImageARB_level, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetCompressedTexImageARB_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCompressedTexImageARB"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetCompressedTexImageARB)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetCompressedTexImageARB_reply_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_glx_GetCompressedTexImageARB_reply_data, (f_length * 4), little_endian); +} + +static void glxDeleteQueriesARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_n; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteQueriesARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_DeleteQueriesARB_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_glx_DeleteQueriesARB_ids, hf_x11_glx_DeleteQueriesARB_ids_item, f_n, little_endian); + length -= f_n * 4; +} + +static void glxGenQueriesARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_n; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenQueriesARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GenQueriesARB_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGenQueriesARB_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GenQueriesARB"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GenQueriesARB)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GenQueriesARB_reply_data, hf_x11_glx_GenQueriesARB_reply_data_item, f_length, little_endian); +} + +static void glxIsQueryARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_id; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsQueryARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsQueryARB_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxIsQueryARB_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ret_val; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-IsQueryARB"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-IsQueryARB)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ret_val = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_IsQueryARB_reply_ret_val, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void glxGetQueryivARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_target; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryivARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_target = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryivARB_target, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryivARB_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetQueryivARB_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetQueryivARB"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetQueryivARB)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryivARB_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryivARB_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetQueryivARB_reply_data, hf_x11_glx_GetQueryivARB_reply_data_item, f_n, little_endian); +} + +static void glxGetQueryObjectivARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_id; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectivARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectivARB_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectivARB_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetQueryObjectivARB_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetQueryObjectivARB"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetQueryObjectivARB)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectivARB_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectivARB_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfInt32(tvb, offsetp, t, hf_x11_glx_GetQueryObjectivARB_reply_data, hf_x11_glx_GetQueryObjectivARB_reply_data_item, f_n, little_endian); +} + +static void glxGetQueryObjectuivARB(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_tag; + int f_id; + int f_pname; + f_context_tag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectuivARB_context_tag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectuivARB_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pname = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectuivARB_pname, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void glxGetQueryObjectuivARB_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_n; + int f_datum; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetQueryObjectuivARB"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (glx-GetQueryObjectuivARB)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + f_n = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectuivARB_reply_n, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_datum = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_glx_GetQueryObjectuivARB_reply_datum, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfCard32(tvb, offsetp, t, hf_x11_glx_GetQueryObjectuivARB_reply_data, hf_x11_glx_GetQueryObjectuivARB_reply_data_item, f_n, little_endian); +} +static const value_string glx_extension_minor[] = { + { 1, "Render" }, + { 2, "RenderLarge" }, + { 3, "CreateContext" }, + { 4, "DestroyContext" }, + { 5, "MakeCurrent" }, + { 6, "IsDirect" }, + { 7, "QueryVersion" }, + { 8, "WaitGL" }, + { 9, "WaitX" }, + { 10, "CopyContext" }, + { 11, "SwapBuffers" }, + { 12, "UseXFont" }, + { 13, "CreateGLXPixmap" }, + { 14, "GetVisualConfigs" }, + { 15, "DestroyGLXPixmap" }, + { 16, "VendorPrivate" }, + { 17, "VendorPrivateWithReply" }, + { 18, "QueryExtensionsString" }, + { 19, "QueryServerString" }, + { 20, "ClientInfo" }, + { 21, "GetFBConfigs" }, + { 22, "CreatePixmap" }, + { 23, "DestroyPixmap" }, + { 24, "CreateNewContext" }, + { 25, "QueryContext" }, + { 26, "MakeContextCurrent" }, + { 27, "CreatePbuffer" }, + { 28, "DestroyPbuffer" }, + { 29, "GetDrawableAttributes" }, + { 30, "ChangeDrawableAttributes" }, + { 31, "CreateWindow" }, + { 32, "DeleteWindow" }, + { 101, "NewList" }, + { 102, "EndList" }, + { 103, "DeleteLists" }, + { 104, "GenLists" }, + { 105, "FeedbackBuffer" }, + { 106, "SelectBuffer" }, + { 107, "RenderMode" }, + { 108, "Finish" }, + { 109, "PixelStoref" }, + { 110, "PixelStorei" }, + { 111, "ReadPixels" }, + { 112, "GetBooleanv" }, + { 113, "GetClipPlane" }, + { 114, "GetDoublev" }, + { 115, "GetError" }, + { 116, "GetFloatv" }, + { 117, "GetIntegerv" }, + { 118, "GetLightfv" }, + { 119, "GetLightiv" }, + { 120, "GetMapdv" }, + { 121, "GetMapfv" }, + { 122, "GetMapiv" }, + { 123, "GetMaterialfv" }, + { 124, "GetMaterialiv" }, + { 125, "GetPixelMapfv" }, + { 126, "GetPixelMapuiv" }, + { 127, "GetPixelMapusv" }, + { 128, "GetPolygonStipple" }, + { 129, "GetString" }, + { 130, "GetTexEnvfv" }, + { 131, "GetTexEnviv" }, + { 132, "GetTexGendv" }, + { 133, "GetTexGenfv" }, + { 134, "GetTexGeniv" }, + { 135, "GetTexImage" }, + { 136, "GetTexParameterfv" }, + { 137, "GetTexParameteriv" }, + { 138, "GetTexLevelParameterfv" }, + { 139, "GetTexLevelParameteriv" }, + { 141, "IsList" }, + { 142, "Flush" }, + { 143, "AreTexturesResident" }, + { 144, "DeleteTextures" }, + { 145, "GenTextures" }, + { 146, "IsTexture" }, + { 147, "GetColorTable" }, + { 148, "GetColorTableParameterfv" }, + { 149, "GetColorTableParameteriv" }, + { 150, "GetConvolutionFilter" }, + { 151, "GetConvolutionParameterfv" }, + { 152, "GetConvolutionParameteriv" }, + { 153, "GetSeparableFilter" }, + { 154, "GetHistogram" }, + { 155, "GetHistogramParameterfv" }, + { 156, "GetHistogramParameteriv" }, + { 157, "GetMinmax" }, + { 158, "GetMinmaxParameterfv" }, + { 159, "GetMinmaxParameteriv" }, + { 160, "GetCompressedTexImageARB" }, + { 161, "DeleteQueriesARB" }, + { 162, "GenQueriesARB" }, + { 163, "IsQueryARB" }, + { 164, "GetQueryivARB" }, + { 165, "GetQueryObjectivARB" }, + { 166, "GetQueryObjectuivARB" }, + { 0, NULL } +}; +const x11_event_info glx_events[] = { + { "glx-PbufferClobber", glxPbufferClobber }, + { NULL, NULL } +}; +static x11_reply_info glx_replies[] = { + { 5, glxMakeCurrent_Reply }, + { 6, glxIsDirect_Reply }, + { 7, glxQueryVersion_Reply }, + { 14, glxGetVisualConfigs_Reply }, + { 17, glxVendorPrivateWithReply_Reply }, + { 18, glxQueryExtensionsString_Reply }, + { 19, glxQueryServerString_Reply }, + { 21, glxGetFBConfigs_Reply }, + { 25, glxQueryContext_Reply }, + { 26, glxMakeContextCurrent_Reply }, + { 29, glxGetDrawableAttributes_Reply }, + { 104, glxGenLists_Reply }, + { 107, glxRenderMode_Reply }, + { 108, glxFinish_Reply }, + { 111, glxReadPixels_Reply }, + { 112, glxGetBooleanv_Reply }, + { 113, glxGetClipPlane_Reply }, + { 114, glxGetDoublev_Reply }, + { 115, glxGetError_Reply }, + { 116, glxGetFloatv_Reply }, + { 117, glxGetIntegerv_Reply }, + { 118, glxGetLightfv_Reply }, + { 119, glxGetLightiv_Reply }, + { 120, glxGetMapdv_Reply }, + { 121, glxGetMapfv_Reply }, + { 122, glxGetMapiv_Reply }, + { 123, glxGetMaterialfv_Reply }, + { 124, glxGetMaterialiv_Reply }, + { 125, glxGetPixelMapfv_Reply }, + { 126, glxGetPixelMapuiv_Reply }, + { 127, glxGetPixelMapusv_Reply }, + { 128, glxGetPolygonStipple_Reply }, + { 129, glxGetString_Reply }, + { 130, glxGetTexEnvfv_Reply }, + { 131, glxGetTexEnviv_Reply }, + { 132, glxGetTexGendv_Reply }, + { 133, glxGetTexGenfv_Reply }, + { 134, glxGetTexGeniv_Reply }, + { 135, glxGetTexImage_Reply }, + { 136, glxGetTexParameterfv_Reply }, + { 137, glxGetTexParameteriv_Reply }, + { 138, glxGetTexLevelParameterfv_Reply }, + { 139, glxGetTexLevelParameteriv_Reply }, + { 141, glxIsList_Reply }, + { 143, glxAreTexturesResident_Reply }, + { 145, glxGenTextures_Reply }, + { 146, glxIsTexture_Reply }, + { 147, glxGetColorTable_Reply }, + { 148, glxGetColorTableParameterfv_Reply }, + { 149, glxGetColorTableParameteriv_Reply }, + { 150, glxGetConvolutionFilter_Reply }, + { 151, glxGetConvolutionParameterfv_Reply }, + { 152, glxGetConvolutionParameteriv_Reply }, + { 153, glxGetSeparableFilter_Reply }, + { 154, glxGetHistogram_Reply }, + { 155, glxGetHistogramParameterfv_Reply }, + { 156, glxGetHistogramParameteriv_Reply }, + { 157, glxGetMinmax_Reply }, + { 158, glxGetMinmaxParameterfv_Reply }, + { 159, glxGetMinmaxParameteriv_Reply }, + { 160, glxGetCompressedTexImageARB_Reply }, + { 162, glxGenQueriesARB_Reply }, + { 163, glxIsQueryARB_Reply }, + { 164, glxGetQueryivARB_Reply }, + { 165, glxGetQueryObjectivARB_Reply }, + { 166, glxGetQueryObjectuivARB_Reply }, + { 0, NULL } +}; + +static void dispatch_glx(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(glx_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, glx_extension_minor, + "")); + switch (minor) { + case 1: + glxRender(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + glxRenderLarge(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + glxCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + glxDestroyContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + glxMakeCurrent(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + glxIsDirect(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + glxQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + glxWaitGL(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + glxWaitX(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + glxCopyContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + glxSwapBuffers(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + glxUseXFont(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + glxCreateGLXPixmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + glxGetVisualConfigs(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + glxDestroyGLXPixmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + glxVendorPrivate(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + glxVendorPrivateWithReply(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + glxQueryExtensionsString(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + glxQueryServerString(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + glxClientInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 21: + glxGetFBConfigs(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + glxCreatePixmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 23: + glxDestroyPixmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 24: + glxCreateNewContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 25: + glxQueryContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 26: + glxMakeContextCurrent(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 27: + glxCreatePbuffer(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 28: + glxDestroyPbuffer(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 29: + glxGetDrawableAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 30: + glxChangeDrawableAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 31: + glxCreateWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 32: + glxDeleteWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 101: + glxNewList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 102: + glxEndList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 103: + glxDeleteLists(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 104: + glxGenLists(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 105: + glxFeedbackBuffer(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 106: + glxSelectBuffer(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 107: + glxRenderMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 108: + glxFinish(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 109: + glxPixelStoref(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 110: + glxPixelStorei(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 111: + glxReadPixels(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 112: + glxGetBooleanv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 113: + glxGetClipPlane(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 114: + glxGetDoublev(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 115: + glxGetError(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 116: + glxGetFloatv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 117: + glxGetIntegerv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 118: + glxGetLightfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 119: + glxGetLightiv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 120: + glxGetMapdv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 121: + glxGetMapfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 122: + glxGetMapiv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 123: + glxGetMaterialfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 124: + glxGetMaterialiv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 125: + glxGetPixelMapfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 126: + glxGetPixelMapuiv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 127: + glxGetPixelMapusv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 128: + glxGetPolygonStipple(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 129: + glxGetString(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 130: + glxGetTexEnvfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 131: + glxGetTexEnviv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 132: + glxGetTexGendv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 133: + glxGetTexGenfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 134: + glxGetTexGeniv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 135: + glxGetTexImage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 136: + glxGetTexParameterfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 137: + glxGetTexParameteriv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 138: + glxGetTexLevelParameterfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 139: + glxGetTexLevelParameteriv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 141: + glxIsList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 142: + glxFlush(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 143: + glxAreTexturesResident(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 144: + glxDeleteTextures(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 145: + glxGenTextures(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 146: + glxIsTexture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 147: + glxGetColorTable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 148: + glxGetColorTableParameterfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 149: + glxGetColorTableParameteriv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 150: + glxGetConvolutionFilter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 151: + glxGetConvolutionParameterfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 152: + glxGetConvolutionParameteriv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 153: + glxGetSeparableFilter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 154: + glxGetHistogram(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 155: + glxGetHistogramParameterfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 156: + glxGetHistogramParameteriv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 157: + glxGetMinmax(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 158: + glxGetMinmaxParameterfv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 159: + glxGetMinmaxParameteriv(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 160: + glxGetCompressedTexImageARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 161: + glxDeleteQueriesARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 162: + glxGenQueriesARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 163: + glxIsQueryARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 164: + glxGetQueryivARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 165: + glxGetQueryObjectivARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 166: + glxGetQueryObjectuivARB(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_glx(void) +{ + set_handler("GLX", dispatch_glx, glx_errors, glx_events, glx_replies); +} + +static void struct_ScreenSize(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_width; + int f_height; + int f_mwidth; + int f_mheight; + + item = proto_tree_add_item(root, hf_x11_struct_ScreenSize, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenSize_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenSize_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mwidth = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenSize_mwidth, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mheight = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenSize_mheight, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static int struct_size_RefreshRates(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_nRates; + f_nRates = VALUE16(tvb, *offsetp + size + 0); + size += f_nRates * 2; + return size + 2; +} + +static void struct_RefreshRates(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_nRates; + + item = proto_tree_add_item(root, hf_x11_struct_RefreshRates, tvb, *offsetp, struct_size_RefreshRates(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_nRates = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_RefreshRates_nRates, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfCard16(tvb, offsetp, t, hf_x11_struct_RefreshRates_rates, hf_x11_struct_RefreshRates_rates_item, f_nRates, little_endian); + } +} + +static void randrQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major_version; + int f_minor_version; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryVersion_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryVersion_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryVersion_reply_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryVersion_reply_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void randrSetScreenConfig(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_timestamp; + int f_config_timestamp; + int f_sizeID; + int f_rotation; + int f_rate; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_sizeID = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_sizeID, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_rotation = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_rotation, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_rate = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_rate, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void randrSetScreenConfig_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_new_timestamp; + int f_config_timestamp; + int f_root; + int f_subpixel_order; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetScreenConfig"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-SetScreenConfig)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_new_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_reply_new_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_reply_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_reply_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_subpixel_order = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenConfig_reply_subpixel_order, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(10); +} + +static void randrSelectInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_enable; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SelectInput_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_enable = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SelectInput_enable, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} + +static void randrGetScreenInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetScreenInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_rotations; + int f_root; + int f_timestamp; + int f_config_timestamp; + int f_nSizes; + int f_sizeID; + int f_rotation; + int f_rate; + int f_nInfo; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetScreenInfo"); + + REPLY(reply); + f_rotations = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_rotations, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetScreenInfo)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_nSizes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_nSizes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_sizeID = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_sizeID, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_rotation = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_rotation, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_rate = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_rate, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_nInfo = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenInfo_reply_nInfo, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + struct_ScreenSize(tvb, offsetp, t, little_endian, f_nSizes); + struct_RefreshRates(tvb, offsetp, t, little_endian, (f_nInfo - f_nSizes)); +} + +static void randrGetScreenSizeRange(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenSizeRange_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetScreenSizeRange_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_min_width; + int f_min_height; + int f_max_width; + int f_max_height; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetScreenSizeRange"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetScreenSizeRange)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_min_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenSizeRange_reply_min_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_min_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenSizeRange_reply_min_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_max_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenSizeRange_reply_max_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_max_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenSizeRange_reply_max_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(16); +} + +static void randrSetScreenSize(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_width; + int f_height; + int f_mm_width; + int f_mm_height; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenSize_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenSize_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenSize_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mm_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenSize_mm_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mm_height = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetScreenSize_mm_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void struct_ModeInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_id; + int f_width; + int f_height; + int f_dot_clock; + int f_hsync_start; + int f_hsync_end; + int f_htotal; + int f_hskew; + int f_vsync_start; + int f_vsync_end; + int f_vtotal; + int f_name_len; + int f_mode_flags; + + item = proto_tree_add_item(root, hf_x11_struct_ModeInfo, tvb, *offsetp, 32, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dot_clock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_dot_clock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hsync_start = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_hsync_start, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsync_end = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_hsync_end, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsync_start = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_vsync_start, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsync_end = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_vsync_end, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_name_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_name_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mode_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ModeInfo_mode_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void randrGetScreenResources(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetScreenResources_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_timestamp; + int f_config_timestamp; + int f_num_crtcs; + int f_num_outputs; + int f_num_modes; + int f_names_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetScreenResources"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetScreenResources)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_reply_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_crtcs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_reply_num_crtcs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_outputs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_reply_num_outputs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_modes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_reply_num_modes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_names_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResources_reply_names_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(8); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetScreenResources_reply_crtcs, hf_x11_randr_GetScreenResources_reply_crtcs_item, f_num_crtcs, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetScreenResources_reply_outputs, hf_x11_randr_GetScreenResources_reply_outputs_item, f_num_outputs, little_endian); + struct_ModeInfo(tvb, offsetp, t, little_endian, f_num_modes); + listOfByte(tvb, offsetp, t, hf_x11_randr_GetScreenResources_reply_names, f_names_len, little_endian); +} + +static void randrGetOutputInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_config_timestamp; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetOutputInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_timestamp; + int f_crtc; + int f_mm_width; + int f_mm_height; + int f_connection; + int f_subpixel_order; + int f_num_crtcs; + int f_num_modes; + int f_num_preferred; + int f_num_clones; + int f_name_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetOutputInfo"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetOutputInfo)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mm_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_mm_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mm_height = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_mm_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_connection = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_connection, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_subpixel_order = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_subpixel_order, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_crtcs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_num_crtcs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_modes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_num_modes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_preferred = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_num_preferred, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_clones = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_num_clones, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_name_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputInfo_reply_name_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetOutputInfo_reply_crtcs, hf_x11_randr_GetOutputInfo_reply_crtcs_item, f_num_crtcs, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetOutputInfo_reply_modes, hf_x11_randr_GetOutputInfo_reply_modes_item, f_num_modes, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetOutputInfo_reply_clones, hf_x11_randr_GetOutputInfo_reply_clones_item, f_num_clones, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_randr_GetOutputInfo_reply_name, f_name_len, little_endian); +} + +static void randrListOutputProperties(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ListOutputProperties_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrListOutputProperties_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_atoms; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListOutputProperties"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-ListOutputProperties)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_atoms = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ListOutputProperties_reply_num_atoms, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); + listOfCard32(tvb, offsetp, t, hf_x11_randr_ListOutputProperties_reply_atoms, hf_x11_randr_ListOutputProperties_reply_atoms_item, f_num_atoms, little_endian); +} + +static void randrQueryOutputProperty(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_property; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryOutputProperty_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryOutputProperty_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrQueryOutputProperty_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_pending; + int f_range; + int f_immutable; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryOutputProperty"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-QueryOutputProperty)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pending = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryOutputProperty_reply_pending, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_range = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryOutputProperty_reply_range, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_immutable = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_QueryOutputProperty_reply_immutable, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(21); + listOfInt32(tvb, offsetp, t, hf_x11_randr_QueryOutputProperty_reply_validValues, hf_x11_randr_QueryOutputProperty_reply_validValues_item, f_length, little_endian); +} + +static void randrConfigureOutputProperty(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_property; + int f_pending; + int f_range; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ConfigureOutputProperty_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ConfigureOutputProperty_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pending = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ConfigureOutputProperty_pending, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_range = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ConfigureOutputProperty_range, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfInt32(tvb, offsetp, t, hf_x11_randr_ConfigureOutputProperty_values, hf_x11_randr_ConfigureOutputProperty_values_item, (length - 16) / 4, little_endian); +} + +static void randrChangeOutputProperty(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_property; + int f_type; + int f_format; + int f_mode; + int f_num_units; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ChangeOutputProperty_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ChangeOutputProperty_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ChangeOutputProperty_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ChangeOutputProperty_format, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ChangeOutputProperty_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + f_num_units = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ChangeOutputProperty_num_units, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_randr_ChangeOutputProperty_data, ((f_num_units * f_format) / 8), little_endian); + length -= ((f_num_units * f_format) / 8) * 1; +} + +static void randrDeleteOutputProperty(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_property; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_DeleteOutputProperty_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_DeleteOutputProperty_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrGetOutputProperty(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_property; + int f_type; + int f_long_offset; + int f_long_length; + int f_delete; + int f_pending; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_long_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_long_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_long_length = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_long_length, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_delete = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_delete, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_pending = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_pending, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); +} +static void randrGetOutputProperty_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_format; + int f_type; + int f_bytes_after; + int f_num_items; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetOutputProperty"); + + REPLY(reply); + f_format = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_reply_format, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetOutputProperty)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_reply_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bytes_after = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_reply_bytes_after, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_items = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputProperty_reply_num_items, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_randr_GetOutputProperty_reply_data, (f_num_items * (f_format / 8)), little_endian); +} + +static void randrCreateMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_CreateMode_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_ModeInfo(tvb, offsetp, t, little_endian, 1); + listOfByte(tvb, offsetp, t, hf_x11_randr_CreateMode_name, (length - 40) / 1, little_endian); +} +static void randrCreateMode_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_mode; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CreateMode"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-CreateMode)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_CreateMode_reply_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void randrDestroyMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_mode; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_DestroyMode_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrAddOutputMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_mode; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_AddOutputMode_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_AddOutputMode_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrDeleteOutputMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output; + int f_mode; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_DeleteOutputMode_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_DeleteOutputMode_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrGetCrtcInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + int f_config_timestamp; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetCrtcInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_timestamp; + int f_x; + int f_y; + int f_width; + int f_height; + int f_mode; + int f_rotation; + int f_rotations; + int f_num_outputs; + int f_num_possible_outputs; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCrtcInfo"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetCrtcInfo)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_rotation = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_rotation, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_rotations = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_rotations, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_outputs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_num_outputs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_possible_outputs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcInfo_reply_num_possible_outputs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetCrtcInfo_reply_outputs, hf_x11_randr_GetCrtcInfo_reply_outputs_item, f_num_outputs, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetCrtcInfo_reply_possible, hf_x11_randr_GetCrtcInfo_reply_possible_item, f_num_possible_outputs, little_endian); +} + +static void randrSetCrtcConfig(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + int f_timestamp; + int f_config_timestamp; + int f_x; + int f_y; + int f_mode; + int f_rotation; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_rotation = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_rotation, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfCard32(tvb, offsetp, t, hf_x11_randr_SetCrtcConfig_outputs, hf_x11_randr_SetCrtcConfig_outputs_item, (length - 28) / 4, little_endian); +} +static void randrSetCrtcConfig_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_timestamp; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetCrtcConfig"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-SetCrtcConfig)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcConfig_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void randrGetCrtcGammaSize(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcGammaSize_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetCrtcGammaSize_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCrtcGammaSize"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetCrtcGammaSize)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcGammaSize_reply_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); +} + +static void randrGetCrtcGamma(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcGamma_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetCrtcGamma_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCrtcGamma"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetCrtcGamma)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcGamma_reply_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); + listOfCard16(tvb, offsetp, t, hf_x11_randr_GetCrtcGamma_reply_red, hf_x11_randr_GetCrtcGamma_reply_red_item, f_size, little_endian); + listOfCard16(tvb, offsetp, t, hf_x11_randr_GetCrtcGamma_reply_green, hf_x11_randr_GetCrtcGamma_reply_green_item, f_size, little_endian); + listOfCard16(tvb, offsetp, t, hf_x11_randr_GetCrtcGamma_reply_blue, hf_x11_randr_GetCrtcGamma_reply_blue_item, f_size, little_endian); +} + +static void randrSetCrtcGamma(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + int f_size; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcGamma_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcGamma_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfCard16(tvb, offsetp, t, hf_x11_randr_SetCrtcGamma_red, hf_x11_randr_SetCrtcGamma_red_item, f_size, little_endian); + length -= f_size * 2; + listOfCard16(tvb, offsetp, t, hf_x11_randr_SetCrtcGamma_green, hf_x11_randr_SetCrtcGamma_green_item, f_size, little_endian); + length -= f_size * 2; + listOfCard16(tvb, offsetp, t, hf_x11_randr_SetCrtcGamma_blue, hf_x11_randr_SetCrtcGamma_blue_item, f_size, little_endian); + length -= f_size * 2; +} + +static void randrGetScreenResourcesCurrent(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetScreenResourcesCurrent_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_timestamp; + int f_config_timestamp; + int f_num_crtcs; + int f_num_outputs; + int f_num_modes; + int f_names_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetScreenResourcesCurrent"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetScreenResourcesCurrent)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_reply_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_crtcs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_reply_num_crtcs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_outputs = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_reply_num_outputs, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_modes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_reply_num_modes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_names_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetScreenResourcesCurrent_reply_names_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(8); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs, hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs_item, f_num_crtcs, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_randr_GetScreenResourcesCurrent_reply_outputs, hf_x11_randr_GetScreenResourcesCurrent_reply_outputs_item, f_num_outputs, little_endian); + struct_ModeInfo(tvb, offsetp, t, little_endian, f_num_modes); + listOfByte(tvb, offsetp, t, hf_x11_randr_GetScreenResourcesCurrent_reply_names, f_names_len, little_endian); +} + +static void randrSetCrtcTransform(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + int f_filter_len; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcTransform_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_TRANSFORM(tvb, offsetp, t, little_endian, 1); + f_filter_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetCrtcTransform_filter_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_randr_SetCrtcTransform_filter_name, f_filter_len, little_endian); + length -= f_filter_len * 1; + listOfInt32(tvb, offsetp, t, hf_x11_randr_SetCrtcTransform_filter_params, hf_x11_randr_SetCrtcTransform_filter_params_item, (length - 48) / 4, little_endian); +} + +static void randrGetCrtcTransform(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcTransform_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetCrtcTransform_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_has_transforms; + int f_pending_len; + int f_pending_nparams; + int f_current_len; + int f_current_nparams; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCrtcTransform"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetCrtcTransform)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_TRANSFORM(tvb, offsetp, t, little_endian, 1); + f_has_transforms = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcTransform_reply_has_transforms, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + struct_TRANSFORM(tvb, offsetp, t, little_endian, 1); + UNUSED(4); + f_pending_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcTransform_reply_pending_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_pending_nparams = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcTransform_reply_pending_nparams, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_current_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcTransform_reply_current_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_current_nparams = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetCrtcTransform_reply_current_nparams, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_randr_GetCrtcTransform_reply_pending_filter_name, f_pending_len, little_endian); + listOfInt32(tvb, offsetp, t, hf_x11_randr_GetCrtcTransform_reply_pending_params, hf_x11_randr_GetCrtcTransform_reply_pending_params_item, f_pending_nparams, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_randr_GetCrtcTransform_reply_current_filter_name, f_current_len, little_endian); + listOfInt32(tvb, offsetp, t, hf_x11_randr_GetCrtcTransform_reply_current_params, hf_x11_randr_GetCrtcTransform_reply_current_params_item, f_current_nparams, little_endian); +} + +static void randrGetPanning(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetPanning_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_timestamp; + int f_left; + int f_top; + int f_width; + int f_height; + int f_track_left; + int f_track_top; + int f_track_width; + int f_track_height; + int f_border_left; + int f_border_top; + int f_border_right; + int f_border_bottom; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPanning"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetPanning)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_track_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_track_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_track_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_track_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_border_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_border_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_right = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_border_right, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_bottom = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetPanning_reply_border_bottom, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void randrSetPanning(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_crtc; + int f_timestamp; + int f_left; + int f_top; + int f_width; + int f_height; + int f_track_left; + int f_track_top; + int f_track_width; + int f_track_height; + int f_border_left; + int f_border_top; + int f_border_right; + int f_border_bottom; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_track_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_track_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_track_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_track_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_track_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_border_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_border_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_right = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_border_right, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_bottom = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_border_bottom, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void randrSetPanning_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_timestamp; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetPanning"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-SetPanning)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetPanning_reply_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrSetOutputPrimary(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_output; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetOutputPrimary_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_SetOutputPrimary_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrGetOutputPrimary(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputPrimary_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void randrGetOutputPrimary_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_output; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetOutputPrimary"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (randr-GetOutputPrimary)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_GetOutputPrimary_reply_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void randrScreenChangeNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_rotation; + int f_timestamp; + int f_config_timestamp; + int f_root; + int f_request_window; + int f_sizeID; + int f_subpixel_order; + int f_width; + int f_height; + int f_mwidth; + int f_mheight; + f_rotation = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_rotation, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_request_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_request_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_sizeID = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_sizeID, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_subpixel_order = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_subpixel_order, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mwidth = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_mwidth, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mheight = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_ScreenChangeNotify_mheight, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void struct_CrtcChange(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_timestamp; + int f_window; + int f_crtc; + int f_mode; + int f_rotation; + int f_x; + int f_y; + int f_width; + int f_height; + + item = proto_tree_add_item(root, hf_x11_struct_CrtcChange, tvb, *offsetp, 28, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_rotation = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_rotation, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_CrtcChange_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void struct_OutputChange(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_timestamp; + int f_config_timestamp; + int f_window; + int f_output; + int f_crtc; + int f_mode; + int f_rotation; + int f_connection; + int f_subpixel_order; + + item = proto_tree_add_item(root, hf_x11_struct_OutputChange, tvb, *offsetp, 28, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_config_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_config_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_crtc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_crtc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_mode, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_rotation = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_rotation, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_connection = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_connection, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_subpixel_order = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputChange_subpixel_order, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + } +} + +static void struct_OutputProperty(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_window; + int f_output; + int f_atom; + int f_timestamp; + int f_status; + + item = proto_tree_add_item(root, hf_x11_struct_OutputProperty, tvb, *offsetp, 28, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputProperty_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_output = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputProperty_output, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_atom = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputProperty_atom, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputProperty_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_OutputProperty_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(11); + } +} + +static void struct_NotifyData(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + int base = *offsetp; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_union_NotifyData, tvb, base, 28, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + + *offsetp = base; + struct_CrtcChange(tvb, offsetp, t, little_endian, 1); + *offsetp = base; + struct_OutputChange(tvb, offsetp, t, little_endian, 1); + *offsetp = base; + struct_OutputProperty(tvb, offsetp, t, little_endian, 1); + base += 28; + } + *offsetp = base; +} + +static void randrNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_subCode; + f_subCode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_randr_Notify_subCode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + struct_NotifyData(tvb, offsetp, t, little_endian, 1); +} +static const value_string randr_extension_minor[] = { + { 0, "QueryVersion" }, + { 2, "SetScreenConfig" }, + { 4, "SelectInput" }, + { 5, "GetScreenInfo" }, + { 6, "GetScreenSizeRange" }, + { 7, "SetScreenSize" }, + { 8, "GetScreenResources" }, + { 9, "GetOutputInfo" }, + { 10, "ListOutputProperties" }, + { 11, "QueryOutputProperty" }, + { 12, "ConfigureOutputProperty" }, + { 13, "ChangeOutputProperty" }, + { 14, "DeleteOutputProperty" }, + { 15, "GetOutputProperty" }, + { 16, "CreateMode" }, + { 17, "DestroyMode" }, + { 18, "AddOutputMode" }, + { 19, "DeleteOutputMode" }, + { 20, "GetCrtcInfo" }, + { 21, "SetCrtcConfig" }, + { 22, "GetCrtcGammaSize" }, + { 23, "GetCrtcGamma" }, + { 24, "SetCrtcGamma" }, + { 25, "GetScreenResourcesCurrent" }, + { 26, "SetCrtcTransform" }, + { 27, "GetCrtcTransform" }, + { 28, "GetPanning" }, + { 29, "SetPanning" }, + { 30, "SetOutputPrimary" }, + { 31, "GetOutputPrimary" }, + { 0, NULL } +}; +const x11_event_info randr_events[] = { + { "randr-ScreenChangeNotify", randrScreenChangeNotify }, + { "randr-Notify", randrNotify }, + { NULL, NULL } +}; +static x11_reply_info randr_replies[] = { + { 0, randrQueryVersion_Reply }, + { 2, randrSetScreenConfig_Reply }, + { 5, randrGetScreenInfo_Reply }, + { 6, randrGetScreenSizeRange_Reply }, + { 8, randrGetScreenResources_Reply }, + { 9, randrGetOutputInfo_Reply }, + { 10, randrListOutputProperties_Reply }, + { 11, randrQueryOutputProperty_Reply }, + { 15, randrGetOutputProperty_Reply }, + { 16, randrCreateMode_Reply }, + { 20, randrGetCrtcInfo_Reply }, + { 21, randrSetCrtcConfig_Reply }, + { 22, randrGetCrtcGammaSize_Reply }, + { 23, randrGetCrtcGamma_Reply }, + { 25, randrGetScreenResourcesCurrent_Reply }, + { 27, randrGetCrtcTransform_Reply }, + { 28, randrGetPanning_Reply }, + { 29, randrSetPanning_Reply }, + { 31, randrGetOutputPrimary_Reply }, + { 0, NULL } +}; + +static void dispatch_randr(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(randr_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, randr_extension_minor, + "")); + switch (minor) { + case 0: + randrQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + randrSetScreenConfig(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + randrSelectInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + randrGetScreenInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + randrGetScreenSizeRange(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + randrSetScreenSize(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + randrGetScreenResources(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + randrGetOutputInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + randrListOutputProperties(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + randrQueryOutputProperty(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + randrConfigureOutputProperty(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + randrChangeOutputProperty(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + randrDeleteOutputProperty(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + randrGetOutputProperty(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + randrCreateMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + randrDestroyMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + randrAddOutputMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + randrDeleteOutputMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + randrGetCrtcInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 21: + randrSetCrtcConfig(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + randrGetCrtcGammaSize(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 23: + randrGetCrtcGamma(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 24: + randrSetCrtcGamma(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 25: + randrGetScreenResourcesCurrent(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 26: + randrSetCrtcTransform(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 27: + randrGetCrtcTransform(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 28: + randrGetPanning(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 29: + randrSetPanning(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 30: + randrSetOutputPrimary(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 31: + randrGetOutputPrimary(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_randr(void) +{ + set_handler("RANDR", dispatch_randr, randr_errors, randr_events, randr_replies); +} + +static void struct_Range8(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_first; + int f_last; + + item = proto_tree_add_item(root, hf_x11_struct_Range8, tvb, *offsetp, 2, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_first = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Range8_first, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_last = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Range8_last, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + } +} + +static void struct_Range16(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_first; + int f_last; + + item = proto_tree_add_item(root, hf_x11_struct_Range16, tvb, *offsetp, 4, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_first = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Range16_first, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_last = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Range16_last, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void struct_ExtRange(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_struct_ExtRange, tvb, *offsetp, 6, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + struct_Range8(tvb, offsetp, t, little_endian, 1); + struct_Range16(tvb, offsetp, t, little_endian, 1); + } +} + +static void struct_Range(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_client_started; + int f_client_died; + + item = proto_tree_add_item(root, hf_x11_struct_Range, tvb, *offsetp, 24, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + struct_Range8(tvb, offsetp, t, little_endian, 1); + struct_Range8(tvb, offsetp, t, little_endian, 1); + struct_ExtRange(tvb, offsetp, t, little_endian, 1); + struct_ExtRange(tvb, offsetp, t, little_endian, 1); + struct_Range8(tvb, offsetp, t, little_endian, 1); + struct_Range8(tvb, offsetp, t, little_endian, 1); + struct_Range8(tvb, offsetp, t, little_endian, 1); + f_client_started = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Range_client_started, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_client_died = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Range_client_died, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + } +} + +static int struct_size_ClientInfo(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_num_ranges; + f_num_ranges = VALUE32(tvb, *offsetp + size + 4); + size += f_num_ranges * 24; + return size + 8; +} + +static void struct_ClientInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_client_resource; + int f_num_ranges; + + item = proto_tree_add_item(root, hf_x11_struct_ClientInfo, tvb, *offsetp, struct_size_ClientInfo(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_client_resource = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ClientInfo_client_resource, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_ranges = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ClientInfo_num_ranges, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_Range(tvb, offsetp, t, little_endian, f_num_ranges); + } +} + +static void recordQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major_version; + int f_minor_version; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_QueryVersion_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_QueryVersion_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void recordQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (record-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_QueryVersion_reply_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_QueryVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void recordCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_element_header; + int f_num_client_specs; + int f_num_ranges; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_CreateContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_element_header = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_CreateContext_element_header, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_num_client_specs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_CreateContext_num_client_specs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_ranges = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_CreateContext_num_ranges, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_record_CreateContext_client_specs, hf_x11_record_CreateContext_client_specs_item, f_num_client_specs, little_endian); + length -= f_num_client_specs * 4; + struct_Range(tvb, offsetp, t, little_endian, f_num_ranges); + length -= f_num_ranges * 24; +} + +static void recordRegisterClients(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_element_header; + int f_num_client_specs; + int f_num_ranges; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_RegisterClients_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_element_header = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_RegisterClients_element_header, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_num_client_specs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_RegisterClients_num_client_specs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_ranges = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_RegisterClients_num_ranges, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_record_RegisterClients_client_specs, hf_x11_record_RegisterClients_client_specs_item, f_num_client_specs, little_endian); + length -= f_num_client_specs * 4; + struct_Range(tvb, offsetp, t, little_endian, f_num_ranges); + length -= f_num_ranges * 24; +} + +static void recordUnregisterClients(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_num_client_specs; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_UnregisterClients_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_client_specs = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_UnregisterClients_num_client_specs, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_record_UnregisterClients_client_specs, hf_x11_record_UnregisterClients_client_specs_item, f_num_client_specs, little_endian); + length -= f_num_client_specs * 4; +} + +static void recordGetContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_GetContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void recordGetContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_enabled; + int f_element_header; + int f_num_intercepted_clients; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetContext"); + + REPLY(reply); + f_enabled = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_GetContext_reply_enabled, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (record-GetContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_element_header = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_GetContext_reply_element_header, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_num_intercepted_clients = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_GetContext_reply_num_intercepted_clients, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + struct_ClientInfo(tvb, offsetp, t, little_endian, f_num_intercepted_clients); +} + +static void recordEnableContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void recordEnableContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_category; + int f_element_header; + int f_client_swapped; + int f_xid_base; + int f_server_time; + int f_rec_sequence_num; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-EnableContext"); + + REPLY(reply); + f_category = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_reply_category, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (record-EnableContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_element_header = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_reply_element_header, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_client_swapped = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_reply_client_swapped, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + f_xid_base = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_reply_xid_base, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_reply_server_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_rec_sequence_num = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_EnableContext_reply_rec_sequence_num, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + listOfByte(tvb, offsetp, t, hf_x11_record_EnableContext_reply_data, (f_length * 4), little_endian); +} + +static void recordDisableContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_DisableContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void recordFreeContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_record_FreeContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string record_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "CreateContext" }, + { 2, "RegisterClients" }, + { 3, "UnregisterClients" }, + { 4, "GetContext" }, + { 5, "EnableContext" }, + { 6, "DisableContext" }, + { 7, "FreeContext" }, + { 0, NULL } +}; +const x11_event_info record_events[] = { + { NULL, NULL } +}; +static x11_reply_info record_replies[] = { + { 0, recordQueryVersion_Reply }, + { 4, recordGetContext_Reply }, + { 5, recordEnableContext_Reply }, + { 0, NULL } +}; + +static void dispatch_record(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(record_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, record_extension_minor, + "")); + switch (minor) { + case 0: + recordQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + recordCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + recordRegisterClients(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + recordUnregisterClients(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + recordGetContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + recordEnableContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + recordDisableContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + recordFreeContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_record(void) +{ + set_handler("RECORD", dispatch_record, record_errors, record_events, record_replies); +} + +static void renderQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryVersion_client_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryVersion_client_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void renderQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (render-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryVersion_reply_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryVersion_reply_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void renderQueryPictFormats(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void renderQueryPictFormats_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_formats; + int f_num_screens; + int f_num_depths; + int f_num_visuals; + int f_num_subpixel; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryPictFormats"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (render-QueryPictFormats)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_formats = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictFormats_reply_num_formats, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_screens = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictFormats_reply_num_screens, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_depths = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictFormats_reply_num_depths, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_visuals = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictFormats_reply_num_visuals, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_subpixel = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictFormats_reply_num_subpixel, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + struct_PICTFORMINFO(tvb, offsetp, t, little_endian, f_num_formats); + struct_PICTSCREEN(tvb, offsetp, t, little_endian, f_num_screens); + listOfCard32(tvb, offsetp, t, hf_x11_render_QueryPictFormats_reply_subpixels, hf_x11_render_QueryPictFormats_reply_subpixels_item, f_num_subpixel, little_endian); +} + +static void renderQueryPictIndexValues(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_format; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictIndexValues_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void renderQueryPictIndexValues_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_values; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryPictIndexValues"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (render-QueryPictIndexValues)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_values = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryPictIndexValues_reply_num_values, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_INDEXVALUE(tvb, offsetp, t, little_endian, f_num_values); +} + +static void renderCreatePicture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_pid; + int f_drawable; + int f_format; + f_pid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreatePicture_pid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreatePicture_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreatePicture_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void renderChangePicture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_ChangePicture_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void renderSetPictureClipRectangles(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_clip_x_origin; + int f_clip_y_origin; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_SetPictureClipRectangles_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_clip_x_origin = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_SetPictureClipRectangles_clip_x_origin, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_clip_y_origin = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_SetPictureClipRectangles_clip_y_origin, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_RECTANGLE(tvb, offsetp, t, little_endian, (length - 12) / 8); +} + +static void renderFreePicture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_FreePicture_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void renderComposite(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_mask; + int f_dst; + int f_src_x; + int f_src_y; + int f_mask_x; + int f_mask_y; + int f_dst_x; + int f_dst_y; + int f_width; + int f_height; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mask_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_mask_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mask_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_mask_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dst_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_dst_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dst_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_dst_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Composite_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void renderTrapezoids(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Trapezoids_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Trapezoids_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Trapezoids_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Trapezoids_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Trapezoids_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Trapezoids_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_TRAPEZOID(tvb, offsetp, t, little_endian, (length - 24) / 40); +} + +static void renderTriangles(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Triangles_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Triangles_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Triangles_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Triangles_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Triangles_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_Triangles_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_TRIANGLE(tvb, offsetp, t, little_endian, (length - 24) / 24); +} + +static void renderTriStrip(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriStrip_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriStrip_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriStrip_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriStrip_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriStrip_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriStrip_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_POINTFIX(tvb, offsetp, t, little_endian, (length - 24) / 8); +} + +static void renderTriFan(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriFan_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriFan_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriFan_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriFan_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriFan_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_TriFan_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_POINTFIX(tvb, offsetp, t, little_endian, (length - 24) / 8); +} + +static void renderCreateGlyphSet(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_gsid; + int f_format; + f_gsid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateGlyphSet_gsid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateGlyphSet_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void renderReferenceGlyphSet(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_gsid; + int f_existing; + f_gsid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_ReferenceGlyphSet_gsid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_existing = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_ReferenceGlyphSet_existing, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void renderFreeGlyphSet(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_glyphset; + f_glyphset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_FreeGlyphSet_glyphset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void renderAddGlyphs(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_glyphset; + int f_glyphs_len; + f_glyphset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_AddGlyphs_glyphset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glyphs_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_AddGlyphs_glyphs_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_render_AddGlyphs_glyphids, hf_x11_render_AddGlyphs_glyphids_item, f_glyphs_len, little_endian); + length -= f_glyphs_len * 4; + struct_GLYPHINFO(tvb, offsetp, t, little_endian, f_glyphs_len); + length -= f_glyphs_len * 12; + listOfByte(tvb, offsetp, t, hf_x11_render_AddGlyphs_data, (length - 12) / 1, little_endian); +} + +static void renderFreeGlyphs(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_glyphset; + f_glyphset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_FreeGlyphs_glyphset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_render_FreeGlyphs_glyphs, hf_x11_render_FreeGlyphs_glyphs_item, (length - 8) / 4, little_endian); +} + +static void renderCompositeGlyphs8(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_glyphset; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glyphset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_glyphset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs8_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_render_CompositeGlyphs8_glyphcmds, (length - 28) / 1, little_endian); +} + +static void renderCompositeGlyphs16(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_glyphset; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glyphset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_glyphset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs16_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_render_CompositeGlyphs16_glyphcmds, (length - 28) / 1, little_endian); +} + +static void renderCompositeGlyphs32(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_src; + int f_dst; + int f_mask_format; + int f_glyphset; + int f_src_x; + int f_src_y; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mask_format = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_mask_format, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_glyphset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_glyphset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CompositeGlyphs32_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_render_CompositeGlyphs32_glyphcmds, (length - 28) / 1, little_endian); +} + +static void renderFillRectangles(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_op; + int f_dst; + f_op = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_FillRectangles_op, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_dst = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_FillRectangles_dst, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_COLOR(tvb, offsetp, t, little_endian, 1); + struct_RECTANGLE(tvb, offsetp, t, little_endian, (length - 20) / 8); +} + +static void renderCreateCursor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cid; + int f_source; + int f_x; + int f_y; + f_cid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateCursor_cid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_source = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateCursor_source, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateCursor_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateCursor_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void renderSetPictureTransform(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_SetPictureTransform_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_TRANSFORM(tvb, offsetp, t, little_endian, 1); +} + +static void renderQueryFilters(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryFilters_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void renderQueryFilters_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_aliases; + int f_num_filters; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryFilters"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (render-QueryFilters)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_aliases = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryFilters_reply_num_aliases, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_filters = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_QueryFilters_reply_num_filters, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + listOfCard16(tvb, offsetp, t, hf_x11_render_QueryFilters_reply_aliases, hf_x11_render_QueryFilters_reply_aliases_item, f_num_aliases, little_endian); + struct_STR(tvb, offsetp, t, little_endian, f_num_filters); +} + +static void renderSetPictureFilter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_filter_len; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_SetPictureFilter_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_filter_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_SetPictureFilter_filter_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_render_SetPictureFilter_filter, f_filter_len, little_endian); + length -= f_filter_len * 1; + listOfInt32(tvb, offsetp, t, hf_x11_render_SetPictureFilter_values, hf_x11_render_SetPictureFilter_values_item, (length - 12) / 4, little_endian); +} + +static void renderCreateAnimCursor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cid; + f_cid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateAnimCursor_cid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_ANIMCURSORELT(tvb, offsetp, t, little_endian, (length - 8) / 8); +} + +static void renderAddTraps(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_x_off; + int f_y_off; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_AddTraps_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_off = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_AddTraps_x_off, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_off = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_AddTraps_y_off, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_TRAP(tvb, offsetp, t, little_endian, (length - 12) / 24); +} + +static void renderCreateSolidFill(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateSolidFill_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_COLOR(tvb, offsetp, t, little_endian, 1); +} + +static void renderCreateLinearGradient(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_num_stops; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateLinearGradient_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + f_num_stops = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateLinearGradient_num_stops, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_render_CreateLinearGradient_stops, hf_x11_render_CreateLinearGradient_stops_item, f_num_stops, little_endian); + length -= f_num_stops * 4; + struct_COLOR(tvb, offsetp, t, little_endian, f_num_stops); + length -= f_num_stops * 8; +} + +static void renderCreateRadialGradient(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_inner_radius; + int f_outer_radius; + int f_num_stops; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateRadialGradient_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + f_inner_radius = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateRadialGradient_inner_radius, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_outer_radius = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateRadialGradient_outer_radius, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_stops = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateRadialGradient_num_stops, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_render_CreateRadialGradient_stops, hf_x11_render_CreateRadialGradient_stops_item, f_num_stops, little_endian); + length -= f_num_stops * 4; + struct_COLOR(tvb, offsetp, t, little_endian, f_num_stops); + length -= f_num_stops * 8; +} + +static void renderCreateConicalGradient(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_angle; + int f_num_stops; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateConicalGradient_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_POINTFIX(tvb, offsetp, t, little_endian, 1); + f_angle = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateConicalGradient_angle, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_stops = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_render_CreateConicalGradient_num_stops, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfInt32(tvb, offsetp, t, hf_x11_render_CreateConicalGradient_stops, hf_x11_render_CreateConicalGradient_stops_item, f_num_stops, little_endian); + length -= f_num_stops * 4; + struct_COLOR(tvb, offsetp, t, little_endian, f_num_stops); + length -= f_num_stops * 8; +} +static const value_string render_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "QueryPictFormats" }, + { 2, "QueryPictIndexValues" }, + { 4, "CreatePicture" }, + { 5, "ChangePicture" }, + { 6, "SetPictureClipRectangles" }, + { 7, "FreePicture" }, + { 8, "Composite" }, + { 10, "Trapezoids" }, + { 11, "Triangles" }, + { 12, "TriStrip" }, + { 13, "TriFan" }, + { 17, "CreateGlyphSet" }, + { 18, "ReferenceGlyphSet" }, + { 19, "FreeGlyphSet" }, + { 20, "AddGlyphs" }, + { 22, "FreeGlyphs" }, + { 23, "CompositeGlyphs8" }, + { 24, "CompositeGlyphs16" }, + { 25, "CompositeGlyphs32" }, + { 26, "FillRectangles" }, + { 27, "CreateCursor" }, + { 28, "SetPictureTransform" }, + { 29, "QueryFilters" }, + { 30, "SetPictureFilter" }, + { 31, "CreateAnimCursor" }, + { 32, "AddTraps" }, + { 33, "CreateSolidFill" }, + { 34, "CreateLinearGradient" }, + { 35, "CreateRadialGradient" }, + { 36, "CreateConicalGradient" }, + { 0, NULL } +}; +const x11_event_info render_events[] = { + { NULL, NULL } +}; +static x11_reply_info render_replies[] = { + { 0, renderQueryVersion_Reply }, + { 1, renderQueryPictFormats_Reply }, + { 2, renderQueryPictIndexValues_Reply }, + { 29, renderQueryFilters_Reply }, + { 0, NULL } +}; + +static void dispatch_render(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(render_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, render_extension_minor, + "")); + switch (minor) { + case 0: + renderQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + renderQueryPictFormats(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + renderQueryPictIndexValues(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + renderCreatePicture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + renderChangePicture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + renderSetPictureClipRectangles(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + renderFreePicture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + renderComposite(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + renderTrapezoids(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + renderTriangles(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + renderTriStrip(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + renderTriFan(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + renderCreateGlyphSet(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + renderReferenceGlyphSet(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + renderFreeGlyphSet(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + renderAddGlyphs(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + renderFreeGlyphs(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 23: + renderCompositeGlyphs8(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 24: + renderCompositeGlyphs16(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 25: + renderCompositeGlyphs32(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 26: + renderFillRectangles(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 27: + renderCreateCursor(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 28: + renderSetPictureTransform(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 29: + renderQueryFilters(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 30: + renderSetPictureFilter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 31: + renderCreateAnimCursor(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 32: + renderAddTraps(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 33: + renderCreateSolidFill(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 34: + renderCreateLinearGradient(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 35: + renderCreateRadialGradient(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 36: + renderCreateConicalGradient(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_render(void) +{ + set_handler("RENDER", dispatch_render, render_errors, render_events, render_replies); +} + +static void struct_Client(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_resource_base; + int f_resource_mask; + + item = proto_tree_add_item(root, hf_x11_struct_Client, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_resource_base = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Client_resource_base, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_resource_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Client_resource_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_Type(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_resource_type; + int f_count; + + item = proto_tree_add_item(root, hf_x11_struct_Type, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_resource_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Type_resource_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_count = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Type_count, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void resQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major; + int f_client_minor; + f_client_major = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryVersion_client_major, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_client_minor = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryVersion_client_minor, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void resQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major; + int f_server_minor; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (res-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryVersion_reply_server_major, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryVersion_reply_server_minor, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void resQueryClients(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void resQueryClients_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_clients; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryClients"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (res-QueryClients)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_clients = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryClients_reply_num_clients, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_Client(tvb, offsetp, t, little_endian, f_num_clients); +} + +static void resQueryClientResources(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_xid; + f_xid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryClientResources_xid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void resQueryClientResources_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_types; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryClientResources"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (res-QueryClientResources)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_types = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryClientResources_reply_num_types, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_Type(tvb, offsetp, t, little_endian, f_num_types); +} + +static void resQueryClientPixmapBytes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_xid; + f_xid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryClientPixmapBytes_xid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void resQueryClientPixmapBytes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_bytes; + int f_bytes_overflow; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryClientPixmapBytes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (res-QueryClientPixmapBytes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bytes = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryClientPixmapBytes_reply_bytes, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bytes_overflow = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_res_QueryClientPixmapBytes_reply_bytes_overflow, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string res_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "QueryClients" }, + { 2, "QueryClientResources" }, + { 3, "QueryClientPixmapBytes" }, + { 0, NULL } +}; +const x11_event_info res_events[] = { + { NULL, NULL } +}; +static x11_reply_info res_replies[] = { + { 0, resQueryVersion_Reply }, + { 1, resQueryClients_Reply }, + { 2, resQueryClientResources_Reply }, + { 3, resQueryClientPixmapBytes_Reply }, + { 0, NULL } +}; + +static void dispatch_res(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(res_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, res_extension_minor, + "")); + switch (minor) { + case 0: + resQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + resQueryClients(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + resQueryClientResources(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + resQueryClientPixmapBytes(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_res(void) +{ + set_handler("X-Resource", dispatch_res, res_errors, res_events, res_replies); +} + +static void screensaverQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryVersion_client_major_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_client_minor_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryVersion_client_minor_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); +} +static void screensaverQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major_version; + int f_server_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (screensaver-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryVersion_reply_server_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryVersion_reply_server_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(20); +} + +static void screensaverQueryInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void screensaverQueryInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_state; + int f_saver_window; + int f_ms_until_server; + int f_ms_since_user_input; + int f_event_mask; + int f_kind; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryInfo"); + + REPLY(reply); + f_state = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_reply_state, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (screensaver-QueryInfo)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_saver_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_reply_saver_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ms_until_server = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_reply_ms_until_server, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ms_since_user_input = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_reply_ms_since_user_input, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_event_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_reply_event_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_QueryInfo_reply_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(7); +} + +static void screensaverSelectInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_event_mask; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SelectInput_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_event_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SelectInput_event_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void screensaverSetAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_x; + int f_y; + int f_width; + int f_height; + int f_border_width; + int f_class; + int f_depth; + int f_visual; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_border_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_border_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_class = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_class, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_SetAttributes_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void screensaverUnsetAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_UnsetAttributes_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void screensaverSuspend(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_suspend; + f_suspend = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Suspend_suspend, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void screensaverNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_code; + int f_state; + int f_sequence_number; + int f_time; + int f_root; + int f_window; + int f_kind; + int f_forced; + f_code = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_code, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_state = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_state, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_sequence_number, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_forced = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_screensaver_Notify_forced, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(14); +} +static const value_string screensaver_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "QueryInfo" }, + { 2, "SelectInput" }, + { 3, "SetAttributes" }, + { 4, "UnsetAttributes" }, + { 5, "Suspend" }, + { 0, NULL } +}; +const x11_event_info screensaver_events[] = { + { "screensaver-Notify", screensaverNotify }, + { NULL, NULL } +}; +static x11_reply_info screensaver_replies[] = { + { 0, screensaverQueryVersion_Reply }, + { 1, screensaverQueryInfo_Reply }, + { 0, NULL } +}; + +static void dispatch_screensaver(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(screensaver_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, screensaver_extension_minor, + "")); + switch (minor) { + case 0: + screensaverQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + screensaverQueryInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + screensaverSelectInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + screensaverSetAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + screensaverUnsetAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + screensaverSuspend(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_screensaver(void) +{ + set_handler("MIT-SCREEN-SAVER", dispatch_screensaver, screensaver_errors, screensaver_events, screensaver_replies); +} + +static void shapeNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_shape_kind; + int f_affected_window; + int f_extents_x; + int f_extents_y; + int f_extents_width; + int f_extents_height; + int f_server_time; + int f_shaped; + f_shape_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_shape_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_affected_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_affected_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_extents_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_extents_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_extents_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_extents_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_extents_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_extents_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_extents_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_extents_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_server_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_shaped = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Notify_shaped, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(11); +} + +static void shapeQueryVersion(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void shapeQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (shape-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryVersion_reply_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void shapeRectangles(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_operation; + int f_destination_kind; + int f_ordering; + int f_destination_window; + int f_x_offset; + int f_y_offset; + f_operation = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Rectangles_operation, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_destination_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Rectangles_destination_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_ordering = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Rectangles_ordering, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Rectangles_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Rectangles_x_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Rectangles_y_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + struct_RECTANGLE(tvb, offsetp, t, little_endian, (length - 16) / 8); +} + +static void shapeMask(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_operation; + int f_destination_kind; + int f_destination_window; + int f_x_offset; + int f_y_offset; + int f_source_bitmap; + f_operation = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Mask_operation, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_destination_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Mask_destination_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Mask_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Mask_x_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Mask_y_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_source_bitmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Mask_source_bitmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shapeCombine(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_operation; + int f_destination_kind; + int f_source_kind; + int f_destination_window; + int f_x_offset; + int f_y_offset; + int f_source_window; + f_operation = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_operation, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_destination_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_destination_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_source_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_source_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_x_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_y_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_source_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Combine_source_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shapeOffset(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_destination_kind; + int f_destination_window; + int f_x_offset; + int f_y_offset; + f_destination_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Offset_destination_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Offset_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Offset_x_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_Offset_y_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void shapeQueryExtents(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_destination_window; + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void shapeQueryExtents_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_bounding_shaped; + int f_clip_shaped; + int f_bounding_shape_extents_x; + int f_bounding_shape_extents_y; + int f_bounding_shape_extents_width; + int f_bounding_shape_extents_height; + int f_clip_shape_extents_x; + int f_clip_shape_extents_y; + int f_clip_shape_extents_width; + int f_clip_shape_extents_height; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryExtents"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (shape-QueryExtents)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bounding_shaped = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_bounding_shaped, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_clip_shaped = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_clip_shaped, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + f_bounding_shape_extents_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_bounding_shape_extents_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_bounding_shape_extents_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_bounding_shape_extents_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_bounding_shape_extents_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_bounding_shape_extents_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_bounding_shape_extents_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_bounding_shape_extents_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_clip_shape_extents_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_clip_shape_extents_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_clip_shape_extents_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_clip_shape_extents_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_clip_shape_extents_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_clip_shape_extents_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_clip_shape_extents_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_QueryExtents_reply_clip_shape_extents_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void shapeSelectInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_destination_window; + int f_enable; + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_SelectInput_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_enable = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_SelectInput_enable, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void shapeInputSelected(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_destination_window; + f_destination_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_InputSelected_destination_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void shapeInputSelected_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_enabled; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-InputSelected"); + + REPLY(reply); + f_enabled = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_InputSelected_reply_enabled, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (shape-InputSelected)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shapeGetRectangles(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_source_kind; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_GetRectangles_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_source_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_GetRectangles_source_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void shapeGetRectangles_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ordering; + int f_rectangles_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetRectangles"); + + REPLY(reply); + f_ordering = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_GetRectangles_reply_ordering, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (shape-GetRectangles)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_rectangles_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shape_GetRectangles_reply_rectangles_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_RECTANGLE(tvb, offsetp, t, little_endian, f_rectangles_len); +} +static const value_string shape_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "Rectangles" }, + { 2, "Mask" }, + { 3, "Combine" }, + { 4, "Offset" }, + { 5, "QueryExtents" }, + { 6, "SelectInput" }, + { 7, "InputSelected" }, + { 8, "GetRectangles" }, + { 0, NULL } +}; +const x11_event_info shape_events[] = { + { "shape-Notify", shapeNotify }, + { NULL, NULL } +}; +static x11_reply_info shape_replies[] = { + { 0, shapeQueryVersion_Reply }, + { 5, shapeQueryExtents_Reply }, + { 7, shapeInputSelected_Reply }, + { 8, shapeGetRectangles_Reply }, + { 0, NULL } +}; + +static void dispatch_shape(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(shape_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, shape_extension_minor, + "")); + switch (minor) { + case 0: + shapeQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + shapeRectangles(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + shapeMask(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + shapeCombine(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + shapeOffset(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + shapeQueryExtents(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + shapeSelectInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + shapeInputSelected(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + shapeGetRectangles(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_shape(void) +{ + set_handler("SHAPE", dispatch_shape, shape_errors, shape_events, shape_replies); +} + +static void shmCompletion(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_drawable; + int f_minor_event; + int f_major_event; + int f_shmseg; + int f_offset; + UNUSED(1); + CARD16(event_sequencenumber); + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Completion_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_event = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Completion_minor_event, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_major_event = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Completion_major_event, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Completion_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Completion_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shmQueryVersion(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void shmQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_shared_pixmaps; + int f_major_version; + int f_minor_version; + int f_uid; + int f_gid; + int f_pixmap_format; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + f_shared_pixmaps = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_QueryVersion_reply_shared_pixmaps, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (shm-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_QueryVersion_reply_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_QueryVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_uid = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_QueryVersion_reply_uid, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_gid = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_QueryVersion_reply_gid, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_pixmap_format = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_QueryVersion_reply_pixmap_format, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(15); +} + +static void shmAttach(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_shmseg; + int f_shmid; + int f_read_only; + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Attach_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_shmid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Attach_shmid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_read_only = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Attach_read_only, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void shmDetach(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_shmseg; + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_Detach_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shmPutImage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_gc; + int f_total_width; + int f_total_height; + int f_src_x; + int f_src_y; + int f_src_width; + int f_src_height; + int f_dst_x; + int f_dst_y; + int f_depth; + int f_format; + int f_send_event; + int f_shmseg; + int f_offset; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_total_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_total_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_total_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_total_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_src_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_src_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dst_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_dst_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dst_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_dst_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_format = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_format, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_send_event = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_send_event, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_PutImage_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shmGetImage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_x; + int f_y; + int f_width; + int f_height; + int f_plane_mask; + int f_format; + int f_shmseg; + int f_offset; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_plane_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_plane_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_format, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void shmGetImage_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_depth; + int f_visual; + int f_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetImage"); + + REPLY(reply); + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_reply_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (shm-GetImage)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_reply_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_GetImage_reply_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void shmCreatePixmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_pid; + int f_drawable; + int f_width; + int f_height; + int f_depth; + int f_shmseg; + int f_offset; + f_pid = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_pid, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_shm_CreatePixmap_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string shm_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "Attach" }, + { 2, "Detach" }, + { 3, "PutImage" }, + { 4, "GetImage" }, + { 5, "CreatePixmap" }, + { 0, NULL } +}; +const x11_event_info shm_events[] = { + { "shm-Completion", shmCompletion }, + { NULL, NULL } +}; +static x11_reply_info shm_replies[] = { + { 0, shmQueryVersion_Reply }, + { 4, shmGetImage_Reply }, + { 0, NULL } +}; + +static void dispatch_shm(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(shm_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, shm_extension_minor, + "")); + switch (minor) { + case 0: + shmQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + shmAttach(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + shmDetach(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + shmPutImage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + shmGetImage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + shmCreatePixmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_shm(void) +{ + set_handler("MIT-SHM", dispatch_shm, shm_errors, shm_events, shm_replies); +} + +static void struct_INT64(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_hi; + int f_lo; + + item = proto_tree_add_item(root, hf_x11_struct_INT64, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_hi = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INT64_hi, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_lo = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_INT64_lo, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static int struct_size_SYSTEMCOUNTER(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_name_len; + f_name_len = VALUE16(tvb, *offsetp + size + 12); + size += f_name_len * 1; + return size + 14; +} + +static void struct_SYSTEMCOUNTER(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_counter; + int f_name_len; + + item = proto_tree_add_item(root, hf_x11_struct_SYSTEMCOUNTER, tvb, *offsetp, struct_size_SYSTEMCOUNTER(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SYSTEMCOUNTER_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); + f_name_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SYSTEMCOUNTER_name_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_struct_SYSTEMCOUNTER_name, f_name_len, little_endian); + } +} + +static void struct_TRIGGER(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_counter; + int f_wait_type; + int f_test_type; + + item = proto_tree_add_item(root, hf_x11_struct_TRIGGER, tvb, *offsetp, 20, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRIGGER_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_wait_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRIGGER_wait_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); + f_test_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_TRIGGER_test_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_WAITCONDITION(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_struct_WAITCONDITION, tvb, *offsetp, 28, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + struct_TRIGGER(tvb, offsetp, t, little_endian, 1); + struct_INT64(tvb, offsetp, t, little_endian, 1); + } +} + +static void syncInitialize(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_desired_major_version; + int f_desired_minor_version; + f_desired_major_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_Initialize_desired_major_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_desired_minor_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_Initialize_desired_minor_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void syncInitialize_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Initialize"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (sync-Initialize)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_Initialize_reply_major_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_minor_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_Initialize_reply_minor_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(22); +} + +static void syncListSystemCounters(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void syncListSystemCounters_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_counters_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListSystemCounters"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (sync-ListSystemCounters)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_counters_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_ListSystemCounters_reply_counters_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_SYSTEMCOUNTER(tvb, offsetp, t, little_endian, f_counters_len); +} + +static void syncCreateCounter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_id; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CreateCounter_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); +} + +static void syncDestroyCounter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_counter; + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_DestroyCounter_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void syncQueryCounter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_counter; + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_QueryCounter_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void syncQueryCounter_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryCounter"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (sync-QueryCounter)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); +} + +static void syncAwait(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + struct_WAITCONDITION(tvb, offsetp, t, little_endian, (length - 4) / 28); +} + +static void syncChangeCounter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_counter; + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_ChangeCounter_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); +} + +static void syncSetCounter(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_counter; + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_SetCounter_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); +} + +static void syncCreateAlarm(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_id; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CreateAlarm_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void syncChangeAlarm(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_id; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_ChangeAlarm_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void syncDestroyAlarm(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_alarm; + f_alarm = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_DestroyAlarm_alarm, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void syncQueryAlarm(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_alarm; + f_alarm = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_QueryAlarm_alarm, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void syncQueryAlarm_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_events; + int f_state; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryAlarm"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (sync-QueryAlarm)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_TRIGGER(tvb, offsetp, t, little_endian, 1); + struct_INT64(tvb, offsetp, t, little_endian, 1); + f_events = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_QueryAlarm_reply_events, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_state = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_QueryAlarm_reply_state, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); +} + +static void syncSetPriority(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_id; + int f_priority; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_SetPriority_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_priority = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_SetPriority_priority, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void syncGetPriority(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_id; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_GetPriority_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void syncGetPriority_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_priority; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPriority"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (sync-GetPriority)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_priority = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_GetPriority_reply_priority, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void syncCounterNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_kind; + int f_counter; + int f_timestamp; + int f_count; + int f_destroyed; + f_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CounterNotify_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_counter = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CounterNotify_counter, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); + struct_INT64(tvb, offsetp, t, little_endian, 1); + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CounterNotify_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_count = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CounterNotify_count, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_destroyed = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_CounterNotify_destroyed, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); +} + +static void syncAlarmNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_kind; + int f_alarm; + int f_timestamp; + int f_state; + f_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_AlarmNotify_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_alarm = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_AlarmNotify_alarm, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_INT64(tvb, offsetp, t, little_endian, 1); + struct_INT64(tvb, offsetp, t, little_endian, 1); + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_AlarmNotify_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_state = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_sync_AlarmNotify_state, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static const value_string sync_extension_minor[] = { + { 0, "Initialize" }, + { 1, "ListSystemCounters" }, + { 2, "CreateCounter" }, + { 3, "SetCounter" }, + { 4, "ChangeCounter" }, + { 5, "QueryCounter" }, + { 6, "DestroyCounter" }, + { 7, "Await" }, + { 8, "CreateAlarm" }, + { 9, "ChangeAlarm" }, + { 10, "QueryAlarm" }, + { 11, "DestroyAlarm" }, + { 12, "SetPriority" }, + { 13, "GetPriority" }, + { 0, NULL } +}; +const x11_event_info sync_events[] = { + { "sync-CounterNotify", syncCounterNotify }, + { "sync-AlarmNotify", syncAlarmNotify }, + { NULL, NULL } +}; +static x11_reply_info sync_replies[] = { + { 0, syncInitialize_Reply }, + { 1, syncListSystemCounters_Reply }, + { 5, syncQueryCounter_Reply }, + { 10, syncQueryAlarm_Reply }, + { 13, syncGetPriority_Reply }, + { 0, NULL } +}; + +static void dispatch_sync(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(sync_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, sync_extension_minor, + "")); + switch (minor) { + case 0: + syncInitialize(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + syncListSystemCounters(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + syncCreateCounter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + syncSetCounter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + syncChangeCounter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + syncQueryCounter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + syncDestroyCounter(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + syncAwait(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + syncCreateAlarm(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + syncChangeAlarm(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + syncQueryAlarm(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + syncDestroyAlarm(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + syncSetPriority(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + syncGetPriority(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_sync(void) +{ + set_handler("SYNC", dispatch_sync, sync_errors, sync_events, sync_replies); +} + +static void xc_miscGetVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetVersion_client_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_client_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetVersion_client_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xc_miscGetVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major_version; + int f_server_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xc_misc-GetVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetVersion_reply_server_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetVersion_reply_server_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xc_miscGetXIDRange(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xc_miscGetXIDRange_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_start_id; + int f_count; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetXIDRange"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xc_misc-GetXIDRange)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_start_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetXIDRange_reply_start_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_count = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetXIDRange_reply_count, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xc_miscGetXIDList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_count; + f_count = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetXIDList_count, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xc_miscGetXIDList_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_ids_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetXIDList"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xc_misc-GetXIDList)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_ids_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xc_misc_GetXIDList_reply_ids_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_xc_misc_GetXIDList_reply_ids, hf_x11_xc_misc_GetXIDList_reply_ids_item, f_ids_len, little_endian); +} +static const value_string xc_misc_extension_minor[] = { + { 0, "GetVersion" }, + { 1, "GetXIDRange" }, + { 2, "GetXIDList" }, + { 0, NULL } +}; +const x11_event_info xc_misc_events[] = { + { NULL, NULL } +}; +static x11_reply_info xc_misc_replies[] = { + { 0, xc_miscGetVersion_Reply }, + { 1, xc_miscGetXIDRange_Reply }, + { 2, xc_miscGetXIDList_Reply }, + { 0, NULL } +}; + +static void dispatch_xc_misc(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xc_misc_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xc_misc_extension_minor, + "")); + switch (minor) { + case 0: + xc_miscGetVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xc_miscGetXIDRange(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xc_miscGetXIDList(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xc_misc(void) +{ + set_handler("XC-MISC", dispatch_xc_misc, xc_misc_errors, xc_misc_events, xc_misc_replies); +} + +static void xevieQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_QueryVersion_client_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_client_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_QueryVersion_client_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xevieQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major_version; + int f_server_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xevie-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_QueryVersion_reply_server_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_QueryVersion_reply_server_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(20); +} + +static void xevieStart(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_Start_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xevieStart_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Start"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xevie-Start)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); +} + +static void xevieEnd(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cmap; + f_cmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_End_cmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xevieEnd_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-End"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xevie-End)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); +} + +static void struct_Event(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + + item = proto_tree_add_item(root, hf_x11_struct_Event, tvb, *offsetp, 32, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + UNUSED(32); + } +} + +static void xevieSend(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_data_type; + struct_Event(tvb, offsetp, t, little_endian, 1); + f_data_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_Send_data_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(64); +} +static void xevieSend_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-Send"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xevie-Send)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); +} + +static void xevieSelectInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_event_mask; + f_event_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xevie_SelectInput_event_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xevieSelectInput_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SelectInput"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xevie-SelectInput)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); +} +static const value_string xevie_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "Start" }, + { 2, "End" }, + { 3, "Send" }, + { 4, "SelectInput" }, + { 0, NULL } +}; +const x11_event_info xevie_events[] = { + { NULL, NULL } +}; +static x11_reply_info xevie_replies[] = { + { 0, xevieQueryVersion_Reply }, + { 1, xevieStart_Reply }, + { 2, xevieEnd_Reply }, + { 3, xevieSend_Reply }, + { 4, xevieSelectInput_Reply }, + { 0, NULL } +}; + +static void dispatch_xevie(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xevie_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xevie_extension_minor, + "")); + switch (minor) { + case 0: + xevieQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xevieStart(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xevieEnd(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xevieSend(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xevieSelectInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xevie(void) +{ + set_handler("XEVIE", dispatch_xevie, xevie_errors, xevie_events, xevie_replies); +} + +static void struct_DrmClipRect(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_x1; + int f_y1; + int f_x2; + int f_x3; + + item = proto_tree_add_item(root, hf_x11_struct_DrmClipRect, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_x1 = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DrmClipRect_x1, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y1 = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DrmClipRect_y1, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_x2 = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DrmClipRect_x2, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_x3 = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DrmClipRect_x3, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void xf86driQueryVersion(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xf86driQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_dri_major_version; + int f_dri_minor_version; + int f_dri_minor_patch; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dri_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_QueryVersion_reply_dri_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dri_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_QueryVersion_reply_dri_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dri_minor_patch = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_QueryVersion_reply_dri_minor_patch, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86driQueryDirectRenderingCapable(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_QueryDirectRenderingCapable_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driQueryDirectRenderingCapable_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_is_capable; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryDirectRenderingCapable"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-QueryDirectRenderingCapable)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_is_capable = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_QueryDirectRenderingCapable_reply_is_capable, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xf86driOpenConnection(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_OpenConnection_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driOpenConnection_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_drm_client_key_low; + int f_drm_client_key_high; + int f_sarea_handle_low; + int f_sarea_handle_high; + int f_bus_id_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-OpenConnection"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-OpenConnection)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drm_client_key_low = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_OpenConnection_reply_drm_client_key_low, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drm_client_key_high = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_OpenConnection_reply_drm_client_key_high, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_sarea_handle_low = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_OpenConnection_reply_sarea_handle_low, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_sarea_handle_high = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_OpenConnection_reply_sarea_handle_high, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bus_id_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_OpenConnection_reply_bus_id_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_xf86dri_OpenConnection_reply_bus_id, f_bus_id_len, little_endian); +} + +static void xf86driCloseConnection(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CloseConnection_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86driGetClientDriverName(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetClientDriverName_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driGetClientDriverName_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_client_driver_major_version; + int f_client_driver_minor_version; + int f_client_driver_patch_version; + int f_client_driver_name_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetClientDriverName"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-GetClientDriverName)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_driver_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetClientDriverName_reply_client_driver_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_driver_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetClientDriverName_reply_client_driver_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_driver_patch_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetClientDriverName_reply_client_driver_patch_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_driver_name_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + listOfByte(tvb, offsetp, t, hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name, f_client_driver_name_len, little_endian); +} + +static void xf86driCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_visual; + int f_screen; + int f_context; + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateContext_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateContext_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driCreateContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_hw_context; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CreateContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-CreateContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hw_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateContext_reply_hw_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86driDestroyContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_context; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_DestroyContext_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_DestroyContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86driCreateDrawable(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_drawable; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateDrawable_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateDrawable_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driCreateDrawable_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_hw_drawable_handle; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CreateDrawable"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-CreateDrawable)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hw_drawable_handle = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_CreateDrawable_reply_hw_drawable_handle, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86driDestroyDrawable(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_drawable; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_DestroyDrawable_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_DestroyDrawable_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86driGetDrawableInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_drawable; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driGetDrawableInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_drawable_table_index; + int f_drawable_table_stamp; + int f_drawable_origin_X; + int f_drawable_origin_Y; + int f_drawable_size_W; + int f_drawable_size_H; + int f_num_clip_rects; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDrawableInfo"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-GetDrawableInfo)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable_table_index = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_index, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable_table_stamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_stamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable_origin_X = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_X, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drawable_origin_Y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_Y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drawable_size_W = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_W, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drawable_size_H = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_H, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_clip_rects = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDrawableInfo_reply_num_clip_rects, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(4); + struct_DrmClipRect(tvb, offsetp, t, little_endian, f_num_clip_rects); +} + +static void xf86driGetDeviceInfo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driGetDeviceInfo_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_framebuffer_handle_low; + int f_framebuffer_handle_high; + int f_framebuffer_origin_offset; + int f_framebuffer_size; + int f_framebuffer_stride; + int f_device_private_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceInfo"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-GetDeviceInfo)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_framebuffer_handle_low = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_low, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_framebuffer_handle_high = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_high, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_framebuffer_origin_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_origin_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_framebuffer_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_framebuffer_stride = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_stride, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_device_private_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_GetDeviceInfo_reply_device_private_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfCard32(tvb, offsetp, t, hf_x11_xf86dri_GetDeviceInfo_reply_device_private, hf_x11_xf86dri_GetDeviceInfo_reply_device_private_item, f_device_private_size, little_endian); +} + +static void xf86driAuthConnection(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_magic; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_AuthConnection_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_magic = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_AuthConnection_magic, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xf86driAuthConnection_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_authenticated; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-AuthConnection"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86dri-AuthConnection)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_authenticated = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86dri_AuthConnection_reply_authenticated, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string xf86dri_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "QueryDirectRenderingCapable" }, + { 2, "OpenConnection" }, + { 3, "CloseConnection" }, + { 4, "GetClientDriverName" }, + { 5, "CreateContext" }, + { 6, "DestroyContext" }, + { 7, "CreateDrawable" }, + { 8, "DestroyDrawable" }, + { 9, "GetDrawableInfo" }, + { 10, "GetDeviceInfo" }, + { 11, "AuthConnection" }, + { 0, NULL } +}; +const x11_event_info xf86dri_events[] = { + { NULL, NULL } +}; +static x11_reply_info xf86dri_replies[] = { + { 0, xf86driQueryVersion_Reply }, + { 1, xf86driQueryDirectRenderingCapable_Reply }, + { 2, xf86driOpenConnection_Reply }, + { 4, xf86driGetClientDriverName_Reply }, + { 5, xf86driCreateContext_Reply }, + { 7, xf86driCreateDrawable_Reply }, + { 9, xf86driGetDrawableInfo_Reply }, + { 10, xf86driGetDeviceInfo_Reply }, + { 11, xf86driAuthConnection_Reply }, + { 0, NULL } +}; + +static void dispatch_xf86dri(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xf86dri_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xf86dri_extension_minor, + "")); + switch (minor) { + case 0: + xf86driQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xf86driQueryDirectRenderingCapable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xf86driOpenConnection(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xf86driCloseConnection(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xf86driGetClientDriverName(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xf86driCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xf86driDestroyContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xf86driCreateDrawable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xf86driDestroyDrawable(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xf86driGetDrawableInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xf86driGetDeviceInfo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xf86driAuthConnection(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xf86dri(void) +{ + set_handler("XFree86-DRI", dispatch_xf86dri, xf86dri_errors, xf86dri_events, xf86dri_replies); +} + +static void xf86vidmodeQueryVersion(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xf86vidmodeQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_QueryVersion_reply_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_QueryVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xf86vidmodeGetModeLine(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetModeLine_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_dotclock; + int f_hdisplay; + int f_hsyncstart; + int f_hsyncend; + int f_htotal; + int f_hskew; + int f_vdisplay; + int f_vsyncstart; + int f_vsyncend; + int f_vtotal; + int f_flags; + int f_privsize; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetModeLine"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetModeLine)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dotclock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_dotclock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + f_privsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetModeLine_reply_privsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_GetModeLine_reply_private, f_privsize, little_endian); +} + +static void xf86vidmodeModModeLine(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_hdisplay; + int f_hsyncstart; + int f_hsyncend; + int f_htotal; + int f_hskew; + int f_vdisplay; + int f_vsyncstart; + int f_vsyncend; + int f_vtotal; + int f_flags; + int f_privsize; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + f_privsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ModModeLine_privsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_ModModeLine_private, f_privsize, little_endian); + length -= f_privsize * 1; +} + +static void xf86vidmodeSwitchMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_zoom; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchMode_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_zoom = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchMode_zoom, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xf86vidmodeGetMonitor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetMonitor_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetMonitor_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_vendor_length; + int f_model_length; + int f_num_hsync; + int f_num_vsync; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetMonitor"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetMonitor)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vendor_length = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetMonitor_reply_vendor_length, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_model_length = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetMonitor_reply_model_length, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_hsync = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetMonitor_reply_num_hsync, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_vsync = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetMonitor_reply_num_vsync, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_xf86vidmode_GetMonitor_reply_hsync, hf_x11_xf86vidmode_GetMonitor_reply_hsync_item, f_num_hsync, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_xf86vidmode_GetMonitor_reply_vsync, hf_x11_xf86vidmode_GetMonitor_reply_vsync_item, f_num_vsync, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_GetMonitor_reply_vendor, f_vendor_length, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_GetMonitor_reply_alignment_pad, (((f_vendor_length + 3 ) & 0xFFFFFFFC) - f_vendor_length), little_endian); + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_GetMonitor_reply_model, f_model_length, little_endian); +} + +static void xf86vidmodeLockModeSwitch(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_lock; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_LockModeSwitch_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_lock = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_LockModeSwitch_lock, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xf86vidmodeGetAllModeLines(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetAllModeLines_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetAllModeLines_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_modecount; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetAllModeLines"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetAllModeLines)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_modecount = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetAllModeLines_reply_modecount, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_ModeInfo(tvb, offsetp, t, little_endian, f_modecount); +} + +static void xf86vidmodeAddModeLine(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_dotclock; + int f_hdisplay; + int f_hsyncstart; + int f_hsyncend; + int f_htotal; + int f_hskew; + int f_vdisplay; + int f_vsyncstart; + int f_vsyncend; + int f_vtotal; + int f_flags; + int f_privsize; + int f_after_dotclock; + int f_after_hdisplay; + int f_after_hsyncstart; + int f_after_hsyncend; + int f_after_htotal; + int f_after_hskew; + int f_after_vdisplay; + int f_after_vsyncstart; + int f_after_vsyncend; + int f_after_vtotal; + int f_after_flags; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dotclock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_dotclock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + f_privsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_privsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_after_dotclock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_dotclock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_after_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_after_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_after_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_AddModeLine_after_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_AddModeLine_private, f_privsize, little_endian); + length -= f_privsize * 1; +} + +static void xf86vidmodeDeleteModeLine(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_dotclock; + int f_hdisplay; + int f_hsyncstart; + int f_hsyncend; + int f_htotal; + int f_hskew; + int f_vdisplay; + int f_vsyncstart; + int f_vsyncend; + int f_vtotal; + int f_flags; + int f_privsize; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dotclock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_dotclock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + f_privsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_DeleteModeLine_privsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_DeleteModeLine_private, f_privsize, little_endian); + length -= f_privsize * 1; +} + +static void xf86vidmodeValidateModeLine(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_dotclock; + int f_hdisplay; + int f_hsyncstart; + int f_hsyncend; + int f_htotal; + int f_hskew; + int f_vdisplay; + int f_vsyncstart; + int f_vsyncend; + int f_vtotal; + int f_flags; + int f_privsize; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dotclock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_dotclock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + f_privsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_privsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_ValidateModeLine_private, f_privsize, little_endian); + length -= f_privsize * 1; +} +static void xf86vidmodeValidateModeLine_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ValidateModeLine"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-ValidateModeLine)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_ValidateModeLine_reply_status, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void xf86vidmodeSwitchToMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_dotclock; + int f_hdisplay; + int f_hsyncstart; + int f_hsyncend; + int f_htotal; + int f_hskew; + int f_vdisplay; + int f_vsyncstart; + int f_vsyncend; + int f_vtotal; + int f_flags; + int f_privsize; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dotclock = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_dotclock, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_hdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_hdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_hsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_hsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_htotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_htotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_hskew = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_hskew, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vdisplay = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_vdisplay, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncstart = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_vsyncstart, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vsyncend = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_vsyncend, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vtotal = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_vtotal, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + f_privsize = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SwitchToMode_privsize, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xf86vidmode_SwitchToMode_private, f_privsize, little_endian); + length -= f_privsize * 1; +} + +static void xf86vidmodeGetViewPort(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetViewPort_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetViewPort_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_x; + int f_y; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetViewPort"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetViewPort)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetViewPort_reply_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_y = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetViewPort_reply_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void xf86vidmodeSetViewPort(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_x; + int f_y; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetViewPort_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_x = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetViewPort_x, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_y = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetViewPort_y, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xf86vidmodeGetDotClocks(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetDotClocks_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetDotClocks_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_flags; + int f_clocks; + int f_maxclocks; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDotClocks"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetDotClocks)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetDotClocks_reply_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_clocks = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetDotClocks_reply_clocks, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_maxclocks = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetDotClocks_reply_maxclocks, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfCard32(tvb, offsetp, t, hf_x11_xf86vidmode_GetDotClocks_reply_clock, hf_x11_xf86vidmode_GetDotClocks_reply_clock_item, ((1 - (f_flags & 1)) * f_clocks), little_endian); +} + +static void xf86vidmodeSetClientVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major; + int f_minor; + f_major = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetClientVersion_major, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetClientVersion_minor, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xf86vidmodeSetGamma(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_red; + int f_green; + int f_blue; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetGamma_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + f_red = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetGamma_red, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_green = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetGamma_green, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_blue = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetGamma_blue, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); +} + +static void xf86vidmodeGetGamma(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGamma_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(26); +} +static void xf86vidmodeGetGamma_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_red; + int f_green; + int f_blue; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetGamma"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetGamma)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_red = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGamma_reply_red, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_green = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGamma_reply_green, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_blue = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGamma_reply_blue, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); +} + +static void xf86vidmodeGetGammaRamp(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_size; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGammaRamp_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGammaRamp_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xf86vidmodeGetGammaRamp_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetGammaRamp"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetGammaRamp)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGammaRamp_reply_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); + listOfCard16(tvb, offsetp, t, hf_x11_xf86vidmode_GetGammaRamp_reply_red, hf_x11_xf86vidmode_GetGammaRamp_reply_red_item, ((f_size + 1) & 0xFFFFFFFE), little_endian); + listOfCard16(tvb, offsetp, t, hf_x11_xf86vidmode_GetGammaRamp_reply_green, hf_x11_xf86vidmode_GetGammaRamp_reply_green_item, ((f_size + 1) & 0xFFFFFFFE), little_endian); + listOfCard16(tvb, offsetp, t, hf_x11_xf86vidmode_GetGammaRamp_reply_blue, hf_x11_xf86vidmode_GetGammaRamp_reply_blue_item, ((f_size + 1) & 0xFFFFFFFE), little_endian); +} + +static void xf86vidmodeSetGammaRamp(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + int f_size; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetGammaRamp_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_SetGammaRamp_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfCard16(tvb, offsetp, t, hf_x11_xf86vidmode_SetGammaRamp_red, hf_x11_xf86vidmode_SetGammaRamp_red_item, ((f_size + 1) & 0xFFFFFFFE), little_endian); + length -= ((f_size + 1) & 0xFFFFFFFE) * 2; + listOfCard16(tvb, offsetp, t, hf_x11_xf86vidmode_SetGammaRamp_green, hf_x11_xf86vidmode_SetGammaRamp_green_item, ((f_size + 1) & 0xFFFFFFFE), little_endian); + length -= ((f_size + 1) & 0xFFFFFFFE) * 2; + listOfCard16(tvb, offsetp, t, hf_x11_xf86vidmode_SetGammaRamp_blue, hf_x11_xf86vidmode_SetGammaRamp_blue_item, ((f_size + 1) & 0xFFFFFFFE), little_endian); + length -= ((f_size + 1) & 0xFFFFFFFE) * 2; +} + +static void xf86vidmodeGetGammaRampSize(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGammaRampSize_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetGammaRampSize_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetGammaRampSize"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetGammaRampSize)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetGammaRampSize_reply_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); +} + +static void xf86vidmodeGetPermissions(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_screen; + f_screen = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetPermissions_screen, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); +} +static void xf86vidmodeGetPermissions_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_permissions; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPermissions"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xf86vidmode-GetPermissions)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_permissions = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xf86vidmode_GetPermissions_reply_permissions, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} +static const value_string xf86vidmode_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "GetModeLine" }, + { 2, "ModModeLine" }, + { 3, "SwitchMode" }, + { 4, "GetMonitor" }, + { 5, "LockModeSwitch" }, + { 6, "GetAllModeLines" }, + { 7, "AddModeLine" }, + { 8, "DeleteModeLine" }, + { 9, "ValidateModeLine" }, + { 10, "SwitchToMode" }, + { 11, "GetViewPort" }, + { 12, "SetViewPort" }, + { 13, "GetDotClocks" }, + { 14, "SetClientVersion" }, + { 15, "SetGamma" }, + { 16, "GetGamma" }, + { 17, "GetGammaRamp" }, + { 18, "SetGammaRamp" }, + { 19, "GetGammaRampSize" }, + { 20, "GetPermissions" }, + { 0, NULL } +}; +const x11_event_info xf86vidmode_events[] = { + { NULL, NULL } +}; +static x11_reply_info xf86vidmode_replies[] = { + { 0, xf86vidmodeQueryVersion_Reply }, + { 1, xf86vidmodeGetModeLine_Reply }, + { 4, xf86vidmodeGetMonitor_Reply }, + { 6, xf86vidmodeGetAllModeLines_Reply }, + { 9, xf86vidmodeValidateModeLine_Reply }, + { 11, xf86vidmodeGetViewPort_Reply }, + { 13, xf86vidmodeGetDotClocks_Reply }, + { 16, xf86vidmodeGetGamma_Reply }, + { 17, xf86vidmodeGetGammaRamp_Reply }, + { 19, xf86vidmodeGetGammaRampSize_Reply }, + { 20, xf86vidmodeGetPermissions_Reply }, + { 0, NULL } +}; + +static void dispatch_xf86vidmode(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xf86vidmode_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xf86vidmode_extension_minor, + "")); + switch (minor) { + case 0: + xf86vidmodeQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xf86vidmodeGetModeLine(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xf86vidmodeModModeLine(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xf86vidmodeSwitchMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xf86vidmodeGetMonitor(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xf86vidmodeLockModeSwitch(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xf86vidmodeGetAllModeLines(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xf86vidmodeAddModeLine(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xf86vidmodeDeleteModeLine(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xf86vidmodeValidateModeLine(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xf86vidmodeSwitchToMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xf86vidmodeGetViewPort(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + xf86vidmodeSetViewPort(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + xf86vidmodeGetDotClocks(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + xf86vidmodeSetClientVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + xf86vidmodeSetGamma(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + xf86vidmodeGetGamma(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + xf86vidmodeGetGammaRamp(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + xf86vidmodeSetGammaRamp(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + xf86vidmodeGetGammaRampSize(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + xf86vidmodeGetPermissions(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xf86vidmode(void) +{ + set_handler("XFree86-VidModeExtension", dispatch_xf86vidmode, xf86vidmode_errors, xf86vidmode_events, xf86vidmode_replies); +} + +static void xfixesQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major_version; + int f_client_minor_version; + f_client_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_QueryVersion_client_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_client_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_QueryVersion_client_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xfixesQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xfixes-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_QueryVersion_reply_major_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_QueryVersion_reply_minor_version, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); +} + +static void xfixesChangeSaveSet(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_mode; + int f_target; + int f_map; + int f_window; + f_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeSaveSet_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_target = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeSaveSet_target, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_map = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeSaveSet_map, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeSaveSet_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesSelectionNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_subtype; + int f_window; + int f_owner; + int f_selection; + int f_timestamp; + int f_selection_timestamp; + f_subtype = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectionNotify_subtype, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectionNotify_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_owner = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectionNotify_owner, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_selection = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectionNotify_selection, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectionNotify_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_selection_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectionNotify_selection_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); +} + +static void xfixesSelectSelectionInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_selection; + int f_event_mask; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectSelectionInput_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_selection = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectSelectionInput_selection, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_event_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectSelectionInput_event_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesCursorNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_subtype; + int f_window; + int f_cursor_serial; + int f_timestamp; + int f_name; + f_subtype = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CursorNotify_subtype, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CursorNotify_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_cursor_serial = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CursorNotify_cursor_serial, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_timestamp = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CursorNotify_timestamp, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_name = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CursorNotify_name, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); +} + +static void xfixesSelectCursorInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_event_mask; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectCursorInput_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_event_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SelectCursorInput_event_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesGetCursorImage(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xfixesGetCursorImage_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_x; + int f_y; + int f_width; + int f_height; + int f_xhot; + int f_yhot; + int f_cursor_serial; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCursorImage"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xfixes-GetCursorImage)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_xhot = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_xhot, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_yhot = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_yhot, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_cursor_serial = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImage_reply_cursor_serial, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + listOfCard32(tvb, offsetp, t, hf_x11_xfixes_GetCursorImage_reply_cursor_image, hf_x11_xfixes_GetCursorImage_reply_cursor_image_item, (f_width * f_height), little_endian); +} + +static void xfixesCreateRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_RECTANGLE(tvb, offsetp, t, little_endian, (length - 8) / 8); +} + +static void xfixesCreateRegionFromBitmap(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + int f_bitmap; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromBitmap_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_bitmap = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromBitmap_bitmap, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesCreateRegionFromWindow(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + int f_window; + int f_kind; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromWindow_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromWindow_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromWindow_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void xfixesCreateRegionFromGC(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + int f_gc; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromGC_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromGC_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesCreateRegionFromPicture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + int f_picture; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromPicture_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CreateRegionFromPicture_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesDestroyRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_DestroyRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesSetRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_RECTANGLE(tvb, offsetp, t, little_endian, (length - 8) / 8); +} + +static void xfixesCopyRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source; + int f_destination; + f_source = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CopyRegion_source, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_CopyRegion_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesUnionRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source1; + int f_source2; + int f_destination; + f_source1 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_UnionRegion_source1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_source2 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_UnionRegion_source2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_UnionRegion_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesIntersectRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source1; + int f_source2; + int f_destination; + f_source1 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_IntersectRegion_source1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_source2 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_IntersectRegion_source2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_IntersectRegion_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesSubtractRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source1; + int f_source2; + int f_destination; + f_source1 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SubtractRegion_source1, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_source2 = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SubtractRegion_source2, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SubtractRegion_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesInvertRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source; + int f_destination; + f_source = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_InvertRegion_source, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_RECTANGLE(tvb, offsetp, t, little_endian, 1); + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_InvertRegion_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesTranslateRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + int f_dx; + int f_dy; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_TranslateRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dx = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_TranslateRegion_dx, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_dy = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_TranslateRegion_dy, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xfixesRegionExtents(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source; + int f_destination; + f_source = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_RegionExtents_source, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_RegionExtents_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesFetchRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_region; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_FetchRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xfixesFetchRegion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-FetchRegion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xfixes-FetchRegion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + struct_RECTANGLE(tvb, offsetp, t, little_endian, 1); + UNUSED(16); + struct_RECTANGLE(tvb, offsetp, t, little_endian, f_length); +} + +static void xfixesSetGCClipRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_gc; + int f_region; + int f_x_origin; + int f_y_origin; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetGCClipRegion_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetGCClipRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_origin = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetGCClipRegion_x_origin, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_origin = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetGCClipRegion_y_origin, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xfixesSetWindowShapeRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_dest; + int f_dest_kind; + int f_x_offset; + int f_y_offset; + int f_region; + f_dest = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetWindowShapeRegion_dest, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dest_kind = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetWindowShapeRegion_dest_kind, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_x_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetWindowShapeRegion_x_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_offset = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetWindowShapeRegion_y_offset, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetWindowShapeRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesSetPictureClipRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_picture; + int f_region; + int f_x_origin; + int f_y_origin; + f_picture = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetPictureClipRegion_picture, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_region = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetPictureClipRegion_region, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x_origin = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetPictureClipRegion_x_origin, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_origin = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetPictureClipRegion_y_origin, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xfixesSetCursorName(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cursor; + int f_nbytes; + f_cursor = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetCursorName_cursor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_nbytes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_SetCursorName_nbytes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_xfixes_SetCursorName_name, f_nbytes, little_endian); + length -= f_nbytes * 1; +} + +static void xfixesGetCursorName(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cursor; + f_cursor = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorName_cursor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xfixesGetCursorName_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_atom; + int f_nbytes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCursorName"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xfixes-GetCursorName)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_atom = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorName_reply_atom, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_nbytes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorName_reply_nbytes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(18); + listOfByte(tvb, offsetp, t, hf_x11_xfixes_GetCursorName_reply_name, f_nbytes, little_endian); +} + +static void xfixesGetCursorImageAndName(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xfixesGetCursorImageAndName_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_x; + int f_y; + int f_width; + int f_height; + int f_xhot; + int f_yhot; + int f_cursor_serial; + int f_cursor_atom; + int f_nbytes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetCursorImageAndName"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xfixes-GetCursorImageAndName)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_xhot = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_xhot, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_yhot = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_yhot, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_cursor_serial = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_cursor_serial, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_cursor_atom = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_cursor_atom, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_nbytes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_GetCursorImageAndName_reply_nbytes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_xfixes_GetCursorImageAndName_reply_name, f_nbytes, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image, hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image_item, (f_width * f_height), little_endian); +} + +static void xfixesChangeCursor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source; + int f_destination; + f_source = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeCursor_source, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeCursor_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesChangeCursorByName(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_src; + int f_nbytes; + f_src = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeCursorByName_src, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_nbytes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ChangeCursorByName_nbytes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_xfixes_ChangeCursorByName_name, f_nbytes, little_endian); + length -= f_nbytes * 1; +} + +static void xfixesExpandRegion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_source; + int f_destination; + int f_left; + int f_right; + int f_top; + int f_bottom; + f_source = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ExpandRegion_source, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ExpandRegion_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_left = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ExpandRegion_left, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_right = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ExpandRegion_right, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_top = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ExpandRegion_top, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_bottom = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ExpandRegion_bottom, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xfixesHideCursor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_HideCursor_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xfixesShowCursor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xfixes_ShowCursor_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string xfixes_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "ChangeSaveSet" }, + { 2, "SelectSelectionInput" }, + { 3, "SelectCursorInput" }, + { 4, "GetCursorImage" }, + { 5, "CreateRegion" }, + { 6, "CreateRegionFromBitmap" }, + { 7, "CreateRegionFromWindow" }, + { 8, "CreateRegionFromGC" }, + { 9, "CreateRegionFromPicture" }, + { 10, "DestroyRegion" }, + { 11, "SetRegion" }, + { 12, "CopyRegion" }, + { 13, "UnionRegion" }, + { 14, "IntersectRegion" }, + { 15, "SubtractRegion" }, + { 16, "InvertRegion" }, + { 17, "TranslateRegion" }, + { 18, "RegionExtents" }, + { 19, "FetchRegion" }, + { 20, "SetGCClipRegion" }, + { 21, "SetWindowShapeRegion" }, + { 22, "SetPictureClipRegion" }, + { 23, "SetCursorName" }, + { 24, "GetCursorName" }, + { 25, "GetCursorImageAndName" }, + { 26, "ChangeCursor" }, + { 27, "ChangeCursorByName" }, + { 28, "ExpandRegion" }, + { 29, "HideCursor" }, + { 30, "ShowCursor" }, + { 0, NULL } +}; +const x11_event_info xfixes_events[] = { + { "xfixes-SelectionNotify", xfixesSelectionNotify }, + { "xfixes-CursorNotify", xfixesCursorNotify }, + { NULL, NULL } +}; +static x11_reply_info xfixes_replies[] = { + { 0, xfixesQueryVersion_Reply }, + { 4, xfixesGetCursorImage_Reply }, + { 19, xfixesFetchRegion_Reply }, + { 24, xfixesGetCursorName_Reply }, + { 25, xfixesGetCursorImageAndName_Reply }, + { 0, NULL } +}; + +static void dispatch_xfixes(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xfixes_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xfixes_extension_minor, + "")); + switch (minor) { + case 0: + xfixesQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xfixesChangeSaveSet(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xfixesSelectSelectionInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xfixesSelectCursorInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xfixesGetCursorImage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xfixesCreateRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xfixesCreateRegionFromBitmap(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xfixesCreateRegionFromWindow(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xfixesCreateRegionFromGC(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xfixesCreateRegionFromPicture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xfixesDestroyRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xfixesSetRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + xfixesCopyRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + xfixesUnionRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + xfixesIntersectRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + xfixesSubtractRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + xfixesInvertRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + xfixesTranslateRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + xfixesRegionExtents(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + xfixesFetchRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + xfixesSetGCClipRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 21: + xfixesSetWindowShapeRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + xfixesSetPictureClipRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 23: + xfixesSetCursorName(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 24: + xfixesGetCursorName(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 25: + xfixesGetCursorImageAndName(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 26: + xfixesChangeCursor(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 27: + xfixesChangeCursorByName(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 28: + xfixesExpandRegion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 29: + xfixesHideCursor(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 30: + xfixesShowCursor(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xfixes(void) +{ + set_handler("XFIXES", dispatch_xfixes, xfixes_errors, xfixes_events, xfixes_replies); +} + +static void struct_ScreenInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_x_org; + int f_y_org; + int f_width; + int f_height; + + item = proto_tree_add_item(root, hf_x11_struct_ScreenInfo, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_x_org = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenInfo_x_org, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_y_org = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenInfo_y_org, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenInfo_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ScreenInfo_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + } +} + +static void xineramaQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major; + int f_minor; + f_major = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_QueryVersion_major, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_minor = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_QueryVersion_minor, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void xineramaQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major; + int f_minor; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinerama-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_QueryVersion_reply_major, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_QueryVersion_reply_minor, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xineramaGetState(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetState_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xineramaGetState_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_state; + int f_window; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetState"); + + REPLY(reply); + f_state = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetState_reply_state, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinerama-GetState)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetState_reply_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xineramaGetScreenCount(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenCount_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xineramaGetScreenCount_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_screen_count; + int f_window; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetScreenCount"); + + REPLY(reply); + f_screen_count = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenCount_reply_screen_count, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinerama-GetScreenCount)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenCount_reply_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xineramaGetScreenSize(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_screen; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenSize_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenSize_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xineramaGetScreenSize_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width; + int f_height; + int f_window; + int f_screen; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetScreenSize"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinerama-GetScreenSize)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenSize_reply_width, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_height = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenSize_reply_height, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenSize_reply_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_screen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_GetScreenSize_reply_screen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xineramaIsActive(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xineramaIsActive_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_state; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-IsActive"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinerama-IsActive)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_state = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_IsActive_reply_state, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xineramaQueryScreens(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xineramaQueryScreens_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryScreens"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinerama-QueryScreens)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_number = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinerama_QueryScreens_reply_number, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_ScreenInfo(tvb, offsetp, t, little_endian, f_number); +} +static const value_string xinerama_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "GetState" }, + { 2, "GetScreenCount" }, + { 3, "GetScreenSize" }, + { 4, "IsActive" }, + { 5, "QueryScreens" }, + { 0, NULL } +}; +const x11_event_info xinerama_events[] = { + { NULL, NULL } +}; +static x11_reply_info xinerama_replies[] = { + { 0, xineramaQueryVersion_Reply }, + { 1, xineramaGetState_Reply }, + { 2, xineramaGetScreenCount_Reply }, + { 3, xineramaGetScreenSize_Reply }, + { 4, xineramaIsActive_Reply }, + { 5, xineramaQueryScreens_Reply }, + { 0, NULL } +}; + +static void dispatch_xinerama(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xinerama_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xinerama_extension_minor, + "")); + switch (minor) { + case 0: + xineramaQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xineramaGetState(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xineramaGetScreenCount(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xineramaGetScreenSize(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xineramaIsActive(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xineramaQueryScreens(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xinerama(void) +{ + set_handler("XINERAMA", dispatch_xinerama, xinerama_errors, xinerama_events, xinerama_replies); +} + +static void xinputGetExtensionVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_name_len; + f_name_len = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetExtensionVersion_name_len, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_xinput_GetExtensionVersion_name, f_name_len, little_endian); + length -= f_name_len * 1; +} +static void xinputGetExtensionVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major; + int f_server_minor; + int f_present; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetExtensionVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetExtensionVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetExtensionVersion_reply_server_major, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetExtensionVersion_reply_server_minor, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_present = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetExtensionVersion_reply_present, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(19); +} + +static void struct_DeviceInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_device_type; + int f_device_id; + int f_num_class_info; + int f_device_use; + + item = proto_tree_add_item(root, hf_x11_struct_DeviceInfo, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_device_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DeviceInfo_device_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DeviceInfo_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_class_info = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DeviceInfo_num_class_info, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_use = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_DeviceInfo_device_use, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + } +} + +static void xinputListInputDevices(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xinputListInputDevices_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_devices_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListInputDevices"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-ListInputDevices)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_devices_len = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ListInputDevices_reply_devices_len, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); + struct_DeviceInfo(tvb, offsetp, t, little_endian, f_devices_len); +} + +static void struct_InputClassInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_class_id; + int f_event_type_base; + + item = proto_tree_add_item(root, hf_x11_struct_InputClassInfo, tvb, *offsetp, 2, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_class_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_InputClassInfo_class_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_event_type_base = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_InputClassInfo_event_type_base, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + } +} + +static void xinputOpenDevice(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_OpenDevice_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputOpenDevice_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_classes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-OpenDevice"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-OpenDevice)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_OpenDevice_reply_num_classes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); + struct_InputClassInfo(tvb, offsetp, t, little_endian, f_num_classes); +} + +static void xinputCloseDevice(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_CloseDevice_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void xinputSetDeviceMode(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_mode; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceMode_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceMode_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); +} +static void xinputSetDeviceMode_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetDeviceMode"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-SetDeviceMode)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceMode_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputSelectExtensionEvent(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_num_classes; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SelectExtensionEvent_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SelectExtensionEvent_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_SelectExtensionEvent_classes, hf_x11_xinput_SelectExtensionEvent_classes_item, f_num_classes, little_endian); + length -= f_num_classes * 4; +} + +static void xinputGetSelectedExtensionEvents(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetSelectedExtensionEvents_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xinputGetSelectedExtensionEvents_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_this_classes; + int f_num_all_classes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetSelectedExtensionEvents"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetSelectedExtensionEvents)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_this_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetSelectedExtensionEvents_reply_num_this_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_all_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetSelectedExtensionEvents_reply_num_all_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes, hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes_item, f_num_this_classes, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes, hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes_item, f_num_all_classes, little_endian); +} + +static void xinputChangeDeviceDontPropagateList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_num_classes; + int f_mode; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceDontPropagateList_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceDontPropagateList_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceDontPropagateList_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_ChangeDeviceDontPropagateList_classes, hf_x11_xinput_ChangeDeviceDontPropagateList_classes_item, f_num_classes, little_endian); + length -= f_num_classes * 4; +} + +static void xinputGetDeviceDontPropagateList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceDontPropagateList_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xinputGetDeviceDontPropagateList_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_classes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceDontPropagateList"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceDontPropagateList)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceDontPropagateList_reply_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GetDeviceDontPropagateList_reply_classes, hf_x11_xinput_GetDeviceDontPropagateList_reply_classes_item, f_num_classes, little_endian); +} + +static void xinputGetDeviceMotionEvents(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_start; + int f_stop; + int f_device_id; + f_start = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceMotionEvents_start, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_stop = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceMotionEvents_stop, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceMotionEvents_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void xinputGetDeviceMotionEvents_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_coords; + int f_num_axes; + int f_device_mode; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceMotionEvents"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceMotionEvents)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_coords = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceMotionEvents_reply_num_coords, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_axes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceMotionEvents_reply_num_axes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceMotionEvents_reply_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(18); +} + +static void xinputChangeKeyboardDevice(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeKeyboardDevice_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputChangeKeyboardDevice_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ChangeKeyboardDevice"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-ChangeKeyboardDevice)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeKeyboardDevice_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputChangePointerDevice(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_x_axis; + int f_y_axis; + int f_device_id; + f_x_axis = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangePointerDevice_x_axis, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_y_axis = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangePointerDevice_y_axis, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangePointerDevice_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); +} +static void xinputChangePointerDevice_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ChangePointerDevice"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-ChangePointerDevice)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangePointerDevice_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputGrabDevice(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_grab_window; + int f_time; + int f_num_classes; + int f_this_device_mode; + int f_other_device_mode; + int f_owner_events; + int f_device_id; + f_grab_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_grab_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_this_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_this_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_other_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_other_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_owner_events = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_owner_events, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GrabDevice_classes, hf_x11_xinput_GrabDevice_classes_item, f_num_classes, little_endian); + length -= f_num_classes * 4; +} +static void xinputGrabDevice_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GrabDevice"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GrabDevice)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDevice_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputUngrabDevice(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_time; + int f_device_id; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDevice_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDevice_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputGrabDeviceKey(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_grab_window; + int f_num_classes; + int f_modifiers; + int f_modifier_device; + int f_grabbed_device; + int f_key; + int f_this_device_mode; + int f_other_device_mode; + int f_owner_events; + f_grab_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_grab_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_modifiers = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_modifiers, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_modifier_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_modifier_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_grabbed_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_grabbed_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_key = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_key, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_this_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_this_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_other_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_other_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_owner_events = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceKey_owner_events, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GrabDeviceKey_classes, hf_x11_xinput_GrabDeviceKey_classes_item, f_num_classes, little_endian); + length -= f_num_classes * 4; +} + +static void xinputUngrabDeviceKey(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_grabWindow; + int f_modifiers; + int f_modifier_device; + int f_key; + int f_grabbed_device; + f_grabWindow = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceKey_grabWindow, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_modifiers = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceKey_modifiers, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_modifier_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceKey_modifier_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_key = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceKey_key, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_grabbed_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceKey_grabbed_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputGrabDeviceButton(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_grab_window; + int f_grabbed_device; + int f_modifier_device; + int f_num_classes; + int f_modifiers; + int f_this_device_mode; + int f_other_device_mode; + int f_button; + int f_owner_events; + f_grab_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_grab_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_grabbed_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_grabbed_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_modifier_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_modifier_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_modifiers = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_modifiers, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_this_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_this_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_other_device_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_other_device_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_button = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_button, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_owner_events = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GrabDeviceButton_owner_events, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GrabDeviceButton_classes, hf_x11_xinput_GrabDeviceButton_classes_item, f_num_classes, little_endian); + length -= f_num_classes * 4; +} + +static void xinputUngrabDeviceButton(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_grab_window; + int f_modifiers; + int f_modifier_device; + int f_button; + int f_grabbed_device; + f_grab_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceButton_grab_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_modifiers = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceButton_modifiers, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_modifier_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceButton_modifier_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_button = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceButton_button, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_grabbed_device = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_UngrabDeviceButton_grabbed_device, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputAllowDeviceEvents(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_time; + int f_mode; + int f_device_id; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_AllowDeviceEvents_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_AllowDeviceEvents_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_AllowDeviceEvents_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputGetDeviceFocus(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceFocus_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputGetDeviceFocus_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_focus; + int f_time; + int f_revert_to; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceFocus"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceFocus)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_focus = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceFocus_reply_focus, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceFocus_reply_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_revert_to = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceFocus_reply_revert_to, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(15); +} + +static void xinputSetDeviceFocus(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_focus; + int f_time; + int f_revert_to; + int f_device_id; + f_focus = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceFocus_focus, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceFocus_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_revert_to = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceFocus_revert_to, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceFocus_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputGetFeedbackControl(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetFeedbackControl_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputGetFeedbackControl_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_feedback; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetFeedbackControl"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetFeedbackControl)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_feedback = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetFeedbackControl_reply_num_feedback, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); +} + +static void xinputGetDeviceKeyMapping(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_first_keycode; + int f_count; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceKeyMapping_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_first_keycode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceKeyMapping_first_keycode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_count = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceKeyMapping_count, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void xinputGetDeviceKeyMapping_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_keysyms_per_keycode; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceKeyMapping"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceKeyMapping)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_keysyms_per_keycode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_per_keycode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms, hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_item, f_length, little_endian); +} + +static void xinputChangeDeviceKeyMapping(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_first_keycode; + int f_keysyms_per_keycode; + int f_keycode_count; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceKeyMapping_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_first_keycode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceKeyMapping_first_keycode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_keysyms_per_keycode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_per_keycode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_keycode_count = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceKeyMapping_keycode_count, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + listOfCard32(tvb, offsetp, t, hf_x11_xinput_ChangeDeviceKeyMapping_keysyms, hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_item, (f_keycode_count * f_keysyms_per_keycode), little_endian); + length -= (f_keycode_count * f_keysyms_per_keycode) * 4; +} + +static void xinputGetDeviceModifierMapping(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceModifierMapping_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputGetDeviceModifierMapping_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_keycodes_per_modifier; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceModifierMapping"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceModifierMapping)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_keycodes_per_modifier = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceModifierMapping_reply_keycodes_per_modifier, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); + listOfByte(tvb, offsetp, t, hf_x11_xinput_GetDeviceModifierMapping_reply_keymaps, (f_keycodes_per_modifier * 8), little_endian); +} + +static void xinputSetDeviceModifierMapping(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_keycodes_per_modifier; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceModifierMapping_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_keycodes_per_modifier = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceModifierMapping_keycodes_per_modifier, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + listOfByte(tvb, offsetp, t, hf_x11_xinput_SetDeviceModifierMapping_keymaps, (f_keycodes_per_modifier * 8), little_endian); + length -= (f_keycodes_per_modifier * 8) * 1; +} +static void xinputSetDeviceModifierMapping_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetDeviceModifierMapping"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-SetDeviceModifierMapping)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceModifierMapping_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputGetDeviceButtonMapping(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceButtonMapping_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputGetDeviceButtonMapping_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_map_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceButtonMapping"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceButtonMapping)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_map_size = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceButtonMapping_reply_map_size, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); + listOfByte(tvb, offsetp, t, hf_x11_xinput_GetDeviceButtonMapping_reply_map, f_map_size, little_endian); +} + +static void xinputSetDeviceButtonMapping(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_map_size; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceButtonMapping_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_map_size = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceButtonMapping_map_size, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_xinput_SetDeviceButtonMapping_map, f_map_size, little_endian); + length -= f_map_size * 1; +} +static void xinputSetDeviceButtonMapping_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetDeviceButtonMapping"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-SetDeviceButtonMapping)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceButtonMapping_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputQueryDeviceState(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_QueryDeviceState_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xinputQueryDeviceState_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_classes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryDeviceState"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-QueryDeviceState)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_classes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_QueryDeviceState_reply_num_classes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputSendExtensionEvent(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_destination; + int f_device_id; + int f_propagate; + int f_num_classes; + int f_num_events; + f_destination = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SendExtensionEvent_destination, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SendExtensionEvent_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_propagate = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SendExtensionEvent_propagate, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_classes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SendExtensionEvent_num_classes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_events = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SendExtensionEvent_num_events, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + listOfByte(tvb, offsetp, t, hf_x11_xinput_SendExtensionEvent_events, (f_num_events * 32), little_endian); + length -= (f_num_events * 32) * 1; + listOfCard32(tvb, offsetp, t, hf_x11_xinput_SendExtensionEvent_classes, hf_x11_xinput_SendExtensionEvent_classes_item, f_num_classes, little_endian); + length -= f_num_classes * 4; +} + +static void xinputDeviceBell(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_feedback_id; + int f_feedback_class; + int f_percent; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceBell_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_feedback_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceBell_feedback_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_feedback_class = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceBell_feedback_class, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_percent = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceBell_percent, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputSetDeviceValuators(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device_id; + int f_first_valuator; + int f_num_valuators; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceValuators_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_first_valuator = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceValuators_first_valuator, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_valuators = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceValuators_num_valuators, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + listOfInt32(tvb, offsetp, t, hf_x11_xinput_SetDeviceValuators_valuators, hf_x11_xinput_SetDeviceValuators_valuators_item, f_num_valuators, little_endian); + length -= f_num_valuators * 4; +} +static void xinputSetDeviceValuators_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-SetDeviceValuators"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-SetDeviceValuators)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_SetDeviceValuators_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputGetDeviceControl(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_control_id; + int f_device_id; + f_control_id = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceControl_control_id, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceControl_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); +} +static void xinputGetDeviceControl_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceControl"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xinput-GetDeviceControl)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_GetDeviceControl_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputDeviceValuator(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_device_id; + int f_device_state; + int f_num_valuators; + int f_first_valuator; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceValuator_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_device_state = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceValuator_device_state, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_valuators = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceValuator_num_valuators, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_first_valuator = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceValuator_first_valuator, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + listOfInt32(tvb, offsetp, t, hf_x11_xinput_DeviceValuator_valuators, hf_x11_xinput_DeviceValuator_valuators_item, 6, little_endian); +} + +static void xinputDeviceKeyPress(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_detail; + int f_time; + int f_root; + int f_event; + int f_child; + int f_root_x; + int f_root_y; + int f_event_x; + int f_event_y; + int f_state; + int f_same_screen; + int f_device_id; + f_detail = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_detail, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_event = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_event, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_child = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_child, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_root_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_root_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_root_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_event_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_event_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_event_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_event_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_state = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_state, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_same_screen = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_same_screen, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyPress_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xinputFocusIn(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_detail; + int f_time; + int f_window; + int f_mode; + int f_device_id; + f_detail = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_FocusIn_detail, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_FocusIn_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_FocusIn_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_FocusIn_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_FocusIn_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(18); +} + +static void xinputDeviceStateNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_device_id; + int f_time; + int f_num_keys; + int f_num_buttons; + int f_num_valuators; + int f_classes_reported; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceStateNotify_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceStateNotify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_keys = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceStateNotify_num_keys, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_buttons = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceStateNotify_num_buttons, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_valuators = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceStateNotify_num_valuators, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_classes_reported = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceStateNotify_classes_reported, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + listOfByte(tvb, offsetp, t, hf_x11_xinput_DeviceStateNotify_buttons, 4, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_xinput_DeviceStateNotify_keys, 4, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_xinput_DeviceStateNotify_valuators, hf_x11_xinput_DeviceStateNotify_valuators_item, 3, little_endian); +} + +static void xinputDeviceMappingNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_device_id; + int f_request; + int f_first_keycode; + int f_count; + int f_time; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceMappingNotify_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_request = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceMappingNotify_request, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_first_keycode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceMappingNotify_first_keycode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_count = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceMappingNotify_count, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceMappingNotify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); +} + +static void xinputChangeDeviceNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_device_id; + int f_time; + int f_request; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceNotify_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceNotify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_request = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_ChangeDeviceNotify_request, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(23); +} + +static void xinputDeviceKeyStateNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceKeyStateNotify_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + listOfByte(tvb, offsetp, t, hf_x11_xinput_DeviceKeyStateNotify_keys, 28, little_endian); +} + +static void xinputDeviceButtonStateNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_device_id; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DeviceButtonStateNotify_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + listOfByte(tvb, offsetp, t, hf_x11_xinput_DeviceButtonStateNotify_buttons, 28, little_endian); +} + +static void xinputDevicePresenceNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_time; + int f_devchange; + int f_device_id; + int f_control; + UNUSED(1); + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DevicePresenceNotify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_devchange = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DevicePresenceNotify_devchange, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_device_id = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DevicePresenceNotify_device_id, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_control = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xinput_DevicePresenceNotify_control, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(20); +} +static const value_string xinput_extension_minor[] = { + { 1, "GetExtensionVersion" }, + { 2, "ListInputDevices" }, + { 3, "OpenDevice" }, + { 4, "CloseDevice" }, + { 5, "SetDeviceMode" }, + { 6, "SelectExtensionEvent" }, + { 7, "GetSelectedExtensionEvents" }, + { 8, "ChangeDeviceDontPropagateList" }, + { 9, "GetDeviceDontPropagateList" }, + { 10, "GetDeviceMotionEvents" }, + { 11, "ChangeKeyboardDevice" }, + { 12, "ChangePointerDevice" }, + { 13, "GrabDevice" }, + { 14, "UngrabDevice" }, + { 15, "GrabDeviceKey" }, + { 16, "UngrabDeviceKey" }, + { 17, "GrabDeviceButton" }, + { 18, "UngrabDeviceButton" }, + { 19, "AllowDeviceEvents" }, + { 20, "GetDeviceFocus" }, + { 21, "SetDeviceFocus" }, + { 22, "GetFeedbackControl" }, + { 24, "GetDeviceKeyMapping" }, + { 25, "ChangeDeviceKeyMapping" }, + { 26, "GetDeviceModifierMapping" }, + { 27, "SetDeviceModifierMapping" }, + { 28, "GetDeviceButtonMapping" }, + { 29, "SetDeviceButtonMapping" }, + { 30, "QueryDeviceState" }, + { 31, "SendExtensionEvent" }, + { 32, "DeviceBell" }, + { 33, "SetDeviceValuators" }, + { 34, "GetDeviceControl" }, + { 0, NULL } +}; +const x11_event_info xinput_events[] = { + { "xinput-DeviceValuator", xinputDeviceValuator }, + { "xinput-DeviceKeyPress", xinputDeviceKeyPress }, + { "xinput-FocusIn", xinputFocusIn }, + { "xinput-DeviceStateNotify", xinputDeviceStateNotify }, + { "xinput-DeviceMappingNotify", xinputDeviceMappingNotify }, + { "xinput-ChangeDeviceNotify", xinputChangeDeviceNotify }, + { "xinput-DeviceKeyStateNotify", xinputDeviceKeyStateNotify }, + { "xinput-DeviceButtonStateNotify", xinputDeviceButtonStateNotify }, + { "xinput-DevicePresenceNotify", xinputDevicePresenceNotify }, + { NULL, NULL } +}; +static x11_reply_info xinput_replies[] = { + { 1, xinputGetExtensionVersion_Reply }, + { 2, xinputListInputDevices_Reply }, + { 3, xinputOpenDevice_Reply }, + { 5, xinputSetDeviceMode_Reply }, + { 7, xinputGetSelectedExtensionEvents_Reply }, + { 9, xinputGetDeviceDontPropagateList_Reply }, + { 10, xinputGetDeviceMotionEvents_Reply }, + { 11, xinputChangeKeyboardDevice_Reply }, + { 12, xinputChangePointerDevice_Reply }, + { 13, xinputGrabDevice_Reply }, + { 20, xinputGetDeviceFocus_Reply }, + { 22, xinputGetFeedbackControl_Reply }, + { 24, xinputGetDeviceKeyMapping_Reply }, + { 26, xinputGetDeviceModifierMapping_Reply }, + { 27, xinputSetDeviceModifierMapping_Reply }, + { 28, xinputGetDeviceButtonMapping_Reply }, + { 29, xinputSetDeviceButtonMapping_Reply }, + { 30, xinputQueryDeviceState_Reply }, + { 33, xinputSetDeviceValuators_Reply }, + { 34, xinputGetDeviceControl_Reply }, + { 0, NULL } +}; + +static void dispatch_xinput(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xinput_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xinput_extension_minor, + "")); + switch (minor) { + case 1: + xinputGetExtensionVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xinputListInputDevices(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xinputOpenDevice(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xinputCloseDevice(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xinputSetDeviceMode(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xinputSelectExtensionEvent(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xinputGetSelectedExtensionEvents(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xinputChangeDeviceDontPropagateList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xinputGetDeviceDontPropagateList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xinputGetDeviceMotionEvents(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xinputChangeKeyboardDevice(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + xinputChangePointerDevice(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + xinputGrabDevice(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + xinputUngrabDevice(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + xinputGrabDeviceKey(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + xinputUngrabDeviceKey(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + xinputGrabDeviceButton(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + xinputUngrabDeviceButton(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + xinputAllowDeviceEvents(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + xinputGetDeviceFocus(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 21: + xinputSetDeviceFocus(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + xinputGetFeedbackControl(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 24: + xinputGetDeviceKeyMapping(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 25: + xinputChangeDeviceKeyMapping(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 26: + xinputGetDeviceModifierMapping(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 27: + xinputSetDeviceModifierMapping(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 28: + xinputGetDeviceButtonMapping(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 29: + xinputSetDeviceButtonMapping(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 30: + xinputQueryDeviceState(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 31: + xinputSendExtensionEvent(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 32: + xinputDeviceBell(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 33: + xinputSetDeviceValuators(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 34: + xinputGetDeviceControl(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xinput(void) +{ + set_handler("XInputExtension", dispatch_xinput, xinput_errors, xinput_events, xinput_replies); +} + +static int struct_size_PRINTER(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_nameLen; + int f_descLen; + f_nameLen = VALUE32(tvb, *offsetp + size + 0); + size += f_nameLen * 1; + f_descLen = VALUE32(tvb, *offsetp + size + 4); + size += f_descLen * 1; + return size + 8; +} + +static void struct_PRINTER(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_nameLen; + int f_descLen; + + item = proto_tree_add_item(root, hf_x11_struct_PRINTER, tvb, *offsetp, struct_size_PRINTER(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_nameLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PRINTER_nameLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_struct_PRINTER_name, f_nameLen, little_endian); + f_descLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_PRINTER_descLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_struct_PRINTER_description, f_descLen, little_endian); + } +} + +static void xprintPrintQueryVersion(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xprintPrintQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintQueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintQueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintQueryVersion_reply_major_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintQueryVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xprintPrintGetPrinterList(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_printerNameLen; + int f_localeLen; + f_printerNameLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPrinterList_printerNameLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_localeLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPrinterList_localeLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintGetPrinterList_printer_name, f_printerNameLen, little_endian); + length -= f_printerNameLen * 1; + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintGetPrinterList_locale, f_localeLen, little_endian); + length -= f_localeLen * 1; +} +static void xprintPrintGetPrinterList_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_listCount; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetPrinterList"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetPrinterList)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_listCount = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPrinterList_reply_listCount, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_PRINTER(tvb, offsetp, t, little_endian, f_listCount); +} + +static void xprintPrintRehashPrinterList(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} + +static void xprintCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_id; + int f_printerNameLen; + int f_localeLen; + f_context_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_CreateContext_context_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_printerNameLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_CreateContext_printerNameLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_localeLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_CreateContext_localeLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xprint_CreateContext_printerName, f_printerNameLen, little_endian); + length -= f_printerNameLen * 1; + listOfByte(tvb, offsetp, t, hf_x11_xprint_CreateContext_locale, f_localeLen, little_endian); + length -= f_localeLen * 1; +} + +static void xprintPrintSetContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintGetContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xprintPrintGetContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetContext_reply_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintDestroyContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintDestroyContext_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintGetScreenOfContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xprintPrintGetScreenOfContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_root; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetScreenOfContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetScreenOfContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetScreenOfContext_reply_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintStartJob(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_output_mode; + f_output_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintStartJob_output_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xprintPrintEndJob(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cancel; + f_cancel = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintEndJob_cancel, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xprintPrintStartDoc(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_driver_mode; + f_driver_mode = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintStartDoc_driver_mode, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xprintPrintEndDoc(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cancel; + f_cancel = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintEndDoc_cancel, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xprintPrintPutDocumentData(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_len_data; + int f_len_fmt; + int f_len_options; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintPutDocumentData_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_len_data = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintPutDocumentData_len_data, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_len_fmt = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintPutDocumentData_len_fmt, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_len_options = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintPutDocumentData_len_options, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintPutDocumentData_data, f_len_data, little_endian); + length -= f_len_data * 1; + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintPutDocumentData_doc_format, (length - 16) / 1, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintPutDocumentData_options, (length - 16) / 1, little_endian); +} + +static void xprintPrintGetDocumentData(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_max_bytes; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetDocumentData_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_max_bytes = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetDocumentData_max_bytes, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xprintPrintGetDocumentData_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status_code; + int f_finished_flag; + int f_dataLen; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetDocumentData"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetDocumentData)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_status_code = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetDocumentData_reply_status_code, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_finished_flag = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetDocumentData_reply_finished_flag, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_dataLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetDocumentData_reply_dataLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(12); + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintGetDocumentData_reply_data, f_dataLen, little_endian); +} + +static void xprintPrintStartPage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintStartPage_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintEndPage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_cancel; + f_cancel = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintEndPage_cancel, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void xprintPrintSelectInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSelectInput_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintInputSelected(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintInputSelected_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xprintPrintInputSelected_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintInputSelected"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintInputSelected)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xprintPrintGetAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_pool; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetAttributes_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pool = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetAttributes_pool, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xprintPrintGetAttributes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_stringLen; + int f_attributes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetAttributes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetAttributes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_stringLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetAttributes_reply_stringLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + f_attributes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetAttributes_reply_attributes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xprintPrintGetOneAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_nameLen; + int f_pool; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetOneAttributes_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_nameLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetOneAttributes_nameLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pool = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetOneAttributes_pool, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintGetOneAttributes_name, f_nameLen, little_endian); + length -= f_nameLen * 1; +} +static void xprintPrintGetOneAttributes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_valueLen; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetOneAttributes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetOneAttributes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_valueLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetOneAttributes_reply_valueLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintGetOneAttributes_reply_value, f_valueLen, little_endian); +} + +static void xprintPrintSetAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_stringLen; + int f_pool; + int f_rule; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetAttributes_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_stringLen = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetAttributes_stringLen, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_pool = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetAttributes_pool, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_rule = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetAttributes_rule, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_xprint_PrintSetAttributes_attributes, (length - 16) / 1, little_endian); +} + +static void xprintPrintGetPageDimensions(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xprintPrintGetPageDimensions_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width; + int f_height; + int f_offset_x; + int f_offset_y; + int f_reproducible_width; + int f_reproducible_height; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetPageDimensions"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetPageDimensions)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_reply_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_reply_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_offset_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_reply_offset_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_offset_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_reply_offset_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_reproducible_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_reproducible_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xprintPrintQueryScreens(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xprintPrintQueryScreens_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_listCount; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintQueryScreens"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintQueryScreens)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_listCount = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintQueryScreens_reply_listCount, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_xprint_PrintQueryScreens_reply_roots, hf_x11_xprint_PrintQueryScreens_reply_roots_item, f_listCount, little_endian); +} + +static void xprintPrintSetImageResolution(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + int f_image_resolution; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetImageResolution_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_image_resolution = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetImageResolution_image_resolution, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xprintPrintSetImageResolution_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_status; + int f_previous_resolutions; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintSetImageResolution"); + + REPLY(reply); + f_status = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetImageResolution_reply_status, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintSetImageResolution)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_previous_resolutions = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintSetImageResolution_reply_previous_resolutions, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xprintPrintGetImageResolution(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetImageResolution_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xprintPrintGetImageResolution_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_image_resolution; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-PrintGetImageResolution"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xprint-PrintGetImageResolution)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_image_resolution = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_PrintGetImageResolution_reply_image_resolution, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xprintNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_detail; + int f_context; + int f_cancel; + f_detail = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_Notify_detail, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_Notify_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_cancel = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_Notify_cancel, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xprintAttributNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_detail; + int f_context; + f_detail = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_AttributNotify_detail, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xprint_AttributNotify_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static const value_string xprint_extension_minor[] = { + { 0, "PrintQueryVersion" }, + { 1, "PrintGetPrinterList" }, + { 2, "CreateContext" }, + { 3, "PrintSetContext" }, + { 4, "PrintGetContext" }, + { 5, "PrintDestroyContext" }, + { 6, "PrintGetScreenOfContext" }, + { 7, "PrintStartJob" }, + { 8, "PrintEndJob" }, + { 9, "PrintStartDoc" }, + { 10, "PrintEndDoc" }, + { 11, "PrintPutDocumentData" }, + { 12, "PrintGetDocumentData" }, + { 13, "PrintStartPage" }, + { 14, "PrintEndPage" }, + { 15, "PrintSelectInput" }, + { 16, "PrintInputSelected" }, + { 17, "PrintGetAttributes" }, + { 18, "PrintSetAttributes" }, + { 19, "PrintGetOneAttributes" }, + { 20, "PrintRehashPrinterList" }, + { 21, "PrintGetPageDimensions" }, + { 22, "PrintQueryScreens" }, + { 23, "PrintSetImageResolution" }, + { 24, "PrintGetImageResolution" }, + { 0, NULL } +}; +const x11_event_info xprint_events[] = { + { "xprint-Notify", xprintNotify }, + { "xprint-AttributNotify", xprintAttributNotify }, + { NULL, NULL } +}; +static x11_reply_info xprint_replies[] = { + { 0, xprintPrintQueryVersion_Reply }, + { 1, xprintPrintGetPrinterList_Reply }, + { 4, xprintPrintGetContext_Reply }, + { 6, xprintPrintGetScreenOfContext_Reply }, + { 12, xprintPrintGetDocumentData_Reply }, + { 16, xprintPrintInputSelected_Reply }, + { 17, xprintPrintGetAttributes_Reply }, + { 19, xprintPrintGetOneAttributes_Reply }, + { 21, xprintPrintGetPageDimensions_Reply }, + { 22, xprintPrintQueryScreens_Reply }, + { 23, xprintPrintSetImageResolution_Reply }, + { 24, xprintPrintGetImageResolution_Reply }, + { 0, NULL } +}; + +static void dispatch_xprint(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xprint_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xprint_extension_minor, + "")); + switch (minor) { + case 0: + xprintPrintQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xprintPrintGetPrinterList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xprintCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xprintPrintSetContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xprintPrintGetContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xprintPrintDestroyContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xprintPrintGetScreenOfContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xprintPrintStartJob(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xprintPrintEndJob(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xprintPrintStartDoc(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xprintPrintEndDoc(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xprintPrintPutDocumentData(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + xprintPrintGetDocumentData(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + xprintPrintStartPage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + xprintPrintEndPage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + xprintPrintSelectInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + xprintPrintInputSelected(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + xprintPrintGetAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + xprintPrintSetAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + xprintPrintGetOneAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + xprintPrintRehashPrinterList(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 21: + xprintPrintGetPageDimensions(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + xprintPrintQueryScreens(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 23: + xprintPrintSetImageResolution(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 24: + xprintPrintGetImageResolution(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xprint(void) +{ + set_handler("XpExtension", dispatch_xprint, xprint_errors, xprint_events, xprint_replies); +} + +static void xselinuxQueryVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_client_major; + int f_client_minor; + f_client_major = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_QueryVersion_client_major, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_client_minor = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_QueryVersion_client_minor, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} +static void xselinuxQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_server_major; + int f_server_minor; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_server_major = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_QueryVersion_reply_server_major, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_server_minor = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_QueryVersion_reply_server_minor, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xselinuxSetDeviceCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_len; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetDeviceCreateContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetDeviceCreateContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetDeviceCreateContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxGetDeviceCreateContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceCreateContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetDeviceCreateContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetDeviceCreateContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetDeviceCreateContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxSetDeviceContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device; + int f_context_len; + f_device = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetDeviceContext_device, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetDeviceContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetDeviceContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetDeviceContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_device; + f_device = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetDeviceContext_device, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetDeviceContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetDeviceContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetDeviceContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetDeviceContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetDeviceContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxSetWindowCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_len; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetWindowCreateContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetWindowCreateContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetWindowCreateContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxGetWindowCreateContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetWindowCreateContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetWindowCreateContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetWindowCreateContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetWindowCreateContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxGetWindowContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetWindowContext_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetWindowContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetWindowContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetWindowContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetWindowContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetWindowContext_reply_context, f_context_len, little_endian); +} + +static int struct_size_ListItem(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_object_context_len; + int f_data_context_len; + f_object_context_len = VALUE32(tvb, *offsetp + size + 4); + f_data_context_len = VALUE32(tvb, *offsetp + size + 8); + size += f_object_context_len * 1; + size += f_data_context_len * 1; + return size + 12; +} + +static void struct_ListItem(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_name; + int f_object_context_len; + int f_data_context_len; + + item = proto_tree_add_item(root, hf_x11_struct_ListItem, tvb, *offsetp, struct_size_ListItem(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_name = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ListItem_name, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_object_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ListItem_object_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_data_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ListItem_data_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_struct_ListItem_object_context, f_object_context_len, little_endian); + listOfByte(tvb, offsetp, t, hf_x11_struct_ListItem_data_context, f_data_context_len, little_endian); + } +} + +static void xselinuxSetPropertyCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_len; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetPropertyCreateContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetPropertyCreateContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetPropertyCreateContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxGetPropertyCreateContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPropertyCreateContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetPropertyCreateContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyCreateContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetPropertyCreateContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxSetPropertyUseContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_len; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetPropertyUseContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetPropertyUseContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetPropertyUseContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxGetPropertyUseContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPropertyUseContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetPropertyUseContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyUseContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetPropertyUseContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxGetPropertyContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_property; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyContext_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyContext_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetPropertyContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPropertyContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetPropertyContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetPropertyContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxGetPropertyDataContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_property; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyDataContext_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_property = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyDataContext_property, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetPropertyDataContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPropertyDataContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetPropertyDataContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetPropertyDataContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetPropertyDataContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxListProperties(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_ListProperties_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxListProperties_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_properties_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListProperties"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-ListProperties)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_properties_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_ListProperties_reply_properties_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_ListItem(tvb, offsetp, t, little_endian, f_properties_len); +} + +static void xselinuxSetSelectionCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_len; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetSelectionCreateContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetSelectionCreateContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetSelectionCreateContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxGetSelectionCreateContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetSelectionCreateContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetSelectionCreateContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetSelectionCreateContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetSelectionCreateContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxSetSelectionUseContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_len; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_SetSelectionUseContext_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_xselinux_SetSelectionUseContext_context, f_context_len, little_endian); + length -= f_context_len * 1; +} + +static void xselinuxGetSelectionUseContext(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxGetSelectionUseContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetSelectionUseContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetSelectionUseContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetSelectionUseContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetSelectionUseContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxGetSelectionContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_selection; + f_selection = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetSelectionContext_selection, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetSelectionContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetSelectionContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetSelectionContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetSelectionContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetSelectionContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxGetSelectionDataContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_selection; + f_selection = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetSelectionDataContext_selection, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetSelectionDataContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetSelectionDataContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetSelectionDataContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetSelectionDataContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetSelectionDataContext_reply_context, f_context_len, little_endian); +} + +static void xselinuxListSelections(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xselinuxListSelections_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_selections_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListSelections"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-ListSelections)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_selections_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_ListSelections_reply_selections_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_ListItem(tvb, offsetp, t, little_endian, f_selections_len); +} + +static void xselinuxGetClientContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_resource; + f_resource = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetClientContext_resource, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xselinuxGetClientContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_context_len; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetClientContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xselinux-GetClientContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_len = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xselinux_GetClientContext_reply_context_len, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfByte(tvb, offsetp, t, hf_x11_xselinux_GetClientContext_reply_context, f_context_len, little_endian); +} +static const value_string xselinux_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "SetDeviceCreateContext" }, + { 2, "GetDeviceCreateContext" }, + { 3, "SetDeviceContext" }, + { 4, "GetDeviceContext" }, + { 5, "SetWindowCreateContext" }, + { 6, "GetWindowCreateContext" }, + { 7, "GetWindowContext" }, + { 8, "SetPropertyCreateContext" }, + { 9, "GetPropertyCreateContext" }, + { 10, "SetPropertyUseContext" }, + { 11, "GetPropertyUseContext" }, + { 12, "GetPropertyContext" }, + { 13, "GetPropertyDataContext" }, + { 14, "ListProperties" }, + { 15, "SetSelectionCreateContext" }, + { 16, "GetSelectionCreateContext" }, + { 17, "SetSelectionUseContext" }, + { 18, "GetSelectionUseContext" }, + { 19, "GetSelectionContext" }, + { 20, "GetSelectionDataContext" }, + { 21, "ListSelections" }, + { 22, "GetClientContext" }, + { 0, NULL } +}; +const x11_event_info xselinux_events[] = { + { NULL, NULL } +}; +static x11_reply_info xselinux_replies[] = { + { 0, xselinuxQueryVersion_Reply }, + { 2, xselinuxGetDeviceCreateContext_Reply }, + { 4, xselinuxGetDeviceContext_Reply }, + { 6, xselinuxGetWindowCreateContext_Reply }, + { 7, xselinuxGetWindowContext_Reply }, + { 9, xselinuxGetPropertyCreateContext_Reply }, + { 11, xselinuxGetPropertyUseContext_Reply }, + { 12, xselinuxGetPropertyContext_Reply }, + { 13, xselinuxGetPropertyDataContext_Reply }, + { 14, xselinuxListProperties_Reply }, + { 16, xselinuxGetSelectionCreateContext_Reply }, + { 18, xselinuxGetSelectionUseContext_Reply }, + { 19, xselinuxGetSelectionContext_Reply }, + { 20, xselinuxGetSelectionDataContext_Reply }, + { 21, xselinuxListSelections_Reply }, + { 22, xselinuxGetClientContext_Reply }, + { 0, NULL } +}; + +static void dispatch_xselinux(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xselinux_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xselinux_extension_minor, + "")); + switch (minor) { + case 0: + xselinuxQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xselinuxSetDeviceCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xselinuxGetDeviceCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xselinuxSetDeviceContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xselinuxGetDeviceContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xselinuxSetWindowCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xselinuxGetWindowCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xselinuxGetWindowContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xselinuxSetPropertyCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xselinuxGetPropertyCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xselinuxSetPropertyUseContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xselinuxGetPropertyUseContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + xselinuxGetPropertyContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + xselinuxGetPropertyDataContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + xselinuxListProperties(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + xselinuxSetSelectionCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + xselinuxGetSelectionCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + xselinuxSetSelectionUseContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + xselinuxGetSelectionUseContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + xselinuxGetSelectionContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 20: + xselinuxGetSelectionDataContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 21: + xselinuxListSelections(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 22: + xselinuxGetClientContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xselinux(void) +{ + set_handler("SELinux", dispatch_xselinux, xselinux_errors, xselinux_events, xselinux_replies); +} + +static void xtestGetVersion(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_major_version; + int f_minor_version; + f_major_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_GetVersion_major_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_GetVersion_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xtestGetVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major_version; + int f_minor_version; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetVersion"); + + REPLY(reply); + f_major_version = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_GetVersion_reply_major_version, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xtest-GetVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor_version = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_GetVersion_reply_minor_version, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xtestCompareCursor(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + int f_cursor; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_CompareCursor_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_cursor = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_CompareCursor_cursor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xtestCompareCursor_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_same; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CompareCursor"); + + REPLY(reply); + f_same = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_CompareCursor_reply_same, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xtest-CompareCursor)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xtestFakeInput(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_type; + int f_detail; + int f_time; + int f_root; + int f_rootX; + int f_rootY; + int f_deviceid; + f_type = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_type, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_detail = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_detail, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_root = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_root, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(8); + f_rootX = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_rootX, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_rootY = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_rootY, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(7); + f_deviceid = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_FakeInput_deviceid, tvb, *offsetp, 1, little_endian); + *offsetp += 1; +} + +static void xtestGrabControl(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_impervious; + f_impervious = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xtest_GrabControl_impervious, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static const value_string xtest_extension_minor[] = { + { 0, "GetVersion" }, + { 1, "CompareCursor" }, + { 2, "FakeInput" }, + { 3, "GrabControl" }, + { 0, NULL } +}; +const x11_event_info xtest_events[] = { + { NULL, NULL } +}; +static x11_reply_info xtest_replies[] = { + { 0, xtestGetVersion_Reply }, + { 1, xtestCompareCursor_Reply }, + { 0, NULL } +}; + +static void dispatch_xtest(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xtest_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xtest_extension_minor, + "")); + switch (minor) { + case 0: + xtestGetVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xtestCompareCursor(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xtestFakeInput(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xtestGrabControl(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xtest(void) +{ + set_handler("XTEST", dispatch_xtest, xtest_errors, xtest_events, xtest_replies); +} + +static void struct_Rational(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_numerator; + int f_denominator; + + item = proto_tree_add_item(root, hf_x11_struct_Rational, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_numerator = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Rational_numerator, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_denominator = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Rational_denominator, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void struct_Format(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_visual; + int f_depth; + + item = proto_tree_add_item(root, hf_x11_struct_Format, tvb, *offsetp, 8, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_visual = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Format_visual, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_Format_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + } +} + +static int struct_size_AdaptorInfo(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_name_size; + int f_num_formats; + f_name_size = VALUE16(tvb, *offsetp + size + 4); + f_num_formats = VALUE16(tvb, *offsetp + size + 8); + size += f_name_size * 1; + size += f_num_formats * 8; + return size + 12; +} + +static void struct_AdaptorInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_base_id; + int f_name_size; + int f_num_ports; + int f_num_formats; + int f_type; + + item = proto_tree_add_item(root, hf_x11_struct_AdaptorInfo, tvb, *offsetp, struct_size_AdaptorInfo(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_base_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AdaptorInfo_base_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_name_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AdaptorInfo_name_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_ports = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AdaptorInfo_num_ports, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_formats = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AdaptorInfo_num_formats, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_type = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AdaptorInfo_type, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(1); + listOfByte(tvb, offsetp, t, hf_x11_struct_AdaptorInfo_name, f_name_size, little_endian); + struct_Format(tvb, offsetp, t, little_endian, f_num_formats); + } +} + +static int struct_size_EncodingInfo(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_name_size; + f_name_size = VALUE16(tvb, *offsetp + size + 4); + size += f_name_size * 1; + return size + 20; +} + +static void struct_EncodingInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_encoding; + int f_name_size; + int f_width; + int f_height; + + item = proto_tree_add_item(root, hf_x11_struct_EncodingInfo, tvb, *offsetp, struct_size_EncodingInfo(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_encoding = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_EncodingInfo_encoding, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_name_size = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_EncodingInfo_name_size, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_EncodingInfo_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_EncodingInfo_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(2); + struct_Rational(tvb, offsetp, t, little_endian, 1); + listOfByte(tvb, offsetp, t, hf_x11_struct_EncodingInfo_name, f_name_size, little_endian); + } +} + +static int struct_size_AttributeInfo(tvbuff_t *tvb, int *offsetp, int little_endian _U_) +{ + int size = 0; + int f_size; + f_size = VALUE32(tvb, *offsetp + size + 12); + size += f_size * 1; + return size + 16; +} + +static void struct_AttributeInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_flags; + int f_min; + int f_max; + int f_size; + + item = proto_tree_add_item(root, hf_x11_struct_AttributeInfo, tvb, *offsetp, struct_size_AttributeInfo(tvb, offsetp, little_endian), little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AttributeInfo_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_min = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AttributeInfo_min, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_max = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AttributeInfo_max, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_AttributeInfo_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_struct_AttributeInfo_name, f_size, little_endian); + } +} + +static void struct_ImageFormatInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_id; + int f_type; + int f_byte_order; + int f_bpp; + int f_num_planes; + int f_depth; + int f_red_mask; + int f_green_mask; + int f_blue_mask; + int f_format; + int f_y_sample_bits; + int f_u_sample_bits; + int f_v_sample_bits; + int f_vhorz_y_period; + int f_vhorz_u_period; + int f_vhorz_v_period; + int f_vvert_y_period; + int f_vvert_u_period; + int f_vvert_v_period; + int f_vscanline_order; + + item = proto_tree_add_item(root, hf_x11_struct_ImageFormatInfo, tvb, *offsetp, 82, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_type = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_type, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_byte_order = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_byte_order, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + listOfByte(tvb, offsetp, t, hf_x11_struct_ImageFormatInfo_guid, 16, little_endian); + f_bpp = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_bpp, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + f_num_planes = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_num_planes, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(2); + f_depth = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_depth, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_red_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_red_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_green_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_green_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_blue_mask = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_blue_mask, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_format = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_format, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); + f_y_sample_bits = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_y_sample_bits, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_u_sample_bits = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_u_sample_bits, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_v_sample_bits = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_v_sample_bits, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vhorz_y_period = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vhorz_y_period, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vhorz_u_period = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vhorz_u_period, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vhorz_v_period = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vhorz_v_period, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vvert_y_period = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vvert_y_period, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vvert_u_period = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vvert_u_period, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vvert_v_period = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vvert_v_period, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + listOfByte(tvb, offsetp, t, hf_x11_struct_ImageFormatInfo_vcomp_order, 32, little_endian); + f_vscanline_order = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_ImageFormatInfo_vscanline_order, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(11); + } +} + +static void xvVideoNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_reason; + int f_time; + int f_drawable; + int f_port; + f_reason = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_VideoNotify_reason, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_VideoNotify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_VideoNotify_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_VideoNotify_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvPortNotify(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian) +{ + int f_time; + int f_port; + int f_attribute; + int f_value; + UNUSED(1); + CARD16(event_sequencenumber); + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PortNotify_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PortNotify_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_attribute = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PortNotify_attribute, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_value = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PortNotify_value, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvQueryExtension(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xvQueryExtension_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major; + int f_minor; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryExtension"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-QueryExtension)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryExtension_reply_major, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_minor = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryExtension_reply_minor, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xvQueryAdaptors(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_window; + f_window = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryAdaptors_window, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvQueryAdaptors_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_adaptors; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryAdaptors"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-QueryAdaptors)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_adaptors = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryAdaptors_reply_num_adaptors, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); + struct_AdaptorInfo(tvb, offsetp, t, little_endian, f_num_adaptors); +} + +static void xvQueryEncodings(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryEncodings_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvQueryEncodings_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_encodings; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryEncodings"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-QueryEncodings)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_encodings = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryEncodings_reply_num_encodings, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(22); + struct_EncodingInfo(tvb, offsetp, t, little_endian, f_num_encodings); +} + +static void xvGrabPort(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_time; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GrabPort_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GrabPort_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvGrabPort_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_result; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GrabPort"); + + REPLY(reply); + f_result = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GrabPort_reply_result, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-GrabPort)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvUngrabPort(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_time; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_UngrabPort_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_time = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_UngrabPort_time, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvPutVideo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + int f_gc; + int f_vid_x; + int f_vid_y; + int f_vid_w; + int f_vid_h; + int f_drw_x; + int f_drw_y; + int f_drw_w; + int f_drw_h; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vid_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_vid_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_vid_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_vid_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_vid_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_drw_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_drw_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutVideo_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xvPutStill(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + int f_gc; + int f_vid_x; + int f_vid_y; + int f_vid_w; + int f_vid_h; + int f_drw_x; + int f_drw_y; + int f_drw_w; + int f_drw_h; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vid_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_vid_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_vid_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_vid_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_vid_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_drw_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_drw_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutStill_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xvGetVideo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + int f_gc; + int f_vid_x; + int f_vid_y; + int f_vid_w; + int f_vid_h; + int f_drw_x; + int f_drw_y; + int f_drw_w; + int f_drw_h; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vid_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_vid_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_vid_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_vid_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_vid_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_drw_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_drw_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetVideo_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xvGetStill(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + int f_gc; + int f_vid_x; + int f_vid_y; + int f_vid_w; + int f_vid_h; + int f_drw_x; + int f_drw_y; + int f_drw_w; + int f_drw_h; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vid_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_vid_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_vid_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_vid_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_vid_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_drw_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_drw_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetStill_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xvStopVideo(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_StopVideo_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_StopVideo_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvSelectVideoNotify(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_drawable; + int f_onoff; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SelectVideoNotify_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_onoff = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SelectVideoNotify_onoff, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void xvSelectPortNotify(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_onoff; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SelectPortNotify_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_onoff = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SelectPortNotify_onoff, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} + +static void xvQueryBestSize(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_vid_w; + int f_vid_h; + int f_drw_w; + int f_drw_h; + int f_motion; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_vid_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_vid_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_vid_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_vid_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_motion = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_motion, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static void xvQueryBestSize_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_actual_width; + int f_actual_height; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryBestSize"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-QueryBestSize)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_actual_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_reply_actual_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_actual_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryBestSize_reply_actual_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} + +static void xvSetPortAttribute(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_attribute; + int f_value; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SetPortAttribute_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_attribute = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SetPortAttribute_attribute, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_value = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_SetPortAttribute_value, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvGetPortAttribute(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_attribute; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetPortAttribute_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_attribute = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetPortAttribute_attribute, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvGetPortAttribute_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_value; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-GetPortAttribute"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-GetPortAttribute)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_value = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_GetPortAttribute_reply_value, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvQueryPortAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryPortAttributes_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvQueryPortAttributes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_attributes; + int f_text_size; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryPortAttributes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-QueryPortAttributes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_attributes = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryPortAttributes_reply_num_attributes, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_text_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryPortAttributes_reply_text_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(16); + struct_AttributeInfo(tvb, offsetp, t, little_endian, f_num_attributes); +} + +static void xvListImageFormats(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ListImageFormats_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvListImageFormats_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_formats; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListImageFormats"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-ListImageFormats)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_formats = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ListImageFormats_reply_num_formats, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_ImageFormatInfo(tvb, offsetp, t, little_endian, f_num_formats); +} + +static void xvQueryImageAttributes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_id; + int f_width; + int f_height; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xvQueryImageAttributes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num_planes; + int f_data_size; + int f_width; + int f_height; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryImageAttributes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xv-QueryImageAttributes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num_planes = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_reply_num_planes, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_data_size = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_reply_data_size, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_reply_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_QueryImageAttributes_reply_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + UNUSED(12); + listOfCard32(tvb, offsetp, t, hf_x11_xv_QueryImageAttributes_reply_pitches, hf_x11_xv_QueryImageAttributes_reply_pitches_item, f_num_planes, little_endian); + listOfCard32(tvb, offsetp, t, hf_x11_xv_QueryImageAttributes_reply_offsets, hf_x11_xv_QueryImageAttributes_reply_offsets_item, f_num_planes, little_endian); +} + +static void xvPutImage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + int f_gc; + int f_id; + int f_src_x; + int f_src_y; + int f_src_w; + int f_src_h; + int f_drw_x; + int f_drw_y; + int f_drw_w; + int f_drw_h; + int f_width; + int f_height; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_src_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_src_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_drw_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_drw_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_PutImage_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_xv_PutImage_data, (length - 40) / 1, little_endian); +} + +static void xvShmPutImage(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port; + int f_drawable; + int f_gc; + int f_shmseg; + int f_id; + int f_offset; + int f_src_x; + int f_src_y; + int f_src_w; + int f_src_h; + int f_drw_x; + int f_drw_y; + int f_drw_w; + int f_drw_h; + int f_width; + int f_height; + int f_send_event; + f_port = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_port, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_drawable = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_drawable, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_gc = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_gc, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_shmseg = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_shmseg, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_offset = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_offset, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_src_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_src_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_src_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_src_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_src_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_src_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_x = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_drw_x, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_y = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_drw_y, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_w = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_drw_w, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_drw_h = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_drw_h, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_send_event = VALUE8(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xv_ShmPutImage_send_event, tvb, *offsetp, 1, little_endian); + *offsetp += 1; + UNUSED(3); +} +static const value_string xv_extension_minor[] = { + { 0, "QueryExtension" }, + { 1, "QueryAdaptors" }, + { 2, "QueryEncodings" }, + { 3, "GrabPort" }, + { 4, "UngrabPort" }, + { 5, "PutVideo" }, + { 6, "PutStill" }, + { 7, "GetVideo" }, + { 8, "GetStill" }, + { 9, "StopVideo" }, + { 10, "SelectVideoNotify" }, + { 11, "SelectPortNotify" }, + { 12, "QueryBestSize" }, + { 13, "SetPortAttribute" }, + { 14, "GetPortAttribute" }, + { 15, "QueryPortAttributes" }, + { 16, "ListImageFormats" }, + { 17, "QueryImageAttributes" }, + { 18, "PutImage" }, + { 19, "ShmPutImage" }, + { 0, NULL } +}; +const x11_event_info xv_events[] = { + { "xv-VideoNotify", xvVideoNotify }, + { "xv-PortNotify", xvPortNotify }, + { NULL, NULL } +}; +static x11_reply_info xv_replies[] = { + { 0, xvQueryExtension_Reply }, + { 1, xvQueryAdaptors_Reply }, + { 2, xvQueryEncodings_Reply }, + { 3, xvGrabPort_Reply }, + { 12, xvQueryBestSize_Reply }, + { 14, xvGetPortAttribute_Reply }, + { 15, xvQueryPortAttributes_Reply }, + { 16, xvListImageFormats_Reply }, + { 17, xvQueryImageAttributes_Reply }, + { 0, NULL } +}; + +static void dispatch_xv(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xv_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xv_extension_minor, + "")); + switch (minor) { + case 0: + xvQueryExtension(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xvQueryAdaptors(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xvQueryEncodings(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xvGrabPort(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xvUngrabPort(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xvPutVideo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xvPutStill(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xvGetVideo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xvGetStill(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 9: + xvStopVideo(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 10: + xvSelectVideoNotify(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 11: + xvSelectPortNotify(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 12: + xvQueryBestSize(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 13: + xvSetPortAttribute(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 14: + xvGetPortAttribute(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 15: + xvQueryPortAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 16: + xvListImageFormats(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 17: + xvQueryImageAttributes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 18: + xvPutImage(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 19: + xvShmPutImage(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xv(void) +{ + set_handler("XVideo", dispatch_xv, xv_errors, xv_events, xv_replies); +} + +static void struct_SurfaceInfo(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count) +{ + int i; + for (i = 0; i < count; i++) { + proto_item *item; + proto_tree *t; + int f_id; + int f_chroma_format; + int f_pad0; + int f_max_width; + int f_max_height; + int f_subpicture_max_width; + int f_subpicture_max_height; + int f_mc_type; + int f_flags; + + item = proto_tree_add_item(root, hf_x11_struct_SurfaceInfo, tvb, *offsetp, 24, little_endian); + t = proto_item_add_subtree(item, ett_x11_rectangle); + f_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_chroma_format = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_chroma_format, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_pad0 = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_pad0, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_max_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_max_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_max_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_max_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_subpicture_max_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_subpicture_max_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_subpicture_max_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_subpicture_max_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_mc_type = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_mc_type, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_struct_SurfaceInfo_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + } +} + +static void xvmcQueryVersion(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_) +{ +} +static void xvmcQueryVersion_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_major; + int f_minor; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-QueryVersion"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xvmc-QueryVersion)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_major = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_QueryVersion_reply_major, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_minor = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_QueryVersion_reply_minor, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvmcListSurfaceTypes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port_id; + f_port_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_ListSurfaceTypes_port_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvmcListSurfaceTypes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListSurfaceTypes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xvmc-ListSurfaceTypes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_ListSurfaceTypes_reply_num, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_SurfaceInfo(tvb, offsetp, t, little_endian, f_num); +} + +static void xvmcCreateContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_id; + int f_port_id; + int f_surface_id; + int f_width; + int f_height; + int f_flags; + f_context_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_context_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_port_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_port_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_surface_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_surface_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_flags = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_flags, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvmcCreateContext_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width_actual; + int f_height_actual; + int f_flags_return; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CreateContext"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xvmc-CreateContext)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width_actual = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_reply_width_actual, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height_actual = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_reply_height_actual, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_flags_return = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateContext_reply_flags_return, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + listOfCard32(tvb, offsetp, t, hf_x11_xvmc_CreateContext_reply_priv_data, hf_x11_xvmc_CreateContext_reply_priv_data_item, f_length, little_endian); +} + +static void xvmcDestroyContext(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_context_id; + f_context_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_DestroyContext_context_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvmcCreateSurface(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_surface_id; + int f_context_id; + f_surface_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSurface_surface_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSurface_context_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvmcCreateSurface_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CreateSurface"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xvmc-CreateSurface)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(24); + listOfCard32(tvb, offsetp, t, hf_x11_xvmc_CreateSurface_reply_priv_data, hf_x11_xvmc_CreateSurface_reply_priv_data_item, f_length, little_endian); +} + +static void xvmcDestroySurface(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_surface_id; + f_surface_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_DestroySurface_surface_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvmcCreateSubpicture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_subpicture_id; + int f_context; + int f_xvimage_id; + int f_width; + int f_height; + f_subpicture_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_subpicture_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_context = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_context, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_xvimage_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_xvimage_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_width, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_height, tvb, *offsetp, 2, little_endian); + *offsetp += 2; +} +static void xvmcCreateSubpicture_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_width_actual; + int f_height_actual; + int f_num_palette_entries; + int f_entry_bytes; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-CreateSubpicture"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xvmc-CreateSubpicture)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_width_actual = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_reply_width_actual, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_height_actual = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_reply_height_actual, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_num_palette_entries = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_reply_num_palette_entries, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + f_entry_bytes = VALUE16(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_CreateSubpicture_reply_entry_bytes, tvb, *offsetp, 2, little_endian); + *offsetp += 2; + listOfByte(tvb, offsetp, t, hf_x11_xvmc_CreateSubpicture_reply_component_order, 4, little_endian); + UNUSED(12); + listOfCard32(tvb, offsetp, t, hf_x11_xvmc_CreateSubpicture_reply_priv_data, hf_x11_xvmc_CreateSubpicture_reply_priv_data_item, f_length, little_endian); +} + +static void xvmcDestroySubpicture(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_subpicture_id; + f_subpicture_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_DestroySubpicture_subpicture_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} + +static void xvmcListSubpictureTypes(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_) +{ + int f_port_id; + int f_surface_id; + f_port_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_ListSubpictureTypes_port_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_surface_id = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_ListSubpictureTypes_surface_id, tvb, *offsetp, 4, little_endian); + *offsetp += 4; +} +static void xvmcListSubpictureTypes_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int f_length, length, sequence_number; + int f_num; + + col_append_fstr(pinfo->cinfo, COL_INFO, "-ListSubpictureTypes"); + + REPLY(reply); + UNUSED(1); + sequence_number = VALUE16(tvb, *offsetp); + proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number, + "sequencenumber: %d (xvmc-ListSubpictureTypes)", sequence_number); + *offsetp += 2; + f_length = VALUE32(tvb, *offsetp); + length = f_length * 4 + 32; + proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + f_num = VALUE32(tvb, *offsetp); + proto_tree_add_item(t, hf_x11_xvmc_ListSubpictureTypes_reply_num, tvb, *offsetp, 4, little_endian); + *offsetp += 4; + UNUSED(20); + struct_ImageFormatInfo(tvb, offsetp, t, little_endian, f_num); +} +static const value_string xvmc_extension_minor[] = { + { 0, "QueryVersion" }, + { 1, "ListSurfaceTypes" }, + { 2, "CreateContext" }, + { 3, "DestroyContext" }, + { 4, "CreateSurface" }, + { 5, "DestroySurface" }, + { 6, "CreateSubpicture" }, + { 7, "DestroySubpicture" }, + { 8, "ListSubpictureTypes" }, + { 0, NULL } +}; +const x11_event_info xvmc_events[] = { + { NULL, NULL } +}; +static x11_reply_info xvmc_replies[] = { + { 0, xvmcQueryVersion_Reply }, + { 1, xvmcListSurfaceTypes_Reply }, + { 2, xvmcCreateContext_Reply }, + { 4, xvmcCreateSurface_Reply }, + { 6, xvmcCreateSubpicture_Reply }, + { 8, xvmcListSubpictureTypes_Reply }, + { 0, NULL } +}; + +static void dispatch_xvmc(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian) +{ + int minor, length; + minor = CARD8(xvmc_extension_minor); + length = REQUEST_LENGTH(); + + col_append_fstr(pinfo->cinfo, COL_INFO, "-%s", + val_to_str(minor, xvmc_extension_minor, + "")); + switch (minor) { + case 0: + xvmcQueryVersion(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 1: + xvmcListSurfaceTypes(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 2: + xvmcCreateContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 3: + xvmcDestroyContext(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 4: + xvmcCreateSurface(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 5: + xvmcDestroySurface(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 6: + xvmcCreateSubpicture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 7: + xvmcDestroySubpicture(tvb, pinfo, offsetp, t, little_endian, length); + break; + case 8: + xvmcListSubpictureTypes(tvb, pinfo, offsetp, t, little_endian, length); + break; + /* No need for a default case here, since Unknown is printed above, + and UNDECODED() is taken care of by dissect_x11_request */ + } +} + +static void register_xvmc(void) +{ + set_handler("XVideo-MotionCompensation", dispatch_xvmc, xvmc_errors, xvmc_events, xvmc_replies); +} +static void register_x11_extensions(void) +{ + register_bigreq(); + register_composite(); + register_damage(); + register_dpms(); + register_ge(); + register_glx(); + register_randr(); + register_record(); + register_render(); + register_res(); + register_screensaver(); + register_shape(); + register_shm(); + register_sync(); + register_xc_misc(); + register_xevie(); + register_xf86dri(); + register_xf86vidmode(); + register_xfixes(); + register_xinerama(); + register_xinput(); + register_xprint(); + register_xselinux(); + register_xtest(); + register_xv(); + register_xvmc(); +} diff --git a/epan/dissectors/x11-glx-render-enum.h b/epan/dissectors/x11-glx-render-enum.h new file mode 100644 index 0000000000..b2cf7c758b --- /dev/null +++ b/epan/dissectors/x11-glx-render-enum.h @@ -0,0 +1,1905 @@ +/* Do not modify this file. */ +/* It was automatically generated by process-x11-xcb.pl. */ +/* $Id$ */ + +/* + * Copyright 2008, 2009 Open Text Corporation + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +static const value_string mesa_enum[] = { +/* OpenGL version 1.0 */ + { 0x0000, "POINTS" }, + { 0x0001, "LINES" }, + { 0x0002, "LINE_LOOP" }, + { 0x0003, "LINE_STRIP" }, + { 0x0004, "TRIANGLES" }, + { 0x0005, "TRIANGLE_STRIP" }, + { 0x0006, "TRIANGLE_FAN" }, + { 0x0007, "QUADS" }, + { 0x0008, "QUAD_STRIP" }, + { 0x0009, "POLYGON" }, + { 0x0100, "ACCUM" }, + { 0x0101, "LOAD" }, + { 0x0102, "RETURN" }, + { 0x0103, "MULT" }, + { 0x0104, "ADD" }, + { 0x0200, "NEVER" }, + { 0x0201, "LESS" }, + { 0x0202, "EQUAL" }, + { 0x0203, "LEQUAL" }, + { 0x0204, "GREATER" }, + { 0x0205, "NOTEQUAL" }, + { 0x0206, "GEQUAL" }, + { 0x0207, "ALWAYS" }, + { 0x0300, "SRC_COLOR" }, + { 0x0301, "ONE_MINUS_SRC_COLOR" }, + { 0x0302, "SRC_ALPHA" }, + { 0x0303, "ONE_MINUS_SRC_ALPHA" }, + { 0x0304, "DST_ALPHA" }, + { 0x0305, "ONE_MINUS_DST_ALPHA" }, + { 0x0306, "DST_COLOR" }, + { 0x0307, "ONE_MINUS_DST_COLOR" }, + { 0x0308, "SRC_ALPHA_SATURATE" }, + { 0x0400, "FRONT_LEFT" }, + { 0x0401, "FRONT_RIGHT" }, + { 0x0402, "BACK_LEFT" }, + { 0x0403, "BACK_RIGHT" }, + { 0x0404, "FRONT" }, + { 0x0405, "BACK" }, + { 0x0406, "LEFT" }, + { 0x0407, "RIGHT" }, + { 0x0408, "FRONT_AND_BACK" }, + { 0x0409, "AUX0" }, + { 0x040A, "AUX1" }, + { 0x040B, "AUX2" }, + { 0x040C, "AUX3" }, + { 0x0501, "INVALID_VALUE" }, + { 0x0500, "INVALID_ENUM" }, + { 0x0502, "INVALID_OPERATION" }, + { 0x0503, "STACK_OVERFLOW" }, + { 0x0504, "STACK_UNDERFLOW" }, + { 0x0505, "OUT_OF_MEMORY" }, + { 0x0600, "2D" }, + { 0x0601, "3D" }, + { 0x0602, "3D_COLOR" }, + { 0x0603, "3D_COLOR_TEXTURE" }, + { 0x0604, "4D_COLOR_TEXTURE" }, + { 0x0700, "PASS_THROUGH_TOKEN" }, + { 0x0701, "POINT_TOKEN" }, + { 0x0702, "LINE_TOKEN" }, + { 0x0703, "POLYGON_TOKEN" }, + { 0x0704, "BITMAP_TOKEN" }, + { 0x0705, "DRAW_PIXEL_TOKEN" }, + { 0x0706, "COPY_PIXEL_TOKEN" }, + { 0x0707, "LINE_RESET_TOKEN" }, + { 0x0800, "EXP" }, + { 0x0801, "EXP2" }, + { 0x0900, "CW" }, + { 0x0901, "CCW" }, + { 0x0A00, "COEFF" }, + { 0x0A01, "ORDER" }, + { 0x0A02, "DOMAIN" }, + { 0x0B00, "CURRENT_COLOR" }, + { 0x0B01, "CURRENT_INDEX" }, + { 0x0B02, "CURRENT_NORMAL" }, + { 0x0B03, "CURRENT_TEXTURE_COORDS" }, + { 0x0B04, "CURRENT_RASTER_COLOR" }, + { 0x0B05, "CURRENT_RASTER_INDEX" }, + { 0x0B06, "CURRENT_RASTER_TEXTURE_COORDS" }, + { 0x0B07, "CURRENT_RASTER_POSITION" }, + { 0x0B08, "CURRENT_RASTER_POSITION_VALID" }, + { 0x0B09, "CURRENT_RASTER_DISTANCE" }, + { 0x0B10, "POINT_SMOOTH" }, + { 0x0B11, "POINT_SIZE" }, + { 0x0B12, "POINT_SIZE_RANGE" }, + { 0x0B13, "POINT_SIZE_GRANULARITY" }, + { 0x0B20, "LINE_SMOOTH" }, + { 0x0B21, "LINE_WIDTH" }, + { 0x0B22, "LINE_WIDTH_RANGE" }, + { 0x0B23, "LINE_WIDTH_GRANULARITY" }, + { 0x0B24, "LINE_STIPPLE" }, + { 0x0B25, "LINE_STIPPLE_PATTERN" }, + { 0x0B26, "LINE_STIPPLE_REPEAT" }, + { 0x0B30, "LIST_MODE" }, + { 0x0B31, "MAX_LIST_NESTING" }, + { 0x0B32, "LIST_BASE" }, + { 0x0B33, "LIST_INDEX" }, + { 0x0B40, "POLYGON_MODE" }, + { 0x0B41, "POLYGON_SMOOTH" }, + { 0x0B42, "POLYGON_STIPPLE" }, + { 0x0B43, "EDGE_FLAG" }, + { 0x0B44, "CULL_FACE" }, + { 0x0B45, "CULL_FACE_MODE" }, + { 0x0B46, "FRONT_FACE" }, + { 0x0B50, "LIGHTING" }, + { 0x0B51, "LIGHT_MODEL_LOCAL_VIEWER" }, + { 0x0B52, "LIGHT_MODEL_TWO_SIDE" }, + { 0x0B53, "LIGHT_MODEL_AMBIENT" }, + { 0x0B54, "SHADE_MODEL" }, + { 0x0B55, "COLOR_MATERIAL_FACE" }, + { 0x0B56, "COLOR_MATERIAL_PARAMETER" }, + { 0x0B57, "COLOR_MATERIAL" }, + { 0x0B60, "FOG" }, + { 0x0B61, "FOG_INDEX" }, + { 0x0B62, "FOG_DENSITY" }, + { 0x0B63, "FOG_START" }, + { 0x0B64, "FOG_END" }, + { 0x0B65, "FOG_MODE" }, + { 0x0B66, "FOG_COLOR" }, + { 0x0B70, "DEPTH_RANGE" }, + { 0x0B71, "DEPTH_TEST" }, + { 0x0B72, "DEPTH_WRITEMASK" }, + { 0x0B73, "DEPTH_CLEAR_VALUE" }, + { 0x0B74, "DEPTH_FUNC" }, + { 0x0B80, "ACCUM_CLEAR_VALUE" }, + { 0x0B90, "STENCIL_TEST" }, + { 0x0B91, "STENCIL_CLEAR_VALUE" }, + { 0x0B92, "STENCIL_FUNC" }, + { 0x0B93, "STENCIL_VALUE_MASK" }, + { 0x0B94, "STENCIL_FAIL" }, + { 0x0B95, "STENCIL_PASS_DEPTH_FAIL" }, + { 0x0B96, "STENCIL_PASS_DEPTH_PASS" }, + { 0x0B97, "STENCIL_REF" }, + { 0x0B98, "STENCIL_WRITEMASK" }, + { 0x0BA0, "MATRIX_MODE" }, + { 0x0BA1, "NORMALIZE" }, + { 0x0BA2, "VIEWPORT" }, + { 0x0BA3, "MODELVIEW_STACK_DEPTH" }, + { 0x0BA4, "PROJECTION_STACK_DEPTH" }, + { 0x0BA5, "TEXTURE_STACK_DEPTH" }, + { 0x0BA6, "MODELVIEW_MATRIX" }, + { 0x0BA7, "PROJECTION_MATRIX" }, + { 0x0BA8, "TEXTURE_MATRIX" }, + { 0x0BB0, "ATTRIB_STACK_DEPTH" }, + { 0x0BB1, "CLIENT_ATTRIB_STACK_DEPTH" }, + { 0x0BC0, "ALPHA_TEST" }, + { 0x0BC1, "ALPHA_TEST_FUNC" }, + { 0x0BC2, "ALPHA_TEST_REF" }, + { 0x0BD0, "DITHER" }, + { 0x0BE0, "BLEND_DST" }, + { 0x0BE1, "BLEND_SRC" }, + { 0x0BE2, "BLEND" }, + { 0x0BF0, "LOGIC_OP_MODE" }, + { 0x0BF1, "LOGIC_OP" }, + { 0x0C00, "AUX_BUFFERS" }, + { 0x0C01, "DRAW_BUFFER" }, + { 0x0C02, "READ_BUFFER" }, + { 0x0C10, "SCISSOR_BOX" }, + { 0x0C11, "SCISSOR_TEST" }, + { 0x0C20, "INDEX_CLEAR_VALUE" }, + { 0x0C21, "INDEX_WRITEMASK" }, + { 0x0C22, "COLOR_CLEAR_VALUE" }, + { 0x0C23, "COLOR_WRITEMASK" }, + { 0x0C30, "INDEX_MODE" }, + { 0x0C31, "RGBA_MODE" }, + { 0x0C32, "DOUBLEBUFFER" }, + { 0x0C33, "STEREO" }, + { 0x0C40, "RENDER_MODE" }, + { 0x0C50, "PERSPECTIVE_CORRECTION_HINT" }, + { 0x0C51, "POINT_SMOOTH_HINT" }, + { 0x0C52, "LINE_SMOOTH_HINT" }, + { 0x0C53, "POLYGON_SMOOTH_HINT" }, + { 0x0C54, "FOG_HINT" }, + { 0x0C60, "TEXTURE_GEN_S" }, + { 0x0C61, "TEXTURE_GEN_T" }, + { 0x0C62, "TEXTURE_GEN_R" }, + { 0x0C63, "TEXTURE_GEN_Q" }, + { 0x0C70, "PIXEL_MAP_I_TO_I" }, + { 0x0C71, "PIXEL_MAP_S_TO_S" }, + { 0x0C72, "PIXEL_MAP_I_TO_R" }, + { 0x0C73, "PIXEL_MAP_I_TO_G" }, + { 0x0C74, "PIXEL_MAP_I_TO_B" }, + { 0x0C75, "PIXEL_MAP_I_TO_A" }, + { 0x0C76, "PIXEL_MAP_R_TO_R" }, + { 0x0C77, "PIXEL_MAP_G_TO_G" }, + { 0x0C78, "PIXEL_MAP_B_TO_B" }, + { 0x0C79, "PIXEL_MAP_A_TO_A" }, + { 0x0CB0, "PIXEL_MAP_I_TO_I_SIZE" }, + { 0x0CB1, "PIXEL_MAP_S_TO_S_SIZE" }, + { 0x0CB2, "PIXEL_MAP_I_TO_R_SIZE" }, + { 0x0CB3, "PIXEL_MAP_I_TO_G_SIZE" }, + { 0x0CB4, "PIXEL_MAP_I_TO_B_SIZE" }, + { 0x0CB5, "PIXEL_MAP_I_TO_A_SIZE" }, + { 0x0CB6, "PIXEL_MAP_R_TO_R_SIZE" }, + { 0x0CB7, "PIXEL_MAP_G_TO_G_SIZE" }, + { 0x0CB8, "PIXEL_MAP_B_TO_B_SIZE" }, + { 0x0CB9, "PIXEL_MAP_A_TO_A_SIZE" }, + { 0x0CF0, "UNPACK_SWAP_BYTES" }, + { 0x0CF1, "UNPACK_LSB_FIRST" }, + { 0x0CF2, "UNPACK_ROW_LENGTH" }, + { 0x0CF4, "UNPACK_SKIP_PIXELS" }, + { 0x0CF3, "UNPACK_SKIP_ROWS" }, + { 0x0CF5, "UNPACK_ALIGNMENT" }, + { 0x0D00, "PACK_SWAP_BYTES" }, + { 0x0D01, "PACK_LSB_FIRST" }, + { 0x0D02, "PACK_ROW_LENGTH" }, + { 0x0D03, "PACK_SKIP_ROWS" }, + { 0x0D04, "PACK_SKIP_PIXELS" }, + { 0x0D05, "PACK_ALIGNMENT" }, + { 0x0D10, "MAP_COLOR" }, + { 0x0D11, "MAP_STENCIL" }, + { 0x0D12, "INDEX_SHIFT" }, + { 0x0D13, "INDEX_OFFSET" }, + { 0x0D14, "RED_SCALE" }, + { 0x0D15, "RED_BIAS" }, + { 0x0D16, "ZOOM_X" }, + { 0x0D17, "ZOOM_Y" }, + { 0x0D18, "GREEN_SCALE" }, + { 0x0D19, "GREEN_BIAS" }, + { 0x0D1A, "BLUE_SCALE" }, + { 0x0D1B, "BLUE_BIAS" }, + { 0x0D1C, "ALPHA_SCALE" }, + { 0x0D1D, "ALPHA_BIAS" }, + { 0x0D1E, "DEPTH_SCALE" }, + { 0x0D1F, "DEPTH_BIAS" }, + { 0x0D30, "MAX_EVAL_ORDER" }, + { 0x0D31, "MAX_LIGHTS" }, + { 0x0D32, "MAX_CLIP_PLANES" }, + { 0x0D33, "MAX_TEXTURE_SIZE" }, + { 0x0D34, "MAX_PIXEL_MAP_TABLE" }, + { 0x0D35, "MAX_ATTRIB_STACK_DEPTH" }, + { 0x0D36, "MAX_MODELVIEW_STACK_DEPTH" }, + { 0x0D37, "MAX_NAME_STACK_DEPTH" }, + { 0x0D38, "MAX_PROJECTION_STACK_DEPTH" }, + { 0x0D39, "MAX_TEXTURE_STACK_DEPTH" }, + { 0x0D3A, "MAX_VIEWPORT_DIMS" }, + { 0x0D3B, "MAX_CLIENT_ATTRIB_STACK_DEPTH" }, + { 0x0D50, "SUBPIXEL_BITS" }, + { 0x0D51, "INDEX_BITS" }, + { 0x0D52, "RED_BITS" }, + { 0x0D53, "GREEN_BITS" }, + { 0x0D54, "BLUE_BITS" }, + { 0x0D55, "ALPHA_BITS" }, + { 0x0D56, "DEPTH_BITS" }, + { 0x0D57, "STENCIL_BITS" }, + { 0x0D58, "ACCUM_RED_BITS" }, + { 0x0D59, "ACCUM_GREEN_BITS" }, + { 0x0D5A, "ACCUM_BLUE_BITS" }, + { 0x0D5B, "ACCUM_ALPHA_BITS" }, + { 0x0D70, "NAME_STACK_DEPTH" }, + { 0x0D80, "AUTO_NORMAL" }, + { 0x0D90, "MAP1_COLOR_4" }, + { 0x0D91, "MAP1_INDEX" }, + { 0x0D92, "MAP1_NORMAL" }, + { 0x0D93, "MAP1_TEXTURE_COORD_1" }, + { 0x0D94, "MAP1_TEXTURE_COORD_2" }, + { 0x0D95, "MAP1_TEXTURE_COORD_3" }, + { 0x0D96, "MAP1_TEXTURE_COORD_4" }, + { 0x0D97, "MAP1_VERTEX_3" }, + { 0x0D98, "MAP1_VERTEX_4" }, + { 0x0DB0, "MAP2_COLOR_4" }, + { 0x0DB1, "MAP2_INDEX" }, + { 0x0DB2, "MAP2_NORMAL" }, + { 0x0DB3, "MAP2_TEXTURE_COORD_1" }, + { 0x0DB4, "MAP2_TEXTURE_COORD_2" }, + { 0x0DB5, "MAP2_TEXTURE_COORD_3" }, + { 0x0DB6, "MAP2_TEXTURE_COORD_4" }, + { 0x0DB7, "MAP2_VERTEX_3" }, + { 0x0DB8, "MAP2_VERTEX_4" }, + { 0x0DD0, "MAP1_GRID_DOMAIN" }, + { 0x0DD1, "MAP1_GRID_SEGMENTS" }, + { 0x0DD2, "MAP2_GRID_DOMAIN" }, + { 0x0DD3, "MAP2_GRID_SEGMENTS" }, + { 0x0DE0, "TEXTURE_1D" }, + { 0x0DE1, "TEXTURE_2D" }, + { 0x0DF0, "FEEDBACK_BUFFER_POINTER" }, + { 0x0DF1, "FEEDBACK_BUFFER_SIZE" }, + { 0x0DF2, "FEEDBACK_BUFFER_TYPE" }, + { 0x0DF3, "SELECTION_BUFFER_POINTER" }, + { 0x0DF4, "SELECTION_BUFFER_SIZE" }, + { 0x1000, "TEXTURE_WIDTH" }, + { 0x1001, "TEXTURE_HEIGHT" }, + { 0x1005, "TEXTURE_BORDER" }, + { 0x1003, "TEXTURE_COMPONENTS" }, + { 0x1004, "TEXTURE_BORDER_COLOR" }, + { 0x1100, "DONT_CARE" }, + { 0x1101, "FASTEST" }, + { 0x1102, "NICEST" }, + { 0x1200, "AMBIENT" }, + { 0x1201, "DIFFUSE" }, + { 0x1202, "SPECULAR" }, + { 0x1203, "POSITION" }, + { 0x1204, "SPOT_DIRECTION" }, + { 0x1205, "SPOT_EXPONENT" }, + { 0x1206, "SPOT_CUTOFF" }, + { 0x1207, "CONSTANT_ATTENUATION" }, + { 0x1208, "LINEAR_ATTENUATION" }, + { 0x1209, "QUADRATIC_ATTENUATION" }, + { 0x1300, "COMPILE" }, + { 0x1301, "COMPILE_AND_EXECUTE" }, + { 0x1400, "BYTE" }, + { 0x1401, "UNSIGNED_BYTE" }, + { 0x1402, "SHORT" }, + { 0x1403, "UNSIGNED_SHORT" }, + { 0x1404, "INT" }, + { 0x1405, "UNSIGNED_INT" }, + { 0x1406, "FLOAT" }, + { 0x1407, "2_BYTES" }, + { 0x1408, "3_BYTES" }, + { 0x1409, "4_BYTES" }, + { 0x1500, "CLEAR" }, + { 0x1501, "AND" }, + { 0x1502, "AND_REVERSE" }, + { 0x1503, "COPY" }, + { 0x1504, "AND_INVERTED" }, + { 0x1505, "NOOP" }, + { 0x1506, "XOR" }, + { 0x1507, "OR" }, + { 0x1508, "NOR" }, + { 0x1509, "EQUIV" }, + { 0x150A, "INVERT" }, + { 0x150B, "OR_REVERSE" }, + { 0x150C, "COPY_INVERTED" }, + { 0x150D, "OR_INVERTED" }, + { 0x150E, "NAND" }, + { 0x150F, "SET" }, + { 0x1600, "EMISSION" }, + { 0x1601, "SHININESS" }, + { 0x1602, "AMBIENT_AND_DIFFUSE" }, + { 0x1603, "COLOR_INDEXES" }, + { 0x1700, "MODELVIEW" }, + { 0x1701, "PROJECTION" }, + { 0x1702, "TEXTURE" }, + { 0x1800, "COLOR" }, + { 0x1801, "DEPTH" }, + { 0x1802, "STENCIL" }, + { 0x1900, "COLOR_INDEX" }, + { 0x1901, "STENCIL_INDEX" }, + { 0x1902, "DEPTH_COMPONENT" }, + { 0x1903, "RED" }, + { 0x1904, "GREEN" }, + { 0x1905, "BLUE" }, + { 0x1906, "ALPHA" }, + { 0x1908, "RGBA" }, + { 0x1907, "RGB" }, + { 0x1909, "LUMINANCE" }, + { 0x190A, "LUMINANCE_ALPHA" }, + { 0x1A00, "BITMAP" }, + { 0x1B00, "POINT" }, + { 0x1B01, "LINE" }, + { 0x1B02, "FILL" }, + { 0x1C01, "FEEDBACK" }, + { 0x1C00, "RENDER" }, + { 0x1C02, "SELECT" }, + { 0x1D00, "FLAT" }, + { 0x1D01, "SMOOTH" }, + { 0x1E00, "KEEP" }, + { 0x1E01, "REPLACE" }, + { 0x1E02, "INCR" }, + { 0x1E03, "DECR" }, + { 0x1F00, "VENDOR" }, + { 0x1F01, "RENDERER" }, + { 0x1F02, "VERSION" }, + { 0x1F03, "EXTENSIONS" }, + { 0x2000, "S" }, + { 0x2001, "T" }, + { 0x2002, "R" }, + { 0x2003, "Q" }, + { 0x2100, "MODULATE" }, + { 0x2101, "DECAL" }, + { 0x2200, "TEXTURE_ENV_MODE" }, + { 0x2201, "TEXTURE_ENV_COLOR" }, + { 0x2300, "TEXTURE_ENV" }, + { 0x2400, "EYE_LINEAR" }, + { 0x2401, "OBJECT_LINEAR" }, + { 0x2402, "SPHERE_MAP" }, + { 0x2500, "TEXTURE_GEN_MODE" }, + { 0x2501, "OBJECT_PLANE" }, + { 0x2502, "EYE_PLANE" }, + { 0x2600, "NEAREST" }, + { 0x2601, "LINEAR" }, + { 0x2700, "NEAREST_MIPMAP_NEAREST" }, + { 0x2701, "LINEAR_MIPMAP_NEAREST" }, + { 0x2702, "NEAREST_MIPMAP_LINEAR" }, + { 0x2703, "LINEAR_MIPMAP_LINEAR" }, + { 0x2800, "TEXTURE_MAG_FILTER" }, + { 0x2801, "TEXTURE_MIN_FILTER" }, + { 0x2802, "TEXTURE_WRAP_S" }, + { 0x2803, "TEXTURE_WRAP_T" }, + { 0x2900, "CLAMP" }, + { 0x2901, "REPEAT" }, + { 0x3000, "CLIP_PLANE0" }, + { 0x3001, "CLIP_PLANE1" }, + { 0x3002, "CLIP_PLANE2" }, + { 0x3003, "CLIP_PLANE3" }, + { 0x3004, "CLIP_PLANE4" }, + { 0x3005, "CLIP_PLANE5" }, + { 0x4000, "LIGHT0" }, + { 0x4001, "LIGHT1" }, + { 0x4002, "LIGHT2" }, + { 0x4003, "LIGHT3" }, + { 0x4004, "LIGHT4" }, + { 0x4005, "LIGHT5" }, + { 0x4006, "LIGHT6" }, + { 0x4007, "LIGHT7" }, +/* OpenGL version 1.1 */ + { 0x0BF1, "INDEX_LOGIC_OP" }, + { 0x0BF2, "COLOR_LOGIC_OP" }, + { 0x1003, "TEXTURE_INTERNAL_FORMAT" }, + { 0x140A, "DOUBLE" }, + { 0x2A00, "POLYGON_OFFSET_UNITS" }, + { 0x2A01, "POLYGON_OFFSET_POINT" }, + { 0x2A02, "POLYGON_OFFSET_LINE" }, + { 0x2A10, "R3_G3_B2" }, + { 0x2A20, "V2F" }, + { 0x2A21, "V3F" }, + { 0x2A22, "C4UB_V2F" }, + { 0x2A23, "C4UB_V3F" }, + { 0x2A24, "C3F_V3F" }, + { 0x2A25, "N3F_V3F" }, + { 0x2A26, "C4F_N3F_V3F" }, + { 0x2A27, "T2F_V3F" }, + { 0x2A28, "T4F_V4F" }, + { 0x2A29, "T2F_C4UB_V3F" }, + { 0x2A2A, "T2F_C3F_V3F" }, + { 0x2A2B, "T2F_N3F_V3F" }, + { 0x2A2C, "T2F_C4F_N3F_V3F" }, + { 0x2A2D, "T4F_C4F_N3F_V4F" }, + { 0x8037, "POLYGON_OFFSET_FILL" }, + { 0x8038, "POLYGON_OFFSET_FACTOR" }, + { 0x8039, "POLYGON_OFFSET_BIAS" }, + { 0x803B, "ALPHA4" }, + { 0x803C, "ALPHA8" }, + { 0x803D, "ALPHA12" }, + { 0x803E, "ALPHA16" }, + { 0x803F, "LUMINANCE4" }, + { 0x8040, "LUMINANCE8" }, + { 0x8041, "LUMINANCE12" }, + { 0x8042, "LUMINANCE16" }, + { 0x8043, "LUMINANCE4_ALPHA4" }, + { 0x8044, "LUMINANCE6_ALPHA2" }, + { 0x8045, "LUMINANCE8_ALPHA8" }, + { 0x8046, "LUMINANCE12_ALPHA4" }, + { 0x8047, "LUMINANCE12_ALPHA12" }, + { 0x8048, "LUMINANCE16_ALPHA16" }, + { 0x8049, "INTENSITY" }, + { 0x804A, "INTENSITY4" }, + { 0x804B, "INTENSITY8" }, + { 0x804C, "INTENSITY12" }, + { 0x804D, "INTENSITY16" }, + { 0x804F, "RGB4" }, + { 0x8050, "RGB5" }, + { 0x8051, "RGB8" }, + { 0x8052, "RGB10" }, + { 0x8053, "RGB12" }, + { 0x8054, "RGB16" }, + { 0x8055, "RGBA2" }, + { 0x8056, "RGBA4" }, + { 0x8057, "RGB5_A1" }, + { 0x8058, "RGBA8" }, + { 0x8059, "RGB10_A2" }, + { 0x805A, "RGBA12" }, + { 0x805B, "RGBA16" }, + { 0x805C, "TEXTURE_RED_SIZE" }, + { 0x805D, "TEXTURE_GREEN_SIZE" }, + { 0x805E, "TEXTURE_BLUE_SIZE" }, + { 0x805F, "TEXTURE_ALPHA_SIZE" }, + { 0x8060, "TEXTURE_LUMINANCE_SIZE" }, + { 0x8061, "TEXTURE_INTENSITY_SIZE" }, + { 0x8063, "PROXY_TEXTURE_1D" }, + { 0x8064, "PROXY_TEXTURE_2D" }, + { 0x8066, "TEXTURE_PRIORITY" }, + { 0x8067, "TEXTURE_RESIDENT" }, + { 0x8068, "TEXTURE_BINDING_1D" }, + { 0x8069, "TEXTURE_BINDING_2D" }, + { 0x8074, "VERTEX_ARRAY" }, + { 0x8075, "NORMAL_ARRAY" }, + { 0x8076, "COLOR_ARRAY" }, + { 0x8077, "INDEX_ARRAY" }, + { 0x8078, "TEXTURE_COORD_ARRAY" }, + { 0x8079, "EDGE_FLAG_ARRAY" }, + { 0x807A, "VERTEX_ARRAY_SIZE" }, + { 0x807B, "VERTEX_ARRAY_TYPE" }, + { 0x807C, "VERTEX_ARRAY_STRIDE" }, + { 0x807E, "NORMAL_ARRAY_TYPE" }, + { 0x807F, "NORMAL_ARRAY_STRIDE" }, + { 0x8081, "COLOR_ARRAY_SIZE" }, + { 0x8082, "COLOR_ARRAY_TYPE" }, + { 0x8083, "COLOR_ARRAY_STRIDE" }, + { 0x8085, "INDEX_ARRAY_TYPE" }, + { 0x8086, "INDEX_ARRAY_STRIDE" }, + { 0x8088, "TEXTURE_COORD_ARRAY_SIZE" }, + { 0x8089, "TEXTURE_COORD_ARRAY_TYPE" }, + { 0x808A, "TEXTURE_COORD_ARRAY_STRIDE" }, + { 0x808C, "EDGE_FLAG_ARRAY_STRIDE" }, + { 0x808E, "VERTEX_ARRAY_POINTER" }, + { 0x808F, "NORMAL_ARRAY_POINTER" }, + { 0x8090, "COLOR_ARRAY_POINTER" }, + { 0x8091, "INDEX_ARRAY_POINTER" }, + { 0x8092, "TEXTURE_COORD_ARRAY_POINTER" }, + { 0x8093, "EDGE_FLAG_ARRAY_POINTER" }, +/* OpenGL version 1.2 */ + { 0x8032, "UNSIGNED_BYTE_3_3_2" }, + { 0x8033, "UNSIGNED_SHORT_4_4_4_4" }, + { 0x8034, "UNSIGNED_SHORT_5_5_5_1" }, + { 0x8035, "UNSIGNED_INT_8_8_8_8" }, + { 0x8036, "UNSIGNED_INT_10_10_10_2" }, + { 0x803A, "RESCALE_NORMAL" }, + { 0x806A, "TEXTURE_BINDING_3D" }, + { 0x806B, "PACK_SKIP_IMAGES" }, + { 0x806C, "PACK_IMAGE_HEIGHT" }, + { 0x806D, "UNPACK_SKIP_IMAGES" }, + { 0x806E, "UNPACK_IMAGE_HEIGHT" }, + { 0x806F, "TEXTURE_3D" }, + { 0x8070, "PROXY_TEXTURE_3D" }, + { 0x8071, "TEXTURE_DEPTH" }, + { 0x8072, "TEXTURE_WRAP_R" }, + { 0x8073, "MAX_3D_TEXTURE_SIZE" }, + { 0x8362, "UNSIGNED_BYTE_2_3_3_REV" }, + { 0x8363, "UNSIGNED_SHORT_5_6_5" }, + { 0x8364, "UNSIGNED_SHORT_5_6_5_REV" }, + { 0x8365, "UNSIGNED_SHORT_4_4_4_4_REV" }, + { 0x8366, "UNSIGNED_SHORT_1_5_5_5_REV" }, + { 0x8367, "UNSIGNED_INT_8_8_8_8_REV" }, + { 0x8368, "UNSIGNED_INT_2_10_10_10_REV" }, + { 0x80E0, "BGR" }, + { 0x80E1, "BGRA" }, + { 0x80E8, "MAX_ELEMENTS_VERTICES" }, + { 0x80E9, "MAX_ELEMENTS_INDICES" }, + { 0x812F, "CLAMP_TO_EDGE" }, + { 0x813A, "TEXTURE_MIN_LOD" }, + { 0x813B, "TEXTURE_MAX_LOD" }, + { 0x813C, "TEXTURE_BASE_LEVEL" }, + { 0x813D, "TEXTURE_MAX_LEVEL" }, + { 0x81F8, "LIGHT_MODEL_COLOR_CONTROL" }, + { 0x81F9, "SINGLE_COLOR" }, + { 0x81FA, "SEPARATE_SPECULAR_COLOR" }, + { 0x0B12, "SMOOTH_POINT_SIZE_RANGE" }, + { 0x0B13, "SMOOTH_POINT_SIZE_GRANULARITY" }, + { 0x0B22, "SMOOTH_LINE_WIDTH_RANGE" }, + { 0x0B23, "SMOOTH_LINE_WIDTH_GRANULARITY" }, + { 0x846D, "ALIASED_POINT_SIZE_RANGE" }, + { 0x846E, "ALIASED_LINE_WIDTH_RANGE" }, + { 0x8001, "CONSTANT_COLOR" }, + { 0x8002, "ONE_MINUS_CONSTANT_COLOR" }, + { 0x8003, "CONSTANT_ALPHA" }, + { 0x8004, "ONE_MINUS_CONSTANT_ALPHA" }, + { 0x8005, "BLEND_COLOR" }, + { 0x8006, "FUNC_ADD" }, + { 0x8007, "MIN" }, + { 0x8008, "MAX" }, + { 0x8009, "BLEND_EQUATION" }, + { 0x800A, "FUNC_SUBTRACT" }, + { 0x800B, "FUNC_REVERSE_SUBTRACT" }, + { 0x8010, "CONVOLUTION_1D" }, + { 0x8011, "CONVOLUTION_2D" }, + { 0x8012, "SEPARABLE_2D" }, + { 0x8013, "CONVOLUTION_BORDER_MODE" }, + { 0x8154, "CONVOLUTION_BORDER_COLOR" }, + { 0x8014, "CONVOLUTION_FILTER_SCALE" }, + { 0x8015, "CONVOLUTION_FILTER_BIAS" }, + { 0x8016, "REDUCE" }, + { 0x8017, "CONVOLUTION_FORMAT" }, + { 0x8018, "CONVOLUTION_WIDTH" }, + { 0x8019, "CONVOLUTION_HEIGHT" }, + { 0x801A, "MAX_CONVOLUTION_WIDTH" }, + { 0x801B, "MAX_CONVOLUTION_HEIGHT" }, + { 0x801C, "POST_CONVOLUTION_RED_SCALE" }, + { 0x801D, "POST_CONVOLUTION_GREEN_SCALE" }, + { 0x801E, "POST_CONVOLUTION_BLUE_SCALE" }, + { 0x801F, "POST_CONVOLUTION_ALPHA_SCALE" }, + { 0x8020, "POST_CONVOLUTION_RED_BIAS" }, + { 0x8021, "POST_CONVOLUTION_GREEN_BIAS" }, + { 0x8022, "POST_CONVOLUTION_BLUE_BIAS" }, + { 0x8023, "POST_CONVOLUTION_ALPHA_BIAS" }, + { 0x8024, "HISTOGRAM" }, + { 0x8025, "PROXY_HISTOGRAM" }, + { 0x8026, "HISTOGRAM_WIDTH" }, + { 0x8027, "HISTOGRAM_FORMAT" }, + { 0x8028, "HISTOGRAM_RED_SIZE" }, + { 0x8029, "HISTOGRAM_GREEN_SIZE" }, + { 0x802A, "HISTOGRAM_BLUE_SIZE" }, + { 0x802B, "HISTOGRAM_ALPHA_SIZE" }, + { 0x802C, "HISTOGRAM_LUMINANCE_SIZE" }, + { 0x802D, "HISTOGRAM_SINK" }, + { 0x802E, "MINMAX" }, + { 0x802F, "MINMAX_FORMAT" }, + { 0x8030, "MINMAX_SINK" }, + { 0x80B1, "COLOR_MATRIX" }, + { 0x80B2, "COLOR_MATRIX_STACK_DEPTH" }, + { 0x80B3, "MAX_COLOR_MATRIX_STACK_DEPTH" }, + { 0x80B4, "POST_COLOR_MATRIX_RED_SCALE" }, + { 0x80B5, "POST_COLOR_MATRIX_GREEN_SCALE" }, + { 0x80B6, "POST_COLOR_MATRIX_BLUE_SCALE" }, + { 0x80B7, "POST_COLOR_MATRIX_ALPHA_SCALE" }, + { 0x80B8, "POST_COLOR_MATRIX_RED_BIAS" }, + { 0x80B9, "POST_COLOR_MATRIX_GREEN_BIAS" }, + { 0x80BA, "POST_COLOR_MATRIX_BLUE_BIAS" }, + { 0x80BB, "POST_COLOR_MATRIX_ALPHA_BIAS" }, + { 0x80D0, "COLOR_TABLE" }, + { 0x80D1, "POST_CONVOLUTION_COLOR_TABLE" }, + { 0x80D2, "POST_COLOR_MATRIX_COLOR_TABLE" }, + { 0x80D3, "PROXY_COLOR_TABLE" }, + { 0x80D4, "PROXY_POST_CONVOLUTION_COLOR_TABLE" }, + { 0x80D5, "PROXY_POST_COLOR_MATRIX_COLOR_TABLE" }, + { 0x80D6, "COLOR_TABLE_SCALE" }, + { 0x80D7, "COLOR_TABLE_BIAS" }, + { 0x80D8, "COLOR_TABLE_FORMAT" }, + { 0x80D9, "COLOR_TABLE_WIDTH" }, + { 0x80DA, "COLOR_TABLE_RED_SIZE" }, + { 0x80DB, "COLOR_TABLE_GREEN_SIZE" }, + { 0x80DC, "COLOR_TABLE_BLUE_SIZE" }, + { 0x80DD, "COLOR_TABLE_ALPHA_SIZE" }, + { 0x80DE, "COLOR_TABLE_LUMINANCE_SIZE" }, + { 0x80DF, "COLOR_TABLE_INTENSITY_SIZE" }, +/* OpenGL version 1.3 */ + { 0x84C0, "TEXTURE0" }, + { 0x84C1, "TEXTURE1" }, + { 0x84C2, "TEXTURE2" }, + { 0x84C3, "TEXTURE3" }, + { 0x84C4, "TEXTURE4" }, + { 0x84C5, "TEXTURE5" }, + { 0x84C6, "TEXTURE6" }, + { 0x84C7, "TEXTURE7" }, + { 0x84C8, "TEXTURE8" }, + { 0x84C9, "TEXTURE9" }, + { 0x84CA, "TEXTURE10" }, + { 0x84CB, "TEXTURE11" }, + { 0x84CC, "TEXTURE12" }, + { 0x84CD, "TEXTURE13" }, + { 0x84CE, "TEXTURE14" }, + { 0x84CF, "TEXTURE15" }, + { 0x84D0, "TEXTURE16" }, + { 0x84D1, "TEXTURE17" }, + { 0x84D2, "TEXTURE18" }, + { 0x84D3, "TEXTURE19" }, + { 0x84D4, "TEXTURE20" }, + { 0x84D5, "TEXTURE21" }, + { 0x84D6, "TEXTURE22" }, + { 0x84D7, "TEXTURE23" }, + { 0x84D8, "TEXTURE24" }, + { 0x84D9, "TEXTURE25" }, + { 0x84DA, "TEXTURE26" }, + { 0x84DB, "TEXTURE27" }, + { 0x84DC, "TEXTURE28" }, + { 0x84DD, "TEXTURE29" }, + { 0x84DE, "TEXTURE30" }, + { 0x84DF, "TEXTURE31" }, + { 0x84E0, "ACTIVE_TEXTURE" }, + { 0x84E1, "CLIENT_ACTIVE_TEXTURE" }, + { 0x84E2, "MAX_TEXTURE_UNITS" }, + { 0x84E3, "TRANSPOSE_MODELVIEW_MATRIX" }, + { 0x84E4, "TRANSPOSE_PROJECTION_MATRIX" }, + { 0x84E5, "TRANSPOSE_TEXTURE_MATRIX" }, + { 0x84E6, "TRANSPOSE_COLOR_MATRIX" }, + { 0x809D, "MULTISAMPLE" }, + { 0x809E, "SAMPLE_ALPHA_TO_COVERAGE" }, + { 0x809F, "SAMPLE_ALPHA_TO_ONE" }, + { 0x80A0, "SAMPLE_COVERAGE" }, + { 0x80A8, "SAMPLE_BUFFERS" }, + { 0x80A9, "SAMPLES" }, + { 0x80AA, "SAMPLE_COVERAGE_VALUE" }, + { 0x80AB, "SAMPLE_COVERAGE_INVERT" }, + { 0x8511, "NORMAL_MAP" }, + { 0x8512, "REFLECTION_MAP" }, + { 0x8513, "TEXTURE_CUBE_MAP" }, + { 0x8514, "TEXTURE_BINDING_CUBE_MAP" }, + { 0x8515, "TEXTURE_CUBE_MAP_POSITIVE_X" }, + { 0x8516, "TEXTURE_CUBE_MAP_NEGATIVE_X" }, + { 0x8517, "TEXTURE_CUBE_MAP_POSITIVE_Y" }, + { 0x8518, "TEXTURE_CUBE_MAP_NEGATIVE_Y" }, + { 0x8519, "TEXTURE_CUBE_MAP_POSITIVE_Z" }, + { 0x851A, "TEXTURE_CUBE_MAP_NEGATIVE_Z" }, + { 0x851B, "PROXY_TEXTURE_CUBE_MAP" }, + { 0x851C, "MAX_CUBE_MAP_TEXTURE_SIZE" }, + { 0x84E9, "COMPRESSED_ALPHA" }, + { 0x84EA, "COMPRESSED_LUMINANCE" }, + { 0x84EB, "COMPRESSED_LUMINANCE_ALPHA" }, + { 0x84EC, "COMPRESSED_INTENSITY" }, + { 0x84ED, "COMPRESSED_RGB" }, + { 0x84EE, "COMPRESSED_RGBA" }, + { 0x84EF, "TEXTURE_COMPRESSION_HINT" }, + { 0x86A0, "TEXTURE_COMPRESSED_IMAGE_SIZE" }, + { 0x86A1, "TEXTURE_COMPRESSED" }, + { 0x86A2, "NUM_COMPRESSED_TEXTURE_FORMATS" }, + { 0x86A3, "COMPRESSED_TEXTURE_FORMATS" }, + { 0x812D, "CLAMP_TO_BORDER" }, + { 0x8570, "COMBINE" }, + { 0x8571, "COMBINE_RGB" }, + { 0x8572, "COMBINE_ALPHA" }, + { 0x8580, "SOURCE0_RGB" }, + { 0x8581, "SOURCE1_RGB" }, + { 0x8582, "SOURCE2_RGB" }, + { 0x8588, "SOURCE0_ALPHA" }, + { 0x8589, "SOURCE1_ALPHA" }, + { 0x858A, "SOURCE2_ALPHA" }, + { 0x8590, "OPERAND0_RGB" }, + { 0x8591, "OPERAND1_RGB" }, + { 0x8592, "OPERAND2_RGB" }, + { 0x8598, "OPERAND0_ALPHA" }, + { 0x8599, "OPERAND1_ALPHA" }, + { 0x859A, "OPERAND2_ALPHA" }, + { 0x8573, "RGB_SCALE" }, + { 0x8574, "ADD_SIGNED" }, + { 0x8575, "INTERPOLATE" }, + { 0x84E7, "SUBTRACT" }, + { 0x8576, "CONSTANT" }, + { 0x8577, "PRIMARY_COLOR" }, + { 0x8578, "PREVIOUS" }, + { 0x86AE, "DOT3_RGB" }, + { 0x86AF, "DOT3_RGBA" }, +/* OpenGL version 1.4 */ + { 0x80C8, "BLEND_DST_RGB" }, + { 0x80C9, "BLEND_SRC_RGB" }, + { 0x80CA, "BLEND_DST_ALPHA" }, + { 0x80CB, "BLEND_SRC_ALPHA" }, + { 0x8126, "POINT_SIZE_MIN" }, + { 0x8127, "POINT_SIZE_MAX" }, + { 0x8128, "POINT_FADE_THRESHOLD_SIZE" }, + { 0x8129, "POINT_DISTANCE_ATTENUATION" }, + { 0x8191, "GENERATE_MIPMAP" }, + { 0x8192, "GENERATE_MIPMAP_HINT" }, + { 0x81A5, "DEPTH_COMPONENT16" }, + { 0x81A6, "DEPTH_COMPONENT24" }, + { 0x81A7, "DEPTH_COMPONENT32" }, + { 0x8370, "MIRRORED_REPEAT" }, + { 0x8450, "FOG_COORDINATE_SOURCE" }, + { 0x8451, "FOG_COORDINATE" }, + { 0x8452, "FRAGMENT_DEPTH" }, + { 0x8453, "CURRENT_FOG_COORDINATE" }, + { 0x8454, "FOG_COORDINATE_ARRAY_TYPE" }, + { 0x8455, "FOG_COORDINATE_ARRAY_STRIDE" }, + { 0x8456, "FOG_COORDINATE_ARRAY_POINTER" }, + { 0x8457, "FOG_COORDINATE_ARRAY" }, + { 0x8458, "COLOR_SUM" }, + { 0x8459, "CURRENT_SECONDARY_COLOR" }, + { 0x845A, "SECONDARY_COLOR_ARRAY_SIZE" }, + { 0x845B, "SECONDARY_COLOR_ARRAY_TYPE" }, + { 0x845C, "SECONDARY_COLOR_ARRAY_STRIDE" }, + { 0x845D, "SECONDARY_COLOR_ARRAY_POINTER" }, + { 0x845E, "SECONDARY_COLOR_ARRAY" }, + { 0x84FD, "MAX_TEXTURE_LOD_BIAS" }, + { 0x8500, "TEXTURE_FILTER_CONTROL" }, + { 0x8501, "TEXTURE_LOD_BIAS" }, + { 0x8507, "INCR_WRAP" }, + { 0x8508, "DECR_WRAP" }, + { 0x884A, "TEXTURE_DEPTH_SIZE" }, + { 0x884B, "DEPTH_TEXTURE_MODE" }, + { 0x884C, "TEXTURE_COMPARE_MODE" }, + { 0x884D, "TEXTURE_COMPARE_FUNC" }, + { 0x884E, "COMPARE_R_TO_TEXTURE" }, +/* OpenGL version 1.5 */ + { 0x8764, "BUFFER_SIZE" }, + { 0x8765, "BUFFER_USAGE" }, + { 0x8864, "QUERY_COUNTER_BITS" }, + { 0x8865, "CURRENT_QUERY" }, + { 0x8866, "QUERY_RESULT" }, + { 0x8867, "QUERY_RESULT_AVAILABLE" }, + { 0x8892, "ARRAY_BUFFER" }, + { 0x8893, "ELEMENT_ARRAY_BUFFER" }, + { 0x8894, "ARRAY_BUFFER_BINDING" }, + { 0x8895, "ELEMENT_ARRAY_BUFFER_BINDING" }, + { 0x8896, "VERTEX_ARRAY_BUFFER_BINDING" }, + { 0x8897, "NORMAL_ARRAY_BUFFER_BINDING" }, + { 0x8898, "COLOR_ARRAY_BUFFER_BINDING" }, + { 0x8899, "INDEX_ARRAY_BUFFER_BINDING" }, + { 0x889A, "TEXTURE_COORD_ARRAY_BUFFER_BINDING" }, + { 0x889B, "EDGE_FLAG_ARRAY_BUFFER_BINDING" }, + { 0x889C, "SECONDARY_COLOR_ARRAY_BUFFER_BINDING" }, + { 0x889D, "FOG_COORDINATE_ARRAY_BUFFER_BINDING" }, + { 0x889E, "WEIGHT_ARRAY_BUFFER_BINDING" }, + { 0x889F, "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING" }, + { 0x88B8, "READ_ONLY" }, + { 0x88B9, "WRITE_ONLY" }, + { 0x88BA, "READ_WRITE" }, + { 0x88BB, "BUFFER_ACCESS" }, + { 0x88BC, "BUFFER_MAPPED" }, + { 0x88BD, "BUFFER_MAP_POINTER" }, + { 0x88E0, "STREAM_DRAW" }, + { 0x88E1, "STREAM_READ" }, + { 0x88E2, "STREAM_COPY" }, + { 0x88E4, "STATIC_DRAW" }, + { 0x88E5, "STATIC_READ" }, + { 0x88E6, "STATIC_COPY" }, + { 0x88E8, "DYNAMIC_DRAW" }, + { 0x88E9, "DYNAMIC_READ" }, + { 0x88EA, "DYNAMIC_COPY" }, + { 0x8914, "SAMPLES_PASSED" }, + { 0x8450, "FOG_COORD_SRC" }, + { 0x8451, "FOG_COORD" }, + { 0x8453, "CURRENT_FOG_COORD" }, + { 0x8454, "FOG_COORD_ARRAY_TYPE" }, + { 0x8455, "FOG_COORD_ARRAY_STRIDE" }, + { 0x8456, "FOG_COORD_ARRAY_POINTER" }, + { 0x8457, "FOG_COORD_ARRAY" }, + { 0x889D, "FOG_COORD_ARRAY_BUFFER_BINDING" }, + { 0x8580, "SRC0_RGB" }, + { 0x8581, "SRC1_RGB" }, + { 0x8582, "SRC2_RGB" }, + { 0x8588, "SRC0_ALPHA" }, + { 0x8589, "SRC1_ALPHA" }, + { 0x858A, "SRC2_ALPHA" }, +/* OpenGL version 2.0 */ + { 0x8009, "BLEND_EQUATION_RGB" }, + { 0x8622, "VERTEX_ATTRIB_ARRAY_ENABLED" }, + { 0x8623, "VERTEX_ATTRIB_ARRAY_SIZE" }, + { 0x8624, "VERTEX_ATTRIB_ARRAY_STRIDE" }, + { 0x8625, "VERTEX_ATTRIB_ARRAY_TYPE" }, + { 0x8626, "CURRENT_VERTEX_ATTRIB" }, + { 0x8642, "VERTEX_PROGRAM_POINT_SIZE" }, + { 0x8643, "VERTEX_PROGRAM_TWO_SIDE" }, + { 0x8645, "VERTEX_ATTRIB_ARRAY_POINTER" }, + { 0x8800, "STENCIL_BACK_FUNC" }, + { 0x8801, "STENCIL_BACK_FAIL" }, + { 0x8802, "STENCIL_BACK_PASS_DEPTH_FAIL" }, + { 0x8803, "STENCIL_BACK_PASS_DEPTH_PASS" }, + { 0x8824, "MAX_DRAW_BUFFERS" }, + { 0x8825, "DRAW_BUFFER0" }, + { 0x8826, "DRAW_BUFFER1" }, + { 0x8827, "DRAW_BUFFER2" }, + { 0x8828, "DRAW_BUFFER3" }, + { 0x8829, "DRAW_BUFFER4" }, + { 0x882A, "DRAW_BUFFER5" }, + { 0x882B, "DRAW_BUFFER6" }, + { 0x882C, "DRAW_BUFFER7" }, + { 0x882D, "DRAW_BUFFER8" }, + { 0x882E, "DRAW_BUFFER9" }, + { 0x882F, "DRAW_BUFFER10" }, + { 0x8830, "DRAW_BUFFER11" }, + { 0x8831, "DRAW_BUFFER12" }, + { 0x8832, "DRAW_BUFFER13" }, + { 0x8833, "DRAW_BUFFER14" }, + { 0x8834, "DRAW_BUFFER15" }, + { 0x883D, "BLEND_EQUATION_ALPHA" }, + { 0x8861, "POINT_SPRITE" }, + { 0x8862, "COORD_REPLACE" }, + { 0x8869, "MAX_VERTEX_ATTRIBS" }, + { 0x886A, "VERTEX_ATTRIB_ARRAY_NORMALIZED" }, + { 0x8871, "MAX_TEXTURE_COORDS" }, + { 0x8872, "MAX_TEXTURE_IMAGE_UNITS" }, + { 0x8B30, "FRAGMENT_SHADER" }, + { 0x8B31, "VERTEX_SHADER" }, + { 0x8B49, "MAX_FRAGMENT_UNIFORM_COMPONENTS" }, + { 0x8B4A, "MAX_VERTEX_UNIFORM_COMPONENTS" }, + { 0x8B4B, "MAX_VARYING_FLOATS" }, + { 0x8B4C, "MAX_VERTEX_TEXTURE_IMAGE_UNITS" }, + { 0x8B4D, "MAX_COMBINED_TEXTURE_IMAGE_UNITS" }, + { 0x8B4F, "SHADER_TYPE" }, + { 0x8B50, "FLOAT_VEC2" }, + { 0x8B51, "FLOAT_VEC3" }, + { 0x8B52, "FLOAT_VEC4" }, + { 0x8B53, "INT_VEC2" }, + { 0x8B54, "INT_VEC3" }, + { 0x8B55, "INT_VEC4" }, + { 0x8B56, "BOOL" }, + { 0x8B57, "BOOL_VEC2" }, + { 0x8B58, "BOOL_VEC3" }, + { 0x8B59, "BOOL_VEC4" }, + { 0x8B5A, "FLOAT_MAT2" }, + { 0x8B5B, "FLOAT_MAT3" }, + { 0x8B5C, "FLOAT_MAT4" }, + { 0x8B5D, "SAMPLER_1D" }, + { 0x8B5E, "SAMPLER_2D" }, + { 0x8B5F, "SAMPLER_3D" }, + { 0x8B60, "SAMPLER_CUBE" }, + { 0x8B61, "SAMPLER_1D_SHADOW" }, + { 0x8B62, "SAMPLER_2D_SHADOW" }, + { 0x8B80, "DELETE_STATUS" }, + { 0x8B81, "COMPILE_STATUS" }, + { 0x8B82, "LINK_STATUS" }, + { 0x8B83, "VALIDATE_STATUS" }, + { 0x8B84, "INFO_LOG_LENGTH" }, + { 0x8B85, "ATTACHED_SHADERS" }, + { 0x8B86, "ACTIVE_UNIFORMS" }, + { 0x8B87, "ACTIVE_UNIFORM_MAX_LENGTH" }, + { 0x8B88, "SHADER_SOURCE_LENGTH" }, + { 0x8B89, "ACTIVE_ATTRIBUTES" }, + { 0x8B8A, "ACTIVE_ATTRIBUTE_MAX_LENGTH" }, + { 0x8B8B, "FRAGMENT_SHADER_DERIVATIVE_HINT" }, + { 0x8B8C, "SHADING_LANGUAGE_VERSION" }, + { 0x8B8D, "CURRENT_PROGRAM" }, + { 0x8CA0, "POINT_SPRITE_COORD_ORIGIN" }, + { 0x8CA1, "LOWER_LEFT" }, + { 0x8CA2, "UPPER_LEFT" }, + { 0x8CA3, "STENCIL_BACK_REF" }, + { 0x8CA4, "STENCIL_BACK_VALUE_MASK" }, + { 0x8CA5, "STENCIL_BACK_WRITEMASK" }, +/* OpenGL version 2.1 */ + { 0x845F, "CURRENT_RASTER_SECONDARY_COLOR" }, + { 0x88EB, "PIXEL_PACK_BUFFER" }, + { 0x88EC, "PIXEL_UNPACK_BUFFER" }, + { 0x88ED, "PIXEL_PACK_BUFFER_BINDING" }, + { 0x88EF, "PIXEL_UNPACK_BUFFER_BINDING" }, + { 0x8B65, "FLOAT_MAT2x3" }, + { 0x8B66, "FLOAT_MAT2x4" }, + { 0x8B67, "FLOAT_MAT3x2" }, + { 0x8B68, "FLOAT_MAT3x4" }, + { 0x8B69, "FLOAT_MAT4x2" }, + { 0x8B6A, "FLOAT_MAT4x3" }, + { 0x8C40, "SRGB" }, + { 0x8C41, "SRGB8" }, + { 0x8C42, "SRGB_ALPHA" }, + { 0x8C43, "SRGB8_ALPHA8" }, + { 0x8C44, "SLUMINANCE_ALPHA" }, + { 0x8C45, "SLUMINANCE8_ALPHA8" }, + { 0x8C46, "SLUMINANCE" }, + { 0x8C47, "SLUMINANCE8" }, + { 0x8C48, "COMPRESSED_SRGB" }, + { 0x8C49, "COMPRESSED_SRGB_ALPHA" }, + { 0x8C4A, "COMPRESSED_SLUMINANCE" }, + { 0x8C4B, "COMPRESSED_SLUMINANCE_ALPHA" }, +/* OpenGL extension GL_ARB_multitexture */ + { 0x84C0, "TEXTURE0_ARB" }, + { 0x84C1, "TEXTURE1_ARB" }, + { 0x84C2, "TEXTURE2_ARB" }, + { 0x84C3, "TEXTURE3_ARB" }, + { 0x84C4, "TEXTURE4_ARB" }, + { 0x84C5, "TEXTURE5_ARB" }, + { 0x84C6, "TEXTURE6_ARB" }, + { 0x84C7, "TEXTURE7_ARB" }, + { 0x84C8, "TEXTURE8_ARB" }, + { 0x84C9, "TEXTURE9_ARB" }, + { 0x84CA, "TEXTURE10_ARB" }, + { 0x84CB, "TEXTURE11_ARB" }, + { 0x84CC, "TEXTURE12_ARB" }, + { 0x84CD, "TEXTURE13_ARB" }, + { 0x84CE, "TEXTURE14_ARB" }, + { 0x84CF, "TEXTURE15_ARB" }, + { 0x84D0, "TEXTURE16_ARB" }, + { 0x84D1, "TEXTURE17_ARB" }, + { 0x84D2, "TEXTURE18_ARB" }, + { 0x84D3, "TEXTURE19_ARB" }, + { 0x84D4, "TEXTURE20_ARB" }, + { 0x84D5, "TEXTURE21_ARB" }, + { 0x84D6, "TEXTURE22_ARB" }, + { 0x84D7, "TEXTURE23_ARB" }, + { 0x84D8, "TEXTURE24_ARB" }, + { 0x84D9, "TEXTURE25_ARB" }, + { 0x84DA, "TEXTURE26_ARB" }, + { 0x84DB, "TEXTURE27_ARB" }, + { 0x84DC, "TEXTURE28_ARB" }, + { 0x84DD, "TEXTURE29_ARB" }, + { 0x84DE, "TEXTURE30_ARB" }, + { 0x84DF, "TEXTURE31_ARB" }, + { 0x84E0, "ACTIVE_TEXTURE_ARB" }, + { 0x84E1, "CLIENT_ACTIVE_TEXTURE_ARB" }, + { 0x84E2, "MAX_TEXTURE_UNITS_ARB" }, +/* OpenGL extension GL_ARB_transpose_matrix */ + { 0x84E3, "TRANSPOSE_MODELVIEW_MATRIX_ARB" }, + { 0x84E4, "TRANSPOSE_PROJECTION_MATRIX_ARB" }, + { 0x84E5, "TRANSPOSE_TEXTURE_MATRIX_ARB" }, + { 0x84E6, "TRANSPOSE_COLOR_MATRIX_ARB" }, +/* OpenGL extension GL_ARB_multisample */ + { 0x809D, "MULTISAMPLE_ARB" }, + { 0x809E, "SAMPLE_ALPHA_TO_COVERAGE_ARB" }, + { 0x809F, "SAMPLE_ALPHA_TO_ONE_ARB" }, + { 0x80A0, "SAMPLE_COVERAGE_ARB" }, + { 0x80A8, "SAMPLE_BUFFERS_ARB" }, + { 0x80A9, "SAMPLES_ARB" }, + { 0x80AA, "SAMPLE_COVERAGE_VALUE_ARB" }, + { 0x80AB, "SAMPLE_COVERAGE_INVERT_ARB" }, +/* OpenGL extension GL_ARB_texture_env_add */ +/* OpenGL extension GL_ARB_texture_cube_map */ + { 0x8511, "NORMAL_MAP_ARB" }, + { 0x8512, "REFLECTION_MAP_ARB" }, + { 0x8513, "TEXTURE_CUBE_MAP_ARB" }, + { 0x8514, "TEXTURE_BINDING_CUBE_MAP_ARB" }, + { 0x8515, "TEXTURE_CUBE_MAP_POSITIVE_X_ARB" }, + { 0x8516, "TEXTURE_CUBE_MAP_NEGATIVE_X_ARB" }, + { 0x8517, "TEXTURE_CUBE_MAP_POSITIVE_Y_ARB" }, + { 0x8518, "TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB" }, + { 0x8519, "TEXTURE_CUBE_MAP_POSITIVE_Z_ARB" }, + { 0x851A, "TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB" }, + { 0x851B, "PROXY_TEXTURE_CUBE_MAP_ARB" }, + { 0x851C, "MAX_CUBE_MAP_TEXTURE_SIZE_ARB" }, +/* OpenGL extension GL_ARB_texture_compression */ + { 0x84E9, "COMPRESSED_ALPHA_ARB" }, + { 0x84EA, "COMPRESSED_LUMINANCE_ARB" }, + { 0x84EB, "COMPRESSED_LUMINANCE_ALPHA_ARB" }, + { 0x84EC, "COMPRESSED_INTENSITY_ARB" }, + { 0x84ED, "COMPRESSED_RGB_ARB" }, + { 0x84EE, "COMPRESSED_RGBA_ARB" }, + { 0x84EF, "TEXTURE_COMPRESSION_HINT_ARB" }, + { 0x86A0, "TEXTURE_COMPRESSED_IMAGE_SIZE_ARB" }, + { 0x86A1, "TEXTURE_COMPRESSED_ARB" }, + { 0x86A2, "NUM_COMPRESSED_TEXTURE_FORMATS_ARB" }, + { 0x86A3, "TEXTURE_COMPRESSED_FORMATS_ARB" }, +/* OpenGL extension GL_ARB_texture_border_clamp */ + { 0x812D, "CLAMP_TO_BORDER_ARB" }, +/* OpenGL extension GL_ARB_point_parameters */ + { 0x8126, "POINT_SIZE_MIN_ARB" }, + { 0x8127, "POINT_SIZE_MAX_ARB" }, + { 0x8128, "POINT_FADE_THRESHOLD_SIZE_ARB" }, + { 0x8129, "POINT_DISTANCE_ATTENUATION_ARB" }, +/* OpenGL extension GL_ARB_vertex_blend */ + { 0x86A4, "MAX_VERTEX_UNITS_ARB" }, + { 0x86A5, "ACTIVE_VERTEX_UNITS_ARB" }, + { 0x86A6, "WEIGHT_SUM_UNITY_ARB" }, + { 0x86A7, "VERTEX_BLEND_ARB" }, + { 0x86A8, "CURRENT_WEIGHT_ARB" }, + { 0x86A9, "WEIGHT_ARRAY_TYPE_ARB" }, + { 0x86AA, "WEIGHT_ARRAY_STRIDE_ARB" }, + { 0x86AB, "WEIGHT_ARRAY_SIZE_ARB" }, + { 0x86AC, "WEIGHT_ARRAY_POINTER_ARB" }, + { 0x86AD, "WEIGHT_ARRAY_ARB" }, + { 0x1700, "MODELVIEW0_ARB" }, + { 0x850A, "MODELVIEW1_ARB" }, + { 0x8722, "MODELVIEW2_ARB" }, + { 0x8723, "MODELVIEW3_ARB" }, + { 0x8724, "MODELVIEW4_ARB" }, + { 0x8725, "MODELVIEW5_ARB" }, + { 0x8726, "MODELVIEW6_ARB" }, + { 0x8727, "MODELVIEW7_ARB" }, + { 0x8728, "MODELVIEW8_ARB" }, + { 0x8729, "MODELVIEW9_ARB" }, + { 0x872A, "MODELVIEW10_ARB" }, + { 0x872B, "MODELVIEW11_ARB" }, + { 0x872C, "MODELVIEW12_ARB" }, + { 0x872D, "MODELVIEW13_ARB" }, + { 0x872E, "MODELVIEW14_ARB" }, + { 0x872F, "MODELVIEW15_ARB" }, + { 0x8730, "MODELVIEW16_ARB" }, + { 0x8731, "MODELVIEW17_ARB" }, + { 0x8732, "MODELVIEW18_ARB" }, + { 0x8733, "MODELVIEW19_ARB" }, + { 0x8734, "MODELVIEW20_ARB" }, + { 0x8735, "MODELVIEW21_ARB" }, + { 0x8736, "MODELVIEW22_ARB" }, + { 0x8737, "MODELVIEW23_ARB" }, + { 0x8738, "MODELVIEW24_ARB" }, + { 0x8739, "MODELVIEW25_ARB" }, + { 0x873A, "MODELVIEW26_ARB" }, + { 0x873B, "MODELVIEW27_ARB" }, + { 0x873C, "MODELVIEW28_ARB" }, + { 0x873D, "MODELVIEW29_ARB" }, + { 0x873E, "MODELVIEW30_ARB" }, + { 0x873F, "MODELVIEW31_ARB" }, +/* OpenGL extension GL_ARB_matrix_palette */ + { 0x8840, "MATRIX_PALETTE_ARB" }, + { 0x8841, "MAX_MATRIX_PALETTE_STACK_DEPTH_ARB" }, + { 0x8842, "MAX_PALETTE_MATRICES_ARB" }, + { 0x8843, "CURRENT_PALETTE_MATRIX_ARB" }, + { 0x8844, "MATRIX_INDEX_ARRAY_ARB" }, + { 0x8845, "CURRENT_MATRIX_INDEX_ARB" }, + { 0x8846, "MATRIX_INDEX_ARRAY_SIZE_ARB" }, + { 0x8847, "MATRIX_INDEX_ARRAY_TYPE_ARB" }, + { 0x8848, "MATRIX_INDEX_ARRAY_STRIDE_ARB" }, + { 0x8849, "MATRIX_INDEX_ARRAY_POINTER_ARB" }, +/* OpenGL extension GL_ARB_texture_env_combine */ + { 0x8570, "COMBINE_ARB" }, + { 0x8571, "COMBINE_RGB_ARB" }, + { 0x8572, "COMBINE_ALPHA_ARB" }, + { 0x8580, "SOURCE0_RGB_ARB" }, + { 0x8581, "SOURCE1_RGB_ARB" }, + { 0x8582, "SOURCE2_RGB_ARB" }, + { 0x8588, "SOURCE0_ALPHA_ARB" }, + { 0x8589, "SOURCE1_ALPHA_ARB" }, + { 0x858A, "SOURCE2_ALPHA_ARB" }, + { 0x8590, "OPERAND0_RGB_ARB" }, + { 0x8591, "OPERAND1_RGB_ARB" }, + { 0x8592, "OPERAND2_RGB_ARB" }, + { 0x8598, "OPERAND0_ALPHA_ARB" }, + { 0x8599, "OPERAND1_ALPHA_ARB" }, + { 0x859A, "OPERAND2_ALPHA_ARB" }, + { 0x8573, "RGB_SCALE_ARB" }, + { 0x8574, "ADD_SIGNED_ARB" }, + { 0x8575, "INTERPOLATE_ARB" }, + { 0x84E7, "SUBTRACT_ARB" }, + { 0x8576, "CONSTANT_ARB" }, + { 0x8577, "PRIMARY_COLOR_ARB" }, + { 0x8578, "PREVIOUS_ARB" }, +/* OpenGL extension GL_ARB_texture_env_crossbar */ +/* OpenGL extension GL_ARB_texture_env_dot3 */ + { 0x86AE, "DOT3_RGB_ARB" }, + { 0x86AF, "DOT3_RGBA_ARB" }, +/* OpenGL extension GL_ARB_texture_mirrored_repeat */ + { 0x8370, "MIRRORED_REPEAT_ARB" }, +/* OpenGL extension GL_ARB_depth_texture */ + { 0x81A5, "DEPTH_COMPONENT16_ARB" }, + { 0x81A6, "DEPTH_COMPONENT24_ARB" }, + { 0x81A7, "DEPTH_COMPONENT32_ARB" }, + { 0x884A, "TEXTURE_DEPTH_SIZE_ARB" }, + { 0x884B, "DEPTH_TEXTURE_MODE_ARB" }, +/* OpenGL extension GL_ARB_shadow */ + { 0x884C, "TEXTURE_COMPARE_MODE_ARB" }, + { 0x884D, "TEXTURE_COMPARE_FUNC_ARB" }, + { 0x884E, "COMPARE_R_TO_TEXTURE_ARB" }, +/* OpenGL extension GL_ARB_shadow_ambient */ + { 0x80BF, "TEXTURE_COMPARE_FAIL_VALUE_ARB" }, +/* OpenGL extension GL_ARB_window_pos */ +/* OpenGL extension GL_ARB_vertex_program */ + { 0x8458, "COLOR_SUM_ARB" }, + { 0x8620, "VERTEX_PROGRAM_ARB" }, + { 0x8622, "VERTEX_ATTRIB_ARRAY_ENABLED_ARB" }, + { 0x8623, "VERTEX_ATTRIB_ARRAY_SIZE_ARB" }, + { 0x8624, "VERTEX_ATTRIB_ARRAY_STRIDE_ARB" }, + { 0x8625, "VERTEX_ATTRIB_ARRAY_TYPE_ARB" }, + { 0x8626, "CURRENT_VERTEX_ATTRIB_ARB" }, + { 0x8627, "PROGRAM_LENGTH_ARB" }, + { 0x8628, "PROGRAM_STRING_ARB" }, + { 0x862E, "MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB" }, + { 0x862F, "MAX_PROGRAM_MATRICES_ARB" }, + { 0x8640, "CURRENT_MATRIX_STACK_DEPTH_ARB" }, + { 0x8641, "CURRENT_MATRIX_ARB" }, + { 0x8642, "VERTEX_PROGRAM_POINT_SIZE_ARB" }, + { 0x8643, "VERTEX_PROGRAM_TWO_SIDE_ARB" }, + { 0x8645, "VERTEX_ATTRIB_ARRAY_POINTER_ARB" }, + { 0x864B, "PROGRAM_ERROR_POSITION_ARB" }, + { 0x8677, "PROGRAM_BINDING_ARB" }, + { 0x8869, "MAX_VERTEX_ATTRIBS_ARB" }, + { 0x886A, "VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB" }, + { 0x8874, "PROGRAM_ERROR_STRING_ARB" }, + { 0x8875, "PROGRAM_FORMAT_ASCII_ARB" }, + { 0x8876, "PROGRAM_FORMAT_ARB" }, + { 0x88A0, "PROGRAM_INSTRUCTIONS_ARB" }, + { 0x88A1, "MAX_PROGRAM_INSTRUCTIONS_ARB" }, + { 0x88A2, "PROGRAM_NATIVE_INSTRUCTIONS_ARB" }, + { 0x88A3, "MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" }, + { 0x88A4, "PROGRAM_TEMPORARIES_ARB" }, + { 0x88A5, "MAX_PROGRAM_TEMPORARIES_ARB" }, + { 0x88A6, "PROGRAM_NATIVE_TEMPORARIES_ARB" }, + { 0x88A7, "MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" }, + { 0x88A8, "PROGRAM_PARAMETERS_ARB" }, + { 0x88A9, "MAX_PROGRAM_PARAMETERS_ARB" }, + { 0x88AA, "PROGRAM_NATIVE_PARAMETERS_ARB" }, + { 0x88AB, "MAX_PROGRAM_NATIVE_PARAMETERS_ARB" }, + { 0x88AC, "PROGRAM_ATTRIBS_ARB" }, + { 0x88AD, "MAX_PROGRAM_ATTRIBS_ARB" }, + { 0x88AE, "PROGRAM_NATIVE_ATTRIBS_ARB" }, + { 0x88AF, "MAX_PROGRAM_NATIVE_ATTRIBS_ARB" }, + { 0x88B0, "PROGRAM_ADDRESS_REGISTERS_ARB" }, + { 0x88B1, "MAX_PROGRAM_ADDRESS_REGISTERS_ARB" }, + { 0x88B2, "PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" }, + { 0x88B3, "MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" }, + { 0x88B4, "MAX_PROGRAM_LOCAL_PARAMETERS_ARB" }, + { 0x88B5, "MAX_PROGRAM_ENV_PARAMETERS_ARB" }, + { 0x88B6, "PROGRAM_UNDER_NATIVE_LIMITS_ARB" }, + { 0x88B7, "TRANSPOSE_CURRENT_MATRIX_ARB" }, + { 0x88C0, "MATRIX0_ARB" }, + { 0x88C1, "MATRIX1_ARB" }, + { 0x88C2, "MATRIX2_ARB" }, + { 0x88C3, "MATRIX3_ARB" }, + { 0x88C4, "MATRIX4_ARB" }, + { 0x88C5, "MATRIX5_ARB" }, + { 0x88C6, "MATRIX6_ARB" }, + { 0x88C7, "MATRIX7_ARB" }, + { 0x88C8, "MATRIX8_ARB" }, + { 0x88C9, "MATRIX9_ARB" }, + { 0x88CA, "MATRIX10_ARB" }, + { 0x88CB, "MATRIX11_ARB" }, + { 0x88CC, "MATRIX12_ARB" }, + { 0x88CD, "MATRIX13_ARB" }, + { 0x88CE, "MATRIX14_ARB" }, + { 0x88CF, "MATRIX15_ARB" }, + { 0x88D0, "MATRIX16_ARB" }, + { 0x88D1, "MATRIX17_ARB" }, + { 0x88D2, "MATRIX18_ARB" }, + { 0x88D3, "MATRIX19_ARB" }, + { 0x88D4, "MATRIX20_ARB" }, + { 0x88D5, "MATRIX21_ARB" }, + { 0x88D6, "MATRIX22_ARB" }, + { 0x88D7, "MATRIX23_ARB" }, + { 0x88D8, "MATRIX24_ARB" }, + { 0x88D9, "MATRIX25_ARB" }, + { 0x88DA, "MATRIX26_ARB" }, + { 0x88DB, "MATRIX27_ARB" }, + { 0x88DC, "MATRIX28_ARB" }, + { 0x88DD, "MATRIX29_ARB" }, + { 0x88DE, "MATRIX30_ARB" }, + { 0x88DF, "MATRIX31_ARB" }, +/* OpenGL extension GL_ARB_fragment_program */ + { 0x8804, "FRAGMENT_PROGRAM_ARB" }, + { 0x8805, "PROGRAM_ALU_INSTRUCTIONS_ARB" }, + { 0x8806, "PROGRAM_TEX_INSTRUCTIONS_ARB" }, + { 0x8807, "PROGRAM_TEX_INDIRECTIONS_ARB" }, + { 0x8808, "PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" }, + { 0x8809, "PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" }, + { 0x880A, "PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" }, + { 0x880B, "MAX_PROGRAM_ALU_INSTRUCTIONS_ARB" }, + { 0x880C, "MAX_PROGRAM_TEX_INSTRUCTIONS_ARB" }, + { 0x880D, "MAX_PROGRAM_TEX_INDIRECTIONS_ARB" }, + { 0x880E, "MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" }, + { 0x880F, "MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" }, + { 0x8810, "MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" }, + { 0x8871, "MAX_TEXTURE_COORDS_ARB" }, + { 0x8872, "MAX_TEXTURE_IMAGE_UNITS_ARB" }, +/* OpenGL extension GL_ARB_vertex_buffer_object */ + { 0x8764, "BUFFER_SIZE_ARB" }, + { 0x8765, "BUFFER_USAGE_ARB" }, + { 0x8894, "ARRAY_BUFFER_BINDING_ARB" }, + { 0x8895, "ELEMENT_ARRAY_BUFFER_BINDING_ARB" }, + { 0x8896, "VERTEX_ARRAY_BUFFER_BINDING_ARB" }, + { 0x8897, "NORMAL_ARRAY_BUFFER_BINDING_ARB" }, + { 0x8898, "COLOR_ARRAY_BUFFER_BINDING_ARB" }, + { 0x8899, "INDEX_ARRAY_BUFFER_BINDING_ARB" }, + { 0x889A, "TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB" }, + { 0x889B, "EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB" }, + { 0x889C, "SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB" }, + { 0x889D, "FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB" }, + { 0x889E, "WEIGHT_ARRAY_BUFFER_BINDING_ARB" }, + { 0x889F, "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB" }, + { 0x88B8, "READ_ONLY_ARB" }, + { 0x88B9, "WRITE_ONLY_ARB" }, + { 0x88BA, "READ_WRITE_ARB" }, + { 0x88BB, "BUFFER_ACCESS_ARB" }, + { 0x88BC, "BUFFER_MAPPED_ARB" }, + { 0x88BD, "BUFFER_MAP_POINTER_ARB" }, + { 0x88E0, "STREAM_DRAW_ARB" }, + { 0x88E1, "STREAM_READ_ARB" }, + { 0x88E2, "STREAM_COPY_ARB" }, + { 0x88E4, "STATIC_DRAW_ARB" }, + { 0x88E5, "STATIC_READ_ARB" }, + { 0x88E6, "STATIC_COPY_ARB" }, + { 0x88E8, "DYNAMIC_DRAW_ARB" }, + { 0x88E9, "DYNAMIC_READ_ARB" }, + { 0x88EA, "DYNAMIC_COPY_ARB" }, +/* OpenGL extension GL_ARB_occlusion_query */ + { 0x8864, "QUERY_COUNTER_BITS_ARB" }, + { 0x8865, "CURRENT_QUERY_ARB" }, + { 0x8866, "QUERY_RESULT_ARB" }, + { 0x8867, "QUERY_RESULT_AVAILABLE_ARB" }, + { 0x8914, "SAMPLES_PASSED_ARB" }, +/* OpenGL extension GL_ARB_shader_objects */ + { 0x8B40, "PROGRAM_OBJECT_ARB" }, + { 0x8B48, "SHADER_OBJECT_ARB" }, + { 0x8B4E, "OBJECT_TYPE_ARB" }, + { 0x8B4F, "OBJECT_SUBTYPE_ARB" }, + { 0x8B50, "FLOAT_VEC2_ARB" }, + { 0x8B51, "FLOAT_VEC3_ARB" }, + { 0x8B52, "FLOAT_VEC4_ARB" }, + { 0x8B53, "INT_VEC2_ARB" }, + { 0x8B54, "INT_VEC3_ARB" }, + { 0x8B55, "INT_VEC4_ARB" }, + { 0x8B56, "BOOL_ARB" }, + { 0x8B57, "BOOL_VEC2_ARB" }, + { 0x8B58, "BOOL_VEC3_ARB" }, + { 0x8B59, "BOOL_VEC4_ARB" }, + { 0x8B5A, "FLOAT_MAT2_ARB" }, + { 0x8B5B, "FLOAT_MAT3_ARB" }, + { 0x8B5C, "FLOAT_MAT4_ARB" }, + { 0x8B80, "OBJECT_DELETE_STATUS_ARB" }, + { 0x8B81, "OBJECT_COMPILE_STATUS_ARB" }, + { 0x8B82, "OBJECT_LINK_STATUS_ARB" }, + { 0x8B83, "OBJECT_VALIDATE_STATUS_ARB" }, + { 0x8B84, "OBJECT_INFO_LOG_LENGTH_ARB" }, + { 0x8B85, "OBJECT_ATTACHED_OBJECTS_ARB" }, + { 0x8B86, "OBJECT_ACTIVE_UNIFORMS_ARB" }, + { 0x8B87, "OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB" }, + { 0x8B88, "OBJECT_SHADER_SOURCE_LENGTH_ARB" }, +/* OpenGL extension GL_ARB_vertex_shader */ + { 0x8B31, "VERTEX_SHADER_ARB" }, + { 0x8B4A, "MAX_VERTEX_UNIFORM_COMPONENTS_ARB" }, + { 0x8B4B, "MAX_VARYING_FLOATS_ARB" }, + { 0x8B4C, "MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" }, + { 0x8B4D, "MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB" }, + { 0x8B89, "OBJECT_ACTIVE_ATTRIBUTES_ARB" }, + { 0x8B8A, "OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB" }, +/* OpenGL extension GL_ARB_fragment_shader */ + { 0x8B30, "FRAGMENT_SHADER_ARB" }, + { 0x8B49, "MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB" }, +/* OpenGL extension GL_ARB_shading_language_100 */ +/* OpenGL extension GL_ARB_texture_non_power_of_two */ +/* OpenGL extension GL_ARB_point_sprite */ + { 0x8861, "POINT_SPRITE_ARB" }, + { 0x8862, "COORD_REPLACE_ARB" }, +/* OpenGL extension GL_ARB_fragment_program_shadow */ +/* OpenGL extension GL_ARB_draw_buffers */ + { 0x8824, "MAX_DRAW_BUFFERS_ARB" }, + { 0x8825, "DRAW_BUFFER0_ARB" }, + { 0x8826, "DRAW_BUFFER1_ARB" }, + { 0x8827, "DRAW_BUFFER2_ARB" }, + { 0x8828, "DRAW_BUFFER3_ARB" }, + { 0x8829, "DRAW_BUFFER4_ARB" }, + { 0x882A, "DRAW_BUFFER5_ARB" }, + { 0x882B, "DRAW_BUFFER6_ARB" }, + { 0x882C, "DRAW_BUFFER7_ARB" }, + { 0x882D, "DRAW_BUFFER8_ARB" }, + { 0x882E, "DRAW_BUFFER9_ARB" }, + { 0x882F, "DRAW_BUFFER10_ARB" }, + { 0x8830, "DRAW_BUFFER11_ARB" }, + { 0x8831, "DRAW_BUFFER12_ARB" }, + { 0x8832, "DRAW_BUFFER13_ARB" }, + { 0x8833, "DRAW_BUFFER14_ARB" }, + { 0x8834, "DRAW_BUFFER15_ARB" }, +/* OpenGL extension GL_ARB_texture_rectangle */ + { 0x84F5, "TEXTURE_RECTANGLE_ARB" }, + { 0x84F6, "TEXTURE_BINDING_RECTANGLE_ARB" }, + { 0x84F7, "PROXY_TEXTURE_RECTANGLE_ARB" }, + { 0x84F8, "MAX_RECTANGLE_TEXTURE_SIZE_ARB" }, +/* OpenGL extension GL_EXT_blend_color */ + { 0x8001, "CONSTANT_COLOR_EXT" }, + { 0x8002, "ONE_MINUS_CONSTANT_COLOR_EXT" }, + { 0x8003, "CONSTANT_ALPHA_EXT" }, + { 0x8004, "ONE_MINUS_CONSTANT_ALPHA_EXT" }, + { 0x8005, "BLEND_COLOR_EXT" }, +/* OpenGL extension GL_EXT_polygon_offset */ +/* OpenGL extension GL_EXT_texture */ + { 0x803B, "ALPHA4_EXT" }, + { 0x803C, "ALPHA8_EXT" }, + { 0x803D, "ALPHA12_EXT" }, + { 0x803E, "ALPHA16_EXT" }, + { 0x803F, "LUMINANCE4_EXT" }, + { 0x8040, "LUMINANCE8_EXT" }, + { 0x8041, "LUMINANCE12_EXT" }, + { 0x8042, "LUMINANCE16_EXT" }, + { 0x8043, "LUMINANCE4_ALPHA4_EXT" }, + { 0x8044, "LUMINANCE6_ALPHA2_EXT" }, + { 0x8045, "LUMINANCE8_ALPHA8_EXT" }, + { 0x8046, "LUMINANCE12_ALPHA4_EXT" }, + { 0x8047, "LUMINANCE12_ALPHA12_EXT" }, + { 0x8048, "LUMINANCE16_ALPHA16_EXT" }, + { 0x8049, "INTENSITY_EXT" }, + { 0x804A, "INTENSITY4_EXT" }, + { 0x804B, "INTENSITY8_EXT" }, + { 0x804C, "INTENSITY12_EXT" }, + { 0x804D, "INTENSITY16_EXT" }, + { 0x804E, "RGB2_EXT" }, + { 0x804F, "RGB4_EXT" }, + { 0x8050, "RGB5_EXT" }, + { 0x8051, "RGB8_EXT" }, + { 0x8052, "RGB10_EXT" }, + { 0x8053, "RGB12_EXT" }, + { 0x8054, "RGB16_EXT" }, + { 0x8055, "RGBA2_EXT" }, + { 0x8056, "RGBA4_EXT" }, + { 0x8057, "RGB5_A1_EXT" }, + { 0x8058, "RGBA8_EXT" }, + { 0x8059, "RGB10_A2_EXT" }, + { 0x805A, "RGBA12_EXT" }, + { 0x805B, "RGBA16_EXT" }, + { 0x805C, "TEXTURE_RED_SIZE_EXT" }, + { 0x805D, "TEXTURE_GREEN_SIZE_EXT" }, + { 0x805E, "TEXTURE_BLUE_SIZE_EXT" }, + { 0x805F, "TEXTURE_ALPHA_SIZE_EXT" }, + { 0x8060, "TEXTURE_LUMINANCE_SIZE_EXT" }, + { 0x8061, "TEXTURE_INTENSITY_SIZE_EXT" }, + { 0x8062, "REPLACE_EXT" }, + { 0x8063, "PROXY_TEXTURE_1D_EXT" }, + { 0x8064, "PROXY_TEXTURE_2D_EXT" }, + { 0x8065, "TEXTURE_TOO_LARGE_EXT" }, +/* OpenGL extension GL_EXT_texture3D */ +/* OpenGL extension GL_SGIS_texture_filter4 */ +/* OpenGL extension GL_EXT_subtexture */ +/* OpenGL extension GL_EXT_copy_texture */ +/* OpenGL extension GL_EXT_histogram */ + { 0x8024, "HISTOGRAM_EXT" }, + { 0x8025, "PROXY_HISTOGRAM_EXT" }, + { 0x8026, "HISTOGRAM_WIDTH_EXT" }, + { 0x8027, "HISTOGRAM_FORMAT_EXT" }, + { 0x8028, "HISTOGRAM_RED_SIZE_EXT" }, + { 0x8029, "HISTOGRAM_GREEN_SIZE_EXT" }, + { 0x802A, "HISTOGRAM_BLUE_SIZE_EXT" }, + { 0x802B, "HISTOGRAM_ALPHA_SIZE_EXT" }, + { 0x802C, "HISTOGRAM_LUMINANCE_SIZE_EXT" }, + { 0x802D, "HISTOGRAM_SINK_EXT" }, + { 0x802E, "MINMAX_EXT" }, + { 0x802F, "MINMAX_FORMAT_EXT" }, + { 0x8030, "MINMAX_SINK_EXT" }, + { 0x8031, "TABLE_TOO_LARGE_EXT" }, +/* OpenGL extension GL_EXT_convolution */ + { 0x8013, "CONVOLUTION_BORDER_MODE_EXT" }, + { 0x8014, "CONVOLUTION_FILTER_SCALE_EXT" }, + { 0x8015, "CONVOLUTION_FILTER_BIAS_EXT" }, + { 0x8016, "REDUCE_EXT" }, + { 0x8017, "CONVOLUTION_FORMAT_EXT" }, + { 0x8018, "CONVOLUTION_WIDTH_EXT" }, + { 0x8019, "CONVOLUTION_HEIGHT_EXT" }, + { 0x801A, "MAX_CONVOLUTION_WIDTH_EXT" }, + { 0x801B, "MAX_CONVOLUTION_HEIGHT_EXT" }, + { 0x801C, "POST_CONVOLUTION_RED_SCALE_EXT" }, + { 0x801D, "POST_CONVOLUTION_GREEN_SCALE_EXT" }, + { 0x801E, "POST_CONVOLUTION_BLUE_SCALE_EXT" }, + { 0x801F, "POST_CONVOLUTION_ALPHA_SCALE_EXT" }, + { 0x8020, "POST_CONVOLUTION_RED_BIAS_EXT" }, + { 0x8021, "POST_CONVOLUTION_GREEN_BIAS_EXT" }, + { 0x8022, "POST_CONVOLUTION_BLUE_BIAS_EXT" }, + { 0x8023, "POST_CONVOLUTION_ALPHA_BIAS_EXT" }, +/* OpenGL extension GL_SGI_color_matrix */ + { 0x80B1, "COLOR_MATRIX_SGI" }, + { 0x80B2, "COLOR_MATRIX_STACK_DEPTH_SGI" }, + { 0x80B3, "MAX_COLOR_MATRIX_STACK_DEPTH_SGI" }, + { 0x80B4, "POST_COLOR_MATRIX_RED_SCALE_SGI" }, + { 0x80B5, "POST_COLOR_MATRIX_GREEN_SCALE_SGI" }, + { 0x80B6, "POST_COLOR_MATRIX_BLUE_SCALE_SGI" }, + { 0x80B7, "POST_COLOR_MATRIX_ALPHA_SCALE_SGI" }, + { 0x80B8, "POST_COLOR_MATRIX_RED_BIAS_SGI" }, + { 0x80B9, "POST_COLOR_MATRIX_GREEN_BIAS_SGI" }, + { 0x80BA, "POST_COLOR_MATRIX_BLUE_BIAS_SGI" }, + { 0x80BB, "POST_COLOR_MATRIX_ALPHA_BIAS_SGI" }, +/* OpenGL extension GL_SGI_color_table */ + { 0x80D6, "COLOR_TABLE_SCALE_SGI" }, + { 0x80D7, "COLOR_TABLE_BIAS_SGI" }, + { 0x80D8, "COLOR_TABLE_FORMAT_SGI" }, + { 0x80D9, "COLOR_TABLE_WIDTH_SGI" }, + { 0x80DA, "COLOR_TABLE_RED_SIZE_SGI" }, + { 0x80DB, "COLOR_TABLE_GREEN_SIZE_SGI" }, + { 0x80DC, "COLOR_TABLE_BLUE_SIZE_SGI" }, + { 0x80DD, "COLOR_TABLE_ALPHA_SIZE_SGI" }, + { 0x80DE, "COLOR_TABLE_LUMINANCE_SIZE_SGI" }, + { 0x80DF, "COLOR_TABLE_INTENSITY_SIZE_SGI" }, +/* OpenGL extension GL_SGIS_pixel_texture */ +/* OpenGL extension GL_SGIS_texture4D */ +/* OpenGL extension GL_SGI_texture_color_table */ + { 0x80BC, "TEXTURE_COLOR_TABLE_SGI" }, + { 0x80BD, "PROXY_TEXTURE_COLOR_TABLE_SGI" }, +/* OpenGL extension GL_EXT_texture_object */ +/* OpenGL extension GL_SGIS_detail_texture */ +/* OpenGL extension GL_SGIS_sharpen_texture */ +/* OpenGL extension GL_SGIS_multisample */ +/* OpenGL extension GL_EXT_rescale_normal */ + { 0x803A, "RESCALE_NORMAL_EXT" }, +/* OpenGL extension GL_EXT_vertex_array */ +/* OpenGL extension GL_SGIS_generate_mipmap */ + { 0x8191, "GENERATE_MIPMAP_SGIS" }, + { 0x8192, "GENERATE_MIPMAP_HINT_SGIS" }, +/* OpenGL extension GL_SGIX_clipmap */ + { 0x8170, "LINEAR_CLIPMAP_LINEAR_SGIX" }, + { 0x8171, "TEXTURE_CLIPMAP_CENTER_SGIX" }, + { 0x8172, "TEXTURE_CLIPMAP_FRAME_SGIX" }, + { 0x8173, "TEXTURE_CLIPMAP_OFFSET_SGIX" }, + { 0x8174, "TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX" }, + { 0x8175, "TEXTURE_CLIPMAP_LOD_OFFSET_SGIX" }, + { 0x8176, "TEXTURE_CLIPMAP_DEPTH_SGIX" }, + { 0x8177, "MAX_CLIPMAP_DEPTH_SGIX" }, + { 0x8178, "MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX" }, + { 0x844D, "NEAREST_CLIPMAP_NEAREST_SGIX" }, + { 0x844E, "NEAREST_CLIPMAP_LINEAR_SGIX" }, + { 0x844F, "LINEAR_CLIPMAP_NEAREST_SGIX" }, +/* OpenGL extension GL_SGIX_shadow */ + { 0x819A, "TEXTURE_COMPARE_SGIX" }, + { 0x819B, "TEXTURE_COMPARE_OPERATOR_SGIX" }, + { 0x819C, "TEXTURE_LEQUAL_R_SGIX" }, + { 0x819D, "TEXTURE_GEQUAL_R_SGIX" }, +/* OpenGL extension GL_SGIS_texture_edge_clamp */ + { 0x812F, "CLAMP_TO_EDGE_SGIS" }, +/* OpenGL extension GL_SGIS_texture_border_clamp */ + { 0x812D, "CLAMP_TO_BORDER_SGIS" }, +/* OpenGL extension GL_EXT_blend_minmax */ + { 0x8006, "FUNC_ADD_EXT" }, + { 0x8007, "MIN_EXT" }, + { 0x8008, "MAX_EXT" }, + { 0x8009, "BLEND_EQUATION_EXT" }, +/* OpenGL extension GL_EXT_blend_subtract */ + { 0x800A, "FUNC_SUBTRACT_EXT" }, + { 0x800B, "FUNC_REVERSE_SUBTRACT_EXT" }, +/* OpenGL extension GL_SGIX_sprite */ +/* OpenGL extension GL_EXT_point_parameters */ + { 0x8126, "POINT_SIZE_MIN_EXT" }, + { 0x8127, "POINT_SIZE_MAX_EXT" }, + { 0x8128, "POINT_FADE_THRESHOLD_SIZE_EXT" }, + { 0x8129, "POINT_DISTANCE_ATTENUATION_EXT" }, +/* OpenGL extension GL_SGIX_instruments */ +/* OpenGL extension GL_SGIX_texture_scale_bias */ + { 0x8179, "POST_TEXTURE_FILTER_BIAS_SGIX" }, + { 0x817A, "POST_TEXTURE_FILTER_SCALE_SGIX" }, + { 0x817B, "POST_TEXTURE_FILTER_BIAS_RANGE_SGIX" }, + { 0x817C, "POST_TEXTURE_FILTER_SCALE_RANGE_SGIX" }, +/* OpenGL extension GL_SGIX_framezoom */ +/* OpenGL extension GL_SGIX_tag_sample_buffer */ +/* OpenGL extension GL_SGIX_reference_plane */ +/* OpenGL extension GL_SGIX_flush_raster */ +/* OpenGL extension GL_SGIX_depth_texture */ + { 0x81A5, "DEPTH_COMPONENT16_SGIX" }, + { 0x81A6, "DEPTH_COMPONENT24_SGIX" }, + { 0x81A7, "DEPTH_COMPONENT32_SGIX" }, +/* OpenGL extension GL_SGIS_fog_function */ +/* OpenGL extension GL_SGIX_fog_offset */ + { 0x8198, "FOG_OFFSET_SGIX" }, + { 0x8199, "FOG_OFFSET_VALUE_SGIX" }, +/* OpenGL extension GL_HP_image_transform */ +/* OpenGL extension GL_HP_convolution_border_modes */ + { 0x8150, "IGNORE_BORDER_HP" }, + { 0x8151, "CONSTANT_BORDER_HP" }, + { 0x8153, "REPLICATE_BORDER_HP" }, + { 0x8154, "CONVOLUTION_BORDER_COLOR_HP" }, +/* OpenGL extension GL_EXT_color_subtable */ +/* OpenGL extension GL_PGI_misc_hints */ +/* OpenGL extension GL_EXT_paletted_texture */ + { 0x80D8, "COLOR_TABLE_FORMAT_EXT" }, + { 0x80D9, "COLOR_TABLE_WIDTH_EXT" }, + { 0x80DA, "COLOR_TABLE_RED_SIZE_EXT" }, + { 0x80DB, "COLOR_TABLE_GREEN_SIZE_EXT" }, + { 0x80DC, "COLOR_TABLE_BLUE_SIZE_EXT" }, + { 0x80DD, "COLOR_TABLE_ALPHA_SIZE_EXT" }, + { 0x80DE, "COLOR_TABLE_LUMINANCE_SIZE_EXT" }, + { 0x80DF, "COLOR_TABLE_INTENSITY_SIZE_EXT" }, + { 0x80ED, "TEXTURE_INDEX_SIZE_EXT" }, +/* OpenGL extension GL_EXT_clip_volume_hint */ + { 0x80F0, "CLIP_VOLUME_CLIPPING_HINT_EXT" }, +/* OpenGL extension GL_SGIX_list_priority */ +/* OpenGL extension GL_SGIX_texture_lod_bias */ + { 0x818E, "TEXTURE_LOD_BIAS_S_SGIX" }, + { 0x818F, "TEXTURE_LOD_BIAS_T_SGIX" }, + { 0x8190, "TEXTURE_LOD_BIAS_R_SGIX" }, +/* OpenGL extension GL_SGIX_shadow_ambient */ + { 0x80BF, "SHADOW_AMBIENT_SGIX" }, +/* OpenGL extension GL_EXT_index_material */ +/* OpenGL extension GL_EXT_index_func */ +/* OpenGL extension GL_EXT_compiled_vertex_array */ +/* OpenGL extension GL_EXT_cull_vertex */ + { 0x81AA, "CULL_VERTEX_EXT" }, + { 0x81AB, "CULL_VERTEX_OBJECT_POSITION_EXT" }, + { 0x81AC, "CULL_VERTEX_EYE_POSITION_EXT" }, +/* OpenGL extension GL_SGIX_fragment_lighting */ +/* OpenGL extension GL_IBM_rasterpos_clip */ + { 0x19262, "RASTER_POSITION_UNCLIPPED_IBM" }, +/* OpenGL extension GL_EXT_draw_range_elements */ +/* OpenGL extension GL_EXT_light_texture */ +/* OpenGL extension GL_SGIX_async */ +/* OpenGL extension GL_INTEL_parallel_arrays */ +/* OpenGL extension GL_HP_occlusion_test */ + { 0x8165, "OCCLUSION_TEST_HP" }, + { 0x8166, "OCCLUSION_TEST_RESULT_HP" }, +/* OpenGL extension GL_EXT_pixel_transform */ +/* OpenGL extension GL_EXT_shared_texture_palette */ + { 0x81FB, "SHARED_TEXTURE_PALETTE_EXT" }, +/* OpenGL extension GL_EXT_separate_specular_color */ + { 0x81F8, "LIGHT_MODEL_COLOR_CONTROL_EXT" }, + { 0x81F9, "SINGLE_COLOR_EXT" }, + { 0x81FA, "SEPARATE_SPECULAR_COLOR_EXT" }, +/* OpenGL extension GL_EXT_secondary_color */ +/* OpenGL extension GL_EXT_texture_perturb_normal */ +/* OpenGL extension GL_EXT_multi_draw_arrays */ +/* OpenGL extension GL_EXT_fog_coord */ +/* OpenGL extension GL_EXT_coordinate_frame */ +/* OpenGL extension GL_EXT_texture_env_combine */ + { 0x8570, "COMBINE_EXT" }, + { 0x8571, "COMBINE_RGB_EXT" }, + { 0x8572, "COMBINE_ALPHA_EXT" }, + { 0x8573, "RGB_SCALE_EXT" }, + { 0x8574, "ADD_SIGNED_EXT" }, + { 0x8575, "INTERPOLATE_EXT" }, + { 0x8576, "CONSTANT_EXT" }, + { 0x8577, "PRIMARY_COLOR_EXT" }, + { 0x8578, "PREVIOUS_EXT" }, + { 0x8580, "SOURCE0_RGB_EXT" }, + { 0x8581, "SOURCE1_RGB_EXT" }, + { 0x8582, "SOURCE2_RGB_EXT" }, + { 0x8588, "SOURCE0_ALPHA_EXT" }, + { 0x8589, "SOURCE1_ALPHA_EXT" }, + { 0x858A, "SOURCE2_ALPHA_EXT" }, + { 0x8590, "OPERAND0_RGB_EXT" }, + { 0x8591, "OPERAND1_RGB_EXT" }, + { 0x8592, "OPERAND2_RGB_EXT" }, + { 0x8598, "OPERAND0_ALPHA_EXT" }, + { 0x8599, "OPERAND1_ALPHA_EXT" }, + { 0x859A, "OPERAND2_ALPHA_EXT" }, +/* OpenGL extension GL_SGIX_pixel_texture */ +/* OpenGL extension GL_SUNX_constant_data */ +/* OpenGL extension GL_SUN_global_alpha */ +/* OpenGL extension GL_SUN_triangle_list */ +/* OpenGL extension GL_SUN_vertex */ +/* OpenGL extension GL_EXT_blend_func_separate */ +/* OpenGL extension GL_EXT_stencil_wrap */ + { 0x8507, "INCR_WRAP_EXT" }, + { 0x8508, "DECR_WRAP_EXT" }, +/* OpenGL extension GL_NV_texgen_reflection */ + { 0x8511, "NORMAL_MAP_NV" }, + { 0x8512, "REFLECTION_MAP_NV" }, +/* OpenGL extension GL_SUN_convolution_border_modes */ + { 0x81D4, "WRAP_BORDER_SUN" }, +/* OpenGL extension GL_EXT_texture_env_add */ +/* OpenGL extension GL_EXT_texture_lod_bias */ + { 0x8501, "TEXTURE_LOD_BIAS_EXT" }, +/* OpenGL extension GL_EXT_texture_filter_anisotropic */ + { 0x84FE, "TEXTURE_MAX_ANISOTROPY_EXT" }, + { 0x84FF, "MAX_TEXTURE_MAX_ANISOTROPY_EXT" }, +/* OpenGL extension GL_EXT_vertex_weighting */ +/* OpenGL extension GL_NV_light_max_exponent */ + { 0x8504, "MAX_SHININESS_NV" }, + { 0x8505, "MAX_SPOT_EXPONENT_NV" }, +/* OpenGL extension GL_NV_vertex_array_range */ +/* OpenGL extension GL_NV_register_combiners */ +/* OpenGL extension GL_NV_fog_distance */ + { 0x855A, "FOG_DISTANCE_MODE_NV" }, + { 0x855B, "EYE_RADIAL_NV" }, + { 0x855C, "EYE_PLANE_ABSOLUTE_NV" }, +/* OpenGL extension GL_NV_blend_square */ +/* OpenGL extension GL_NV_texture_env_combine4 */ + { 0x8503, "COMBINE4" }, + { 0x8583, "SOURCE3_RGB_NV" }, + { 0x858B, "SOURCE3_ALPHA_NV" }, + { 0x8593, "OPERAND3_RGB_NV" }, + { 0x859B, "OPERAND3_ALPHA_NV" }, +/* OpenGL extension GL_MESA_resize_buffers */ +/* OpenGL extension GL_MESA_window_pos */ +/* OpenGL extension GL_EXT_texture_compression_s3tc */ + { 0x83F0, "COMPRESSED_RGB_S3TC_DXT1_EXT" }, + { 0x83F1, "COMPRESSED_RGBA_S3TC_DXT1_EXT" }, + { 0x83F2, "COMPRESSED_RGBA_S3TC_DXT3_EXT" }, + { 0x83F3, "COMPRESSED_RGBA_S3TC_DXT5_EXT" }, +/* OpenGL extension GL_IBM_multimode_draw_arrays */ +/* OpenGL extension GL_IBM_vertex_array_lists */ +/* OpenGL extension GL_3DFX_texture_compression_FXT1 */ + { 0x86B0, "COMPRESSED_RGB_FXT1_3DFX" }, + { 0x86B1, "COMPRESSED_RGBA_FXT1_3DFX" }, +/* OpenGL extension GL_3DFX_multisample */ + { 0x86B2, "MULTISAMPLE_3DFX" }, + { 0x86B3, "SAMPLE_BUFFERS_3DFX" }, + { 0x86B4, "SAMPLES_3DFX" }, +/* OpenGL extension GL_3DFX_tbuffer */ +/* OpenGL extension GL_EXT_multisample */ +/* OpenGL extension GL_SGIS_texture_color_mask */ + { 0x81EF, "TEXTURE_COLOR_WRITEMASK_SGIS" }, +/* OpenGL extension GL_EXT_texture_env_dot3 */ + { 0x8740, "DOT3_RGB_EXT" }, + { 0x8741, "DOT3_RGBA_EXT" }, +/* OpenGL extension GL_ATI_texture_mirror_once */ + { 0x8742, "MIRROR_CLAMP_ATI" }, + { 0x8743, "MIRROR_CLAMP_TO_EDGE_ATI" }, +/* OpenGL extension GL_NV_fence */ +/* OpenGL extension GL_IBM_texture_mirrored_repeat */ + { 0x8370, "MIRRORED_REPEAT_IBM" }, +/* OpenGL extension GL_NV_evaluators */ +/* OpenGL extension GL_NV_packed_depth_stencil */ + { 0x84F9, "DEPTH_STENCIL_NV" }, + { 0x84FA, "UNSIGNED_INT_24_8_NV" }, +/* OpenGL extension GL_NV_register_combiners2 */ +/* OpenGL extension GL_NV_texture_compression_vtc */ + { 0x83F0, "COMPRESSED_RGB_S3TC_DXT1_EXT" }, + { 0x83F1, "COMPRESSED_RGBA_S3TC_DXT1_EXT" }, + { 0x83F2, "COMPRESSED_RGBA_S3TC_DXT3_EXT" }, + { 0x83F3, "COMPRESSED_RGBA_S3TC_DXT5_EXT" }, +/* OpenGL extension GL_NV_texture_rectangle */ + { 0x84F5, "TEXTURE_RECTANGLE_NV" }, + { 0x84F6, "TEXTURE_BINDING_RECTANGLE_NV" }, + { 0x84F7, "PROXY_TEXTURE_RECTANGLE_NV" }, + { 0x84F8, "MAX_RECTANGLE_TEXTURE_SIZE_NV" }, +/* OpenGL extension GL_NV_vertex_program */ + { 0x8620, "VERTEX_PROGRAM_NV" }, + { 0x8621, "VERTEX_STATE_PROGRAM_NV" }, + { 0x8623, "ATTRIB_ARRAY_SIZE_NV" }, + { 0x8624, "ATTRIB_ARRAY_STRIDE_NV" }, + { 0x8625, "ATTRIB_ARRAY_TYPE_NV" }, + { 0x8626, "CURRENT_ATTRIB_NV" }, + { 0x8627, "PROGRAM_LENGTH_NV" }, + { 0x8628, "PROGRAM_STRING_NV" }, + { 0x8629, "MODELVIEW_PROJECTION_NV" }, + { 0x862A, "IDENTITY_NV" }, + { 0x862B, "INVERSE_NV" }, + { 0x862C, "TRANSPOSE_NV" }, + { 0x862D, "INVERSE_TRANSPOSE_NV" }, + { 0x862E, "MAX_TRACK_MATRIX_STACK_DEPTH_NV" }, + { 0x862F, "MAX_TRACK_MATRICES_NV" }, + { 0x8630, "MATRIX0_NV" }, + { 0x8631, "MATRIX1_NV" }, + { 0x8632, "MATRIX2_NV" }, + { 0x8633, "MATRIX3_NV" }, + { 0x8634, "MATRIX4_NV" }, + { 0x8635, "MATRIX5_NV" }, + { 0x8636, "MATRIX6_NV" }, + { 0x8637, "MATRIX7_NV" }, + { 0x8640, "CURRENT_MATRIX_STACK_DEPTH_NV" }, + { 0x8641, "CURRENT_MATRIX_NV" }, + { 0x8642, "VERTEX_PROGRAM_POINT_SIZE_NV" }, + { 0x8643, "VERTEX_PROGRAM_TWO_SIDE_NV" }, + { 0x8644, "PROGRAM_PARAMETER_NV" }, + { 0x8645, "ATTRIB_ARRAY_POINTER_NV" }, + { 0x8646, "PROGRAM_TARGET_NV" }, + { 0x8647, "PROGRAM_RESIDENT_NV" }, + { 0x8648, "TRACK_MATRIX_NV" }, + { 0x8649, "TRACK_MATRIX_TRANSFORM_NV" }, + { 0x864A, "VERTEX_PROGRAM_BINDING_NV" }, + { 0x864B, "PROGRAM_ERROR_POSITION_NV" }, + { 0x8650, "VERTEX_ATTRIB_ARRAY0_NV" }, + { 0x8651, "VERTEX_ATTRIB_ARRAY1_NV" }, + { 0x8652, "VERTEX_ATTRIB_ARRAY2_NV" }, + { 0x8653, "VERTEX_ATTRIB_ARRAY3_NV" }, + { 0x8654, "VERTEX_ATTRIB_ARRAY4_NV" }, + { 0x8655, "VERTEX_ATTRIB_ARRAY5_NV" }, + { 0x8656, "VERTEX_ATTRIB_ARRAY6_NV" }, + { 0x8657, "VERTEX_ATTRIB_ARRAY7_NV" }, + { 0x8658, "VERTEX_ATTRIB_ARRAY8_NV" }, + { 0x8659, "VERTEX_ATTRIB_ARRAY9_NV" }, + { 0x865A, "VERTEX_ATTRIB_ARRAY10_NV" }, + { 0x865B, "VERTEX_ATTRIB_ARRAY11_NV" }, + { 0x865C, "VERTEX_ATTRIB_ARRAY12_NV" }, + { 0x865D, "VERTEX_ATTRIB_ARRAY13_NV" }, + { 0x865E, "VERTEX_ATTRIB_ARRAY14_NV" }, + { 0x865F, "VERTEX_ATTRIB_ARRAY15_NV" }, + { 0x8660, "MAP1_VERTEX_ATTRIB0_4_NV" }, + { 0x8661, "MAP1_VERTEX_ATTRIB1_4_NV" }, + { 0x8662, "MAP1_VERTEX_ATTRIB2_4_NV" }, + { 0x8663, "MAP1_VERTEX_ATTRIB3_4_NV" }, + { 0x8664, "MAP1_VERTEX_ATTRIB4_4_NV" }, + { 0x8665, "MAP1_VERTEX_ATTRIB5_4_NV" }, + { 0x8666, "MAP1_VERTEX_ATTRIB6_4_NV" }, + { 0x8667, "MAP1_VERTEX_ATTRIB7_4_NV" }, + { 0x8668, "MAP1_VERTEX_ATTRIB8_4_NV" }, + { 0x8669, "MAP1_VERTEX_ATTRIB9_4_NV" }, + { 0x866A, "MAP1_VERTEX_ATTRIB10_4_NV" }, + { 0x866B, "MAP1_VERTEX_ATTRIB11_4_NV" }, + { 0x866C, "MAP1_VERTEX_ATTRIB12_4_NV" }, + { 0x866D, "MAP1_VERTEX_ATTRIB13_4_NV" }, + { 0x866E, "MAP1_VERTEX_ATTRIB14_4_NV" }, + { 0x866F, "MAP1_VERTEX_ATTRIB15_4_NV" }, + { 0x8670, "MAP2_VERTEX_ATTRIB0_4_NV" }, + { 0x8671, "MAP2_VERTEX_ATTRIB1_4_NV" }, + { 0x8672, "MAP2_VERTEX_ATTRIB2_4_NV" }, + { 0x8673, "MAP2_VERTEX_ATTRIB3_4_NV" }, + { 0x8674, "MAP2_VERTEX_ATTRIB4_4_NV" }, + { 0x8675, "MAP2_VERTEX_ATTRIB5_4_NV" }, + { 0x8676, "MAP2_VERTEX_ATTRIB6_4_NV" }, + { 0x8677, "MAP2_VERTEX_ATTRIB7_4_NV" }, + { 0x8678, "MAP2_VERTEX_ATTRIB8_4_NV" }, + { 0x8679, "MAP2_VERTEX_ATTRIB9_4_NV" }, + { 0x867A, "MAP2_VERTEX_ATTRIB10_4_NV" }, + { 0x867B, "MAP2_VERTEX_ATTRIB11_4_NV" }, + { 0x867C, "MAP2_VERTEX_ATTRIB12_4_NV" }, + { 0x867D, "MAP2_VERTEX_ATTRIB13_4_NV" }, + { 0x867E, "MAP2_VERTEX_ATTRIB14_4_NV" }, + { 0x867F, "MAP2_VERTEX_ATTRIB15_4_NV" }, +/* OpenGL extension GL_SGIX_texture_coordinate_clamp */ + { 0x8369, "TEXTURE_MAX_CLAMP_S_SGIX" }, + { 0x836A, "TEXTURE_MAX_CLAMP_T_SGIX" }, + { 0x836B, "TEXTURE_MAX_CLAMP_R_SGIX" }, +/* OpenGL extension GL_NV_copy_depth_to_color */ + { 0x886E, "DEPTH_STENCIL_TO_RGBA_NV" }, + { 0x886F, "DEPTH_STENCIL_TO_BGRA_NV" }, +/* OpenGL extension GL_ATI_envmap_bumpmap */ + { 0x8775, "BUMP_ROT_MATRIX_ATI" }, + { 0x8776, "BUMP_ROT_MATRIX_SIZE_ATI" }, + { 0x8777, "BUMP_NUM_TEX_UNITS_ATI" }, + { 0x8778, "BUMP_TEX_UNITS_ATI" }, + { 0x8779, "DUDV_ATI" }, + { 0x877A, "DU8DV8_ATI" }, + { 0x877B, "BUMP_ENVMAP_ATI" }, + { 0x877C, "BUMP_TARGET_ATI" }, +/* OpenGL extension GL_ATI_fragment_shader */ +/* OpenGL extension GL_SUN_mesh_array */ + { 0x8614, "QUAD_MESH_SUN" }, + { 0x8615, "TRIANGLE_MESH_SUN" }, +/* OpenGL extension GL_SUN_slice_accum */ + { 0x85CC, "SLICE_ACCUM_SUN" }, +/* OpenGL extension GL_NV_multisample_filter_hint */ + { 0x8534, "MULTISAMPLE_FILTER_HINT_NV" }, +/* OpenGL extension GL_NV_depth_clamp */ + { 0x864F, "DEPTH_CLAMP_NV" }, +/* OpenGL extension GL_NV_point_sprite */ + { 0x8126, "POINT_SIZE_MIN_EXT" }, + { 0x8127, "POINT_SIZE_MAX_EXT" }, + { 0x8128, "POINT_FADE_THRESHOLD_SIZE_EXT" }, + { 0x8129, "POINT_DISTANCE_ATTENUATION_EXT" }, + { 0x8861, "POINT_SPRITE_NV" }, + { 0x8862, "COORD_REPLACE_NV" }, + { 0x8863, "POINT_SPRITE_R_MODE_NV" }, +/* OpenGL extension GL_EXT_shadow_funcs */ +/* OpenGL extension GL_EXT_stencil_two_side */ + { 0x8910, "STENCIL_TEST_TWO_SIDE_EXT" }, + { 0x8911, "ACTIVE_STENCIL_FACE_EXT" }, +/* OpenGL extension GL_APPLE_ycbcr_422 */ + { 0x85B9, "YCBCR_422_APPLE" }, + { 0x85BA, "UNSIGNED_SHORT_8_8_APPLE" }, + { 0x85BB, "UNSIGNED_SHORT_8_8_REV_APPLE" }, +/* OpenGL extension GL_S3_s3tc */ + { 0x83A0, "RGB_S3TC" }, + { 0x83A1, "RGB4_S3TC" }, + { 0x83A2, "RGBA_S3TC" }, + { 0x83A3, "RGBA4_S3TC" }, + { 0x83A4, "RGBA_DXT5_S3TC" }, + { 0x83A5, "RGBA4_DXT5_S3TC" }, +/* OpenGL extension GL_ATI_draw_buffers */ + { 0x8824, "MAX_DRAW_BUFFERS_ATI" }, + { 0x8825, "DRAW_BUFFER0_ATI" }, + { 0x8826, "DRAW_BUFFER1_ATI" }, + { 0x8827, "DRAW_BUFFER2_ATI" }, + { 0x8828, "DRAW_BUFFER3_ATI" }, + { 0x8829, "DRAW_BUFFER4_ATI" }, + { 0x882A, "DRAW_BUFFER5_ATI" }, + { 0x882B, "DRAW_BUFFER6_ATI" }, + { 0x882C, "DRAW_BUFFER7_ATI" }, + { 0x882D, "DRAW_BUFFER8_ATI" }, + { 0x882E, "DRAW_BUFFER9_ATI" }, + { 0x882F, "DRAW_BUFFER10_ATI" }, + { 0x8830, "DRAW_BUFFER11_ATI" }, + { 0x8831, "DRAW_BUFFER12_ATI" }, + { 0x8832, "DRAW_BUFFER13_ATI" }, + { 0x8833, "DRAW_BUFFER14_ATI" }, + { 0x8834, "DRAW_BUFFER15_ATI" }, +/* OpenGL extension GL_ATI_texture_env_combine3 */ + { 0x8744, "MODULATE_ADD_ATI" }, + { 0x8745, "MODULATE_SIGNED_ADD_ATI" }, + { 0x8746, "MODULATE_SUBTRACT_ATI" }, +/* OpenGL extension GL_NV_fragment_program */ +/* OpenGL extension GL_NV_texture_expand_normal */ + { 0x888F, "TEXTURE_UNSIGNED_REMAP_MODE_NV" }, +/* OpenGL extension GL_OES_compressed_paletted_texture */ + { 0x8B90, "PALETTE4_RGB8_OES" }, + { 0x8B91, "PALETTE4_RGBA8_OES" }, + { 0x8B92, "PALETTE4_R5_G6_B5_OES" }, + { 0x8B93, "PALETTE4_RGBA4_OES" }, + { 0x8B94, "PALETTE4_RGB5_A1_OES" }, + { 0x8B95, "PALETTE8_RGB8_OES" }, + { 0x8B96, "PALETTE8_RGBA8_OES" }, + { 0x8B97, "PALETTE8_R5_G6_B5_OES" }, + { 0x8B98, "PALETTE8_RGBA4_OES" }, + { 0x8B99, "PALETTE8_RGB5_A1_OES" }, +/* OpenGL extension GL_OES_read_format */ + { 0x8B9A, "IMPLEMENTATION_COLOR_READ_TYPE_OES" }, + { 0x8B9B, "IMPLEMENTATION_COLOR_READ_FORMAT_OES" }, +/* OpenGL extension GL_EXT_depth_bounds_test */ + { 0x8890, "DEPTH_BOUNDS_TEST_EXT" }, + { 0x8891, "DEPTH_BOUNDS_EXT" }, +/* OpenGL extension GL_EXT_texture_mirror_clamp */ + { 0x8742, "MIRROR_CLAMP_EXT" }, + { 0x8743, "MIRROR_CLAMP_TO_EDGE_EXT" }, + { 0x8912, "MIRROR_CLAMP_TO_BORDER_EXT" }, +/* OpenGL extension GL_EXT_blend_equation_separate */ + { 0x8009, "BLEND_EQUATION_RGB_EXT" }, + { 0x883D, "BLEND_EQUATION_ALPHA_EXT" }, +/* OpenGL extension GL_MESA_pack_invert */ + { 0x8758, "PACK_INVERT_MESA" }, +/* OpenGL extension GL_MESA_ycbcr_texture */ + { 0x8757, "YCBCR_MESA" }, + { 0x85BA, "UNSIGNED_SHORT_8_8_MESA" }, + { 0x85BB, "UNSIGNED_SHORT_8_8_REV_MESA" }, +/* OpenGL extension GL_EXT_pixel_buffer_object */ + { 0x88EB, "PIXEL_PACK_BUFFER_EXT" }, + { 0x88EC, "PIXEL_UNPACK_BUFFER_EXT" }, + { 0x88ED, "PIXEL_PACK_BUFFER_BINDING_EXT" }, + { 0x88EF, "PIXEL_UNPACK_BUFFER_BINDING_EXT" }, +/* OpenGL extension GL_NV_fragment_program_option */ +/* OpenGL extension GL_NV_fragment_program2 */ + { 0x88F4, "MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" }, + { 0x88F5, "MAX_PROGRAM_CALL_DEPTH_NV" }, + { 0x88F6, "MAX_PROGRAM_IF_DEPTH_NV" }, + { 0x88F7, "MAX_PROGRAM_LOOP_DEPTH_NV" }, + { 0x88F8, "MAX_PROGRAM_LOOP_COUNT_NV" }, +/* OpenGL extension GL_NV_vertex_program2_option */ + { 0x88F4, "MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" }, + { 0x88F5, "MAX_PROGRAM_CALL_DEPTH_NV" }, +/* OpenGL extension GL_NV_vertex_program3 */ + { 0x8B4C, "MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" }, +/* OpenGL extension GL_EXT_texture_compression_dxt1 */ + { 0x83F0, "COMPRESSED_RGB_S3TC_DXT1_EXT" }, + { 0x83F1, "COMPRESSED_RGBA_S3TC_DXT1_EXT" }, +/* OpenGL extension GL_EXT_framebuffer_blit */ + { 0x8CA8, "READ_FRAMEBUFFER_EXT" }, + { 0x8CA9, "DRAW_FRAMEBUFFER_EXT" }, + { 0x8CA6, "DRAW_FRAMEBUFFER_BINDING_EXT" }, + { 0x8CAA, "READ_FRAMEBUFFER_BINDING_EXT" }, +/* OpenGL extension GL_APPLE_flush_buffer_range */ + { 0x8A12, "BUFFER_SERIALIZED_MODIFY_APPLE" }, + { 0x8A13, "BUFFER_FLUSHING_UNMAP_APPLE" }, +/* OpenGL extension GL_APPLE_texture_range */ + { 0x85BC, "TEXTURE_STORAGE_HINT_APPLE" }, + { 0x85BD, "STORAGE_PRIVATE_APPLE" }, + { 0x85BE, "STORAGE_CACHED_APPLE" }, + { 0x85BF, "STORAGE_SHARED_APPLE" }, + { 0x85B7, "TEXTURE_RANGE_LENGTH_APPLE" }, + { 0x85B8, "TEXTURE_RANGE_POINTER_APPLE" }, +/* OpenGL extension GL_ATI_blend_equation_separate */ +/* OpenGL extension GL_ATI_separate_stencil */ + { 0x8800, "STENCIL_BACK_FUNC_ATI" }, + { 0x8801, "STENCIL_BACK_FAIL_ATI" }, + { 0x8802, "STENCIL_BACK_PASS_DEPTH_FAIL_ATI" }, + { 0x8803, "STENCIL_BACK_PASS_DEPTH_PASS_ATI" }, +/* OpenGL extension GL_EXT_gpu_program_parameters */ +/* OpenGL extension GL_EXT_timer_query */ + { 0x88BF, "TIME_ELAPSED_EXT" }, +/* OpenGL extension GL_INGR_blend_func_separate */ +/* OpenGL extension GL_MESA_texture_signed_rgba */ + { 0x8F9C, "SIGNED_NORMALIZED" }, + { 0x8F93, "RGBA_SNORM" }, + { 0x8F97, "RGBA8_SNORM" }, +/* OpenGL extension GL_MESA_shader_debug */ + { 0x8759, "DEBUG_OBJECT_MESA" }, + { 0x875A, "DEBUG_PRINT_MESA" }, + { 0x875B, "DEBUG_ASSERT_MESA" }, +/* OpenGL extension GL_SGIS_point_parameters */ + { 0x8126, "POINT_SIZE_MIN_SGIS" }, + { 0x8127, "POINT_SIZE_MAX_SGIS" }, + { 0x8128, "POINT_FADE_THRESHOLD_SIZE_SGIS" }, + { 0x8129, "POINT_DISTANCE_ATTENUATION_SGIS" }, +/* OpenGL extension GL_SGIX_igloo_interface */ +/* OpenGL extension GL_SGIX_polynomial_ffd */ + { 0, NULL } +}; diff --git a/epan/dissectors/x11-register-info.h b/epan/dissectors/x11-register-info.h new file mode 100644 index 0000000000..bf187cc4db --- /dev/null +++ b/epan/dissectors/x11-register-info.h @@ -0,0 +1,4118 @@ +/* Do not modify this file. */ +/* It was automatically generated by ./process-x11-fields.pl. */ +/* $Id$ */ + +/* + * Copyright 2000, Christophe Tronche + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +{ &hf_x11_above_sibling, { "above-sibling", "x11.above-sibling", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_acceleration_denominator, { "acceleration-denominator", "x11.acceleration-denominator", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_acceleration_numerator, { "acceleration-numerator", "x11.acceleration-numerator", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_access_mode, { "access-mode", "x11.access-mode", FT_UINT8, BASE_DEC, VALS(access_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_address, { "address", "x11.address", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_ip_address, { "ip-address", "x11.ip-address", FT_IPv4, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_address_length, { "address-length", "x11.address-length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_alloc, { "alloc", "x11.alloc", FT_UINT8, BASE_DEC, VALS(alloc_vals), 0, NULL, HFILL }}, +{ &hf_x11_allow_events_mode, { "allow-events-mode", "x11.allow-events-mode", FT_UINT8, BASE_DEC, VALS(allow_events_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_allow_exposures, { "allow-exposures", "x11.allow-exposures", FT_UINT8, BASE_DEC, VALS(yes_no_default_vals), 0, NULL, HFILL }}, +{ &hf_x11_arcs, { "arcs", "x11.arcs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc, { "arc", "x11.arc", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_x, { "x", "x11.arc.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_y, { "y", "x11.arc.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_width, { "width", "x11.arc.width", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_height, { "height", "x11.arc.height", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_angle1, { "angle1", "x11.arc.angle1", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_angle2, { "angle2", "x11.arc.angle2", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_arc_mode, { "arc-mode", "x11.arc-mode", FT_UINT8, BASE_DEC, VALS(arc_mode_vals), 0, "Tell us if we're drawing an arc or a pie", HFILL }}, +{ &hf_x11_atom, { "atom", "x11.atom", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_authorization_protocol_name_length, { "authorization-protocol-name-length", "x11.authorization-protocol-name-length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_authorization_protocol_name, { "authorization-protocol-name", "x11.authorization-protocol-name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_authorization_protocol_data_length, { "authorization-protocol-data-length", "x11.authorization-protocol-data-length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_authorization_protocol_data, { "authorization-protocol-data", "x11.authorization-protocol-data", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_auto_repeat_mode, { "auto-repeat-mode", "x11.auto-repeat-mode", FT_UINT8, BASE_DEC, VALS(auto_repeat_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_bitmap_format_bit_order, { "bitmap-format-bit-order", "x11.bitmap-format-bit-order", FT_UINT8, BASE_HEX, VALS(image_byte_order_vals), 0, NULL, HFILL }}, +{ &hf_x11_bitmap_format_scanline_pad, { "bitmap-format-scanline-pad", "x11.bitmap-format-scanline-pad", FT_UINT8, BASE_DEC, NULL, 0, "bitmap format scanline-pad", HFILL }}, +{ &hf_x11_bitmap_format_scanline_unit, { "bitmap-format-scanline-unit", "x11.bitmap-format-scanline-unit", FT_UINT8, BASE_DEC, NULL, 0, "bitmap format scanline unit", HFILL }}, +{ &hf_x11_bytes_after, { "bytes-after", "x11.bytes-after", FT_UINT32, BASE_DEC, NULL, 0, "bytes after", HFILL }}, +{ &hf_x11_back_blue, { "back-blue", "x11.back-blue", FT_UINT16, BASE_DEC, NULL, 0, "Background blue value for a cursor", HFILL }}, +{ &hf_x11_back_green, { "back-green", "x11.back-green", FT_UINT16, BASE_DEC, NULL, 0, "Background green value for a cursor", HFILL }}, +{ &hf_x11_back_red, { "back-red", "x11.back-red", FT_UINT16, BASE_DEC, NULL, 0, "Background red value for a cursor", HFILL }}, +{ &hf_x11_background, { "background", "x11.background", FT_UINT32, BASE_HEX, NULL, 0, "Background color", HFILL }}, +{ &hf_x11_background_pixel, { "background-pixel", "x11.background-pixel", FT_UINT32, BASE_HEX, NULL, 0, "Background color for a window", HFILL }}, +{ &hf_x11_background_pixmap, { "background-pixmap", "x11.background-pixmap", FT_UINT32, BASE_HEX, VALS(background_pixmap_vals), 0, "Background pixmap for a window", HFILL }}, +{ &hf_x11_backing_pixel, { "backing-pixel", "x11.backing-pixel", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_backing_planes, { "backing-planes", "x11.backing-planes", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_backing_store, { "backing-store", "x11.backing-store", FT_UINT8, BASE_DEC, VALS(backing_store_vals), 0, NULL, HFILL }}, +{ &hf_x11_bell_duration, { "bell-duration", "x11.bell-duration", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_bell_percent, { "bell-percent", "x11.bell-percent", FT_INT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_bell_pitch, { "bell-pitch", "x11.bell-pitch", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_bit_gravity, { "bit-gravity", "x11.bit-gravity", FT_UINT8, BASE_DEC, VALS(gravity_vals), 0, NULL, HFILL }}, +{ &hf_x11_bit_plane, { "bit-plane", "x11.bit-plane", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_blue, { "blue", "x11.blue", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_blues, { "blues", "x11.blues", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_border_pixel, { "border-pixel", "x11.border-pixel", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_border_pixmap, { "border-pixmap", "x11.border-pixmap", FT_UINT32, BASE_HEX, VALS(border_pixmap_vals), 0, NULL, HFILL }}, +{ &hf_x11_border_width, { "border-width", "x11.border-width", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_button, { "button", "x11.button", FT_UINT8, BASE_DEC, VALS(button_vals), 0, NULL, HFILL }}, +{ &hf_x11_byte_order, { "byte-order", "x11.byte-order", FT_UINT8, BASE_HEX, VALS(byte_order_vals), 0, NULL, HFILL }}, +{ &hf_x11_childwindow, { "childwindow", "x11.childwindow", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_cap_style, { "cap-style", "x11.cap-style", FT_UINT8, BASE_DEC, VALS(cap_style_vals), 0, NULL, HFILL }}, +{ &hf_x11_change_host_mode, { "change-host-mode", "x11.change-host-mode", FT_UINT8, BASE_DEC, VALS(insert_delete_vals), 0, NULL, HFILL }}, +{ &hf_x11_cid, { "cid", "x11.cid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_class, { "class", "x11.class", FT_UINT8, BASE_DEC, VALS(class_vals), 0, NULL, HFILL }}, +{ &hf_x11_clip_mask, { "clip-mask", "x11.clip-mask", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_clip_x_origin, { "clip-x-origin", "x11.clip-x-origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_clip_y_origin, { "clip-y-origin", "x11.clip-y-origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_close_down_mode, { "close-down-mode", "x11.close-down-mode", FT_UINT8, BASE_DEC, VALS(close_down_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_cmap, { "cmap", "x11.cmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_colormap, { "colormap", "x11.colormap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_colormap_state, { "colormap-state", "x11.colormap-state", FT_UINT8, BASE_DEC, VALS(colormap_state_vals), 0, NULL, HFILL }}, +{ &hf_x11_color_items, { "color-items", "x11.color-items", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem, { "coloritem", "x11.coloritem", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem_pixel, { "pixel", "x11.coloritem.pixel", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem_red, { "red", "x11.coloritem.red", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem_green, { "green", "x11.coloritem.green", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem_blue, { "blue", "x11.coloritem.blue", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem_flags, { "flags", "x11.coloritem.flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coloritem_flags_do_red, { "do-red", "x11.coloritem.flags.do-red", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL }}, +{ &hf_x11_coloritem_flags_do_green, { "do-green", "x11.coloritem.flags.do-green", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL }}, +{ &hf_x11_coloritem_flags_do_blue, { "do-blue", "x11.coloritem.flags.do-blue", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL }}, +{ &hf_x11_coloritem_flags_unused, { "unused", "x11.coloritem.flags.unused", FT_BOOLEAN, 8, NULL, 0xf8, NULL, HFILL }}, +{ &hf_x11_coloritem_unused, { "unused", "x11.coloritem.unused", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_colors, { "colors", "x11.colors", FT_UINT16, BASE_DEC, NULL, 0, "The number of color cells to allocate", HFILL }}, +{ &hf_x11_configure_window_mask, { "configure-window-mask", "x11.configure-window-mask", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_x, { "x", "x11.configure-window-mask.x", FT_BOOLEAN, 16, NULL, 0x0001, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_y, { "y", "x11.configure-window-mask.y", FT_BOOLEAN, 16, NULL, 0x0002, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_width, { "width", "x11.configure-window-mask.width", FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_height, { "height", "x11.configure-window-mask.height", FT_BOOLEAN, 16, NULL, 0x0008, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_border_width, { "border-width", "x11.configure-window-mask.border-width", FT_BOOLEAN, 16, NULL, 0x0010, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_sibling, { "sibling", "x11.configure-window-mask.sibling", FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL }}, +{ &hf_x11_configure_window_mask_stack_mode, { "stack-mode", "x11.configure-window-mask.stack-mode", FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL }}, +{ &hf_x11_confine_to, { "confine-to", "x11.confine-to", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_contiguous, { "contiguous", "x11.contiguous", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_coordinate_mode, { "coordinate-mode", "x11.coordinate-mode", FT_UINT8, BASE_DEC, VALS(coordinate_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_count, { "count", "x11.count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_cursor, { "cursor", "x11.cursor", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_dash_offset, { "dash-offset", "x11.dash-offset", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dashes, { "dashes", "x11.dashes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dashes_length, { "dashes-length", "x11.dashes-length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_do_acceleration, { "do-acceleration", "x11.do-acceleration", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_do_threshold, { "do-threshold", "x11.do-threshold", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_detail, { "detail", "x11.detail", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask, { "do-not-propagate-mask", "x11.do-not-propagate-mask", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_KeyPress, { "KeyPress", "x11.do-not-propagate-mask.KeyPress", FT_BOOLEAN, 32, NULL, 0x00000001, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_KeyRelease, { "KeyRelease", "x11.do-not-propagate-mask.KeyRelease", FT_BOOLEAN, 32, NULL, 0x00000002, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_ButtonPress, { "ButtonPress", "x11.do-not-propagate-mask.ButtonPress", FT_BOOLEAN, 32, NULL, 0x00000004, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_ButtonRelease, { "ButtonRelease", "x11.do-not-propagate-mask.ButtonRelease", FT_BOOLEAN, 32, NULL, 0x00000008, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_PointerMotion, { "PointerMotion", "x11.do-not-propagate-mask.PointerMotion", FT_BOOLEAN, 32, NULL, 0x00000040, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_Button1Motion, { "Button1Motion", "x11.do-not-propagate-mask.Button1Motion", FT_BOOLEAN, 32, NULL, 0x00000100, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_Button2Motion, { "Button2Motion", "x11.do-not-propagate-mask.Button2Motion", FT_BOOLEAN, 32, NULL, 0x00000200, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_Button3Motion, { "Button3Motion", "x11.do-not-propagate-mask.Button3Motion", FT_BOOLEAN, 32, NULL, 0x00000400, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_Button4Motion, { "Button4Motion", "x11.do-not-propagate-mask.Button4Motion", FT_BOOLEAN, 32, NULL, 0x00000800, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_Button5Motion, { "Button5Motion", "x11.do-not-propagate-mask.Button5Motion", FT_BOOLEAN, 32, NULL, 0x00001000, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_ButtonMotion, { "ButtonMotion", "x11.do-not-propagate-mask.ButtonMotion", FT_BOOLEAN, 32, NULL, 0x00002000, NULL, HFILL }}, +{ &hf_x11_do_not_propagate_mask_erroneous_bits, { "erroneous-bits", "x11.do-not-propagate-mask.erroneous-bits", FT_BOOLEAN, 32, NULL, 0xffffc0b0, NULL, HFILL }}, +{ &hf_x11_event_sequencenumber, { "event-sequencenumber", "x11.event-sequencenumber", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_error, { "error", "x11.error", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_error_badvalue, { "error-badvalue", "x11.error-badvalue", FT_UINT32, BASE_DEC, NULL, 0, "error badvalue", HFILL }}, +{ &hf_x11_error_sequencenumber, { "error_sequencenumber", "x11.error_sequencenumber", FT_UINT16, BASE_DEC, NULL, 0, "error sequencenumber", HFILL }}, +{ &hf_x11_errorcode, { "errorcode", "x11.errorcode", FT_UINT8, BASE_DEC, VALS(errorcode_vals), 0, NULL, HFILL }}, +{ &hf_x11_event_x, { "event-x", "x11.event-x", FT_UINT16, BASE_DEC, NULL, 0, "event x", HFILL }}, +{ &hf_x11_event_y, { "event-y", "x11.event-y", FT_UINT16, BASE_DEC, NULL, 0, "event y", HFILL }}, +{ &hf_x11_eventbutton, { "eventbutton", "x11.eventbutton", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_eventcode, { "eventcode", "x11.eventcode", FT_UINT8, BASE_DEC, VALS(eventcode_vals), 0, NULL, HFILL }}, +{ &hf_x11_eventwindow, { "eventwindow", "x11.eventwindow", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_first_event, { "first-event", "x11.first-event", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_first_error, { "first-error", "x11.first-error", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_gc_dashes, { "gc-dashes", "x11.gc-dashes", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_gc_value_mask, { "gc-value-mask", "x11.gc-value-mask", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_function, { "function", "x11.gc-value-mask.function", FT_BOOLEAN, 32, NULL, 0x00000001, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_plane_mask, { "plane-mask", "x11.gc-value-mask.plane-mask", FT_BOOLEAN, 32, NULL, 0x00000002, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_foreground, { "foreground", "x11.gc-value-mask.foreground", FT_BOOLEAN, 32, NULL, 0x00000004, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_background, { "background", "x11.gc-value-mask.background", FT_BOOLEAN, 32, NULL, 0x00000008, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_line_width, { "line-width", "x11.gc-value-mask.line-width", FT_BOOLEAN, 32, NULL, 0x00000010, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_line_style, { "line-style", "x11.gc-value-mask.line-style", FT_BOOLEAN, 32, NULL, 0x00000020, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_cap_style, { "cap-style", "x11.gc-value-mask.cap-style", FT_BOOLEAN, 32, NULL, 0x00000040, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_join_style, { "join-style", "x11.gc-value-mask.join-style", FT_BOOLEAN, 32, NULL, 0x00000080, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_fill_style, { "fill-style", "x11.gc-value-mask.fill-style", FT_BOOLEAN, 32, NULL, 0x00000100, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_fill_rule, { "fill-rule", "x11.gc-value-mask.fill-rule", FT_BOOLEAN, 32, NULL, 0x00000200, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_tile, { "tile", "x11.gc-value-mask.tile", FT_BOOLEAN, 32, NULL, 0x00000400, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_stipple, { "stipple", "x11.gc-value-mask.stipple", FT_BOOLEAN, 32, NULL, 0x00000800, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_tile_stipple_x_origin, { "tile-stipple-x-origin", "x11.gc-value-mask.tile-stipple-x-origin", FT_BOOLEAN, 32, NULL, 0x00001000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_tile_stipple_y_origin, { "tile-stipple-y-origin", "x11.gc-value-mask.tile-stipple-y-origin", FT_BOOLEAN, 32, NULL, 0x00002000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_font, { "font", "x11.gc-value-mask.font", FT_BOOLEAN, 32, NULL, 0x00004000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_subwindow_mode, { "subwindow-mode", "x11.gc-value-mask.subwindow-mode", FT_BOOLEAN, 32, NULL, 0x00008000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_graphics_exposures, { "graphics-exposures", "x11.gc-value-mask.graphics-exposures", FT_BOOLEAN, 32, NULL, 0x00010000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_clip_x_origin, { "clip-x-origin", "x11.gc-value-mask.clip-x-origin", FT_BOOLEAN, 32, NULL, 0x00020000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_clip_y_origin, { "clip-y-origin", "x11.gc-value-mask.clip-y-origin", FT_BOOLEAN, 32, NULL, 0x00040000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_clip_mask, { "clip-mask", "x11.gc-value-mask.clip-mask", FT_BOOLEAN, 32, NULL, 0x00080000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_dash_offset, { "dash-offset", "x11.gc-value-mask.dash-offset", FT_BOOLEAN, 32, NULL, 0x00100000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_gc_dashes, { "gc-dashes", "x11.gc-value-mask.gc-dashes", FT_BOOLEAN, 32, NULL, 0x00200000, NULL, HFILL }}, +{ &hf_x11_gc_value_mask_arc_mode, { "arc-mode", "x11.gc-value-mask.arc-mode", FT_BOOLEAN, 32, NULL, 0x00400000, NULL, HFILL }}, +{ &hf_x11_green, { "green", "x11.green", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_greens, { "greens", "x11.greens", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_data, { "data", "x11.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_data_length, { "data-length", "x11.data-length", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_delete, { "delete", "x11.delete", FT_BOOLEAN, BASE_NONE, NULL, 0, "Delete this property after reading", HFILL }}, +{ &hf_x11_delta, { "delta", "x11.delta", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_depth, { "depth", "x11.depth", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_destination, { "destination", "x11.destination", FT_UINT8, BASE_DEC, VALS(destination_vals), 0, NULL, HFILL }}, +{ &hf_x11_direction, { "direction", "x11.direction", FT_UINT8, BASE_DEC, VALS(direction_vals), 0, NULL, HFILL }}, +{ &hf_x11_drawable, { "drawable", "x11.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dst_drawable, { "dst-drawable", "x11.dst-drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dst_gc, { "dst-gc", "x11.dst-gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dst_window, { "dst-window", "x11.dst-window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dst_x, { "dst-x", "x11.dst-x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dst_y, { "dst-y", "x11.dst-y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_event_detail, { "event-detail", "x11.event-detail", FT_UINT8, BASE_DEC, VALS(event_detail_vals), 0, NULL, HFILL }}, +{ &hf_x11_event_mask, { "event-mask", "x11.event-mask", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_event_mask_KeyPress, { "KeyPress", "x11.event-mask.KeyPress", FT_BOOLEAN, 32, NULL, 0x00000001, NULL, HFILL }}, +{ &hf_x11_event_mask_KeyRelease, { "KeyRelease", "x11.event-mask.KeyRelease", FT_BOOLEAN, 32, NULL, 0x00000002, NULL, HFILL }}, +{ &hf_x11_event_mask_ButtonPress, { "ButtonPress", "x11.event-mask.ButtonPress", FT_BOOLEAN, 32, NULL, 0x00000004, NULL, HFILL }}, +{ &hf_x11_event_mask_ButtonRelease, { "ButtonRelease", "x11.event-mask.ButtonRelease", FT_BOOLEAN, 32, NULL, 0x00000008, NULL, HFILL }}, +{ &hf_x11_event_mask_EnterWindow, { "EnterWindow", "x11.event-mask.EnterWindow", FT_BOOLEAN, 32, NULL, 0x00000010, NULL, HFILL }}, +{ &hf_x11_event_mask_LeaveWindow, { "LeaveWindow", "x11.event-mask.LeaveWindow", FT_BOOLEAN, 32, NULL, 0x00000020, NULL, HFILL }}, +{ &hf_x11_event_mask_PointerMotion, { "PointerMotion", "x11.event-mask.PointerMotion", FT_BOOLEAN, 32, NULL, 0x00000040, NULL, HFILL }}, +{ &hf_x11_event_mask_PointerMotionHint, { "PointerMotionHint", "x11.event-mask.PointerMotionHint", FT_BOOLEAN, 32, NULL, 0x00000080, NULL, HFILL }}, +{ &hf_x11_event_mask_Button1Motion, { "Button1Motion", "x11.event-mask.Button1Motion", FT_BOOLEAN, 32, NULL, 0x00000100, NULL, HFILL }}, +{ &hf_x11_event_mask_Button2Motion, { "Button2Motion", "x11.event-mask.Button2Motion", FT_BOOLEAN, 32, NULL, 0x00000200, NULL, HFILL }}, +{ &hf_x11_event_mask_Button3Motion, { "Button3Motion", "x11.event-mask.Button3Motion", FT_BOOLEAN, 32, NULL, 0x00000400, NULL, HFILL }}, +{ &hf_x11_event_mask_Button4Motion, { "Button4Motion", "x11.event-mask.Button4Motion", FT_BOOLEAN, 32, NULL, 0x00000800, NULL, HFILL }}, +{ &hf_x11_event_mask_Button5Motion, { "Button5Motion", "x11.event-mask.Button5Motion", FT_BOOLEAN, 32, NULL, 0x00001000, NULL, HFILL }}, +{ &hf_x11_event_mask_ButtonMotion, { "ButtonMotion", "x11.event-mask.ButtonMotion", FT_BOOLEAN, 32, NULL, 0x00002000, NULL, HFILL }}, +{ &hf_x11_event_mask_KeymapState, { "KeymapState", "x11.event-mask.KeymapState", FT_BOOLEAN, 32, NULL, 0x00004000, NULL, HFILL }}, +{ &hf_x11_event_mask_Exposure, { "Exposure", "x11.event-mask.Exposure", FT_BOOLEAN, 32, NULL, 0x00008000, NULL, HFILL }}, +{ &hf_x11_event_mask_VisibilityChange, { "VisibilityChange", "x11.event-mask.VisibilityChange", FT_BOOLEAN, 32, NULL, 0x00010000, NULL, HFILL }}, +{ &hf_x11_event_mask_StructureNotify, { "StructureNotify", "x11.event-mask.StructureNotify", FT_BOOLEAN, 32, NULL, 0x00020000, NULL, HFILL }}, +{ &hf_x11_event_mask_ResizeRedirect, { "ResizeRedirect", "x11.event-mask.ResizeRedirect", FT_BOOLEAN, 32, NULL, 0x00040000, NULL, HFILL }}, +{ &hf_x11_event_mask_SubstructureNotify, { "SubstructureNotify", "x11.event-mask.SubstructureNotify", FT_BOOLEAN, 32, NULL, 0x00080000, NULL, HFILL }}, +{ &hf_x11_event_mask_SubstructureRedirect, { "SubstructureRedirect", "x11.event-mask.SubstructureRedirect", FT_BOOLEAN, 32, NULL, 0x00100000, NULL, HFILL }}, +{ &hf_x11_event_mask_FocusChange, { "FocusChange", "x11.event-mask.FocusChange", FT_BOOLEAN, 32, NULL, 0x00200000, NULL, HFILL }}, +{ &hf_x11_event_mask_PropertyChange, { "PropertyChange", "x11.event-mask.PropertyChange", FT_BOOLEAN, 32, NULL, 0x00400000, NULL, HFILL }}, +{ &hf_x11_event_mask_ColormapChange, { "ColormapChange", "x11.event-mask.ColormapChange", FT_BOOLEAN, 32, NULL, 0x00800000, NULL, HFILL }}, +{ &hf_x11_event_mask_OwnerGrabButton, { "OwnerGrabButton", "x11.event-mask.OwnerGrabButton", FT_BOOLEAN, 32, NULL, 0x01000000, NULL, HFILL }}, +{ &hf_x11_event_mask_erroneous_bits, { "erroneous-bits", "x11.event-mask.erroneous-bits", FT_BOOLEAN, 32, NULL, 0xfe000000, NULL, HFILL }}, +{ &hf_x11_exact_blue, { "exact-blue", "x11.exact-blue", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_exact_green, { "exact-green", "x11.exact-green", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_exact_red, { "exact-red", "x11.exact-red", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_exposures, { "exposures", "x11.exposures", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_family, { "family", "x11.family", FT_UINT8, BASE_DEC, VALS(family_vals), 0, NULL, HFILL }}, +{ &hf_x11_fid, { "fid", "x11.fid", FT_UINT32, BASE_HEX, NULL, 0, "Font id", HFILL }}, +{ &hf_x11_fill_rule, { "fill-rule", "x11.fill-rule", FT_UINT8, BASE_DEC, VALS(fill_rule_vals), 0, NULL, HFILL }}, +{ &hf_x11_fill_style, { "fill-style", "x11.fill-style", FT_UINT8, BASE_DEC, VALS(fill_style_vals), 0, NULL, HFILL }}, +{ &hf_x11_first_keycode, { "first-keycode", "x11.first-keycode", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_focus, { "focus", "x11.focus", FT_UINT8, BASE_DEC, VALS(focus_vals), 0, NULL, HFILL }}, +{ &hf_x11_focus_detail, { "focus-detail", "x11.focus-detail", FT_UINT8, BASE_DEC, VALS(focus_detail_vals), 0, NULL, HFILL }}, +{ &hf_x11_focus_mode, { "focus-mode", "x11.focus-mode", FT_UINT8, BASE_DEC, VALS(focus_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_font, { "font", "x11.font", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_fore_blue, { "fore-blue", "x11.fore-blue", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_fore_green, { "fore-green", "x11.fore-green", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_fore_red, { "fore-red", "x11.fore-red", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_foreground, { "foreground", "x11.foreground", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_format, { "format", "x11.format", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_from_configure, { "from-configure", "x11.from-configure", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_function, { "function", "x11.function", FT_UINT8, BASE_DEC, VALS(function_vals), 0, NULL, HFILL }}, +{ &hf_x11_gc, { "gc", "x11.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_get_property_type, { "get-property-type", "x11.get-property-type", FT_UINT32, BASE_HEX, VALS(zero_is_any_property_type_vals), 0, NULL, HFILL }}, +{ &hf_x11_grab_mode, { "grab-mode", "x11.grab-mode", FT_UINT8, BASE_DEC, VALS(grab_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_grab_status, { "grab-status", "x11.grab-status", FT_UINT8, BASE_DEC, VALS(grab_status_vals), 0, NULL, HFILL }}, +{ &hf_x11_grab_window, { "grab-window", "x11.grab-window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_graphics_exposures, { "graphics-exposures", "x11.graphics-exposures", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_height, { "height", "x11.height", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_image_byte_order, { "image-byte-order", "x11.image-byte-order", FT_UINT8, BASE_HEX, VALS(image_byte_order_vals), 0, NULL, HFILL }}, +{ &hf_x11_initial_connection, { "initial-connection", "x11.initial-connection", FT_NONE, BASE_NONE, NULL, 0, "undecoded", HFILL }}, +{ &hf_x11_image_format, { "image-format", "x11.image-format", FT_UINT8, BASE_DEC, VALS(image_format_vals), 0, NULL, HFILL }}, +{ &hf_x11_image_pixmap_format, { "image-pixmap-format", "x11.image-pixmap-format", FT_UINT8, BASE_DEC, VALS(image_pixmap_format_vals), 0, NULL, HFILL }}, +{ &hf_x11_interval, { "interval", "x11.interval", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_items, { "items", "x11.items", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_join_style, { "join-style", "x11.join-style", FT_UINT8, BASE_DEC, VALS(join_style_vals), 0, NULL, HFILL }}, +{ &hf_x11_key, { "key", "x11.key", FT_UINT8, BASE_DEC, VALS(key_vals), 0, NULL, HFILL }}, +{ &hf_x11_key_click_percent, { "key-click-percent", "x11.key-click-percent", FT_INT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keyboard_key, { "keyboard-key", "x11.keyboard-key", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keyboard_mode, { "keyboard-mode", "x11.keyboard-mode", FT_UINT8, BASE_DEC, VALS(pointer_keyboard_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_keybut_mask_erroneous_bits, { "keybut-mask-erroneous-bits", "x11.keybut-mask-erroneous-bits", FT_BOOLEAN, 16, NULL, 0xe000, "keybut mask erroneous bits", HFILL }}, +{ &hf_x11_keycode, { "keycode", "x11.keycode", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask, { "keyboard-value-mask", "x11.keyboard-value-mask", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_key_click_percent, { "key-click-percent", "x11.keyboard-value-mask.key-click-percent", FT_BOOLEAN, 32, NULL, 0x0001, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_bell_percent, { "bell-percent", "x11.keyboard-value-mask.bell-percent", FT_BOOLEAN, 32, NULL, 0x0002, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_bell_pitch, { "bell-pitch", "x11.keyboard-value-mask.bell-pitch", FT_BOOLEAN, 32, NULL, 0x0004, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_bell_duration, { "bell-duration", "x11.keyboard-value-mask.bell-duration", FT_BOOLEAN, 32, NULL, 0x0008, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_led, { "led", "x11.keyboard-value-mask.led", FT_BOOLEAN, 32, NULL, 0x0010, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_led_mode, { "led-mode", "x11.keyboard-value-mask.led-mode", FT_BOOLEAN, 32, NULL, 0x0020, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_keyboard_key, { "keyboard-key", "x11.keyboard-value-mask.keyboard-key", FT_BOOLEAN, 32, NULL, 0x0040, NULL, HFILL }}, +{ &hf_x11_keyboard_value_mask_auto_repeat_mode, { "auto-repeat-mode", "x11.keyboard-value-mask.auto-repeat-mode", FT_BOOLEAN, 32, NULL, 0x0080, NULL, HFILL }}, +{ &hf_x11_keycode_count, { "keycode-count", "x11.keycode-count", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keycodes, { "keycodes", "x11.keycodes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keycodes_item, { "item", "x11.keycodes.item", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keycodes_per_modifier, { "keycodes-per-modifier", "x11.keycodes-per-modifier", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keys, { "keys", "x11.keys", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keysyms, { "keysyms", "x11.keysyms", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keysyms_item, { "item", "x11.keysyms.item", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keysyms_item_keysym, { "keysym", "x11.keysyms.item.keysym", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_keysyms_per_keycode, { "keysyms-per-keycode", "x11.keysyms-per-keycode", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_length_of_reason, { "length-of-reason", "x11.length-of-reason", FT_UINT8, BASE_DEC, NULL, 0, "length of reason", HFILL }}, +{ &hf_x11_length_of_vendor, { "length-of-vendor", "x11.length-of-vendor", FT_UINT16, BASE_DEC, NULL, 0, "length of vendor", HFILL }}, +{ &hf_x11_led, { "led", "x11.led", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_led_mode, { "led-mode", "x11.led-mode", FT_UINT8, BASE_DEC, VALS(on_off_vals), 0, NULL, HFILL }}, +{ &hf_x11_left_pad, { "left-pad", "x11.left-pad", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_line_style, { "line-style", "x11.line-style", FT_UINT8, BASE_DEC, VALS(line_style_vals), 0, NULL, HFILL }}, +{ &hf_x11_line_width, { "line-width", "x11.line-width", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_long_length, { "long-length", "x11.long-length", FT_UINT32, BASE_DEC, NULL, 0, "The maximum length of the property in bytes", HFILL }}, +{ &hf_x11_long_offset, { "long-offset", "x11.long-offset", FT_UINT32, BASE_DEC, NULL, 0, "The starting position in the property bytes array", HFILL }}, +{ &hf_x11_map, { "map", "x11.map", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_map_length, { "map-length", "x11.map-length", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_mapping_request, { "mapping-request", "x11.mapping-request", FT_UINT8, BASE_DEC, VALS(mapping_request_vals), 0, NULL, HFILL }}, +{ &hf_x11_mask, { "mask", "x11.mask", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_mask_char, { "mask-char", "x11.mask-char", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_mask_font, { "mask-font", "x11.mask-font", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_max_names, { "max-names", "x11.max-names", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_mid, { "mid", "x11.mid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_mode, { "mode", "x11.mode", FT_UINT8, BASE_DEC, VALS(mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_major_opcode, { "major-opcode", "x11.major-opcode", FT_UINT16, BASE_DEC, NULL, 0, "major opcode", HFILL }}, +{ &hf_x11_max_keycode, { "max-keycode", "x11.max-keycode", FT_UINT8, BASE_DEC, NULL, 0, "max keycode", HFILL }}, +{ &hf_x11_maximum_request_length, { "maximum-request-length", "x11.maximum-request-length", FT_UINT16, BASE_DEC, NULL, 0, "maximum request length", HFILL }}, +{ &hf_x11_min_keycode, { "min-keycode", "x11.min-keycode", FT_UINT8, BASE_DEC, NULL, 0, "min keycode", HFILL }}, +{ &hf_x11_minor_opcode, { "minor-opcode", "x11.minor-opcode", FT_UINT16, BASE_DEC, NULL, 0, "minor opcode", HFILL }}, +{ &hf_x11_modifiers_mask, { "modifiers-mask", "x11.modifiers-mask", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Shift, { "Shift", "x11.modifiers-mask.Shift", FT_BOOLEAN, 16, NULL, 0x0001, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Lock, { "Lock", "x11.modifiers-mask.Lock", FT_BOOLEAN, 16, NULL, 0x0002, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Control, { "Control", "x11.modifiers-mask.Control", FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Mod1, { "Mod1", "x11.modifiers-mask.Mod1", FT_BOOLEAN, 16, NULL, 0x0008, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Mod2, { "Mod2", "x11.modifiers-mask.Mod2", FT_BOOLEAN, 16, NULL, 0x0010, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Mod3, { "Mod3", "x11.modifiers-mask.Mod3", FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Mod4, { "Mod4", "x11.modifiers-mask.Mod4", FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Mod5, { "Mod5", "x11.modifiers-mask.Mod5", FT_BOOLEAN, 16, NULL, 0x0080, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Button1, { "Button1", "x11.modifiers-mask.Button1", FT_BOOLEAN, 16, NULL, 0x0100, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Button2, { "Button2", "x11.modifiers-mask.Button2", FT_BOOLEAN, 16, NULL, 0x0200, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Button3, { "Button3", "x11.modifiers-mask.Button3", FT_BOOLEAN, 16, NULL, 0x0400, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Button4, { "Button4", "x11.modifiers-mask.Button4", FT_BOOLEAN, 16, NULL, 0x0800, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_Button5, { "Button5", "x11.modifiers-mask.Button5", FT_BOOLEAN, 16, NULL, 0x1000, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_AnyModifier, { "AnyModifier", "x11.modifiers-mask.AnyModifier", FT_UINT16, BASE_HEX, NULL, 0x8000, NULL, HFILL }}, +{ &hf_x11_modifiers_mask_erroneous_bits, { "erroneous-bits", "x11.modifiers-mask.erroneous-bits", FT_BOOLEAN, 16, NULL, 0xff00, NULL, HFILL }}, +{ &hf_x11_motion_buffer_size, { "motion-buffer-size", "x11.motion-buffer-size", FT_UINT16, BASE_DEC, NULL, 0, "motion buffer size", HFILL }}, +{ &hf_x11_new, { "new", "x11.new", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_number_of_formats_in_pixmap_formats, { "number-of-formats-in-pixmap-formats", "x11.number-of-formats-in-pixmap-formats", FT_UINT8, BASE_DEC, NULL, 0, "number of formats in pixmap formats", HFILL }}, +{ &hf_x11_number_of_screens_in_roots, { "number-of-screens-in-roots", "x11.number-of-screens-in-roots", FT_UINT8, BASE_DEC, NULL, 0, "number of screens in roots", HFILL }}, +{ &hf_x11_name, { "name", "x11.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_name_length, { "name-length", "x11.name-length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_odd_length, { "odd-length", "x11.odd-length", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_only_if_exists, { "only-if-exists", "x11.only-if-exists", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_opcode, { "opcode", "x11.opcode", FT_UINT8, BASE_DEC, VALS(opcode_vals), 0, NULL, HFILL }}, +{ &hf_x11_ordering, { "ordering", "x11.ordering", FT_UINT8, BASE_DEC, VALS(ordering_vals), 0, NULL, HFILL }}, +{ &hf_x11_override_redirect, { "override-redirect", "x11.override-redirect", FT_BOOLEAN, BASE_NONE, NULL, 0, "Window manager doesn't manage this window when true", HFILL }}, +{ &hf_x11_owner, { "owner", "x11.owner", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_owner_events, { "owner-events", "x11.owner-events", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_parent, { "parent", "x11.parent", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_path, { "path", "x11.path", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_path_string, { "string", "x11.path.string", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pattern, { "pattern", "x11.pattern", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pattern_length, { "pattern-length", "x11.pattern-length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_percent, { "percent", "x11.percent", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pid, { "pid", "x11.pid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pixel, { "pixel", "x11.pixel", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pixels, { "pixels", "x11.pixels", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pixels_item, { "pixels_item", "x11.pixels_item", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pixmap, { "pixmap", "x11.pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_place, { "place", "x11.place", FT_UINT8, BASE_DEC, VALS(place_vals), 0, NULL, HFILL }}, +{ &hf_x11_plane_mask, { "plane-mask", "x11.plane-mask", FT_UINT32, BASE_HEX, VALS(plane_mask_vals), 0, NULL, HFILL }}, +{ &hf_x11_planes, { "planes", "x11.planes", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_point, { "point", "x11.point", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_points, { "points", "x11.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_point_x, { "point-x", "x11.point-x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_point_y, { "point-y", "x11.point-y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask, { "pointer-event-mask", "x11.pointer-event-mask", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_ButtonPress, { "ButtonPress", "x11.pointer-event-mask.ButtonPress", FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_ButtonRelease, { "ButtonRelease", "x11.pointer-event-mask.ButtonRelease", FT_BOOLEAN, 16, NULL, 0x0008, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_EnterWindow, { "EnterWindow", "x11.pointer-event-mask.EnterWindow", FT_BOOLEAN, 16, NULL, 0x0010, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_LeaveWindow, { "LeaveWindow", "x11.pointer-event-mask.LeaveWindow", FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_PointerMotion, { "PointerMotion", "x11.pointer-event-mask.PointerMotion", FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_PointerMotionHint, { "PointerMotionHint", "x11.pointer-event-mask.PointerMotionHint", FT_BOOLEAN, 16, NULL, 0x0080, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_Button1Motion, { "Button1Motion", "x11.pointer-event-mask.Button1Motion", FT_BOOLEAN, 16, NULL, 0x0100, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_Button2Motion, { "Button2Motion", "x11.pointer-event-mask.Button2Motion", FT_BOOLEAN, 16, NULL, 0x0200, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_Button3Motion, { "Button3Motion", "x11.pointer-event-mask.Button3Motion", FT_BOOLEAN, 16, NULL, 0x0400, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_Button4Motion, { "Button4Motion", "x11.pointer-event-mask.Button4Motion", FT_BOOLEAN, 16, NULL, 0x0800, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_Button5Motion, { "Button5Motion", "x11.pointer-event-mask.Button5Motion", FT_BOOLEAN, 16, NULL, 0x1000, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_ButtonMotion, { "ButtonMotion", "x11.pointer-event-mask.ButtonMotion", FT_BOOLEAN, 16, NULL, 0x2000, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_KeymapState, { "KeymapState", "x11.pointer-event-mask.KeymapState", FT_BOOLEAN, 16, NULL, 0x4000, NULL, HFILL }}, +{ &hf_x11_pointer_event_mask_erroneous_bits, { "erroneous-bits", "x11.pointer-event-mask.erroneous-bits", FT_BOOLEAN, 16, NULL, 0x8003, NULL, HFILL }}, +{ &hf_x11_pointer_mode, { "pointer-mode", "x11.pointer-mode", FT_UINT8, BASE_DEC, VALS(pointer_keyboard_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_prefer_blanking, { "prefer-blanking", "x11.prefer-blanking", FT_UINT8, BASE_DEC, VALS(yes_no_default_vals), 0, NULL, HFILL }}, +{ &hf_x11_present, { "present", "x11.present", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_propagate, { "propagate", "x11.propagate", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_properties, { "properties", "x11.properties", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_properties_item, { "item", "x11.properties.item", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_property, { "property", "x11.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_property_number, { "property-number", "x11.property-number", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_property_state, { "property-state", "x11.property-state", FT_UINT8, BASE_DEC, VALS(property_state_vals), 0, NULL, HFILL }}, +{ &hf_x11_protocol_major_version, { "protocol-major-version", "x11.protocol-major-version", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_protocol_minor_version, { "protocol-minor-version", "x11.protocol-minor-version", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_reason, { "reason", "x11.reason", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_rectangle_height, { "rectangle-height", "x11.rectangle-height", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_rectangles, { "rectangles", "x11.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_rectangle, { "rectangle", "x11.rectangle", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_rectangle_width, { "rectangle-width", "x11.rectangle-width", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_rectangle_x, { "rectangle-x", "x11.rectangle-x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_rectangle_y, { "rectangle-y", "x11.rectangle-y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_red, { "red", "x11.red", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_reds, { "reds", "x11.reds", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_request, { "request", "x11.request", FT_UINT8, BASE_DEC, VALS(opcode_vals), 0, NULL, HFILL }}, +{ &hf_x11_requestor, { "requestor", "x11.requestor", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_request_length, { "request-length", "x11.request-length", FT_UINT16, BASE_DEC, NULL, 0, "Request length", HFILL }}, +{ &hf_x11_resource, { "resource", "x11.resource", FT_UINT32, BASE_HEX, VALS(all_temporary_vals), 0, NULL, HFILL }}, +{ &hf_x11_revert_to, { "revert-to", "x11.revert-to", FT_UINT8, BASE_DEC, VALS(revert_to_vals), 0, NULL, HFILL }}, +{ &hf_x11_release_number, { "release-number", "x11.release-number", FT_UINT32, BASE_DEC, NULL, 0, "release number", HFILL }}, +{ &hf_x11_reply, { "reply", "x11.reply", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_reply_sequencenumber, { "reply-sequencenumber", "x11.reply-sequencenumber", FT_UINT16, BASE_DEC, VALS(opcode_vals), 0, NULL, HFILL }}, +{ &hf_x11_replylength, { "replylength", "x11.replylength", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_replyopcode, { "replyopcode", "x11.replyopcode", FT_UINT8, BASE_DEC, VALS(opcode_vals), 0, NULL, HFILL }}, +{ &hf_x11_resource_id_base, { "resource-id-base", "x11.resource-id-base", FT_UINT32, BASE_HEX, NULL, 0, "resource id base", HFILL }}, +{ &hf_x11_resource_id_mask, { "resource-id-mask", "x11.resource-id-mask", FT_UINT32, BASE_HEX, NULL, 0, "resource id mask", HFILL }}, +{ &hf_x11_root_x, { "root-x", "x11.root-x", FT_UINT16, BASE_DEC, NULL, 0, "root x", HFILL }}, +{ &hf_x11_root_y, { "root-y", "x11.root-y", FT_UINT16, BASE_DEC, NULL, 0, "root y", HFILL }}, +{ &hf_x11_rootwindow, { "rootwindow", "x11.rootwindow", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_same_screen, { "same-screen", "x11.same-screen", FT_BOOLEAN, BASE_NONE, NULL, 0, "same screen", HFILL }}, +{ &hf_x11_same_screen_focus_mask, { "same-screen-focus-mask", "x11.same-screen-focus-mask", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_same_screen_focus_mask_focus, { "focus", "x11.same-screen-focus-mask.focus", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL }}, +{ &hf_x11_same_screen_focus_mask_same_screen, { "same-screen", "x11.same-screen-focus-mask.same-screen", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL }}, +{ &hf_x11_success, { "success", "x11.success", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_save_set_mode, { "save-set-mode", "x11.save-set-mode", FT_UINT8, BASE_DEC, VALS(insert_delete_vals), 0, NULL, HFILL }}, +{ &hf_x11_save_under, { "save-under", "x11.save-under", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screen_saver_mode, { "screen-saver-mode", "x11.screen-saver-mode", FT_UINT8, BASE_DEC, VALS(screen_saver_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_segment, { "segment", "x11.segment", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_segments, { "segments", "x11.segments", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_segment_x1, { "segment_x1", "x11.segment_x1", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_segment_x2, { "segment_x2", "x11.segment_x2", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_segment_y1, { "segment_y1", "x11.segment_y1", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_segment_y2, { "segment_y2", "x11.segment_y2", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_selection, { "selection", "x11.selection", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape, { "shape", "x11.shape", FT_UINT8, BASE_DEC, VALS(shape_vals), 0, NULL, HFILL }}, +{ &hf_x11_sibling, { "sibling", "x11.sibling", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_source_pixmap, { "source-pixmap", "x11.source-pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_source_font, { "source-font", "x11.source-font", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_source_char, { "source-char", "x11.source-char", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_cmap, { "src-cmap", "x11.src-cmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_drawable, { "src-drawable", "x11.src-drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_gc, { "src-gc", "x11.src-gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_height, { "src-height", "x11.src-height", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_width, { "src-width", "x11.src-width", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_window, { "src-window", "x11.src-window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_x, { "src-x", "x11.src-x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_src_y, { "src-y", "x11.src-y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_start, { "start", "x11.start", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_stack_mode, { "stack-mode", "x11.stack-mode", FT_UINT8, BASE_DEC, VALS(stack_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_stipple, { "stipple", "x11.stipple", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_stop, { "stop", "x11.stop", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_str_number_in_path, { "str-number-in-path", "x11.str-number-in-path", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_string, { "string", "x11.string", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_string16, { "string16", "x11.string16", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_string16_bytes, { "bytes", "x11.string16.bytes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_string_length, { "string-length", "x11.string-length", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_subwindow_mode, { "subwindow-mode", "x11.subwindow-mode", FT_UINT8, BASE_DEC, VALS(subwindow_mode_vals), 0, NULL, HFILL }}, +{ &hf_x11_target, { "target", "x11.target", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem, { "textitem", "x11.textitem", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem_font, { "font", "x11.textitem.font", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem_string, { "string", "x11.textitem.string", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem_string_delta, { "delta", "x11.textitem.string.delta", FT_INT8, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem_string_string8, { "string8", "x11.textitem.string.string8", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem_string_string16, { "string16", "x11.textitem.string.string16", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_textitem_string_string16_bytes, { "bytes", "x11.textitem.string.string16.bytes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_threshold, { "threshold", "x11.threshold", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_tile, { "tile", "x11.tile", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_tile_stipple_x_origin, { "tile-stipple-x-origin", "x11.tile-stipple-x-origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_tile_stipple_y_origin, { "tile-stipple-y-origin", "x11.tile-stipple-y-origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_time, { "time", "x11.time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_timeout, { "timeout", "x11.timeout", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_type, { "type", "x11.type", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_undecoded, { "undecoded", "x11.undecoded", FT_NONE, BASE_NONE, NULL, 0, "Yet undecoded by dissector", HFILL }}, +{ &hf_x11_unused, { "unused", "x11.unused", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_valuelength, { "valuelength", "x11.valuelength", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_vendor, { "vendor", "x11.vendor", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_visibility_state, { "visibility-state", "x11.visibility-state", FT_UINT8, BASE_DEC, VALS(visibility_state_vals), 0, NULL, HFILL }}, +{ &hf_x11_visual, { "visual", "x11.visual", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_visual_blue, { "visual-blue", "x11.visual-blue", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_visual_green, { "visual-green", "x11.visual-green", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_visual_red, { "visual-red", "x11.visual-red", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_visualid, { "visualid", "x11.visualid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_warp_pointer_dst_window, { "warp-pointer-dst-window", "x11.warp-pointer-dst-window", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_warp_pointer_src_window, { "warp-pointer-src-window", "x11.warp-pointer-src-window", FT_UINT32, BASE_HEX, VALS(zero_is_none_vals), 0, NULL, HFILL }}, +{ &hf_x11_wid, { "wid", "x11.wid", FT_UINT32, BASE_HEX, NULL, 0, "Window id", HFILL }}, +{ &hf_x11_width, { "width", "x11.width", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_win_gravity, { "win-gravity", "x11.win-gravity", FT_UINT8, BASE_DEC, VALS(gravity_vals), 0, NULL, HFILL }}, +{ &hf_x11_win_x, { "win-x", "x11.win-x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_win_y, { "win-y", "x11.win-y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_window, { "window", "x11.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_window_class, { "window-class", "x11.window-class", FT_UINT16, BASE_DEC, VALS(window_class_vals), 0, "Window class", HFILL }}, +{ &hf_x11_window_value_mask, { "window-value-mask", "x11.window-value-mask", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_window_value_mask_background_pixmap, { "background-pixmap", "x11.window-value-mask.background-pixmap", FT_BOOLEAN, 32, NULL, 0x00000001, NULL, HFILL }}, +{ &hf_x11_window_value_mask_background_pixel, { "background-pixel", "x11.window-value-mask.background-pixel", FT_BOOLEAN, 32, NULL, 0x00000002, NULL, HFILL }}, +{ &hf_x11_window_value_mask_border_pixmap, { "border-pixmap", "x11.window-value-mask.border-pixmap", FT_BOOLEAN, 32, NULL, 0x00000004, NULL, HFILL }}, +{ &hf_x11_window_value_mask_border_pixel, { "border-pixel", "x11.window-value-mask.border-pixel", FT_BOOLEAN, 32, NULL, 0x00000008, NULL, HFILL }}, +{ &hf_x11_window_value_mask_bit_gravity, { "bit-gravity", "x11.window-value-mask.bit-gravity", FT_BOOLEAN, 32, NULL, 0x00000010, NULL, HFILL }}, +{ &hf_x11_window_value_mask_win_gravity, { "win-gravity", "x11.window-value-mask.win-gravity", FT_BOOLEAN, 32, NULL, 0x00000020, NULL, HFILL }}, +{ &hf_x11_window_value_mask_backing_store, { "backing-store", "x11.window-value-mask.backing-store", FT_BOOLEAN, 32, NULL, 0x00000040, NULL, HFILL }}, +{ &hf_x11_window_value_mask_backing_planes, { "backing-planes", "x11.window-value-mask.backing-planes", FT_BOOLEAN, 32, NULL, 0x00000080, NULL, HFILL }}, +{ &hf_x11_window_value_mask_backing_pixel, { "backing-pixel", "x11.window-value-mask.backing-pixel", FT_BOOLEAN, 32, NULL, 0x00000100, NULL, HFILL }}, +{ &hf_x11_window_value_mask_override_redirect, { "override-redirect", "x11.window-value-mask.override-redirect", FT_BOOLEAN, 32, NULL, 0x00000200, NULL, HFILL }}, +{ &hf_x11_window_value_mask_save_under, { "save-under", "x11.window-value-mask.save-under", FT_BOOLEAN, 32, NULL, 0x00000400, NULL, HFILL }}, +{ &hf_x11_window_value_mask_event_mask, { "event-mask", "x11.window-value-mask.event-mask", FT_BOOLEAN, 32, NULL, 0x00000800, NULL, HFILL }}, +{ &hf_x11_window_value_mask_do_not_propagate_mask, { "do-not-propagate-mask", "x11.window-value-mask.do-not-propagate-mask", FT_BOOLEAN, 32, NULL, 0x00001000, NULL, HFILL }}, +{ &hf_x11_window_value_mask_colormap, { "colormap", "x11.window-value-mask.colormap", FT_BOOLEAN, 32, NULL, 0x00002000, NULL, HFILL }}, +{ &hf_x11_window_value_mask_cursor, { "cursor", "x11.window-value-mask.cursor", FT_BOOLEAN, 32, NULL, 0x00004000, NULL, HFILL }}, +{ &hf_x11_x, { "x", "x11.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_y, { "y", "x11.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, + +/* Generated by process-x11-xcb.pl below this line */ +{ &hf_x11_glx_render_CallList_list, { "list", "x11.glx.render.CallList.list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CallLists_n, { "n", "x11.glx.render.CallLists.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CallLists_type, { "type", "x11.glx.render.CallLists.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CallLists_lists, { "lists", "x11.glx.render.CallLists.lists", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ListBase_base, { "base", "x11.glx.render.ListBase.base", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Begin_mode, { "mode", "x11.glx.render.Begin.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_width, { "width", "x11.glx.render.Bitmap.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_height, { "height", "x11.glx.render.Bitmap.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_xorig, { "xorig", "x11.glx.render.Bitmap.xorig", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_yorig, { "yorig", "x11.glx.render.Bitmap.yorig", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_xmove, { "xmove", "x11.glx.render.Bitmap.xmove", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_ymove, { "ymove", "x11.glx.render.Bitmap.ymove", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_bitmap, { "bitmap", "x11.glx.render.Bitmap.bitmap", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_swapbytes, { "swap bytes", "x11.glx.render.Bitmap.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_lsbfirst, { "lsb first", "x11.glx.render.Bitmap.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_rowlength, { "row length", "x11.glx.render.Bitmap.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_skiprows, { "skip rows", "x11.glx.render.Bitmap.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_skippixels, { "skip pixels", "x11.glx.render.Bitmap.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Bitmap_alignment, { "alignment", "x11.glx.render.Bitmap.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3bv_v, { "v", "x11.glx.render.Color3bv.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3dv_v, { "v", "x11.glx.render.Color3dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3dv_v_item, { "v", "x11.glx.render.Color3dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3fv_v, { "v", "x11.glx.render.Color3fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3fv_v_item, { "v", "x11.glx.render.Color3fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3iv_v, { "v", "x11.glx.render.Color3iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3iv_v_item, { "v", "x11.glx.render.Color3iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3sv_v, { "v", "x11.glx.render.Color3sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3sv_v_item, { "v", "x11.glx.render.Color3sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3ubv_v, { "v", "x11.glx.render.Color3ubv.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3uiv_v, { "v", "x11.glx.render.Color3uiv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3uiv_v_item, { "v", "x11.glx.render.Color3uiv.v", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3usv_v, { "v", "x11.glx.render.Color3usv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color3usv_v_item, { "v", "x11.glx.render.Color3usv.v", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4bv_v, { "v", "x11.glx.render.Color4bv.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4dv_v, { "v", "x11.glx.render.Color4dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4dv_v_item, { "v", "x11.glx.render.Color4dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4fv_v, { "v", "x11.glx.render.Color4fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4fv_v_item, { "v", "x11.glx.render.Color4fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4iv_v, { "v", "x11.glx.render.Color4iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4iv_v_item, { "v", "x11.glx.render.Color4iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4sv_v, { "v", "x11.glx.render.Color4sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4sv_v_item, { "v", "x11.glx.render.Color4sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4ubv_v, { "v", "x11.glx.render.Color4ubv.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4uiv_v, { "v", "x11.glx.render.Color4uiv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4uiv_v_item, { "v", "x11.glx.render.Color4uiv.v", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4usv_v, { "v", "x11.glx.render.Color4usv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Color4usv_v_item, { "v", "x11.glx.render.Color4usv.v", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EdgeFlagv_flag, { "flag", "x11.glx.render.EdgeFlagv.flag", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexdv_c, { "c", "x11.glx.render.Indexdv.c", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexdv_c_item, { "c", "x11.glx.render.Indexdv.c", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexfv_c, { "c", "x11.glx.render.Indexfv.c", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexfv_c_item, { "c", "x11.glx.render.Indexfv.c", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexiv_c, { "c", "x11.glx.render.Indexiv.c", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexiv_c_item, { "c", "x11.glx.render.Indexiv.c", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexsv_c, { "c", "x11.glx.render.Indexsv.c", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexsv_c_item, { "c", "x11.glx.render.Indexsv.c", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3bv_v, { "v", "x11.glx.render.Normal3bv.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3dv_v, { "v", "x11.glx.render.Normal3dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3dv_v_item, { "v", "x11.glx.render.Normal3dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3fv_v, { "v", "x11.glx.render.Normal3fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3fv_v_item, { "v", "x11.glx.render.Normal3fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3iv_v, { "v", "x11.glx.render.Normal3iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3iv_v_item, { "v", "x11.glx.render.Normal3iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3sv_v, { "v", "x11.glx.render.Normal3sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Normal3sv_v_item, { "v", "x11.glx.render.Normal3sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2dv_v, { "v", "x11.glx.render.RasterPos2dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2dv_v_item, { "v", "x11.glx.render.RasterPos2dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2fv_v, { "v", "x11.glx.render.RasterPos2fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2fv_v_item, { "v", "x11.glx.render.RasterPos2fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2iv_v, { "v", "x11.glx.render.RasterPos2iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2iv_v_item, { "v", "x11.glx.render.RasterPos2iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2sv_v, { "v", "x11.glx.render.RasterPos2sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos2sv_v_item, { "v", "x11.glx.render.RasterPos2sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3dv_v, { "v", "x11.glx.render.RasterPos3dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3dv_v_item, { "v", "x11.glx.render.RasterPos3dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3fv_v, { "v", "x11.glx.render.RasterPos3fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3fv_v_item, { "v", "x11.glx.render.RasterPos3fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3iv_v, { "v", "x11.glx.render.RasterPos3iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3iv_v_item, { "v", "x11.glx.render.RasterPos3iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3sv_v, { "v", "x11.glx.render.RasterPos3sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos3sv_v_item, { "v", "x11.glx.render.RasterPos3sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4dv_v, { "v", "x11.glx.render.RasterPos4dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4dv_v_item, { "v", "x11.glx.render.RasterPos4dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4fv_v, { "v", "x11.glx.render.RasterPos4fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4fv_v_item, { "v", "x11.glx.render.RasterPos4fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4iv_v, { "v", "x11.glx.render.RasterPos4iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4iv_v_item, { "v", "x11.glx.render.RasterPos4iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4sv_v, { "v", "x11.glx.render.RasterPos4sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RasterPos4sv_v_item, { "v", "x11.glx.render.RasterPos4sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectdv_v1, { "v1", "x11.glx.render.Rectdv.v1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectdv_v1_item, { "v1", "x11.glx.render.Rectdv.v1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectdv_v2, { "v2", "x11.glx.render.Rectdv.v2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectdv_v2_item, { "v2", "x11.glx.render.Rectdv.v2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectfv_v1, { "v1", "x11.glx.render.Rectfv.v1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectfv_v1_item, { "v1", "x11.glx.render.Rectfv.v1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectfv_v2, { "v2", "x11.glx.render.Rectfv.v2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectfv_v2_item, { "v2", "x11.glx.render.Rectfv.v2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectiv_v1, { "v1", "x11.glx.render.Rectiv.v1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectiv_v1_item, { "v1", "x11.glx.render.Rectiv.v1", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectiv_v2, { "v2", "x11.glx.render.Rectiv.v2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectiv_v2_item, { "v2", "x11.glx.render.Rectiv.v2", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectsv_v1, { "v1", "x11.glx.render.Rectsv.v1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectsv_v1_item, { "v1", "x11.glx.render.Rectsv.v1", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectsv_v2, { "v2", "x11.glx.render.Rectsv.v2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rectsv_v2_item, { "v2", "x11.glx.render.Rectsv.v2", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1dv_v, { "v", "x11.glx.render.TexCoord1dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1dv_v_item, { "v", "x11.glx.render.TexCoord1dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1fv_v, { "v", "x11.glx.render.TexCoord1fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1fv_v_item, { "v", "x11.glx.render.TexCoord1fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1iv_v, { "v", "x11.glx.render.TexCoord1iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1iv_v_item, { "v", "x11.glx.render.TexCoord1iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1sv_v, { "v", "x11.glx.render.TexCoord1sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord1sv_v_item, { "v", "x11.glx.render.TexCoord1sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2dv_v, { "v", "x11.glx.render.TexCoord2dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2dv_v_item, { "v", "x11.glx.render.TexCoord2dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2fv_v, { "v", "x11.glx.render.TexCoord2fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2fv_v_item, { "v", "x11.glx.render.TexCoord2fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2iv_v, { "v", "x11.glx.render.TexCoord2iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2iv_v_item, { "v", "x11.glx.render.TexCoord2iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2sv_v, { "v", "x11.glx.render.TexCoord2sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord2sv_v_item, { "v", "x11.glx.render.TexCoord2sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3dv_v, { "v", "x11.glx.render.TexCoord3dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3dv_v_item, { "v", "x11.glx.render.TexCoord3dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3fv_v, { "v", "x11.glx.render.TexCoord3fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3fv_v_item, { "v", "x11.glx.render.TexCoord3fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3iv_v, { "v", "x11.glx.render.TexCoord3iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3iv_v_item, { "v", "x11.glx.render.TexCoord3iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3sv_v, { "v", "x11.glx.render.TexCoord3sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord3sv_v_item, { "v", "x11.glx.render.TexCoord3sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4dv_v, { "v", "x11.glx.render.TexCoord4dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4dv_v_item, { "v", "x11.glx.render.TexCoord4dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4fv_v, { "v", "x11.glx.render.TexCoord4fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4fv_v_item, { "v", "x11.glx.render.TexCoord4fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4iv_v, { "v", "x11.glx.render.TexCoord4iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4iv_v_item, { "v", "x11.glx.render.TexCoord4iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4sv_v, { "v", "x11.glx.render.TexCoord4sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexCoord4sv_v_item, { "v", "x11.glx.render.TexCoord4sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2dv_v, { "v", "x11.glx.render.Vertex2dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2dv_v_item, { "v", "x11.glx.render.Vertex2dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2fv_v, { "v", "x11.glx.render.Vertex2fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2fv_v_item, { "v", "x11.glx.render.Vertex2fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2iv_v, { "v", "x11.glx.render.Vertex2iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2iv_v_item, { "v", "x11.glx.render.Vertex2iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2sv_v, { "v", "x11.glx.render.Vertex2sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex2sv_v_item, { "v", "x11.glx.render.Vertex2sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3dv_v, { "v", "x11.glx.render.Vertex3dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3dv_v_item, { "v", "x11.glx.render.Vertex3dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3fv_v, { "v", "x11.glx.render.Vertex3fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3fv_v_item, { "v", "x11.glx.render.Vertex3fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3iv_v, { "v", "x11.glx.render.Vertex3iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3iv_v_item, { "v", "x11.glx.render.Vertex3iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3sv_v, { "v", "x11.glx.render.Vertex3sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex3sv_v_item, { "v", "x11.glx.render.Vertex3sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4dv_v, { "v", "x11.glx.render.Vertex4dv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4dv_v_item, { "v", "x11.glx.render.Vertex4dv.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4fv_v, { "v", "x11.glx.render.Vertex4fv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4fv_v_item, { "v", "x11.glx.render.Vertex4fv.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4iv_v, { "v", "x11.glx.render.Vertex4iv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4iv_v_item, { "v", "x11.glx.render.Vertex4iv.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4sv_v, { "v", "x11.glx.render.Vertex4sv.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Vertex4sv_v_item, { "v", "x11.glx.render.Vertex4sv.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClipPlane_plane, { "plane", "x11.glx.render.ClipPlane.plane", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClipPlane_equation, { "equation", "x11.glx.render.ClipPlane.equation", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClipPlane_equation_item, { "equation", "x11.glx.render.ClipPlane.equation", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorMaterial_face, { "face", "x11.glx.render.ColorMaterial.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorMaterial_mode, { "mode", "x11.glx.render.ColorMaterial.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CullFace_mode, { "mode", "x11.glx.render.CullFace.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogf_pname, { "pname", "x11.glx.render.Fogf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogf_param, { "param", "x11.glx.render.Fogf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogfv_pname, { "pname", "x11.glx.render.Fogfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogfv_params, { "params", "x11.glx.render.Fogfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogfv_params_item, { "params", "x11.glx.render.Fogfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogi_pname, { "pname", "x11.glx.render.Fogi.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogi_param, { "param", "x11.glx.render.Fogi.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogiv_pname, { "pname", "x11.glx.render.Fogiv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogiv_params, { "params", "x11.glx.render.Fogiv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Fogiv_params_item, { "params", "x11.glx.render.Fogiv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FrontFace_mode, { "mode", "x11.glx.render.FrontFace.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Hint_target, { "target", "x11.glx.render.Hint.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Hint_mode, { "mode", "x11.glx.render.Hint.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightf_light, { "light", "x11.glx.render.Lightf.light", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightf_pname, { "pname", "x11.glx.render.Lightf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightf_param, { "param", "x11.glx.render.Lightf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightfv_light, { "light", "x11.glx.render.Lightfv.light", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightfv_pname, { "pname", "x11.glx.render.Lightfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightfv_params, { "params", "x11.glx.render.Lightfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightfv_params_item, { "params", "x11.glx.render.Lightfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lighti_light, { "light", "x11.glx.render.Lighti.light", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lighti_pname, { "pname", "x11.glx.render.Lighti.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lighti_param, { "param", "x11.glx.render.Lighti.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightiv_light, { "light", "x11.glx.render.Lightiv.light", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightiv_pname, { "pname", "x11.glx.render.Lightiv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightiv_params, { "params", "x11.glx.render.Lightiv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Lightiv_params_item, { "params", "x11.glx.render.Lightiv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModelf_pname, { "pname", "x11.glx.render.LightModelf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModelf_param, { "param", "x11.glx.render.LightModelf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModelfv_pname, { "pname", "x11.glx.render.LightModelfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModelfv_params, { "params", "x11.glx.render.LightModelfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModelfv_params_item, { "params", "x11.glx.render.LightModelfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModeli_pname, { "pname", "x11.glx.render.LightModeli.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModeli_param, { "param", "x11.glx.render.LightModeli.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModeliv_pname, { "pname", "x11.glx.render.LightModeliv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModeliv_params, { "params", "x11.glx.render.LightModeliv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LightModeliv_params_item, { "params", "x11.glx.render.LightModeliv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LineStipple_factor, { "factor", "x11.glx.render.LineStipple.factor", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LineStipple_pattern, { "pattern", "x11.glx.render.LineStipple.pattern", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LineWidth_width, { "width", "x11.glx.render.LineWidth.width", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialf_face, { "face", "x11.glx.render.Materialf.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialf_pname, { "pname", "x11.glx.render.Materialf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialf_param, { "param", "x11.glx.render.Materialf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialfv_face, { "face", "x11.glx.render.Materialfv.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialfv_pname, { "pname", "x11.glx.render.Materialfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialfv_params, { "params", "x11.glx.render.Materialfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialfv_params_item, { "params", "x11.glx.render.Materialfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materiali_face, { "face", "x11.glx.render.Materiali.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materiali_pname, { "pname", "x11.glx.render.Materiali.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materiali_param, { "param", "x11.glx.render.Materiali.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialiv_face, { "face", "x11.glx.render.Materialiv.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialiv_pname, { "pname", "x11.glx.render.Materialiv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialiv_params, { "params", "x11.glx.render.Materialiv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Materialiv_params_item, { "params", "x11.glx.render.Materialiv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointSize_size, { "size", "x11.glx.render.PointSize.size", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonMode_face, { "face", "x11.glx.render.PolygonMode.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonMode_mode, { "mode", "x11.glx.render.PolygonMode.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_mask, { "mask", "x11.glx.render.PolygonStipple.mask", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_swapbytes, { "swap bytes", "x11.glx.render.PolygonStipple.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_lsbfirst, { "lsb first", "x11.glx.render.PolygonStipple.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_rowlength, { "row length", "x11.glx.render.PolygonStipple.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_skiprows, { "skip rows", "x11.glx.render.PolygonStipple.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_skippixels, { "skip pixels", "x11.glx.render.PolygonStipple.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonStipple_alignment, { "alignment", "x11.glx.render.PolygonStipple.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scissor_x, { "x", "x11.glx.render.Scissor.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scissor_y, { "y", "x11.glx.render.Scissor.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scissor_width, { "width", "x11.glx.render.Scissor.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scissor_height, { "height", "x11.glx.render.Scissor.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ShadeModel_mode, { "mode", "x11.glx.render.ShadeModel.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterf_target, { "target", "x11.glx.render.TexParameterf.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterf_pname, { "pname", "x11.glx.render.TexParameterf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterf_param, { "param", "x11.glx.render.TexParameterf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterfv_target, { "target", "x11.glx.render.TexParameterfv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterfv_pname, { "pname", "x11.glx.render.TexParameterfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterfv_params, { "params", "x11.glx.render.TexParameterfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameterfv_params_item, { "params", "x11.glx.render.TexParameterfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteri_target, { "target", "x11.glx.render.TexParameteri.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteri_pname, { "pname", "x11.glx.render.TexParameteri.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteri_param, { "param", "x11.glx.render.TexParameteri.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteriv_target, { "target", "x11.glx.render.TexParameteriv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteriv_pname, { "pname", "x11.glx.render.TexParameteriv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteriv_params, { "params", "x11.glx.render.TexParameteriv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexParameteriv_params_item, { "params", "x11.glx.render.TexParameteriv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_target, { "target", "x11.glx.render.TexImage1D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_level, { "level", "x11.glx.render.TexImage1D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_internalformat, { "internalformat", "x11.glx.render.TexImage1D.internalformat", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_width, { "width", "x11.glx.render.TexImage1D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_border, { "border", "x11.glx.render.TexImage1D.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_format, { "format", "x11.glx.render.TexImage1D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_type, { "type", "x11.glx.render.TexImage1D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_pixels, { "pixels", "x11.glx.render.TexImage1D.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_swapbytes, { "swap bytes", "x11.glx.render.TexImage1D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_lsbfirst, { "lsb first", "x11.glx.render.TexImage1D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_rowlength, { "row length", "x11.glx.render.TexImage1D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_skiprows, { "skip rows", "x11.glx.render.TexImage1D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_skippixels, { "skip pixels", "x11.glx.render.TexImage1D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage1D_alignment, { "alignment", "x11.glx.render.TexImage1D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_target, { "target", "x11.glx.render.TexImage2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_level, { "level", "x11.glx.render.TexImage2D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_internalformat, { "internalformat", "x11.glx.render.TexImage2D.internalformat", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_width, { "width", "x11.glx.render.TexImage2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_height, { "height", "x11.glx.render.TexImage2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_border, { "border", "x11.glx.render.TexImage2D.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_format, { "format", "x11.glx.render.TexImage2D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_type, { "type", "x11.glx.render.TexImage2D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_pixels, { "pixels", "x11.glx.render.TexImage2D.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_swapbytes, { "swap bytes", "x11.glx.render.TexImage2D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_lsbfirst, { "lsb first", "x11.glx.render.TexImage2D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_rowlength, { "row length", "x11.glx.render.TexImage2D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_skiprows, { "skip rows", "x11.glx.render.TexImage2D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_skippixels, { "skip pixels", "x11.glx.render.TexImage2D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage2D_alignment, { "alignment", "x11.glx.render.TexImage2D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvf_target, { "target", "x11.glx.render.TexEnvf.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvf_pname, { "pname", "x11.glx.render.TexEnvf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvf_param, { "param", "x11.glx.render.TexEnvf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvfv_target, { "target", "x11.glx.render.TexEnvfv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvfv_pname, { "pname", "x11.glx.render.TexEnvfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvfv_params, { "params", "x11.glx.render.TexEnvfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvfv_params_item, { "params", "x11.glx.render.TexEnvfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvi_target, { "target", "x11.glx.render.TexEnvi.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvi_pname, { "pname", "x11.glx.render.TexEnvi.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnvi_param, { "param", "x11.glx.render.TexEnvi.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnviv_target, { "target", "x11.glx.render.TexEnviv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnviv_pname, { "pname", "x11.glx.render.TexEnviv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnviv_params, { "params", "x11.glx.render.TexEnviv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexEnviv_params_item, { "params", "x11.glx.render.TexEnviv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGend_coord, { "coord", "x11.glx.render.TexGend.coord", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGend_pname, { "pname", "x11.glx.render.TexGend.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGend_param, { "param", "x11.glx.render.TexGend.param", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGendv_coord, { "coord", "x11.glx.render.TexGendv.coord", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGendv_pname, { "pname", "x11.glx.render.TexGendv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGendv_params, { "params", "x11.glx.render.TexGendv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGendv_params_item, { "params", "x11.glx.render.TexGendv.params", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenf_coord, { "coord", "x11.glx.render.TexGenf.coord", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenf_pname, { "pname", "x11.glx.render.TexGenf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenf_param, { "param", "x11.glx.render.TexGenf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenfv_coord, { "coord", "x11.glx.render.TexGenfv.coord", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenfv_pname, { "pname", "x11.glx.render.TexGenfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenfv_params, { "params", "x11.glx.render.TexGenfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGenfv_params_item, { "params", "x11.glx.render.TexGenfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeni_coord, { "coord", "x11.glx.render.TexGeni.coord", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeni_pname, { "pname", "x11.glx.render.TexGeni.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeni_param, { "param", "x11.glx.render.TexGeni.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeniv_coord, { "coord", "x11.glx.render.TexGeniv.coord", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeniv_pname, { "pname", "x11.glx.render.TexGeniv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeniv_params, { "params", "x11.glx.render.TexGeniv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexGeniv_params_item, { "params", "x11.glx.render.TexGeniv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadName_name, { "name", "x11.glx.render.LoadName.name", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PassThrough_token, { "token", "x11.glx.render.PassThrough.token", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PushName_name, { "name", "x11.glx.render.PushName.name", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawBuffer_mode, { "mode", "x11.glx.render.DrawBuffer.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Clear_mask, { "mask", "x11.glx.render.Clear.mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearAccum_red, { "red", "x11.glx.render.ClearAccum.red", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearAccum_green, { "green", "x11.glx.render.ClearAccum.green", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearAccum_blue, { "blue", "x11.glx.render.ClearAccum.blue", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearAccum_alpha, { "alpha", "x11.glx.render.ClearAccum.alpha", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearIndex_c, { "c", "x11.glx.render.ClearIndex.c", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearColor_red, { "red", "x11.glx.render.ClearColor.red", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearColor_green, { "green", "x11.glx.render.ClearColor.green", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearColor_blue, { "blue", "x11.glx.render.ClearColor.blue", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearColor_alpha, { "alpha", "x11.glx.render.ClearColor.alpha", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearStencil_s, { "s", "x11.glx.render.ClearStencil.s", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ClearDepth_depth, { "depth", "x11.glx.render.ClearDepth.depth", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilMask_mask, { "mask", "x11.glx.render.StencilMask.mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorMask_red, { "red", "x11.glx.render.ColorMask.red", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorMask_green, { "green", "x11.glx.render.ColorMask.green", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorMask_blue, { "blue", "x11.glx.render.ColorMask.blue", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorMask_alpha, { "alpha", "x11.glx.render.ColorMask.alpha", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DepthMask_flag, { "flag", "x11.glx.render.DepthMask.flag", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_IndexMask_mask, { "mask", "x11.glx.render.IndexMask.mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Accum_op, { "op", "x11.glx.render.Accum.op", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Accum_value, { "value", "x11.glx.render.Accum.value", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Disable_cap, { "cap", "x11.glx.render.Disable.cap", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Enable_cap, { "cap", "x11.glx.render.Enable.cap", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PushAttrib_mask, { "mask", "x11.glx.render.PushAttrib.mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_target, { "target", "x11.glx.render.Map1d.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_u1, { "u1", "x11.glx.render.Map1d.u1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_u2, { "u2", "x11.glx.render.Map1d.u2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_stride, { "stride", "x11.glx.render.Map1d.stride", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_order, { "order", "x11.glx.render.Map1d.order", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_points, { "points", "x11.glx.render.Map1d.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1d_points_item, { "points", "x11.glx.render.Map1d.points", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_target, { "target", "x11.glx.render.Map1f.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_u1, { "u1", "x11.glx.render.Map1f.u1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_u2, { "u2", "x11.glx.render.Map1f.u2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_stride, { "stride", "x11.glx.render.Map1f.stride", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_order, { "order", "x11.glx.render.Map1f.order", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_points, { "points", "x11.glx.render.Map1f.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map1f_points_item, { "points", "x11.glx.render.Map1f.points", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_target, { "target", "x11.glx.render.Map2d.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_u1, { "u1", "x11.glx.render.Map2d.u1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_u2, { "u2", "x11.glx.render.Map2d.u2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_ustride, { "ustride", "x11.glx.render.Map2d.ustride", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_uorder, { "uorder", "x11.glx.render.Map2d.uorder", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_v1, { "v1", "x11.glx.render.Map2d.v1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_v2, { "v2", "x11.glx.render.Map2d.v2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_vstride, { "vstride", "x11.glx.render.Map2d.vstride", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_vorder, { "vorder", "x11.glx.render.Map2d.vorder", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_points, { "points", "x11.glx.render.Map2d.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2d_points_item, { "points", "x11.glx.render.Map2d.points", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_target, { "target", "x11.glx.render.Map2f.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_u1, { "u1", "x11.glx.render.Map2f.u1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_u2, { "u2", "x11.glx.render.Map2f.u2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_ustride, { "ustride", "x11.glx.render.Map2f.ustride", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_uorder, { "uorder", "x11.glx.render.Map2f.uorder", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_v1, { "v1", "x11.glx.render.Map2f.v1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_v2, { "v2", "x11.glx.render.Map2f.v2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_vstride, { "vstride", "x11.glx.render.Map2f.vstride", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_vorder, { "vorder", "x11.glx.render.Map2f.vorder", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_points, { "points", "x11.glx.render.Map2f.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Map2f_points_item, { "points", "x11.glx.render.Map2f.points", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid1d_un, { "un", "x11.glx.render.MapGrid1d.un", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid1d_u1, { "u1", "x11.glx.render.MapGrid1d.u1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid1d_u2, { "u2", "x11.glx.render.MapGrid1d.u2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid1f_un, { "un", "x11.glx.render.MapGrid1f.un", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid1f_u1, { "u1", "x11.glx.render.MapGrid1f.u1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid1f_u2, { "u2", "x11.glx.render.MapGrid1f.u2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2d_un, { "un", "x11.glx.render.MapGrid2d.un", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2d_u1, { "u1", "x11.glx.render.MapGrid2d.u1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2d_u2, { "u2", "x11.glx.render.MapGrid2d.u2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2d_vn, { "vn", "x11.glx.render.MapGrid2d.vn", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2d_v1, { "v1", "x11.glx.render.MapGrid2d.v1", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2d_v2, { "v2", "x11.glx.render.MapGrid2d.v2", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2f_un, { "un", "x11.glx.render.MapGrid2f.un", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2f_u1, { "u1", "x11.glx.render.MapGrid2f.u1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2f_u2, { "u2", "x11.glx.render.MapGrid2f.u2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2f_vn, { "vn", "x11.glx.render.MapGrid2f.vn", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2f_v1, { "v1", "x11.glx.render.MapGrid2f.v1", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MapGrid2f_v2, { "v2", "x11.glx.render.MapGrid2f.v2", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord1dv_u, { "u", "x11.glx.render.EvalCoord1dv.u", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord1dv_u_item, { "u", "x11.glx.render.EvalCoord1dv.u", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord1fv_u, { "u", "x11.glx.render.EvalCoord1fv.u", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord1fv_u_item, { "u", "x11.glx.render.EvalCoord1fv.u", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord2dv_u, { "u", "x11.glx.render.EvalCoord2dv.u", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord2dv_u_item, { "u", "x11.glx.render.EvalCoord2dv.u", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord2fv_u, { "u", "x11.glx.render.EvalCoord2fv.u", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalCoord2fv_u_item, { "u", "x11.glx.render.EvalCoord2fv.u", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh1_mode, { "mode", "x11.glx.render.EvalMesh1.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh1_i1, { "i1", "x11.glx.render.EvalMesh1.i1", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh1_i2, { "i2", "x11.glx.render.EvalMesh1.i2", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalPoint1_i, { "i", "x11.glx.render.EvalPoint1.i", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh2_mode, { "mode", "x11.glx.render.EvalMesh2.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh2_i1, { "i1", "x11.glx.render.EvalMesh2.i1", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh2_i2, { "i2", "x11.glx.render.EvalMesh2.i2", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh2_j1, { "j1", "x11.glx.render.EvalMesh2.j1", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalMesh2_j2, { "j2", "x11.glx.render.EvalMesh2.j2", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalPoint2_i, { "i", "x11.glx.render.EvalPoint2.i", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EvalPoint2_j, { "j", "x11.glx.render.EvalPoint2.j", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_AlphaFunc_func, { "func", "x11.glx.render.AlphaFunc.func", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_AlphaFunc_ref, { "ref", "x11.glx.render.AlphaFunc.ref", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendFunc_sfactor, { "sfactor", "x11.glx.render.BlendFunc.sfactor", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendFunc_dfactor, { "dfactor", "x11.glx.render.BlendFunc.dfactor", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LogicOp_opcode, { "opcode", "x11.glx.render.LogicOp.opcode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilFunc_func, { "func", "x11.glx.render.StencilFunc.func", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilFunc_ref, { "ref", "x11.glx.render.StencilFunc.ref", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilFunc_mask, { "mask", "x11.glx.render.StencilFunc.mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilOp_fail, { "fail", "x11.glx.render.StencilOp.fail", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilOp_zfail, { "zfail", "x11.glx.render.StencilOp.zfail", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_StencilOp_zpass, { "zpass", "x11.glx.render.StencilOp.zpass", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DepthFunc_func, { "func", "x11.glx.render.DepthFunc.func", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelZoom_xfactor, { "xfactor", "x11.glx.render.PixelZoom.xfactor", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelZoom_yfactor, { "yfactor", "x11.glx.render.PixelZoom.yfactor", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelTransferf_pname, { "pname", "x11.glx.render.PixelTransferf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelTransferf_param, { "param", "x11.glx.render.PixelTransferf.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelTransferi_pname, { "pname", "x11.glx.render.PixelTransferi.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelTransferi_param, { "param", "x11.glx.render.PixelTransferi.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapfv_map, { "map", "x11.glx.render.PixelMapfv.map", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapfv_mapsize, { "mapsize", "x11.glx.render.PixelMapfv.mapsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapfv_values, { "values", "x11.glx.render.PixelMapfv.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapfv_values_item, { "values", "x11.glx.render.PixelMapfv.values", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapuiv_map, { "map", "x11.glx.render.PixelMapuiv.map", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapuiv_mapsize, { "mapsize", "x11.glx.render.PixelMapuiv.mapsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapuiv_values, { "values", "x11.glx.render.PixelMapuiv.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapuiv_values_item, { "values", "x11.glx.render.PixelMapuiv.values", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapusv_map, { "map", "x11.glx.render.PixelMapusv.map", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapusv_mapsize, { "mapsize", "x11.glx.render.PixelMapusv.mapsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapusv_values, { "values", "x11.glx.render.PixelMapusv.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelMapusv_values_item, { "values", "x11.glx.render.PixelMapusv.values", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ReadBuffer_mode, { "mode", "x11.glx.render.ReadBuffer.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyPixels_x, { "x", "x11.glx.render.CopyPixels.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyPixels_y, { "y", "x11.glx.render.CopyPixels.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyPixels_width, { "width", "x11.glx.render.CopyPixels.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyPixels_height, { "height", "x11.glx.render.CopyPixels.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyPixels_type, { "type", "x11.glx.render.CopyPixels.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_width, { "width", "x11.glx.render.DrawPixels.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_height, { "height", "x11.glx.render.DrawPixels.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_format, { "format", "x11.glx.render.DrawPixels.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_type, { "type", "x11.glx.render.DrawPixels.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_pixels, { "pixels", "x11.glx.render.DrawPixels.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_swapbytes, { "swap bytes", "x11.glx.render.DrawPixels.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_lsbfirst, { "lsb first", "x11.glx.render.DrawPixels.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_rowlength, { "row length", "x11.glx.render.DrawPixels.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_skiprows, { "skip rows", "x11.glx.render.DrawPixels.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_skippixels, { "skip pixels", "x11.glx.render.DrawPixels.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawPixels_alignment, { "alignment", "x11.glx.render.DrawPixels.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DepthRange_zNear, { "zNear", "x11.glx.render.DepthRange.zNear", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DepthRange_zFar, { "zFar", "x11.glx.render.DepthRange.zFar", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Frustum_left, { "left", "x11.glx.render.Frustum.left", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Frustum_right, { "right", "x11.glx.render.Frustum.right", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Frustum_bottom, { "bottom", "x11.glx.render.Frustum.bottom", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Frustum_top, { "top", "x11.glx.render.Frustum.top", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Frustum_zNear, { "zNear", "x11.glx.render.Frustum.zNear", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Frustum_zFar, { "zFar", "x11.glx.render.Frustum.zFar", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadMatrixf_m, { "m", "x11.glx.render.LoadMatrixf.m", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadMatrixf_m_item, { "m", "x11.glx.render.LoadMatrixf.m", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadMatrixd_m, { "m", "x11.glx.render.LoadMatrixd.m", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadMatrixd_m_item, { "m", "x11.glx.render.LoadMatrixd.m", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixMode_mode, { "mode", "x11.glx.render.MatrixMode.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultMatrixf_m, { "m", "x11.glx.render.MultMatrixf.m", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultMatrixf_m_item, { "m", "x11.glx.render.MultMatrixf.m", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultMatrixd_m, { "m", "x11.glx.render.MultMatrixd.m", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultMatrixd_m_item, { "m", "x11.glx.render.MultMatrixd.m", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Ortho_left, { "left", "x11.glx.render.Ortho.left", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Ortho_right, { "right", "x11.glx.render.Ortho.right", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Ortho_bottom, { "bottom", "x11.glx.render.Ortho.bottom", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Ortho_top, { "top", "x11.glx.render.Ortho.top", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Ortho_zNear, { "zNear", "x11.glx.render.Ortho.zNear", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Ortho_zFar, { "zFar", "x11.glx.render.Ortho.zFar", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotated_angle, { "angle", "x11.glx.render.Rotated.angle", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotated_x, { "x", "x11.glx.render.Rotated.x", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotated_y, { "y", "x11.glx.render.Rotated.y", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotated_z, { "z", "x11.glx.render.Rotated.z", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotatef_angle, { "angle", "x11.glx.render.Rotatef.angle", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotatef_x, { "x", "x11.glx.render.Rotatef.x", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotatef_y, { "y", "x11.glx.render.Rotatef.y", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Rotatef_z, { "z", "x11.glx.render.Rotatef.z", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scaled_x, { "x", "x11.glx.render.Scaled.x", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scaled_y, { "y", "x11.glx.render.Scaled.y", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scaled_z, { "z", "x11.glx.render.Scaled.z", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scalef_x, { "x", "x11.glx.render.Scalef.x", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scalef_y, { "y", "x11.glx.render.Scalef.y", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Scalef_z, { "z", "x11.glx.render.Scalef.z", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Translated_x, { "x", "x11.glx.render.Translated.x", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Translated_y, { "y", "x11.glx.render.Translated.y", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Translated_z, { "z", "x11.glx.render.Translated.z", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Translatef_x, { "x", "x11.glx.render.Translatef.x", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Translatef_y, { "y", "x11.glx.render.Translatef.y", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Translatef_z, { "z", "x11.glx.render.Translatef.z", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Viewport_x, { "x", "x11.glx.render.Viewport.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Viewport_y, { "y", "x11.glx.render.Viewport.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Viewport_width, { "width", "x11.glx.render.Viewport.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Viewport_height, { "height", "x11.glx.render.Viewport.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawArrays_mode, { "mode", "x11.glx.render.DrawArrays.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawArrays_first, { "first", "x11.glx.render.DrawArrays.first", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawArrays_count, { "count", "x11.glx.render.DrawArrays.count", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonOffset_factor, { "factor", "x11.glx.render.PolygonOffset.factor", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonOffset_units, { "units", "x11.glx.render.PolygonOffset.units", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_target, { "target", "x11.glx.render.CopyTexImage1D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_level, { "level", "x11.glx.render.CopyTexImage1D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_internalformat, { "internalformat", "x11.glx.render.CopyTexImage1D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_x, { "x", "x11.glx.render.CopyTexImage1D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_y, { "y", "x11.glx.render.CopyTexImage1D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_width, { "width", "x11.glx.render.CopyTexImage1D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage1D_border, { "border", "x11.glx.render.CopyTexImage1D.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_target, { "target", "x11.glx.render.CopyTexImage2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_level, { "level", "x11.glx.render.CopyTexImage2D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_internalformat, { "internalformat", "x11.glx.render.CopyTexImage2D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_x, { "x", "x11.glx.render.CopyTexImage2D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_y, { "y", "x11.glx.render.CopyTexImage2D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_width, { "width", "x11.glx.render.CopyTexImage2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_height, { "height", "x11.glx.render.CopyTexImage2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexImage2D_border, { "border", "x11.glx.render.CopyTexImage2D.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage1D_target, { "target", "x11.glx.render.CopyTexSubImage1D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage1D_level, { "level", "x11.glx.render.CopyTexSubImage1D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage1D_xoffset, { "xoffset", "x11.glx.render.CopyTexSubImage1D.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage1D_x, { "x", "x11.glx.render.CopyTexSubImage1D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage1D_y, { "y", "x11.glx.render.CopyTexSubImage1D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage1D_width, { "width", "x11.glx.render.CopyTexSubImage1D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_target, { "target", "x11.glx.render.CopyTexSubImage2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_level, { "level", "x11.glx.render.CopyTexSubImage2D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_xoffset, { "xoffset", "x11.glx.render.CopyTexSubImage2D.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_yoffset, { "yoffset", "x11.glx.render.CopyTexSubImage2D.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_x, { "x", "x11.glx.render.CopyTexSubImage2D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_y, { "y", "x11.glx.render.CopyTexSubImage2D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_width, { "width", "x11.glx.render.CopyTexSubImage2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage2D_height, { "height", "x11.glx.render.CopyTexSubImage2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_target, { "target", "x11.glx.render.TexSubImage1D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_level, { "level", "x11.glx.render.TexSubImage1D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_xoffset, { "xoffset", "x11.glx.render.TexSubImage1D.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_width, { "width", "x11.glx.render.TexSubImage1D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_format, { "format", "x11.glx.render.TexSubImage1D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_type, { "type", "x11.glx.render.TexSubImage1D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_UNUSED, { "UNUSED", "x11.glx.render.TexSubImage1D.UNUSED", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_pixels, { "pixels", "x11.glx.render.TexSubImage1D.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_swapbytes, { "swap bytes", "x11.glx.render.TexSubImage1D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_lsbfirst, { "lsb first", "x11.glx.render.TexSubImage1D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_rowlength, { "row length", "x11.glx.render.TexSubImage1D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_skiprows, { "skip rows", "x11.glx.render.TexSubImage1D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_skippixels, { "skip pixels", "x11.glx.render.TexSubImage1D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage1D_alignment, { "alignment", "x11.glx.render.TexSubImage1D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_target, { "target", "x11.glx.render.TexSubImage2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_level, { "level", "x11.glx.render.TexSubImage2D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_xoffset, { "xoffset", "x11.glx.render.TexSubImage2D.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_yoffset, { "yoffset", "x11.glx.render.TexSubImage2D.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_width, { "width", "x11.glx.render.TexSubImage2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_height, { "height", "x11.glx.render.TexSubImage2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_format, { "format", "x11.glx.render.TexSubImage2D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_type, { "type", "x11.glx.render.TexSubImage2D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_UNUSED, { "UNUSED", "x11.glx.render.TexSubImage2D.UNUSED", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_pixels, { "pixels", "x11.glx.render.TexSubImage2D.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_swapbytes, { "swap bytes", "x11.glx.render.TexSubImage2D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_lsbfirst, { "lsb first", "x11.glx.render.TexSubImage2D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_rowlength, { "row length", "x11.glx.render.TexSubImage2D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_skiprows, { "skip rows", "x11.glx.render.TexSubImage2D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_skippixels, { "skip pixels", "x11.glx.render.TexSubImage2D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage2D_alignment, { "alignment", "x11.glx.render.TexSubImage2D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BindTexture_target, { "target", "x11.glx.render.BindTexture.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BindTexture_texture, { "texture", "x11.glx.render.BindTexture.texture", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PrioritizeTextures_n, { "n", "x11.glx.render.PrioritizeTextures.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PrioritizeTextures_textures, { "textures", "x11.glx.render.PrioritizeTextures.textures", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PrioritizeTextures_textures_item, { "textures", "x11.glx.render.PrioritizeTextures.textures", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PrioritizeTextures_priorities, { "priorities", "x11.glx.render.PrioritizeTextures.priorities", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PrioritizeTextures_priorities_item, { "priorities", "x11.glx.render.PrioritizeTextures.priorities", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Indexubv_c, { "c", "x11.glx.render.Indexubv.c", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendColor_red, { "red", "x11.glx.render.BlendColor.red", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendColor_green, { "green", "x11.glx.render.BlendColor.green", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendColor_blue, { "blue", "x11.glx.render.BlendColor.blue", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendColor_alpha, { "alpha", "x11.glx.render.BlendColor.alpha", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendEquation_mode, { "mode", "x11.glx.render.BlendEquation.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_target, { "target", "x11.glx.render.ColorTable.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_internalformat, { "internalformat", "x11.glx.render.ColorTable.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_width, { "width", "x11.glx.render.ColorTable.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_format, { "format", "x11.glx.render.ColorTable.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_type, { "type", "x11.glx.render.ColorTable.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_table, { "table", "x11.glx.render.ColorTable.table", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_swapbytes, { "swap bytes", "x11.glx.render.ColorTable.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_lsbfirst, { "lsb first", "x11.glx.render.ColorTable.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_rowlength, { "row length", "x11.glx.render.ColorTable.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_skiprows, { "skip rows", "x11.glx.render.ColorTable.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_skippixels, { "skip pixels", "x11.glx.render.ColorTable.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTable_alignment, { "alignment", "x11.glx.render.ColorTable.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameterfv_target, { "target", "x11.glx.render.ColorTableParameterfv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameterfv_pname, { "pname", "x11.glx.render.ColorTableParameterfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameterfv_params, { "params", "x11.glx.render.ColorTableParameterfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameterfv_params_item, { "params", "x11.glx.render.ColorTableParameterfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameteriv_target, { "target", "x11.glx.render.ColorTableParameteriv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameteriv_pname, { "pname", "x11.glx.render.ColorTableParameteriv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameteriv_params, { "params", "x11.glx.render.ColorTableParameteriv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorTableParameteriv_params_item, { "params", "x11.glx.render.ColorTableParameteriv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorTable_target, { "target", "x11.glx.render.CopyColorTable.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorTable_internalformat, { "internalformat", "x11.glx.render.CopyColorTable.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorTable_x, { "x", "x11.glx.render.CopyColorTable.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorTable_y, { "y", "x11.glx.render.CopyColorTable.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorTable_width, { "width", "x11.glx.render.CopyColorTable.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_target, { "target", "x11.glx.render.ColorSubTable.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_start, { "start", "x11.glx.render.ColorSubTable.start", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_count, { "count", "x11.glx.render.ColorSubTable.count", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_format, { "format", "x11.glx.render.ColorSubTable.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_type, { "type", "x11.glx.render.ColorSubTable.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_data, { "data", "x11.glx.render.ColorSubTable.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_swapbytes, { "swap bytes", "x11.glx.render.ColorSubTable.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_lsbfirst, { "lsb first", "x11.glx.render.ColorSubTable.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_rowlength, { "row length", "x11.glx.render.ColorSubTable.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_skiprows, { "skip rows", "x11.glx.render.ColorSubTable.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_skippixels, { "skip pixels", "x11.glx.render.ColorSubTable.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ColorSubTable_alignment, { "alignment", "x11.glx.render.ColorSubTable.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorSubTable_target, { "target", "x11.glx.render.CopyColorSubTable.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorSubTable_start, { "start", "x11.glx.render.CopyColorSubTable.start", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorSubTable_x, { "x", "x11.glx.render.CopyColorSubTable.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorSubTable_y, { "y", "x11.glx.render.CopyColorSubTable.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyColorSubTable_width, { "width", "x11.glx.render.CopyColorSubTable.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_target, { "target", "x11.glx.render.ConvolutionFilter1D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_internalformat, { "internalformat", "x11.glx.render.ConvolutionFilter1D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_width, { "width", "x11.glx.render.ConvolutionFilter1D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_format, { "format", "x11.glx.render.ConvolutionFilter1D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_type, { "type", "x11.glx.render.ConvolutionFilter1D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_image, { "image", "x11.glx.render.ConvolutionFilter1D.image", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_swapbytes, { "swap bytes", "x11.glx.render.ConvolutionFilter1D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_lsbfirst, { "lsb first", "x11.glx.render.ConvolutionFilter1D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_rowlength, { "row length", "x11.glx.render.ConvolutionFilter1D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_skiprows, { "skip rows", "x11.glx.render.ConvolutionFilter1D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_skippixels, { "skip pixels", "x11.glx.render.ConvolutionFilter1D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter1D_alignment, { "alignment", "x11.glx.render.ConvolutionFilter1D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_target, { "target", "x11.glx.render.ConvolutionFilter2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_internalformat, { "internalformat", "x11.glx.render.ConvolutionFilter2D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_width, { "width", "x11.glx.render.ConvolutionFilter2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_height, { "height", "x11.glx.render.ConvolutionFilter2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_format, { "format", "x11.glx.render.ConvolutionFilter2D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_type, { "type", "x11.glx.render.ConvolutionFilter2D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_image, { "image", "x11.glx.render.ConvolutionFilter2D.image", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_swapbytes, { "swap bytes", "x11.glx.render.ConvolutionFilter2D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_lsbfirst, { "lsb first", "x11.glx.render.ConvolutionFilter2D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_rowlength, { "row length", "x11.glx.render.ConvolutionFilter2D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_skiprows, { "skip rows", "x11.glx.render.ConvolutionFilter2D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_skippixels, { "skip pixels", "x11.glx.render.ConvolutionFilter2D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionFilter2D_alignment, { "alignment", "x11.glx.render.ConvolutionFilter2D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterf_target, { "target", "x11.glx.render.ConvolutionParameterf.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterf_pname, { "pname", "x11.glx.render.ConvolutionParameterf.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterf_params, { "params", "x11.glx.render.ConvolutionParameterf.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterfv_target, { "target", "x11.glx.render.ConvolutionParameterfv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterfv_pname, { "pname", "x11.glx.render.ConvolutionParameterfv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterfv_params, { "params", "x11.glx.render.ConvolutionParameterfv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameterfv_params_item, { "params", "x11.glx.render.ConvolutionParameterfv.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteri_target, { "target", "x11.glx.render.ConvolutionParameteri.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteri_pname, { "pname", "x11.glx.render.ConvolutionParameteri.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteri_params, { "params", "x11.glx.render.ConvolutionParameteri.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteriv_target, { "target", "x11.glx.render.ConvolutionParameteriv.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteriv_pname, { "pname", "x11.glx.render.ConvolutionParameteriv.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteriv_params, { "params", "x11.glx.render.ConvolutionParameteriv.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ConvolutionParameteriv_params_item, { "params", "x11.glx.render.ConvolutionParameteriv.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter1D_target, { "target", "x11.glx.render.CopyConvolutionFilter1D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter1D_internalformat, { "internalformat", "x11.glx.render.CopyConvolutionFilter1D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter1D_x, { "x", "x11.glx.render.CopyConvolutionFilter1D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter1D_y, { "y", "x11.glx.render.CopyConvolutionFilter1D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter1D_width, { "width", "x11.glx.render.CopyConvolutionFilter1D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter2D_target, { "target", "x11.glx.render.CopyConvolutionFilter2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter2D_internalformat, { "internalformat", "x11.glx.render.CopyConvolutionFilter2D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter2D_x, { "x", "x11.glx.render.CopyConvolutionFilter2D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter2D_y, { "y", "x11.glx.render.CopyConvolutionFilter2D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter2D_width, { "width", "x11.glx.render.CopyConvolutionFilter2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyConvolutionFilter2D_height, { "height", "x11.glx.render.CopyConvolutionFilter2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_target, { "target", "x11.glx.render.SeparableFilter2D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_internalformat, { "internalformat", "x11.glx.render.SeparableFilter2D.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_width, { "width", "x11.glx.render.SeparableFilter2D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_height, { "height", "x11.glx.render.SeparableFilter2D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_format, { "format", "x11.glx.render.SeparableFilter2D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_type, { "type", "x11.glx.render.SeparableFilter2D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_row, { "row", "x11.glx.render.SeparableFilter2D.row", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SeparableFilter2D_column, { "column", "x11.glx.render.SeparableFilter2D.column", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Histogram_target, { "target", "x11.glx.render.Histogram.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Histogram_width, { "width", "x11.glx.render.Histogram.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Histogram_internalformat, { "internalformat", "x11.glx.render.Histogram.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Histogram_sink, { "sink", "x11.glx.render.Histogram.sink", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Minmax_target, { "target", "x11.glx.render.Minmax.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Minmax_internalformat, { "internalformat", "x11.glx.render.Minmax.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_Minmax_sink, { "sink", "x11.glx.render.Minmax.sink", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ResetHistogram_target, { "target", "x11.glx.render.ResetHistogram.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ResetMinmax_target, { "target", "x11.glx.render.ResetMinmax.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_target, { "target", "x11.glx.render.TexImage3D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_level, { "level", "x11.glx.render.TexImage3D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_internalformat, { "internalformat", "x11.glx.render.TexImage3D.internalformat", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_width, { "width", "x11.glx.render.TexImage3D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_height, { "height", "x11.glx.render.TexImage3D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_depth, { "depth", "x11.glx.render.TexImage3D.depth", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_border, { "border", "x11.glx.render.TexImage3D.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_format, { "format", "x11.glx.render.TexImage3D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_type, { "type", "x11.glx.render.TexImage3D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_pixels, { "pixels", "x11.glx.render.TexImage3D.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_swapbytes, { "swap bytes", "x11.glx.render.TexImage3D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_lsbfirst, { "lsb first", "x11.glx.render.TexImage3D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_rowlength, { "row length", "x11.glx.render.TexImage3D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_skiprows, { "skip rows", "x11.glx.render.TexImage3D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_skippixels, { "skip pixels", "x11.glx.render.TexImage3D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage3D_alignment, { "alignment", "x11.glx.render.TexImage3D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_target, { "target", "x11.glx.render.TexSubImage3D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_level, { "level", "x11.glx.render.TexSubImage3D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_xoffset, { "xoffset", "x11.glx.render.TexSubImage3D.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_yoffset, { "yoffset", "x11.glx.render.TexSubImage3D.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_zoffset, { "zoffset", "x11.glx.render.TexSubImage3D.zoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_width, { "width", "x11.glx.render.TexSubImage3D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_height, { "height", "x11.glx.render.TexSubImage3D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_depth, { "depth", "x11.glx.render.TexSubImage3D.depth", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_format, { "format", "x11.glx.render.TexSubImage3D.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_type, { "type", "x11.glx.render.TexSubImage3D.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_UNUSED, { "UNUSED", "x11.glx.render.TexSubImage3D.UNUSED", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_pixels, { "pixels", "x11.glx.render.TexSubImage3D.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_swapbytes, { "swap bytes", "x11.glx.render.TexSubImage3D.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_lsbfirst, { "lsb first", "x11.glx.render.TexSubImage3D.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_rowlength, { "row length", "x11.glx.render.TexSubImage3D.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_skiprows, { "skip rows", "x11.glx.render.TexSubImage3D.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_skippixels, { "skip pixels", "x11.glx.render.TexSubImage3D.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage3D_alignment, { "alignment", "x11.glx.render.TexSubImage3D.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_target, { "target", "x11.glx.render.CopyTexSubImage3D.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_level, { "level", "x11.glx.render.CopyTexSubImage3D.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_xoffset, { "xoffset", "x11.glx.render.CopyTexSubImage3D.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_yoffset, { "yoffset", "x11.glx.render.CopyTexSubImage3D.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_zoffset, { "zoffset", "x11.glx.render.CopyTexSubImage3D.zoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_x, { "x", "x11.glx.render.CopyTexSubImage3D.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_y, { "y", "x11.glx.render.CopyTexSubImage3D.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_width, { "width", "x11.glx.render.CopyTexSubImage3D.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CopyTexSubImage3D_height, { "height", "x11.glx.render.CopyTexSubImage3D.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ActiveTextureARB_texture, { "texture", "x11.glx.render.ActiveTextureARB.texture", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1dvARB_target, { "target", "x11.glx.render.MultiTexCoord1dvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1dvARB_v, { "v", "x11.glx.render.MultiTexCoord1dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1dvARB_v_item, { "v", "x11.glx.render.MultiTexCoord1dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1fvARB_target, { "target", "x11.glx.render.MultiTexCoord1fvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1fvARB_v, { "v", "x11.glx.render.MultiTexCoord1fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1fvARB_v_item, { "v", "x11.glx.render.MultiTexCoord1fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1ivARB_target, { "target", "x11.glx.render.MultiTexCoord1ivARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1ivARB_v, { "v", "x11.glx.render.MultiTexCoord1ivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1ivARB_v_item, { "v", "x11.glx.render.MultiTexCoord1ivARB.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1svARB_target, { "target", "x11.glx.render.MultiTexCoord1svARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1svARB_v, { "v", "x11.glx.render.MultiTexCoord1svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord1svARB_v_item, { "v", "x11.glx.render.MultiTexCoord1svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2dvARB_target, { "target", "x11.glx.render.MultiTexCoord2dvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2dvARB_v, { "v", "x11.glx.render.MultiTexCoord2dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2dvARB_v_item, { "v", "x11.glx.render.MultiTexCoord2dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2fvARB_target, { "target", "x11.glx.render.MultiTexCoord2fvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2fvARB_v, { "v", "x11.glx.render.MultiTexCoord2fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2fvARB_v_item, { "v", "x11.glx.render.MultiTexCoord2fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2ivARB_target, { "target", "x11.glx.render.MultiTexCoord2ivARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2ivARB_v, { "v", "x11.glx.render.MultiTexCoord2ivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2ivARB_v_item, { "v", "x11.glx.render.MultiTexCoord2ivARB.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2svARB_target, { "target", "x11.glx.render.MultiTexCoord2svARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2svARB_v, { "v", "x11.glx.render.MultiTexCoord2svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord2svARB_v_item, { "v", "x11.glx.render.MultiTexCoord2svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3dvARB_target, { "target", "x11.glx.render.MultiTexCoord3dvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3dvARB_v, { "v", "x11.glx.render.MultiTexCoord3dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3dvARB_v_item, { "v", "x11.glx.render.MultiTexCoord3dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3fvARB_target, { "target", "x11.glx.render.MultiTexCoord3fvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3fvARB_v, { "v", "x11.glx.render.MultiTexCoord3fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3fvARB_v_item, { "v", "x11.glx.render.MultiTexCoord3fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3ivARB_target, { "target", "x11.glx.render.MultiTexCoord3ivARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3ivARB_v, { "v", "x11.glx.render.MultiTexCoord3ivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3ivARB_v_item, { "v", "x11.glx.render.MultiTexCoord3ivARB.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3svARB_target, { "target", "x11.glx.render.MultiTexCoord3svARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3svARB_v, { "v", "x11.glx.render.MultiTexCoord3svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord3svARB_v_item, { "v", "x11.glx.render.MultiTexCoord3svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4dvARB_target, { "target", "x11.glx.render.MultiTexCoord4dvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4dvARB_v, { "v", "x11.glx.render.MultiTexCoord4dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4dvARB_v_item, { "v", "x11.glx.render.MultiTexCoord4dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4fvARB_target, { "target", "x11.glx.render.MultiTexCoord4fvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4fvARB_v, { "v", "x11.glx.render.MultiTexCoord4fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4fvARB_v_item, { "v", "x11.glx.render.MultiTexCoord4fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4ivARB_target, { "target", "x11.glx.render.MultiTexCoord4ivARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4ivARB_v, { "v", "x11.glx.render.MultiTexCoord4ivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4ivARB_v_item, { "v", "x11.glx.render.MultiTexCoord4ivARB.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4svARB_target, { "target", "x11.glx.render.MultiTexCoord4svARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4svARB_v, { "v", "x11.glx.render.MultiTexCoord4svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MultiTexCoord4svARB_v_item, { "v", "x11.glx.render.MultiTexCoord4svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SampleCoverageARB_value, { "value", "x11.glx.render.SampleCoverageARB.value", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SampleCoverageARB_invert, { "invert", "x11.glx.render.SampleCoverageARB.invert", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_target, { "target", "x11.glx.render.CompressedTexImage3DARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_level, { "level", "x11.glx.render.CompressedTexImage3DARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_internalformat, { "internalformat", "x11.glx.render.CompressedTexImage3DARB.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_width, { "width", "x11.glx.render.CompressedTexImage3DARB.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_height, { "height", "x11.glx.render.CompressedTexImage3DARB.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_depth, { "depth", "x11.glx.render.CompressedTexImage3DARB.depth", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_border, { "border", "x11.glx.render.CompressedTexImage3DARB.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_imageSize, { "imageSize", "x11.glx.render.CompressedTexImage3DARB.imageSize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage3DARB_data, { "data", "x11.glx.render.CompressedTexImage3DARB.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_target, { "target", "x11.glx.render.CompressedTexImage2DARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_level, { "level", "x11.glx.render.CompressedTexImage2DARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_internalformat, { "internalformat", "x11.glx.render.CompressedTexImage2DARB.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_width, { "width", "x11.glx.render.CompressedTexImage2DARB.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_height, { "height", "x11.glx.render.CompressedTexImage2DARB.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_border, { "border", "x11.glx.render.CompressedTexImage2DARB.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_imageSize, { "imageSize", "x11.glx.render.CompressedTexImage2DARB.imageSize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage2DARB_data, { "data", "x11.glx.render.CompressedTexImage2DARB.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_target, { "target", "x11.glx.render.CompressedTexImage1DARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_level, { "level", "x11.glx.render.CompressedTexImage1DARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_internalformat, { "internalformat", "x11.glx.render.CompressedTexImage1DARB.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_width, { "width", "x11.glx.render.CompressedTexImage1DARB.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_border, { "border", "x11.glx.render.CompressedTexImage1DARB.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_imageSize, { "imageSize", "x11.glx.render.CompressedTexImage1DARB.imageSize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexImage1DARB_data, { "data", "x11.glx.render.CompressedTexImage1DARB.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_target, { "target", "x11.glx.render.CompressedTexSubImage3DARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_level, { "level", "x11.glx.render.CompressedTexSubImage3DARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_xoffset, { "xoffset", "x11.glx.render.CompressedTexSubImage3DARB.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_yoffset, { "yoffset", "x11.glx.render.CompressedTexSubImage3DARB.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_zoffset, { "zoffset", "x11.glx.render.CompressedTexSubImage3DARB.zoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_width, { "width", "x11.glx.render.CompressedTexSubImage3DARB.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_height, { "height", "x11.glx.render.CompressedTexSubImage3DARB.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_depth, { "depth", "x11.glx.render.CompressedTexSubImage3DARB.depth", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_format, { "format", "x11.glx.render.CompressedTexSubImage3DARB.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_imageSize, { "imageSize", "x11.glx.render.CompressedTexSubImage3DARB.imageSize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage3DARB_data, { "data", "x11.glx.render.CompressedTexSubImage3DARB.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_target, { "target", "x11.glx.render.CompressedTexSubImage2DARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_level, { "level", "x11.glx.render.CompressedTexSubImage2DARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_xoffset, { "xoffset", "x11.glx.render.CompressedTexSubImage2DARB.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_yoffset, { "yoffset", "x11.glx.render.CompressedTexSubImage2DARB.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_width, { "width", "x11.glx.render.CompressedTexSubImage2DARB.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_height, { "height", "x11.glx.render.CompressedTexSubImage2DARB.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_format, { "format", "x11.glx.render.CompressedTexSubImage2DARB.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_imageSize, { "imageSize", "x11.glx.render.CompressedTexSubImage2DARB.imageSize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage2DARB_data, { "data", "x11.glx.render.CompressedTexSubImage2DARB.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_target, { "target", "x11.glx.render.CompressedTexSubImage1DARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_level, { "level", "x11.glx.render.CompressedTexSubImage1DARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_xoffset, { "xoffset", "x11.glx.render.CompressedTexSubImage1DARB.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_width, { "width", "x11.glx.render.CompressedTexSubImage1DARB.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_format, { "format", "x11.glx.render.CompressedTexSubImage1DARB.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_imageSize, { "imageSize", "x11.glx.render.CompressedTexSubImage1DARB.imageSize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CompressedTexSubImage1DARB_data, { "data", "x11.glx.render.CompressedTexSubImage1DARB.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CurrentPaletteMatrixARB_index, { "index", "x11.glx.render.CurrentPaletteMatrixARB.index", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexubvARB_size, { "size", "x11.glx.render.MatrixIndexubvARB.size", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexubvARB_indices, { "indices", "x11.glx.render.MatrixIndexubvARB.indices", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexusvARB_size, { "size", "x11.glx.render.MatrixIndexusvARB.size", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexusvARB_indices, { "indices", "x11.glx.render.MatrixIndexusvARB.indices", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexusvARB_indices_item, { "indices", "x11.glx.render.MatrixIndexusvARB.indices", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexuivARB_size, { "size", "x11.glx.render.MatrixIndexuivARB.size", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexuivARB_indices, { "indices", "x11.glx.render.MatrixIndexuivARB.indices", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_MatrixIndexuivARB_indices_item, { "indices", "x11.glx.render.MatrixIndexuivARB.indices", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1dvARB_index, { "index", "x11.glx.render.VertexAttrib1dvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1dvARB_v, { "v", "x11.glx.render.VertexAttrib1dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1dvARB_v_item, { "v", "x11.glx.render.VertexAttrib1dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1fvARB_index, { "index", "x11.glx.render.VertexAttrib1fvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1fvARB_v, { "v", "x11.glx.render.VertexAttrib1fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1fvARB_v_item, { "v", "x11.glx.render.VertexAttrib1fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1svARB_index, { "index", "x11.glx.render.VertexAttrib1svARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1svARB_v, { "v", "x11.glx.render.VertexAttrib1svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1svARB_v_item, { "v", "x11.glx.render.VertexAttrib1svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2dvARB_index, { "index", "x11.glx.render.VertexAttrib2dvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2dvARB_v, { "v", "x11.glx.render.VertexAttrib2dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2dvARB_v_item, { "v", "x11.glx.render.VertexAttrib2dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2fvARB_index, { "index", "x11.glx.render.VertexAttrib2fvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2fvARB_v, { "v", "x11.glx.render.VertexAttrib2fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2fvARB_v_item, { "v", "x11.glx.render.VertexAttrib2fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2svARB_index, { "index", "x11.glx.render.VertexAttrib2svARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2svARB_v, { "v", "x11.glx.render.VertexAttrib2svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2svARB_v_item, { "v", "x11.glx.render.VertexAttrib2svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3dvARB_index, { "index", "x11.glx.render.VertexAttrib3dvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3dvARB_v, { "v", "x11.glx.render.VertexAttrib3dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3dvARB_v_item, { "v", "x11.glx.render.VertexAttrib3dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3fvARB_index, { "index", "x11.glx.render.VertexAttrib3fvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3fvARB_v, { "v", "x11.glx.render.VertexAttrib3fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3fvARB_v_item, { "v", "x11.glx.render.VertexAttrib3fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3svARB_index, { "index", "x11.glx.render.VertexAttrib3svARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3svARB_v, { "v", "x11.glx.render.VertexAttrib3svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3svARB_v_item, { "v", "x11.glx.render.VertexAttrib3svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4dvARB_index, { "index", "x11.glx.render.VertexAttrib4dvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4dvARB_v, { "v", "x11.glx.render.VertexAttrib4dvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4dvARB_v_item, { "v", "x11.glx.render.VertexAttrib4dvARB.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4fvARB_index, { "index", "x11.glx.render.VertexAttrib4fvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4fvARB_v, { "v", "x11.glx.render.VertexAttrib4fvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4fvARB_v_item, { "v", "x11.glx.render.VertexAttrib4fvARB.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4svARB_index, { "index", "x11.glx.render.VertexAttrib4svARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4svARB_v, { "v", "x11.glx.render.VertexAttrib4svARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4svARB_v_item, { "v", "x11.glx.render.VertexAttrib4svARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NubvARB_index, { "index", "x11.glx.render.VertexAttrib4NubvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NubvARB_v, { "v", "x11.glx.render.VertexAttrib4NubvARB.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4bvARB_index, { "index", "x11.glx.render.VertexAttrib4bvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4bvARB_v, { "v", "x11.glx.render.VertexAttrib4bvARB.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ivARB_index, { "index", "x11.glx.render.VertexAttrib4ivARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ivARB_v, { "v", "x11.glx.render.VertexAttrib4ivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ivARB_v_item, { "v", "x11.glx.render.VertexAttrib4ivARB.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ubvARB_index, { "index", "x11.glx.render.VertexAttrib4ubvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ubvARB_v, { "v", "x11.glx.render.VertexAttrib4ubvARB.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4usvARB_index, { "index", "x11.glx.render.VertexAttrib4usvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4usvARB_v, { "v", "x11.glx.render.VertexAttrib4usvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4usvARB_v_item, { "v", "x11.glx.render.VertexAttrib4usvARB.v", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4uivARB_index, { "index", "x11.glx.render.VertexAttrib4uivARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4uivARB_v, { "v", "x11.glx.render.VertexAttrib4uivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4uivARB_v_item, { "v", "x11.glx.render.VertexAttrib4uivARB.v", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NbvARB_index, { "index", "x11.glx.render.VertexAttrib4NbvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NbvARB_v, { "v", "x11.glx.render.VertexAttrib4NbvARB.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NsvARB_index, { "index", "x11.glx.render.VertexAttrib4NsvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NsvARB_v, { "v", "x11.glx.render.VertexAttrib4NsvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NsvARB_v_item, { "v", "x11.glx.render.VertexAttrib4NsvARB.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NivARB_index, { "index", "x11.glx.render.VertexAttrib4NivARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NivARB_v, { "v", "x11.glx.render.VertexAttrib4NivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NivARB_v_item, { "v", "x11.glx.render.VertexAttrib4NivARB.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NusvARB_index, { "index", "x11.glx.render.VertexAttrib4NusvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NusvARB_v, { "v", "x11.glx.render.VertexAttrib4NusvARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NusvARB_v_item, { "v", "x11.glx.render.VertexAttrib4NusvARB.v", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NuivARB_index, { "index", "x11.glx.render.VertexAttrib4NuivARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NuivARB_v, { "v", "x11.glx.render.VertexAttrib4NuivARB.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4NuivARB_v_item, { "v", "x11.glx.render.VertexAttrib4NuivARB.v", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramStringARB_target, { "target", "x11.glx.render.ProgramStringARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramStringARB_format, { "format", "x11.glx.render.ProgramStringARB.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramStringARB_len, { "len", "x11.glx.render.ProgramStringARB.len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramStringARB_string, { "string", "x11.glx.render.ProgramStringARB.string", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4dvARB_target, { "target", "x11.glx.render.ProgramEnvParameter4dvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4dvARB_index, { "index", "x11.glx.render.ProgramEnvParameter4dvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4dvARB_params, { "params", "x11.glx.render.ProgramEnvParameter4dvARB.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4dvARB_params_item, { "params", "x11.glx.render.ProgramEnvParameter4dvARB.params", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4fvARB_target, { "target", "x11.glx.render.ProgramEnvParameter4fvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4fvARB_index, { "index", "x11.glx.render.ProgramEnvParameter4fvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4fvARB_params, { "params", "x11.glx.render.ProgramEnvParameter4fvARB.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramEnvParameter4fvARB_params_item, { "params", "x11.glx.render.ProgramEnvParameter4fvARB.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4dvARB_target, { "target", "x11.glx.render.ProgramLocalParameter4dvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4dvARB_index, { "index", "x11.glx.render.ProgramLocalParameter4dvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4dvARB_params, { "params", "x11.glx.render.ProgramLocalParameter4dvARB.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4dvARB_params_item, { "params", "x11.glx.render.ProgramLocalParameter4dvARB.params", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4fvARB_target, { "target", "x11.glx.render.ProgramLocalParameter4fvARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4fvARB_index, { "index", "x11.glx.render.ProgramLocalParameter4fvARB.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4fvARB_params, { "params", "x11.glx.render.ProgramLocalParameter4fvARB.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramLocalParameter4fvARB_params_item, { "params", "x11.glx.render.ProgramLocalParameter4fvARB.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BeginQueryARB_target, { "target", "x11.glx.render.BeginQueryARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BeginQueryARB_id, { "id", "x11.glx.render.BeginQueryARB.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_EndQueryARB_target, { "target", "x11.glx.render.EndQueryARB.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawBuffersARB_n, { "n", "x11.glx.render.DrawBuffersARB.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawBuffersARB_bufs, { "bufs", "x11.glx.render.DrawBuffersARB.bufs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DrawBuffersARB_bufs_item, { "bufs", "x11.glx.render.DrawBuffersARB.bufs", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonOffsetEXT_factor, { "factor", "x11.glx.render.PolygonOffsetEXT.factor", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PolygonOffsetEXT_bias, { "bias", "x11.glx.render.PolygonOffsetEXT.bias", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexFilterFuncSGIS_target, { "target", "x11.glx.render.TexFilterFuncSGIS.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexFilterFuncSGIS_filter, { "filter", "x11.glx.render.TexFilterFuncSGIS.filter", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexFilterFuncSGIS_n, { "n", "x11.glx.render.TexFilterFuncSGIS.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexFilterFuncSGIS_weights, { "weights", "x11.glx.render.TexFilterFuncSGIS.weights", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexFilterFuncSGIS_weights_item, { "weights", "x11.glx.render.TexFilterFuncSGIS.weights", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_target, { "target", "x11.glx.render.TexImage4DSGIS.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_level, { "level", "x11.glx.render.TexImage4DSGIS.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_internalformat, { "internalformat", "x11.glx.render.TexImage4DSGIS.internalformat", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_width, { "width", "x11.glx.render.TexImage4DSGIS.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_height, { "height", "x11.glx.render.TexImage4DSGIS.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_depth, { "depth", "x11.glx.render.TexImage4DSGIS.depth", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_size4d, { "size4d", "x11.glx.render.TexImage4DSGIS.size4d", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_border, { "border", "x11.glx.render.TexImage4DSGIS.border", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_format, { "format", "x11.glx.render.TexImage4DSGIS.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_type, { "type", "x11.glx.render.TexImage4DSGIS.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_pixels, { "pixels", "x11.glx.render.TexImage4DSGIS.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_swapbytes, { "swap bytes", "x11.glx.render.TexImage4DSGIS.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_lsbfirst, { "lsb first", "x11.glx.render.TexImage4DSGIS.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_rowlength, { "row length", "x11.glx.render.TexImage4DSGIS.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_skiprows, { "skip rows", "x11.glx.render.TexImage4DSGIS.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_skippixels, { "skip pixels", "x11.glx.render.TexImage4DSGIS.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexImage4DSGIS_alignment, { "alignment", "x11.glx.render.TexImage4DSGIS.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_target, { "target", "x11.glx.render.TexSubImage4DSGIS.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_level, { "level", "x11.glx.render.TexSubImage4DSGIS.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_xoffset, { "xoffset", "x11.glx.render.TexSubImage4DSGIS.xoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_yoffset, { "yoffset", "x11.glx.render.TexSubImage4DSGIS.yoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_zoffset, { "zoffset", "x11.glx.render.TexSubImage4DSGIS.zoffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_woffset, { "woffset", "x11.glx.render.TexSubImage4DSGIS.woffset", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_width, { "width", "x11.glx.render.TexSubImage4DSGIS.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_height, { "height", "x11.glx.render.TexSubImage4DSGIS.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_depth, { "depth", "x11.glx.render.TexSubImage4DSGIS.depth", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_size4d, { "size4d", "x11.glx.render.TexSubImage4DSGIS.size4d", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_format, { "format", "x11.glx.render.TexSubImage4DSGIS.format", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_type, { "type", "x11.glx.render.TexSubImage4DSGIS.type", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_UNUSED, { "UNUSED", "x11.glx.render.TexSubImage4DSGIS.UNUSED", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_pixels, { "pixels", "x11.glx.render.TexSubImage4DSGIS.pixels", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_swapbytes, { "swap bytes", "x11.glx.render.TexSubImage4DSGIS.swapbytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_lsbfirst, { "lsb first", "x11.glx.render.TexSubImage4DSGIS.lsbfirst", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_rowlength, { "row length", "x11.glx.render.TexSubImage4DSGIS.rowlength", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_skiprows, { "skip rows", "x11.glx.render.TexSubImage4DSGIS.skiprows", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_skippixels, { "skip pixels", "x11.glx.render.TexSubImage4DSGIS.skippixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TexSubImage4DSGIS_alignment, { "alignment", "x11.glx.render.TexSubImage4DSGIS.alignment", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DetailTexFuncSGIS_target, { "target", "x11.glx.render.DetailTexFuncSGIS.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DetailTexFuncSGIS_n, { "n", "x11.glx.render.DetailTexFuncSGIS.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DetailTexFuncSGIS_points, { "points", "x11.glx.render.DetailTexFuncSGIS.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DetailTexFuncSGIS_points_item, { "points", "x11.glx.render.DetailTexFuncSGIS.points", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SharpenTexFuncSGIS_target, { "target", "x11.glx.render.SharpenTexFuncSGIS.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SharpenTexFuncSGIS_n, { "n", "x11.glx.render.SharpenTexFuncSGIS.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SharpenTexFuncSGIS_points, { "points", "x11.glx.render.SharpenTexFuncSGIS.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SharpenTexFuncSGIS_points_item, { "points", "x11.glx.render.SharpenTexFuncSGIS.points", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SampleMaskSGIS_value, { "value", "x11.glx.render.SampleMaskSGIS.value", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SampleMaskSGIS_invert, { "invert", "x11.glx.render.SampleMaskSGIS.invert", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SamplePatternSGIS_pattern, { "pattern", "x11.glx.render.SamplePatternSGIS.pattern", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterfEXT_pname, { "pname", "x11.glx.render.PointParameterfEXT.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterfEXT_param, { "param", "x11.glx.render.PointParameterfEXT.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterfvEXT_pname, { "pname", "x11.glx.render.PointParameterfvEXT.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterfvEXT_params, { "params", "x11.glx.render.PointParameterfvEXT.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterfvEXT_params_item, { "params", "x11.glx.render.PointParameterfvEXT.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FrameZoomSGIX_factor, { "factor", "x11.glx.render.FrameZoomSGIX.factor", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ReferencePlaneSGIX_equation, { "equation", "x11.glx.render.ReferencePlaneSGIX.equation", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ReferencePlaneSGIX_equation_item, { "equation", "x11.glx.render.ReferencePlaneSGIX.equation", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogFuncSGIS_n, { "n", "x11.glx.render.FogFuncSGIS.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogFuncSGIS_points, { "points", "x11.glx.render.FogFuncSGIS.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogFuncSGIS_points_item, { "points", "x11.glx.render.FogFuncSGIS.points", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3bvEXT_v, { "v", "x11.glx.render.SecondaryColor3bvEXT.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3dvEXT_v, { "v", "x11.glx.render.SecondaryColor3dvEXT.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3dvEXT_v_item, { "v", "x11.glx.render.SecondaryColor3dvEXT.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3fvEXT_v, { "v", "x11.glx.render.SecondaryColor3fvEXT.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3fvEXT_v_item, { "v", "x11.glx.render.SecondaryColor3fvEXT.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3ivEXT_v, { "v", "x11.glx.render.SecondaryColor3ivEXT.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3ivEXT_v_item, { "v", "x11.glx.render.SecondaryColor3ivEXT.v", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3svEXT_v, { "v", "x11.glx.render.SecondaryColor3svEXT.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3svEXT_v_item, { "v", "x11.glx.render.SecondaryColor3svEXT.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3ubvEXT_v, { "v", "x11.glx.render.SecondaryColor3ubvEXT.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3uivEXT_v, { "v", "x11.glx.render.SecondaryColor3uivEXT.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3uivEXT_v_item, { "v", "x11.glx.render.SecondaryColor3uivEXT.v", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3usvEXT_v, { "v", "x11.glx.render.SecondaryColor3usvEXT.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_SecondaryColor3usvEXT_v_item, { "v", "x11.glx.render.SecondaryColor3usvEXT.v", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogCoordfvEXT_coord, { "coord", "x11.glx.render.FogCoordfvEXT.coord", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogCoordfvEXT_coord_item, { "coord", "x11.glx.render.FogCoordfvEXT.coord", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogCoorddvEXT_coord, { "coord", "x11.glx.render.FogCoorddvEXT.coord", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FogCoorddvEXT_coord_item, { "coord", "x11.glx.render.FogCoorddvEXT.coord", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PixelTexGenSGIX_mode, { "mode", "x11.glx.render.PixelTexGenSGIX.mode", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendFuncSeparateEXT_sfactorRGB, { "sfactorRGB", "x11.glx.render.BlendFuncSeparateEXT.sfactorRGB", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendFuncSeparateEXT_dfactorRGB, { "dfactorRGB", "x11.glx.render.BlendFuncSeparateEXT.dfactorRGB", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendFuncSeparateEXT_sfactorAlpha, { "sfactorAlpha", "x11.glx.render.BlendFuncSeparateEXT.sfactorAlpha", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendFuncSeparateEXT_dfactorAlpha, { "dfactorAlpha", "x11.glx.render.BlendFuncSeparateEXT.dfactorAlpha", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexWeightfvEXT_weight, { "weight", "x11.glx.render.VertexWeightfvEXT.weight", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexWeightfvEXT_weight_item, { "weight", "x11.glx.render.VertexWeightfvEXT.weight", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterfvNV_pname, { "pname", "x11.glx.render.CombinerParameterfvNV.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterfvNV_params, { "params", "x11.glx.render.CombinerParameterfvNV.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterfvNV_params_item, { "params", "x11.glx.render.CombinerParameterfvNV.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterfNV_pname, { "pname", "x11.glx.render.CombinerParameterfNV.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterfNV_param, { "param", "x11.glx.render.CombinerParameterfNV.param", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterivNV_pname, { "pname", "x11.glx.render.CombinerParameterivNV.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterivNV_params, { "params", "x11.glx.render.CombinerParameterivNV.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameterivNV_params_item, { "params", "x11.glx.render.CombinerParameterivNV.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameteriNV_pname, { "pname", "x11.glx.render.CombinerParameteriNV.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerParameteriNV_param, { "param", "x11.glx.render.CombinerParameteriNV.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerInputNV_stage, { "stage", "x11.glx.render.CombinerInputNV.stage", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerInputNV_portion, { "portion", "x11.glx.render.CombinerInputNV.portion", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerInputNV_variable, { "variable", "x11.glx.render.CombinerInputNV.variable", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerInputNV_input, { "input", "x11.glx.render.CombinerInputNV.input", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerInputNV_mapping, { "mapping", "x11.glx.render.CombinerInputNV.mapping", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerInputNV_componentUsage, { "componentUsage", "x11.glx.render.CombinerInputNV.componentUsage", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_stage, { "stage", "x11.glx.render.CombinerOutputNV.stage", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_portion, { "portion", "x11.glx.render.CombinerOutputNV.portion", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_abOutput, { "abOutput", "x11.glx.render.CombinerOutputNV.abOutput", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_cdOutput, { "cdOutput", "x11.glx.render.CombinerOutputNV.cdOutput", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_sumOutput, { "sumOutput", "x11.glx.render.CombinerOutputNV.sumOutput", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_scale, { "scale", "x11.glx.render.CombinerOutputNV.scale", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_bias, { "bias", "x11.glx.render.CombinerOutputNV.bias", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_abDotProduct, { "abDotProduct", "x11.glx.render.CombinerOutputNV.abDotProduct", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_cdDotProduct, { "cdDotProduct", "x11.glx.render.CombinerOutputNV.cdDotProduct", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_CombinerOutputNV_muxSum, { "muxSum", "x11.glx.render.CombinerOutputNV.muxSum", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FinalCombinerInputNV_variable, { "variable", "x11.glx.render.FinalCombinerInputNV.variable", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FinalCombinerInputNV_input, { "input", "x11.glx.render.FinalCombinerInputNV.input", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FinalCombinerInputNV_mapping, { "mapping", "x11.glx.render.FinalCombinerInputNV.mapping", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_FinalCombinerInputNV_componentUsage, { "componentUsage", "x11.glx.render.FinalCombinerInputNV.componentUsage", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_WindowPos3fvMESA_v, { "v", "x11.glx.render.WindowPos3fvMESA.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_WindowPos3fvMESA_v_item, { "v", "x11.glx.render.WindowPos3fvMESA.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TextureColorMaskSGIS_red, { "red", "x11.glx.render.TextureColorMaskSGIS.red", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TextureColorMaskSGIS_green, { "green", "x11.glx.render.TextureColorMaskSGIS.green", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TextureColorMaskSGIS_blue, { "blue", "x11.glx.render.TextureColorMaskSGIS.blue", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TextureColorMaskSGIS_alpha, { "alpha", "x11.glx.render.TextureColorMaskSGIS.alpha", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BindProgramNV_target, { "target", "x11.glx.render.BindProgramNV.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BindProgramNV_program, { "program", "x11.glx.render.BindProgramNV.program", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ExecuteProgramNV_target, { "target", "x11.glx.render.ExecuteProgramNV.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ExecuteProgramNV_id, { "id", "x11.glx.render.ExecuteProgramNV.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ExecuteProgramNV_params, { "params", "x11.glx.render.ExecuteProgramNV.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ExecuteProgramNV_params_item, { "params", "x11.glx.render.ExecuteProgramNV.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadProgramNV_target, { "target", "x11.glx.render.LoadProgramNV.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadProgramNV_id, { "id", "x11.glx.render.LoadProgramNV.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadProgramNV_len, { "len", "x11.glx.render.LoadProgramNV.len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_LoadProgramNV_program, { "program", "x11.glx.render.LoadProgramNV.program", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4dvNV_target, { "target", "x11.glx.render.ProgramParameters4dvNV.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4dvNV_index, { "index", "x11.glx.render.ProgramParameters4dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4dvNV_num, { "num", "x11.glx.render.ProgramParameters4dvNV.num", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4dvNV_params, { "params", "x11.glx.render.ProgramParameters4dvNV.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4dvNV_params_item, { "params", "x11.glx.render.ProgramParameters4dvNV.params", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4fvNV_target, { "target", "x11.glx.render.ProgramParameters4fvNV.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4fvNV_index, { "index", "x11.glx.render.ProgramParameters4fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4fvNV_num, { "num", "x11.glx.render.ProgramParameters4fvNV.num", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4fvNV_params, { "params", "x11.glx.render.ProgramParameters4fvNV.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramParameters4fvNV_params_item, { "params", "x11.glx.render.ProgramParameters4fvNV.params", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RequestResidentProgramsNV_n, { "n", "x11.glx.render.RequestResidentProgramsNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RequestResidentProgramsNV_ids, { "ids", "x11.glx.render.RequestResidentProgramsNV.ids", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_RequestResidentProgramsNV_ids_item, { "ids", "x11.glx.render.RequestResidentProgramsNV.ids", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TrackMatrixNV_target, { "target", "x11.glx.render.TrackMatrixNV.target", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TrackMatrixNV_address, { "address", "x11.glx.render.TrackMatrixNV.address", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TrackMatrixNV_matrix, { "matrix", "x11.glx.render.TrackMatrixNV.matrix", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_TrackMatrixNV_transform, { "transform", "x11.glx.render.TrackMatrixNV.transform", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1svNV_index, { "index", "x11.glx.render.VertexAttrib1svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1svNV_v, { "v", "x11.glx.render.VertexAttrib1svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1svNV_v_item, { "v", "x11.glx.render.VertexAttrib1svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2svNV_index, { "index", "x11.glx.render.VertexAttrib2svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2svNV_v, { "v", "x11.glx.render.VertexAttrib2svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2svNV_v_item, { "v", "x11.glx.render.VertexAttrib2svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3svNV_index, { "index", "x11.glx.render.VertexAttrib3svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3svNV_v, { "v", "x11.glx.render.VertexAttrib3svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3svNV_v_item, { "v", "x11.glx.render.VertexAttrib3svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4svNV_index, { "index", "x11.glx.render.VertexAttrib4svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4svNV_v, { "v", "x11.glx.render.VertexAttrib4svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4svNV_v_item, { "v", "x11.glx.render.VertexAttrib4svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1fvNV_index, { "index", "x11.glx.render.VertexAttrib1fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1fvNV_v, { "v", "x11.glx.render.VertexAttrib1fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1fvNV_v_item, { "v", "x11.glx.render.VertexAttrib1fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2fvNV_index, { "index", "x11.glx.render.VertexAttrib2fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2fvNV_v, { "v", "x11.glx.render.VertexAttrib2fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2fvNV_v_item, { "v", "x11.glx.render.VertexAttrib2fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3fvNV_index, { "index", "x11.glx.render.VertexAttrib3fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3fvNV_v, { "v", "x11.glx.render.VertexAttrib3fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3fvNV_v_item, { "v", "x11.glx.render.VertexAttrib3fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4fvNV_index, { "index", "x11.glx.render.VertexAttrib4fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4fvNV_v, { "v", "x11.glx.render.VertexAttrib4fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4fvNV_v_item, { "v", "x11.glx.render.VertexAttrib4fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1dvNV_index, { "index", "x11.glx.render.VertexAttrib1dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1dvNV_v, { "v", "x11.glx.render.VertexAttrib1dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib1dvNV_v_item, { "v", "x11.glx.render.VertexAttrib1dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2dvNV_index, { "index", "x11.glx.render.VertexAttrib2dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2dvNV_v, { "v", "x11.glx.render.VertexAttrib2dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib2dvNV_v_item, { "v", "x11.glx.render.VertexAttrib2dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3dvNV_index, { "index", "x11.glx.render.VertexAttrib3dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3dvNV_v, { "v", "x11.glx.render.VertexAttrib3dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib3dvNV_v_item, { "v", "x11.glx.render.VertexAttrib3dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4dvNV_index, { "index", "x11.glx.render.VertexAttrib4dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4dvNV_v, { "v", "x11.glx.render.VertexAttrib4dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4dvNV_v_item, { "v", "x11.glx.render.VertexAttrib4dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ubvNV_index, { "index", "x11.glx.render.VertexAttrib4ubvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttrib4ubvNV_v, { "v", "x11.glx.render.VertexAttrib4ubvNV.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1svNV_index, { "index", "x11.glx.render.VertexAttribs1svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1svNV_n, { "n", "x11.glx.render.VertexAttribs1svNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1svNV_v, { "v", "x11.glx.render.VertexAttribs1svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1svNV_v_item, { "v", "x11.glx.render.VertexAttribs1svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2svNV_index, { "index", "x11.glx.render.VertexAttribs2svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2svNV_n, { "n", "x11.glx.render.VertexAttribs2svNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2svNV_v, { "v", "x11.glx.render.VertexAttribs2svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2svNV_v_item, { "v", "x11.glx.render.VertexAttribs2svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3svNV_index, { "index", "x11.glx.render.VertexAttribs3svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3svNV_n, { "n", "x11.glx.render.VertexAttribs3svNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3svNV_v, { "v", "x11.glx.render.VertexAttribs3svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3svNV_v_item, { "v", "x11.glx.render.VertexAttribs3svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4svNV_index, { "index", "x11.glx.render.VertexAttribs4svNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4svNV_n, { "n", "x11.glx.render.VertexAttribs4svNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4svNV_v, { "v", "x11.glx.render.VertexAttribs4svNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4svNV_v_item, { "v", "x11.glx.render.VertexAttribs4svNV.v", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1fvNV_index, { "index", "x11.glx.render.VertexAttribs1fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1fvNV_n, { "n", "x11.glx.render.VertexAttribs1fvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1fvNV_v, { "v", "x11.glx.render.VertexAttribs1fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1fvNV_v_item, { "v", "x11.glx.render.VertexAttribs1fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2fvNV_index, { "index", "x11.glx.render.VertexAttribs2fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2fvNV_n, { "n", "x11.glx.render.VertexAttribs2fvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2fvNV_v, { "v", "x11.glx.render.VertexAttribs2fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2fvNV_v_item, { "v", "x11.glx.render.VertexAttribs2fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3fvNV_index, { "index", "x11.glx.render.VertexAttribs3fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3fvNV_n, { "n", "x11.glx.render.VertexAttribs3fvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3fvNV_v, { "v", "x11.glx.render.VertexAttribs3fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3fvNV_v_item, { "v", "x11.glx.render.VertexAttribs3fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4fvNV_index, { "index", "x11.glx.render.VertexAttribs4fvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4fvNV_n, { "n", "x11.glx.render.VertexAttribs4fvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4fvNV_v, { "v", "x11.glx.render.VertexAttribs4fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4fvNV_v_item, { "v", "x11.glx.render.VertexAttribs4fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1dvNV_index, { "index", "x11.glx.render.VertexAttribs1dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1dvNV_n, { "n", "x11.glx.render.VertexAttribs1dvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1dvNV_v, { "v", "x11.glx.render.VertexAttribs1dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs1dvNV_v_item, { "v", "x11.glx.render.VertexAttribs1dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2dvNV_index, { "index", "x11.glx.render.VertexAttribs2dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2dvNV_n, { "n", "x11.glx.render.VertexAttribs2dvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2dvNV_v, { "v", "x11.glx.render.VertexAttribs2dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs2dvNV_v_item, { "v", "x11.glx.render.VertexAttribs2dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3dvNV_index, { "index", "x11.glx.render.VertexAttribs3dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3dvNV_n, { "n", "x11.glx.render.VertexAttribs3dvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3dvNV_v, { "v", "x11.glx.render.VertexAttribs3dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs3dvNV_v_item, { "v", "x11.glx.render.VertexAttribs3dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4dvNV_index, { "index", "x11.glx.render.VertexAttribs4dvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4dvNV_n, { "n", "x11.glx.render.VertexAttribs4dvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4dvNV_v, { "v", "x11.glx.render.VertexAttribs4dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4dvNV_v_item, { "v", "x11.glx.render.VertexAttribs4dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4ubvNV_index, { "index", "x11.glx.render.VertexAttribs4ubvNV.index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4ubvNV_n, { "n", "x11.glx.render.VertexAttribs4ubvNV.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_VertexAttribs4ubvNV_v, { "v", "x11.glx.render.VertexAttribs4ubvNV.v", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameteriNV_pname, { "pname", "x11.glx.render.PointParameteriNV.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameteriNV_param, { "param", "x11.glx.render.PointParameteriNV.param", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterivNV_pname, { "pname", "x11.glx.render.PointParameterivNV.pname", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterivNV_params, { "params", "x11.glx.render.PointParameterivNV.params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_PointParameterivNV_params_item, { "params", "x11.glx.render.PointParameterivNV.params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ActiveStencilFaceEXT_face, { "face", "x11.glx.render.ActiveStencilFaceEXT.face", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4fvNV_id, { "id", "x11.glx.render.ProgramNamedParameter4fvNV.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4fvNV_len, { "len", "x11.glx.render.ProgramNamedParameter4fvNV.len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4fvNV_name, { "name", "x11.glx.render.ProgramNamedParameter4fvNV.name", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4fvNV_v, { "v", "x11.glx.render.ProgramNamedParameter4fvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4fvNV_v_item, { "v", "x11.glx.render.ProgramNamedParameter4fvNV.v", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4dvNV_id, { "id", "x11.glx.render.ProgramNamedParameter4dvNV.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4dvNV_len, { "len", "x11.glx.render.ProgramNamedParameter4dvNV.len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4dvNV_name, { "name", "x11.glx.render.ProgramNamedParameter4dvNV.name", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4dvNV_v, { "v", "x11.glx.render.ProgramNamedParameter4dvNV.v", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_ProgramNamedParameter4dvNV_v_item, { "v", "x11.glx.render.ProgramNamedParameter4dvNV.v", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DepthBoundsEXT_zmin, { "zmin", "x11.glx.render.DepthBoundsEXT.zmin", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_DepthBoundsEXT_zmax, { "zmax", "x11.glx.render.DepthBoundsEXT.zmax", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendEquationSeparateEXT_modeRGB, { "modeRGB", "x11.glx.render.BlendEquationSeparateEXT.modeRGB", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_BlendEquationSeparateEXT_modeA, { "modeA", "x11.glx.render.BlendEquationSeparateEXT.modeA", FT_UINT32, BASE_HEX, VALS(mesa_enum), 0, NULL, HFILL }}, +{ &hf_x11_glx_render_op_name, { "render op", "x11.glx.render.op", FT_UINT16, BASE_DEC, VALS(glx_render_op_name), 0, "render op", HFILL }}, + +{ &hf_x11_bigreq_Enable_reply_maximum_request_length, { "maximum_request_length", "x11.bigreq.Enable.reply.maximum_request_length", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_bigreq_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(bigreq_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_RECTANGLE, { "RECTANGLE", "x11.struct.RECTANGLE", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RECTANGLE_x, { "x", "x11.struct.RECTANGLE.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RECTANGLE_y, { "y", "x11.struct.RECTANGLE.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RECTANGLE_width, { "width", "x11.struct.RECTANGLE.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RECTANGLE_height, { "height", "x11.struct.RECTANGLE.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_STR, { "STR", "x11.struct.STR", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_STR_name_len, { "name_len", "x11.struct.STR.name_len", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_STR_name, { "name", "x11.struct.STR.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT, { "DIRECTFORMAT", "x11.struct.DIRECTFORMAT", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_red_shift, { "red_shift", "x11.struct.DIRECTFORMAT.red_shift", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_red_mask, { "red_mask", "x11.struct.DIRECTFORMAT.red_mask", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_green_shift, { "green_shift", "x11.struct.DIRECTFORMAT.green_shift", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_green_mask, { "green_mask", "x11.struct.DIRECTFORMAT.green_mask", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_blue_shift, { "blue_shift", "x11.struct.DIRECTFORMAT.blue_shift", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_blue_mask, { "blue_mask", "x11.struct.DIRECTFORMAT.blue_mask", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_alpha_shift, { "alpha_shift", "x11.struct.DIRECTFORMAT.alpha_shift", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DIRECTFORMAT_alpha_mask, { "alpha_mask", "x11.struct.DIRECTFORMAT.alpha_mask", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTFORMINFO, { "PICTFORMINFO", "x11.struct.PICTFORMINFO", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTFORMINFO_id, { "id", "x11.struct.PICTFORMINFO.id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTFORMINFO_type, { "type", "x11.struct.PICTFORMINFO.type", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTFORMINFO_depth, { "depth", "x11.struct.PICTFORMINFO.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTFORMINFO_direct, { "direct", "x11.struct.PICTFORMINFO.direct", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTFORMINFO_colormap, { "colormap", "x11.struct.PICTFORMINFO.colormap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTVISUAL, { "PICTVISUAL", "x11.struct.PICTVISUAL", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTVISUAL_visual, { "visual", "x11.struct.PICTVISUAL.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTVISUAL_format, { "format", "x11.struct.PICTVISUAL.format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTDEPTH, { "PICTDEPTH", "x11.struct.PICTDEPTH", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTDEPTH_depth, { "depth", "x11.struct.PICTDEPTH.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTDEPTH_num_visuals, { "num_visuals", "x11.struct.PICTDEPTH.num_visuals", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTDEPTH_visuals, { "visuals", "x11.struct.PICTDEPTH.visuals", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTDEPTH_visuals_item, { "visuals", "x11.struct.PICTDEPTH.visuals", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTSCREEN, { "PICTSCREEN", "x11.struct.PICTSCREEN", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTSCREEN_num_depths, { "num_depths", "x11.struct.PICTSCREEN.num_depths", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTSCREEN_fallback, { "fallback", "x11.struct.PICTSCREEN.fallback", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PICTSCREEN_depths, { "depths", "x11.struct.PICTSCREEN.depths", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INDEXVALUE, { "INDEXVALUE", "x11.struct.INDEXVALUE", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INDEXVALUE_pixel, { "pixel", "x11.struct.INDEXVALUE.pixel", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INDEXVALUE_red, { "red", "x11.struct.INDEXVALUE.red", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INDEXVALUE_green, { "green", "x11.struct.INDEXVALUE.green", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INDEXVALUE_blue, { "blue", "x11.struct.INDEXVALUE.blue", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INDEXVALUE_alpha, { "alpha", "x11.struct.INDEXVALUE.alpha", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_COLOR, { "COLOR", "x11.struct.COLOR", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_COLOR_red, { "red", "x11.struct.COLOR.red", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_COLOR_green, { "green", "x11.struct.COLOR.green", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_COLOR_blue, { "blue", "x11.struct.COLOR.blue", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_COLOR_alpha, { "alpha", "x11.struct.COLOR.alpha", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_POINTFIX, { "POINTFIX", "x11.struct.POINTFIX", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_POINTFIX_x, { "x", "x11.struct.POINTFIX.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_POINTFIX_y, { "y", "x11.struct.POINTFIX.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_LINEFIX, { "LINEFIX", "x11.struct.LINEFIX", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_LINEFIX_p1, { "p1", "x11.struct.LINEFIX.p1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_LINEFIX_p2, { "p2", "x11.struct.LINEFIX.p2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIANGLE, { "TRIANGLE", "x11.struct.TRIANGLE", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIANGLE_p1, { "p1", "x11.struct.TRIANGLE.p1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIANGLE_p2, { "p2", "x11.struct.TRIANGLE.p2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIANGLE_p3, { "p3", "x11.struct.TRIANGLE.p3", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAPEZOID, { "TRAPEZOID", "x11.struct.TRAPEZOID", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAPEZOID_top, { "top", "x11.struct.TRAPEZOID.top", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAPEZOID_bottom, { "bottom", "x11.struct.TRAPEZOID.bottom", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAPEZOID_left, { "left", "x11.struct.TRAPEZOID.left", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAPEZOID_right, { "right", "x11.struct.TRAPEZOID.right", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO, { "GLYPHINFO", "x11.struct.GLYPHINFO", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO_width, { "width", "x11.struct.GLYPHINFO.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO_height, { "height", "x11.struct.GLYPHINFO.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO_x, { "x", "x11.struct.GLYPHINFO.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO_y, { "y", "x11.struct.GLYPHINFO.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO_x_off, { "x_off", "x11.struct.GLYPHINFO.x_off", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_GLYPHINFO_y_off, { "y_off", "x11.struct.GLYPHINFO.y_off", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM, { "TRANSFORM", "x11.struct.TRANSFORM", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix11, { "matrix11", "x11.struct.TRANSFORM.matrix11", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix12, { "matrix12", "x11.struct.TRANSFORM.matrix12", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix13, { "matrix13", "x11.struct.TRANSFORM.matrix13", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix21, { "matrix21", "x11.struct.TRANSFORM.matrix21", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix22, { "matrix22", "x11.struct.TRANSFORM.matrix22", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix23, { "matrix23", "x11.struct.TRANSFORM.matrix23", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix31, { "matrix31", "x11.struct.TRANSFORM.matrix31", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix32, { "matrix32", "x11.struct.TRANSFORM.matrix32", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRANSFORM_matrix33, { "matrix33", "x11.struct.TRANSFORM.matrix33", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ANIMCURSORELT, { "ANIMCURSORELT", "x11.struct.ANIMCURSORELT", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ANIMCURSORELT_cursor, { "cursor", "x11.struct.ANIMCURSORELT.cursor", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ANIMCURSORELT_delay, { "delay", "x11.struct.ANIMCURSORELT.delay", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SPANFIX, { "SPANFIX", "x11.struct.SPANFIX", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SPANFIX_l, { "l", "x11.struct.SPANFIX.l", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SPANFIX_r, { "r", "x11.struct.SPANFIX.r", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SPANFIX_y, { "y", "x11.struct.SPANFIX.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAP, { "TRAP", "x11.struct.TRAP", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAP_top, { "top", "x11.struct.TRAP.top", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRAP_bot, { "bot", "x11.struct.TRAP.bot", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_QueryVersion_client_major_version, { "client_major_version", "x11.composite.QueryVersion.client_major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_QueryVersion_client_minor_version, { "client_minor_version", "x11.composite.QueryVersion.client_minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_QueryVersion_reply_major_version, { "major_version", "x11.composite.QueryVersion.reply.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_QueryVersion_reply_minor_version, { "minor_version", "x11.composite.QueryVersion.reply.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_RedirectWindow_window, { "window", "x11.composite.RedirectWindow.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_RedirectWindow_update, { "update", "x11.composite.RedirectWindow.update", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_RedirectSubwindows_window, { "window", "x11.composite.RedirectSubwindows.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_RedirectSubwindows_update, { "update", "x11.composite.RedirectSubwindows.update", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_UnredirectWindow_window, { "window", "x11.composite.UnredirectWindow.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_UnredirectWindow_update, { "update", "x11.composite.UnredirectWindow.update", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_UnredirectSubwindows_window, { "window", "x11.composite.UnredirectSubwindows.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_UnredirectSubwindows_update, { "update", "x11.composite.UnredirectSubwindows.update", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_CreateRegionFromBorderClip_region, { "region", "x11.composite.CreateRegionFromBorderClip.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_CreateRegionFromBorderClip_window, { "window", "x11.composite.CreateRegionFromBorderClip.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_NameWindowPixmap_window, { "window", "x11.composite.NameWindowPixmap.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_NameWindowPixmap_pixmap, { "pixmap", "x11.composite.NameWindowPixmap.pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_GetOverlayWindow_window, { "window", "x11.composite.GetOverlayWindow.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_GetOverlayWindow_reply_overlay_win, { "overlay_win", "x11.composite.GetOverlayWindow.reply.overlay_win", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_ReleaseOverlayWindow_window, { "window", "x11.composite.ReleaseOverlayWindow.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_composite_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(composite_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_damage_QueryVersion_client_major_version, { "client_major_version", "x11.damage.QueryVersion.client_major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_QueryVersion_client_minor_version, { "client_minor_version", "x11.damage.QueryVersion.client_minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_QueryVersion_reply_major_version, { "major_version", "x11.damage.QueryVersion.reply.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_QueryVersion_reply_minor_version, { "minor_version", "x11.damage.QueryVersion.reply.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Create_damage, { "damage", "x11.damage.Create.damage", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Create_drawable, { "drawable", "x11.damage.Create.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Create_level, { "level", "x11.damage.Create.level", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Destroy_damage, { "damage", "x11.damage.Destroy.damage", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Subtract_damage, { "damage", "x11.damage.Subtract.damage", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Subtract_repair, { "repair", "x11.damage.Subtract.repair", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Subtract_parts, { "parts", "x11.damage.Subtract.parts", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Add_drawable, { "drawable", "x11.damage.Add.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Add_region, { "region", "x11.damage.Add.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Notify_level, { "level", "x11.damage.Notify.level", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Notify_drawable, { "drawable", "x11.damage.Notify.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Notify_damage, { "damage", "x11.damage.Notify.damage", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Notify_timestamp, { "timestamp", "x11.damage.Notify.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Notify_area, { "area", "x11.damage.Notify.area", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_Notify_geometry, { "geometry", "x11.damage.Notify.geometry", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_damage_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(damage_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_dpms_GetVersion_client_major_version, { "client_major_version", "x11.dpms.GetVersion.client_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_GetVersion_client_minor_version, { "client_minor_version", "x11.dpms.GetVersion.client_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_GetVersion_reply_server_major_version, { "server_major_version", "x11.dpms.GetVersion.reply.server_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_GetVersion_reply_server_minor_version, { "server_minor_version", "x11.dpms.GetVersion.reply.server_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_Capable_reply_capable, { "capable", "x11.dpms.Capable.reply.capable", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_GetTimeouts_reply_standby_timeout, { "standby_timeout", "x11.dpms.GetTimeouts.reply.standby_timeout", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_GetTimeouts_reply_suspend_timeout, { "suspend_timeout", "x11.dpms.GetTimeouts.reply.suspend_timeout", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_GetTimeouts_reply_off_timeout, { "off_timeout", "x11.dpms.GetTimeouts.reply.off_timeout", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_SetTimeouts_standby_timeout, { "standby_timeout", "x11.dpms.SetTimeouts.standby_timeout", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_SetTimeouts_suspend_timeout, { "suspend_timeout", "x11.dpms.SetTimeouts.suspend_timeout", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_SetTimeouts_off_timeout, { "off_timeout", "x11.dpms.SetTimeouts.off_timeout", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_ForceLevel_power_level, { "power_level", "x11.dpms.ForceLevel.power_level", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_Info_reply_power_level, { "power_level", "x11.dpms.Info.reply.power_level", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_Info_reply_state, { "state", "x11.dpms.Info.reply.state", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_dpms_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(dpms_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_ge_QueryVersion_client_major_version, { "client_major_version", "x11.ge.QueryVersion.client_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_ge_QueryVersion_client_minor_version, { "client_minor_version", "x11.ge.QueryVersion.client_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_ge_QueryVersion_reply_major_version, { "major_version", "x11.ge.QueryVersion.reply.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_ge_QueryVersion_reply_minor_version, { "minor_version", "x11.ge.QueryVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_ge_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(ge_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_glx_PbufferClobber_event_type, { "event_type", "x11.glx.PbufferClobber.event_type", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_draw_type, { "draw_type", "x11.glx.PbufferClobber.draw_type", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_drawable, { "drawable", "x11.glx.PbufferClobber.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_b_mask, { "b_mask", "x11.glx.PbufferClobber.b_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_aux_buffer, { "aux_buffer", "x11.glx.PbufferClobber.aux_buffer", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_x, { "x", "x11.glx.PbufferClobber.x", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_y, { "y", "x11.glx.PbufferClobber.y", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_width, { "width", "x11.glx.PbufferClobber.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_height, { "height", "x11.glx.PbufferClobber.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PbufferClobber_count, { "count", "x11.glx.PbufferClobber.count", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_Render_context_tag, { "context_tag", "x11.glx.Render.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_Render_data, { "data", "x11.glx.Render.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderLarge_context_tag, { "context_tag", "x11.glx.RenderLarge.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderLarge_request_num, { "request_num", "x11.glx.RenderLarge.request_num", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderLarge_request_total, { "request_total", "x11.glx.RenderLarge.request_total", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderLarge_data_len, { "data_len", "x11.glx.RenderLarge.data_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderLarge_data, { "data", "x11.glx.RenderLarge.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateContext_context, { "context", "x11.glx.CreateContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateContext_visual, { "visual", "x11.glx.CreateContext.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateContext_screen, { "screen", "x11.glx.CreateContext.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateContext_share_list, { "share_list", "x11.glx.CreateContext.share_list", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateContext_is_direct, { "is_direct", "x11.glx.CreateContext.is_direct", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DestroyContext_context, { "context", "x11.glx.DestroyContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeCurrent_drawable, { "drawable", "x11.glx.MakeCurrent.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeCurrent_context, { "context", "x11.glx.MakeCurrent.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeCurrent_old_context_tag, { "old_context_tag", "x11.glx.MakeCurrent.old_context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeCurrent_reply_context_tag, { "context_tag", "x11.glx.MakeCurrent.reply.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsDirect_context, { "context", "x11.glx.IsDirect.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsDirect_reply_is_direct, { "is_direct", "x11.glx.IsDirect.reply.is_direct", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryVersion_major_version, { "major_version", "x11.glx.QueryVersion.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryVersion_minor_version, { "minor_version", "x11.glx.QueryVersion.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryVersion_reply_major_version, { "major_version", "x11.glx.QueryVersion.reply.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryVersion_reply_minor_version, { "minor_version", "x11.glx.QueryVersion.reply.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_WaitGL_context_tag, { "context_tag", "x11.glx.WaitGL.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_WaitX_context_tag, { "context_tag", "x11.glx.WaitX.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CopyContext_src, { "src", "x11.glx.CopyContext.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CopyContext_dest, { "dest", "x11.glx.CopyContext.dest", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CopyContext_mask, { "mask", "x11.glx.CopyContext.mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CopyContext_src_context_tag, { "src_context_tag", "x11.glx.CopyContext.src_context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_SwapBuffers_context_tag, { "context_tag", "x11.glx.SwapBuffers.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_SwapBuffers_drawable, { "drawable", "x11.glx.SwapBuffers.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_UseXFont_context_tag, { "context_tag", "x11.glx.UseXFont.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_UseXFont_font, { "font", "x11.glx.UseXFont.font", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_UseXFont_first, { "first", "x11.glx.UseXFont.first", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_UseXFont_count, { "count", "x11.glx.UseXFont.count", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_UseXFont_list_base, { "list_base", "x11.glx.UseXFont.list_base", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateGLXPixmap_screen, { "screen", "x11.glx.CreateGLXPixmap.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateGLXPixmap_visual, { "visual", "x11.glx.CreateGLXPixmap.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateGLXPixmap_pixmap, { "pixmap", "x11.glx.CreateGLXPixmap.pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateGLXPixmap_glx_pixmap, { "glx_pixmap", "x11.glx.CreateGLXPixmap.glx_pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetVisualConfigs_screen, { "screen", "x11.glx.GetVisualConfigs.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetVisualConfigs_reply_num_visuals, { "num_visuals", "x11.glx.GetVisualConfigs.reply.num_visuals", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetVisualConfigs_reply_num_properties, { "num_properties", "x11.glx.GetVisualConfigs.reply.num_properties", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetVisualConfigs_reply_property_list, { "property_list", "x11.glx.GetVisualConfigs.reply.property_list", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetVisualConfigs_reply_property_list_item, { "property_list", "x11.glx.GetVisualConfigs.reply.property_list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DestroyGLXPixmap_glx_pixmap, { "glx_pixmap", "x11.glx.DestroyGLXPixmap.glx_pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivate_vendor_code, { "vendor_code", "x11.glx.VendorPrivate.vendor_code", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivate_context_tag, { "context_tag", "x11.glx.VendorPrivate.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivate_data, { "data", "x11.glx.VendorPrivate.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivateWithReply_vendor_code, { "vendor_code", "x11.glx.VendorPrivateWithReply.vendor_code", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivateWithReply_context_tag, { "context_tag", "x11.glx.VendorPrivateWithReply.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivateWithReply_data, { "data", "x11.glx.VendorPrivateWithReply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivateWithReply_reply_retval, { "retval", "x11.glx.VendorPrivateWithReply.reply.retval", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivateWithReply_reply_data1, { "data1", "x11.glx.VendorPrivateWithReply.reply.data1", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_VendorPrivateWithReply_reply_data2, { "data2", "x11.glx.VendorPrivateWithReply.reply.data2", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryExtensionsString_screen, { "screen", "x11.glx.QueryExtensionsString.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryExtensionsString_reply_n, { "n", "x11.glx.QueryExtensionsString.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryServerString_screen, { "screen", "x11.glx.QueryServerString.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryServerString_name, { "name", "x11.glx.QueryServerString.name", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryServerString_reply_str_len, { "str_len", "x11.glx.QueryServerString.reply.str_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryServerString_reply_string, { "string", "x11.glx.QueryServerString.reply.string", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ClientInfo_major_version, { "major_version", "x11.glx.ClientInfo.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ClientInfo_minor_version, { "minor_version", "x11.glx.ClientInfo.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ClientInfo_str_len, { "str_len", "x11.glx.ClientInfo.str_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ClientInfo_string, { "string", "x11.glx.ClientInfo.string", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFBConfigs_screen, { "screen", "x11.glx.GetFBConfigs.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFBConfigs_reply_num_FB_configs, { "num_FB_configs", "x11.glx.GetFBConfigs.reply.num_FB_configs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFBConfigs_reply_num_properties, { "num_properties", "x11.glx.GetFBConfigs.reply.num_properties", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFBConfigs_reply_property_list, { "property_list", "x11.glx.GetFBConfigs.reply.property_list", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFBConfigs_reply_property_list_item, { "property_list", "x11.glx.GetFBConfigs.reply.property_list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_screen, { "screen", "x11.glx.CreatePixmap.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_fbconfig, { "fbconfig", "x11.glx.CreatePixmap.fbconfig", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_pixmap, { "pixmap", "x11.glx.CreatePixmap.pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_glx_pixmap, { "glx_pixmap", "x11.glx.CreatePixmap.glx_pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_num_attribs, { "num_attribs", "x11.glx.CreatePixmap.num_attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_attribs, { "attribs", "x11.glx.CreatePixmap.attribs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePixmap_attribs_item, { "attribs", "x11.glx.CreatePixmap.attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DestroyPixmap_glx_pixmap, { "glx_pixmap", "x11.glx.DestroyPixmap.glx_pixmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_context, { "context", "x11.glx.CreateNewContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_fbconfig, { "fbconfig", "x11.glx.CreateNewContext.fbconfig", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_screen, { "screen", "x11.glx.CreateNewContext.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_render_type, { "render_type", "x11.glx.CreateNewContext.render_type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_share_list, { "share_list", "x11.glx.CreateNewContext.share_list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_is_direct, { "is_direct", "x11.glx.CreateNewContext.is_direct", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_reserved1, { "reserved1", "x11.glx.CreateNewContext.reserved1", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateNewContext_reserved2, { "reserved2", "x11.glx.CreateNewContext.reserved2", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryContext_context, { "context", "x11.glx.QueryContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryContext_reply_num_attribs, { "num_attribs", "x11.glx.QueryContext.reply.num_attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryContext_reply_attribs, { "attribs", "x11.glx.QueryContext.reply.attribs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_QueryContext_reply_attribs_item, { "attribs", "x11.glx.QueryContext.reply.attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeContextCurrent_old_context_tag, { "old_context_tag", "x11.glx.MakeContextCurrent.old_context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeContextCurrent_drawable, { "drawable", "x11.glx.MakeContextCurrent.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeContextCurrent_read_drawable, { "read_drawable", "x11.glx.MakeContextCurrent.read_drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeContextCurrent_context, { "context", "x11.glx.MakeContextCurrent.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_MakeContextCurrent_reply_context_tag, { "context_tag", "x11.glx.MakeContextCurrent.reply.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePbuffer_screen, { "screen", "x11.glx.CreatePbuffer.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePbuffer_fbconfig, { "fbconfig", "x11.glx.CreatePbuffer.fbconfig", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePbuffer_pbuffer, { "pbuffer", "x11.glx.CreatePbuffer.pbuffer", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePbuffer_num_attribs, { "num_attribs", "x11.glx.CreatePbuffer.num_attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePbuffer_attribs, { "attribs", "x11.glx.CreatePbuffer.attribs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreatePbuffer_attribs_item, { "attribs", "x11.glx.CreatePbuffer.attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DestroyPbuffer_pbuffer, { "pbuffer", "x11.glx.DestroyPbuffer.pbuffer", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDrawableAttributes_drawable, { "drawable", "x11.glx.GetDrawableAttributes.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDrawableAttributes_reply_num_attribs, { "num_attribs", "x11.glx.GetDrawableAttributes.reply.num_attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDrawableAttributes_reply_attribs, { "attribs", "x11.glx.GetDrawableAttributes.reply.attribs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDrawableAttributes_reply_attribs_item, { "attribs", "x11.glx.GetDrawableAttributes.reply.attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ChangeDrawableAttributes_drawable, { "drawable", "x11.glx.ChangeDrawableAttributes.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ChangeDrawableAttributes_num_attribs, { "num_attribs", "x11.glx.ChangeDrawableAttributes.num_attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ChangeDrawableAttributes_attribs, { "attribs", "x11.glx.ChangeDrawableAttributes.attribs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ChangeDrawableAttributes_attribs_item, { "attribs", "x11.glx.ChangeDrawableAttributes.attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_screen, { "screen", "x11.glx.CreateWindow.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_fbconfig, { "fbconfig", "x11.glx.CreateWindow.fbconfig", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_window, { "window", "x11.glx.CreateWindow.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_glx_window, { "glx_window", "x11.glx.CreateWindow.glx_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_num_attribs, { "num_attribs", "x11.glx.CreateWindow.num_attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_attribs, { "attribs", "x11.glx.CreateWindow.attribs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_CreateWindow_attribs_item, { "attribs", "x11.glx.CreateWindow.attribs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteWindow_glxwindow, { "glxwindow", "x11.glx.DeleteWindow.glxwindow", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_NewList_context_tag, { "context_tag", "x11.glx.NewList.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_NewList_list, { "list", "x11.glx.NewList.list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_NewList_mode, { "mode", "x11.glx.NewList.mode", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_EndList_context_tag, { "context_tag", "x11.glx.EndList.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteLists_context_tag, { "context_tag", "x11.glx.DeleteLists.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteLists_list, { "list", "x11.glx.DeleteLists.list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteLists_range, { "range", "x11.glx.DeleteLists.range", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenLists_context_tag, { "context_tag", "x11.glx.GenLists.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenLists_range, { "range", "x11.glx.GenLists.range", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenLists_reply_ret_val, { "ret_val", "x11.glx.GenLists.reply.ret_val", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_FeedbackBuffer_context_tag, { "context_tag", "x11.glx.FeedbackBuffer.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_FeedbackBuffer_size, { "size", "x11.glx.FeedbackBuffer.size", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_FeedbackBuffer_type, { "type", "x11.glx.FeedbackBuffer.type", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_SelectBuffer_context_tag, { "context_tag", "x11.glx.SelectBuffer.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_SelectBuffer_size, { "size", "x11.glx.SelectBuffer.size", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_context_tag, { "context_tag", "x11.glx.RenderMode.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_mode, { "mode", "x11.glx.RenderMode.mode", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_reply_ret_val, { "ret_val", "x11.glx.RenderMode.reply.ret_val", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_reply_n, { "n", "x11.glx.RenderMode.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_reply_new_mode, { "new_mode", "x11.glx.RenderMode.reply.new_mode", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_reply_data, { "data", "x11.glx.RenderMode.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_RenderMode_reply_data_item, { "data", "x11.glx.RenderMode.reply.data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_Finish_context_tag, { "context_tag", "x11.glx.Finish.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PixelStoref_context_tag, { "context_tag", "x11.glx.PixelStoref.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PixelStoref_pname, { "pname", "x11.glx.PixelStoref.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PixelStoref_datum, { "datum", "x11.glx.PixelStoref.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PixelStorei_context_tag, { "context_tag", "x11.glx.PixelStorei.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PixelStorei_pname, { "pname", "x11.glx.PixelStorei.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_PixelStorei_datum, { "datum", "x11.glx.PixelStorei.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_context_tag, { "context_tag", "x11.glx.ReadPixels.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_x, { "x", "x11.glx.ReadPixels.x", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_y, { "y", "x11.glx.ReadPixels.y", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_width, { "width", "x11.glx.ReadPixels.width", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_height, { "height", "x11.glx.ReadPixels.height", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_format, { "format", "x11.glx.ReadPixels.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_type, { "type", "x11.glx.ReadPixels.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_swap_bytes, { "swap_bytes", "x11.glx.ReadPixels.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_lsb_first, { "lsb_first", "x11.glx.ReadPixels.lsb_first", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_ReadPixels_reply_data, { "data", "x11.glx.ReadPixels.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetBooleanv_context_tag, { "context_tag", "x11.glx.GetBooleanv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetBooleanv_pname, { "pname", "x11.glx.GetBooleanv.pname", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetBooleanv_reply_n, { "n", "x11.glx.GetBooleanv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetBooleanv_reply_datum, { "datum", "x11.glx.GetBooleanv.reply.datum", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetBooleanv_reply_data, { "data", "x11.glx.GetBooleanv.reply.data", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetClipPlane_context_tag, { "context_tag", "x11.glx.GetClipPlane.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetClipPlane_plane, { "plane", "x11.glx.GetClipPlane.plane", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetClipPlane_reply_data, { "data", "x11.glx.GetClipPlane.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetClipPlane_reply_data_item, { "data", "x11.glx.GetClipPlane.reply.data", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDoublev_context_tag, { "context_tag", "x11.glx.GetDoublev.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDoublev_pname, { "pname", "x11.glx.GetDoublev.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDoublev_reply_n, { "n", "x11.glx.GetDoublev.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDoublev_reply_datum, { "datum", "x11.glx.GetDoublev.reply.datum", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDoublev_reply_data, { "data", "x11.glx.GetDoublev.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetDoublev_reply_data_item, { "data", "x11.glx.GetDoublev.reply.data", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetError_context_tag, { "context_tag", "x11.glx.GetError.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetError_reply_error, { "error", "x11.glx.GetError.reply.error", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFloatv_context_tag, { "context_tag", "x11.glx.GetFloatv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFloatv_pname, { "pname", "x11.glx.GetFloatv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFloatv_reply_n, { "n", "x11.glx.GetFloatv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFloatv_reply_datum, { "datum", "x11.glx.GetFloatv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFloatv_reply_data, { "data", "x11.glx.GetFloatv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetFloatv_reply_data_item, { "data", "x11.glx.GetFloatv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetIntegerv_context_tag, { "context_tag", "x11.glx.GetIntegerv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetIntegerv_pname, { "pname", "x11.glx.GetIntegerv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetIntegerv_reply_n, { "n", "x11.glx.GetIntegerv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetIntegerv_reply_datum, { "datum", "x11.glx.GetIntegerv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetIntegerv_reply_data, { "data", "x11.glx.GetIntegerv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetIntegerv_reply_data_item, { "data", "x11.glx.GetIntegerv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_context_tag, { "context_tag", "x11.glx.GetLightfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_light, { "light", "x11.glx.GetLightfv.light", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_pname, { "pname", "x11.glx.GetLightfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_reply_n, { "n", "x11.glx.GetLightfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_reply_datum, { "datum", "x11.glx.GetLightfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_reply_data, { "data", "x11.glx.GetLightfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightfv_reply_data_item, { "data", "x11.glx.GetLightfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_context_tag, { "context_tag", "x11.glx.GetLightiv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_light, { "light", "x11.glx.GetLightiv.light", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_pname, { "pname", "x11.glx.GetLightiv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_reply_n, { "n", "x11.glx.GetLightiv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_reply_datum, { "datum", "x11.glx.GetLightiv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_reply_data, { "data", "x11.glx.GetLightiv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetLightiv_reply_data_item, { "data", "x11.glx.GetLightiv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_context_tag, { "context_tag", "x11.glx.GetMapdv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_target, { "target", "x11.glx.GetMapdv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_query, { "query", "x11.glx.GetMapdv.query", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_reply_n, { "n", "x11.glx.GetMapdv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_reply_datum, { "datum", "x11.glx.GetMapdv.reply.datum", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_reply_data, { "data", "x11.glx.GetMapdv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapdv_reply_data_item, { "data", "x11.glx.GetMapdv.reply.data", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_context_tag, { "context_tag", "x11.glx.GetMapfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_target, { "target", "x11.glx.GetMapfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_query, { "query", "x11.glx.GetMapfv.query", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_reply_n, { "n", "x11.glx.GetMapfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_reply_datum, { "datum", "x11.glx.GetMapfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_reply_data, { "data", "x11.glx.GetMapfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapfv_reply_data_item, { "data", "x11.glx.GetMapfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_context_tag, { "context_tag", "x11.glx.GetMapiv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_target, { "target", "x11.glx.GetMapiv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_query, { "query", "x11.glx.GetMapiv.query", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_reply_n, { "n", "x11.glx.GetMapiv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_reply_datum, { "datum", "x11.glx.GetMapiv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_reply_data, { "data", "x11.glx.GetMapiv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMapiv_reply_data_item, { "data", "x11.glx.GetMapiv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_context_tag, { "context_tag", "x11.glx.GetMaterialfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_face, { "face", "x11.glx.GetMaterialfv.face", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_pname, { "pname", "x11.glx.GetMaterialfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_reply_n, { "n", "x11.glx.GetMaterialfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_reply_datum, { "datum", "x11.glx.GetMaterialfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_reply_data, { "data", "x11.glx.GetMaterialfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialfv_reply_data_item, { "data", "x11.glx.GetMaterialfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_context_tag, { "context_tag", "x11.glx.GetMaterialiv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_face, { "face", "x11.glx.GetMaterialiv.face", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_pname, { "pname", "x11.glx.GetMaterialiv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_reply_n, { "n", "x11.glx.GetMaterialiv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_reply_datum, { "datum", "x11.glx.GetMaterialiv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_reply_data, { "data", "x11.glx.GetMaterialiv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMaterialiv_reply_data_item, { "data", "x11.glx.GetMaterialiv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapfv_context_tag, { "context_tag", "x11.glx.GetPixelMapfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapfv_map, { "map", "x11.glx.GetPixelMapfv.map", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapfv_reply_n, { "n", "x11.glx.GetPixelMapfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapfv_reply_datum, { "datum", "x11.glx.GetPixelMapfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapfv_reply_data, { "data", "x11.glx.GetPixelMapfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapfv_reply_data_item, { "data", "x11.glx.GetPixelMapfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapuiv_context_tag, { "context_tag", "x11.glx.GetPixelMapuiv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapuiv_map, { "map", "x11.glx.GetPixelMapuiv.map", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapuiv_reply_n, { "n", "x11.glx.GetPixelMapuiv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapuiv_reply_datum, { "datum", "x11.glx.GetPixelMapuiv.reply.datum", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapuiv_reply_data, { "data", "x11.glx.GetPixelMapuiv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapuiv_reply_data_item, { "data", "x11.glx.GetPixelMapuiv.reply.data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapusv_context_tag, { "context_tag", "x11.glx.GetPixelMapusv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapusv_map, { "map", "x11.glx.GetPixelMapusv.map", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapusv_reply_n, { "n", "x11.glx.GetPixelMapusv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapusv_reply_datum, { "datum", "x11.glx.GetPixelMapusv.reply.datum", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapusv_reply_data, { "data", "x11.glx.GetPixelMapusv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPixelMapusv_reply_data_item, { "data", "x11.glx.GetPixelMapusv.reply.data", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPolygonStipple_context_tag, { "context_tag", "x11.glx.GetPolygonStipple.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPolygonStipple_lsb_first, { "lsb_first", "x11.glx.GetPolygonStipple.lsb_first", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetPolygonStipple_reply_data, { "data", "x11.glx.GetPolygonStipple.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetString_context_tag, { "context_tag", "x11.glx.GetString.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetString_name, { "name", "x11.glx.GetString.name", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetString_reply_n, { "n", "x11.glx.GetString.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetString_reply_string, { "string", "x11.glx.GetString.reply.string", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_context_tag, { "context_tag", "x11.glx.GetTexEnvfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_target, { "target", "x11.glx.GetTexEnvfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_pname, { "pname", "x11.glx.GetTexEnvfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_reply_n, { "n", "x11.glx.GetTexEnvfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_reply_datum, { "datum", "x11.glx.GetTexEnvfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_reply_data, { "data", "x11.glx.GetTexEnvfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnvfv_reply_data_item, { "data", "x11.glx.GetTexEnvfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_context_tag, { "context_tag", "x11.glx.GetTexEnviv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_target, { "target", "x11.glx.GetTexEnviv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_pname, { "pname", "x11.glx.GetTexEnviv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_reply_n, { "n", "x11.glx.GetTexEnviv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_reply_datum, { "datum", "x11.glx.GetTexEnviv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_reply_data, { "data", "x11.glx.GetTexEnviv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexEnviv_reply_data_item, { "data", "x11.glx.GetTexEnviv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_context_tag, { "context_tag", "x11.glx.GetTexGendv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_coord, { "coord", "x11.glx.GetTexGendv.coord", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_pname, { "pname", "x11.glx.GetTexGendv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_reply_n, { "n", "x11.glx.GetTexGendv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_reply_datum, { "datum", "x11.glx.GetTexGendv.reply.datum", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_reply_data, { "data", "x11.glx.GetTexGendv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGendv_reply_data_item, { "data", "x11.glx.GetTexGendv.reply.data", FT_DOUBLE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_context_tag, { "context_tag", "x11.glx.GetTexGenfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_coord, { "coord", "x11.glx.GetTexGenfv.coord", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_pname, { "pname", "x11.glx.GetTexGenfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_reply_n, { "n", "x11.glx.GetTexGenfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_reply_datum, { "datum", "x11.glx.GetTexGenfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_reply_data, { "data", "x11.glx.GetTexGenfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGenfv_reply_data_item, { "data", "x11.glx.GetTexGenfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_context_tag, { "context_tag", "x11.glx.GetTexGeniv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_coord, { "coord", "x11.glx.GetTexGeniv.coord", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_pname, { "pname", "x11.glx.GetTexGeniv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_reply_n, { "n", "x11.glx.GetTexGeniv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_reply_datum, { "datum", "x11.glx.GetTexGeniv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_reply_data, { "data", "x11.glx.GetTexGeniv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexGeniv_reply_data_item, { "data", "x11.glx.GetTexGeniv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_context_tag, { "context_tag", "x11.glx.GetTexImage.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_target, { "target", "x11.glx.GetTexImage.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_level, { "level", "x11.glx.GetTexImage.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_format, { "format", "x11.glx.GetTexImage.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_type, { "type", "x11.glx.GetTexImage.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_swap_bytes, { "swap_bytes", "x11.glx.GetTexImage.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_reply_width, { "width", "x11.glx.GetTexImage.reply.width", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_reply_height, { "height", "x11.glx.GetTexImage.reply.height", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_reply_depth, { "depth", "x11.glx.GetTexImage.reply.depth", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexImage_reply_data, { "data", "x11.glx.GetTexImage.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_context_tag, { "context_tag", "x11.glx.GetTexParameterfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_target, { "target", "x11.glx.GetTexParameterfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_pname, { "pname", "x11.glx.GetTexParameterfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_reply_n, { "n", "x11.glx.GetTexParameterfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_reply_datum, { "datum", "x11.glx.GetTexParameterfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_reply_data, { "data", "x11.glx.GetTexParameterfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameterfv_reply_data_item, { "data", "x11.glx.GetTexParameterfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_context_tag, { "context_tag", "x11.glx.GetTexParameteriv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_target, { "target", "x11.glx.GetTexParameteriv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_pname, { "pname", "x11.glx.GetTexParameteriv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_reply_n, { "n", "x11.glx.GetTexParameteriv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_reply_datum, { "datum", "x11.glx.GetTexParameteriv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_reply_data, { "data", "x11.glx.GetTexParameteriv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexParameteriv_reply_data_item, { "data", "x11.glx.GetTexParameteriv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_context_tag, { "context_tag", "x11.glx.GetTexLevelParameterfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_target, { "target", "x11.glx.GetTexLevelParameterfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_level, { "level", "x11.glx.GetTexLevelParameterfv.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_pname, { "pname", "x11.glx.GetTexLevelParameterfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_reply_n, { "n", "x11.glx.GetTexLevelParameterfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_reply_datum, { "datum", "x11.glx.GetTexLevelParameterfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_reply_data, { "data", "x11.glx.GetTexLevelParameterfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameterfv_reply_data_item, { "data", "x11.glx.GetTexLevelParameterfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_context_tag, { "context_tag", "x11.glx.GetTexLevelParameteriv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_target, { "target", "x11.glx.GetTexLevelParameteriv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_level, { "level", "x11.glx.GetTexLevelParameteriv.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_pname, { "pname", "x11.glx.GetTexLevelParameteriv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_reply_n, { "n", "x11.glx.GetTexLevelParameteriv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_reply_datum, { "datum", "x11.glx.GetTexLevelParameteriv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_reply_data, { "data", "x11.glx.GetTexLevelParameteriv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetTexLevelParameteriv_reply_data_item, { "data", "x11.glx.GetTexLevelParameteriv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsList_context_tag, { "context_tag", "x11.glx.IsList.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsList_list, { "list", "x11.glx.IsList.list", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsList_reply_ret_val, { "ret_val", "x11.glx.IsList.reply.ret_val", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_Flush_context_tag, { "context_tag", "x11.glx.Flush.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_AreTexturesResident_context_tag, { "context_tag", "x11.glx.AreTexturesResident.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_AreTexturesResident_n, { "n", "x11.glx.AreTexturesResident.n", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_AreTexturesResident_textures, { "textures", "x11.glx.AreTexturesResident.textures", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_AreTexturesResident_textures_item, { "textures", "x11.glx.AreTexturesResident.textures", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_AreTexturesResident_reply_ret_val, { "ret_val", "x11.glx.AreTexturesResident.reply.ret_val", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_AreTexturesResident_reply_data, { "data", "x11.glx.AreTexturesResident.reply.data", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteTextures_context_tag, { "context_tag", "x11.glx.DeleteTextures.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteTextures_n, { "n", "x11.glx.DeleteTextures.n", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteTextures_textures, { "textures", "x11.glx.DeleteTextures.textures", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteTextures_textures_item, { "textures", "x11.glx.DeleteTextures.textures", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenTextures_context_tag, { "context_tag", "x11.glx.GenTextures.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenTextures_n, { "n", "x11.glx.GenTextures.n", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenTextures_reply_data, { "data", "x11.glx.GenTextures.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenTextures_reply_data_item, { "data", "x11.glx.GenTextures.reply.data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsTexture_context_tag, { "context_tag", "x11.glx.IsTexture.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsTexture_texture, { "texture", "x11.glx.IsTexture.texture", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsTexture_reply_ret_val, { "ret_val", "x11.glx.IsTexture.reply.ret_val", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_context_tag, { "context_tag", "x11.glx.GetColorTable.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_target, { "target", "x11.glx.GetColorTable.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_format, { "format", "x11.glx.GetColorTable.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_type, { "type", "x11.glx.GetColorTable.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_swap_bytes, { "swap_bytes", "x11.glx.GetColorTable.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_reply_width, { "width", "x11.glx.GetColorTable.reply.width", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTable_reply_data, { "data", "x11.glx.GetColorTable.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_context_tag, { "context_tag", "x11.glx.GetColorTableParameterfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_target, { "target", "x11.glx.GetColorTableParameterfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_pname, { "pname", "x11.glx.GetColorTableParameterfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_reply_n, { "n", "x11.glx.GetColorTableParameterfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_reply_datum, { "datum", "x11.glx.GetColorTableParameterfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_reply_data, { "data", "x11.glx.GetColorTableParameterfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameterfv_reply_data_item, { "data", "x11.glx.GetColorTableParameterfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_context_tag, { "context_tag", "x11.glx.GetColorTableParameteriv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_target, { "target", "x11.glx.GetColorTableParameteriv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_pname, { "pname", "x11.glx.GetColorTableParameteriv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_reply_n, { "n", "x11.glx.GetColorTableParameteriv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_reply_datum, { "datum", "x11.glx.GetColorTableParameteriv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_reply_data, { "data", "x11.glx.GetColorTableParameteriv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetColorTableParameteriv_reply_data_item, { "data", "x11.glx.GetColorTableParameteriv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_context_tag, { "context_tag", "x11.glx.GetConvolutionFilter.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_target, { "target", "x11.glx.GetConvolutionFilter.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_format, { "format", "x11.glx.GetConvolutionFilter.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_type, { "type", "x11.glx.GetConvolutionFilter.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_swap_bytes, { "swap_bytes", "x11.glx.GetConvolutionFilter.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_reply_width, { "width", "x11.glx.GetConvolutionFilter.reply.width", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_reply_height, { "height", "x11.glx.GetConvolutionFilter.reply.height", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionFilter_reply_data, { "data", "x11.glx.GetConvolutionFilter.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_context_tag, { "context_tag", "x11.glx.GetConvolutionParameterfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_target, { "target", "x11.glx.GetConvolutionParameterfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_pname, { "pname", "x11.glx.GetConvolutionParameterfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_reply_n, { "n", "x11.glx.GetConvolutionParameterfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_reply_datum, { "datum", "x11.glx.GetConvolutionParameterfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_reply_data, { "data", "x11.glx.GetConvolutionParameterfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameterfv_reply_data_item, { "data", "x11.glx.GetConvolutionParameterfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_context_tag, { "context_tag", "x11.glx.GetConvolutionParameteriv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_target, { "target", "x11.glx.GetConvolutionParameteriv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_pname, { "pname", "x11.glx.GetConvolutionParameteriv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_reply_n, { "n", "x11.glx.GetConvolutionParameteriv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_reply_datum, { "datum", "x11.glx.GetConvolutionParameteriv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_reply_data, { "data", "x11.glx.GetConvolutionParameteriv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetConvolutionParameteriv_reply_data_item, { "data", "x11.glx.GetConvolutionParameteriv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_context_tag, { "context_tag", "x11.glx.GetSeparableFilter.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_target, { "target", "x11.glx.GetSeparableFilter.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_format, { "format", "x11.glx.GetSeparableFilter.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_type, { "type", "x11.glx.GetSeparableFilter.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_swap_bytes, { "swap_bytes", "x11.glx.GetSeparableFilter.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_reply_row_w, { "row_w", "x11.glx.GetSeparableFilter.reply.row_w", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_reply_col_h, { "col_h", "x11.glx.GetSeparableFilter.reply.col_h", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetSeparableFilter_reply_rows_and_cols, { "rows_and_cols", "x11.glx.GetSeparableFilter.reply.rows_and_cols", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_context_tag, { "context_tag", "x11.glx.GetHistogram.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_target, { "target", "x11.glx.GetHistogram.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_format, { "format", "x11.glx.GetHistogram.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_type, { "type", "x11.glx.GetHistogram.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_swap_bytes, { "swap_bytes", "x11.glx.GetHistogram.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_reset, { "reset", "x11.glx.GetHistogram.reset", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_reply_width, { "width", "x11.glx.GetHistogram.reply.width", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogram_reply_data, { "data", "x11.glx.GetHistogram.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_context_tag, { "context_tag", "x11.glx.GetHistogramParameterfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_target, { "target", "x11.glx.GetHistogramParameterfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_pname, { "pname", "x11.glx.GetHistogramParameterfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_reply_n, { "n", "x11.glx.GetHistogramParameterfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_reply_datum, { "datum", "x11.glx.GetHistogramParameterfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_reply_data, { "data", "x11.glx.GetHistogramParameterfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameterfv_reply_data_item, { "data", "x11.glx.GetHistogramParameterfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_context_tag, { "context_tag", "x11.glx.GetHistogramParameteriv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_target, { "target", "x11.glx.GetHistogramParameteriv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_pname, { "pname", "x11.glx.GetHistogramParameteriv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_reply_n, { "n", "x11.glx.GetHistogramParameteriv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_reply_datum, { "datum", "x11.glx.GetHistogramParameteriv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_reply_data, { "data", "x11.glx.GetHistogramParameteriv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetHistogramParameteriv_reply_data_item, { "data", "x11.glx.GetHistogramParameteriv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_context_tag, { "context_tag", "x11.glx.GetMinmax.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_target, { "target", "x11.glx.GetMinmax.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_format, { "format", "x11.glx.GetMinmax.format", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_type, { "type", "x11.glx.GetMinmax.type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_swap_bytes, { "swap_bytes", "x11.glx.GetMinmax.swap_bytes", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_reset, { "reset", "x11.glx.GetMinmax.reset", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmax_reply_data, { "data", "x11.glx.GetMinmax.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_context_tag, { "context_tag", "x11.glx.GetMinmaxParameterfv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_target, { "target", "x11.glx.GetMinmaxParameterfv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_pname, { "pname", "x11.glx.GetMinmaxParameterfv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_reply_n, { "n", "x11.glx.GetMinmaxParameterfv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_reply_datum, { "datum", "x11.glx.GetMinmaxParameterfv.reply.datum", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_reply_data, { "data", "x11.glx.GetMinmaxParameterfv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameterfv_reply_data_item, { "data", "x11.glx.GetMinmaxParameterfv.reply.data", FT_FLOAT, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_context_tag, { "context_tag", "x11.glx.GetMinmaxParameteriv.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_target, { "target", "x11.glx.GetMinmaxParameteriv.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_pname, { "pname", "x11.glx.GetMinmaxParameteriv.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_reply_n, { "n", "x11.glx.GetMinmaxParameteriv.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_reply_datum, { "datum", "x11.glx.GetMinmaxParameteriv.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_reply_data, { "data", "x11.glx.GetMinmaxParameteriv.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetMinmaxParameteriv_reply_data_item, { "data", "x11.glx.GetMinmaxParameteriv.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetCompressedTexImageARB_context_tag, { "context_tag", "x11.glx.GetCompressedTexImageARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetCompressedTexImageARB_target, { "target", "x11.glx.GetCompressedTexImageARB.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetCompressedTexImageARB_level, { "level", "x11.glx.GetCompressedTexImageARB.level", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetCompressedTexImageARB_reply_size, { "size", "x11.glx.GetCompressedTexImageARB.reply.size", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetCompressedTexImageARB_reply_data, { "data", "x11.glx.GetCompressedTexImageARB.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteQueriesARB_context_tag, { "context_tag", "x11.glx.DeleteQueriesARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteQueriesARB_n, { "n", "x11.glx.DeleteQueriesARB.n", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteQueriesARB_ids, { "ids", "x11.glx.DeleteQueriesARB.ids", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_DeleteQueriesARB_ids_item, { "ids", "x11.glx.DeleteQueriesARB.ids", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenQueriesARB_context_tag, { "context_tag", "x11.glx.GenQueriesARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenQueriesARB_n, { "n", "x11.glx.GenQueriesARB.n", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenQueriesARB_reply_data, { "data", "x11.glx.GenQueriesARB.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GenQueriesARB_reply_data_item, { "data", "x11.glx.GenQueriesARB.reply.data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsQueryARB_context_tag, { "context_tag", "x11.glx.IsQueryARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsQueryARB_id, { "id", "x11.glx.IsQueryARB.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_IsQueryARB_reply_ret_val, { "ret_val", "x11.glx.IsQueryARB.reply.ret_val", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_context_tag, { "context_tag", "x11.glx.GetQueryivARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_target, { "target", "x11.glx.GetQueryivARB.target", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_pname, { "pname", "x11.glx.GetQueryivARB.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_reply_n, { "n", "x11.glx.GetQueryivARB.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_reply_datum, { "datum", "x11.glx.GetQueryivARB.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_reply_data, { "data", "x11.glx.GetQueryivARB.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryivARB_reply_data_item, { "data", "x11.glx.GetQueryivARB.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_context_tag, { "context_tag", "x11.glx.GetQueryObjectivARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_id, { "id", "x11.glx.GetQueryObjectivARB.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_pname, { "pname", "x11.glx.GetQueryObjectivARB.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_reply_n, { "n", "x11.glx.GetQueryObjectivARB.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_reply_datum, { "datum", "x11.glx.GetQueryObjectivARB.reply.datum", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_reply_data, { "data", "x11.glx.GetQueryObjectivARB.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectivARB_reply_data_item, { "data", "x11.glx.GetQueryObjectivARB.reply.data", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_context_tag, { "context_tag", "x11.glx.GetQueryObjectuivARB.context_tag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_id, { "id", "x11.glx.GetQueryObjectuivARB.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_pname, { "pname", "x11.glx.GetQueryObjectuivARB.pname", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_reply_n, { "n", "x11.glx.GetQueryObjectuivARB.reply.n", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_reply_datum, { "datum", "x11.glx.GetQueryObjectuivARB.reply.datum", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_reply_data, { "data", "x11.glx.GetQueryObjectuivARB.reply.data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_GetQueryObjectuivARB_reply_data_item, { "data", "x11.glx.GetQueryObjectuivARB.reply.data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_glx_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(glx_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_ScreenSize, { "ScreenSize", "x11.struct.ScreenSize", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenSize_width, { "width", "x11.struct.ScreenSize.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenSize_height, { "height", "x11.struct.ScreenSize.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenSize_mwidth, { "mwidth", "x11.struct.ScreenSize.mwidth", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenSize_mheight, { "mheight", "x11.struct.ScreenSize.mheight", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RefreshRates, { "RefreshRates", "x11.struct.RefreshRates", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RefreshRates_nRates, { "nRates", "x11.struct.RefreshRates.nRates", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RefreshRates_rates, { "rates", "x11.struct.RefreshRates.rates", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_RefreshRates_rates_item, { "rates", "x11.struct.RefreshRates.rates", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryVersion_major_version, { "major_version", "x11.randr.QueryVersion.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryVersion_minor_version, { "minor_version", "x11.randr.QueryVersion.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryVersion_reply_major_version, { "major_version", "x11.randr.QueryVersion.reply.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryVersion_reply_minor_version, { "minor_version", "x11.randr.QueryVersion.reply.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_window, { "window", "x11.randr.SetScreenConfig.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_timestamp, { "timestamp", "x11.randr.SetScreenConfig.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_config_timestamp, { "config_timestamp", "x11.randr.SetScreenConfig.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_sizeID, { "sizeID", "x11.randr.SetScreenConfig.sizeID", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_rotation, { "rotation", "x11.randr.SetScreenConfig.rotation", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_rate, { "rate", "x11.randr.SetScreenConfig.rate", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_reply_status, { "status", "x11.randr.SetScreenConfig.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_reply_new_timestamp, { "new_timestamp", "x11.randr.SetScreenConfig.reply.new_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_reply_config_timestamp, { "config_timestamp", "x11.randr.SetScreenConfig.reply.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_reply_root, { "root", "x11.randr.SetScreenConfig.reply.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenConfig_reply_subpixel_order, { "subpixel_order", "x11.randr.SetScreenConfig.reply.subpixel_order", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SelectInput_window, { "window", "x11.randr.SelectInput.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SelectInput_enable, { "enable", "x11.randr.SelectInput.enable", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_window, { "window", "x11.randr.GetScreenInfo.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_rotations, { "rotations", "x11.randr.GetScreenInfo.reply.rotations", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_root, { "root", "x11.randr.GetScreenInfo.reply.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_timestamp, { "timestamp", "x11.randr.GetScreenInfo.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_config_timestamp, { "config_timestamp", "x11.randr.GetScreenInfo.reply.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_nSizes, { "nSizes", "x11.randr.GetScreenInfo.reply.nSizes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_sizeID, { "sizeID", "x11.randr.GetScreenInfo.reply.sizeID", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_rotation, { "rotation", "x11.randr.GetScreenInfo.reply.rotation", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_rate, { "rate", "x11.randr.GetScreenInfo.reply.rate", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_nInfo, { "nInfo", "x11.randr.GetScreenInfo.reply.nInfo", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_sizes, { "sizes", "x11.randr.GetScreenInfo.reply.sizes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_sizes_item, { "sizes", "x11.randr.GetScreenInfo.reply.sizes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenInfo_reply_rates, { "rates", "x11.randr.GetScreenInfo.reply.rates", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenSizeRange_window, { "window", "x11.randr.GetScreenSizeRange.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenSizeRange_reply_min_width, { "min_width", "x11.randr.GetScreenSizeRange.reply.min_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenSizeRange_reply_min_height, { "min_height", "x11.randr.GetScreenSizeRange.reply.min_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenSizeRange_reply_max_width, { "max_width", "x11.randr.GetScreenSizeRange.reply.max_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenSizeRange_reply_max_height, { "max_height", "x11.randr.GetScreenSizeRange.reply.max_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenSize_window, { "window", "x11.randr.SetScreenSize.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenSize_width, { "width", "x11.randr.SetScreenSize.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenSize_height, { "height", "x11.randr.SetScreenSize.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenSize_mm_width, { "mm_width", "x11.randr.SetScreenSize.mm_width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetScreenSize_mm_height, { "mm_height", "x11.randr.SetScreenSize.mm_height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo, { "ModeInfo", "x11.struct.ModeInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_id, { "id", "x11.struct.ModeInfo.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_width, { "width", "x11.struct.ModeInfo.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_height, { "height", "x11.struct.ModeInfo.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_dot_clock, { "dot_clock", "x11.struct.ModeInfo.dot_clock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_hsync_start, { "hsync_start", "x11.struct.ModeInfo.hsync_start", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_hsync_end, { "hsync_end", "x11.struct.ModeInfo.hsync_end", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_htotal, { "htotal", "x11.struct.ModeInfo.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_hskew, { "hskew", "x11.struct.ModeInfo.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_vsync_start, { "vsync_start", "x11.struct.ModeInfo.vsync_start", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_vsync_end, { "vsync_end", "x11.struct.ModeInfo.vsync_end", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_vtotal, { "vtotal", "x11.struct.ModeInfo.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_name_len, { "name_len", "x11.struct.ModeInfo.name_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ModeInfo_mode_flags, { "mode_flags", "x11.struct.ModeInfo.mode_flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_window, { "window", "x11.randr.GetScreenResources.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_timestamp, { "timestamp", "x11.randr.GetScreenResources.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_config_timestamp, { "config_timestamp", "x11.randr.GetScreenResources.reply.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_num_crtcs, { "num_crtcs", "x11.randr.GetScreenResources.reply.num_crtcs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_num_outputs, { "num_outputs", "x11.randr.GetScreenResources.reply.num_outputs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_num_modes, { "num_modes", "x11.randr.GetScreenResources.reply.num_modes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_names_len, { "names_len", "x11.randr.GetScreenResources.reply.names_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_crtcs, { "crtcs", "x11.randr.GetScreenResources.reply.crtcs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_crtcs_item, { "crtcs", "x11.randr.GetScreenResources.reply.crtcs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_outputs, { "outputs", "x11.randr.GetScreenResources.reply.outputs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_outputs_item, { "outputs", "x11.randr.GetScreenResources.reply.outputs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_modes, { "modes", "x11.randr.GetScreenResources.reply.modes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_modes_item, { "modes", "x11.randr.GetScreenResources.reply.modes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResources_reply_names, { "names", "x11.randr.GetScreenResources.reply.names", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_output, { "output", "x11.randr.GetOutputInfo.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_config_timestamp, { "config_timestamp", "x11.randr.GetOutputInfo.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_status, { "status", "x11.randr.GetOutputInfo.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_timestamp, { "timestamp", "x11.randr.GetOutputInfo.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_crtc, { "crtc", "x11.randr.GetOutputInfo.reply.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_mm_width, { "mm_width", "x11.randr.GetOutputInfo.reply.mm_width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_mm_height, { "mm_height", "x11.randr.GetOutputInfo.reply.mm_height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_connection, { "connection", "x11.randr.GetOutputInfo.reply.connection", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_subpixel_order, { "subpixel_order", "x11.randr.GetOutputInfo.reply.subpixel_order", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_num_crtcs, { "num_crtcs", "x11.randr.GetOutputInfo.reply.num_crtcs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_num_modes, { "num_modes", "x11.randr.GetOutputInfo.reply.num_modes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_num_preferred, { "num_preferred", "x11.randr.GetOutputInfo.reply.num_preferred", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_num_clones, { "num_clones", "x11.randr.GetOutputInfo.reply.num_clones", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_name_len, { "name_len", "x11.randr.GetOutputInfo.reply.name_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_crtcs, { "crtcs", "x11.randr.GetOutputInfo.reply.crtcs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_crtcs_item, { "crtcs", "x11.randr.GetOutputInfo.reply.crtcs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_modes, { "modes", "x11.randr.GetOutputInfo.reply.modes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_modes_item, { "modes", "x11.randr.GetOutputInfo.reply.modes", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_clones, { "clones", "x11.randr.GetOutputInfo.reply.clones", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_clones_item, { "clones", "x11.randr.GetOutputInfo.reply.clones", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputInfo_reply_name, { "name", "x11.randr.GetOutputInfo.reply.name", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ListOutputProperties_output, { "output", "x11.randr.ListOutputProperties.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ListOutputProperties_reply_num_atoms, { "num_atoms", "x11.randr.ListOutputProperties.reply.num_atoms", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ListOutputProperties_reply_atoms, { "atoms", "x11.randr.ListOutputProperties.reply.atoms", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ListOutputProperties_reply_atoms_item, { "atoms", "x11.randr.ListOutputProperties.reply.atoms", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_output, { "output", "x11.randr.QueryOutputProperty.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_property, { "property", "x11.randr.QueryOutputProperty.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_reply_pending, { "pending", "x11.randr.QueryOutputProperty.reply.pending", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_reply_range, { "range", "x11.randr.QueryOutputProperty.reply.range", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_reply_immutable, { "immutable", "x11.randr.QueryOutputProperty.reply.immutable", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_reply_validValues, { "validValues", "x11.randr.QueryOutputProperty.reply.validValues", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_QueryOutputProperty_reply_validValues_item, { "validValues", "x11.randr.QueryOutputProperty.reply.validValues", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ConfigureOutputProperty_output, { "output", "x11.randr.ConfigureOutputProperty.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ConfigureOutputProperty_property, { "property", "x11.randr.ConfigureOutputProperty.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ConfigureOutputProperty_pending, { "pending", "x11.randr.ConfigureOutputProperty.pending", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ConfigureOutputProperty_range, { "range", "x11.randr.ConfigureOutputProperty.range", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ConfigureOutputProperty_values, { "values", "x11.randr.ConfigureOutputProperty.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ConfigureOutputProperty_values_item, { "values", "x11.randr.ConfigureOutputProperty.values", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_output, { "output", "x11.randr.ChangeOutputProperty.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_property, { "property", "x11.randr.ChangeOutputProperty.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_type, { "type", "x11.randr.ChangeOutputProperty.type", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_format, { "format", "x11.randr.ChangeOutputProperty.format", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_mode, { "mode", "x11.randr.ChangeOutputProperty.mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_num_units, { "num_units", "x11.randr.ChangeOutputProperty.num_units", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ChangeOutputProperty_data, { "data", "x11.randr.ChangeOutputProperty.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_DeleteOutputProperty_output, { "output", "x11.randr.DeleteOutputProperty.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_DeleteOutputProperty_property, { "property", "x11.randr.DeleteOutputProperty.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_output, { "output", "x11.randr.GetOutputProperty.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_property, { "property", "x11.randr.GetOutputProperty.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_type, { "type", "x11.randr.GetOutputProperty.type", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_long_offset, { "long_offset", "x11.randr.GetOutputProperty.long_offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_long_length, { "long_length", "x11.randr.GetOutputProperty.long_length", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_delete, { "delete", "x11.randr.GetOutputProperty.delete", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_pending, { "pending", "x11.randr.GetOutputProperty.pending", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_reply_format, { "format", "x11.randr.GetOutputProperty.reply.format", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_reply_type, { "type", "x11.randr.GetOutputProperty.reply.type", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_reply_bytes_after, { "bytes_after", "x11.randr.GetOutputProperty.reply.bytes_after", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_reply_num_items, { "num_items", "x11.randr.GetOutputProperty.reply.num_items", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputProperty_reply_data, { "data", "x11.randr.GetOutputProperty.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_CreateMode_window, { "window", "x11.randr.CreateMode.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_CreateMode_mode_info, { "mode_info", "x11.randr.CreateMode.mode_info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_CreateMode_name, { "name", "x11.randr.CreateMode.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_CreateMode_reply_mode, { "mode", "x11.randr.CreateMode.reply.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_DestroyMode_mode, { "mode", "x11.randr.DestroyMode.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_AddOutputMode_output, { "output", "x11.randr.AddOutputMode.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_AddOutputMode_mode, { "mode", "x11.randr.AddOutputMode.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_DeleteOutputMode_output, { "output", "x11.randr.DeleteOutputMode.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_DeleteOutputMode_mode, { "mode", "x11.randr.DeleteOutputMode.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_crtc, { "crtc", "x11.randr.GetCrtcInfo.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_config_timestamp, { "config_timestamp", "x11.randr.GetCrtcInfo.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_status, { "status", "x11.randr.GetCrtcInfo.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_timestamp, { "timestamp", "x11.randr.GetCrtcInfo.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_x, { "x", "x11.randr.GetCrtcInfo.reply.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_y, { "y", "x11.randr.GetCrtcInfo.reply.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_width, { "width", "x11.randr.GetCrtcInfo.reply.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_height, { "height", "x11.randr.GetCrtcInfo.reply.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_mode, { "mode", "x11.randr.GetCrtcInfo.reply.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_rotation, { "rotation", "x11.randr.GetCrtcInfo.reply.rotation", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_rotations, { "rotations", "x11.randr.GetCrtcInfo.reply.rotations", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_num_outputs, { "num_outputs", "x11.randr.GetCrtcInfo.reply.num_outputs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_num_possible_outputs, { "num_possible_outputs", "x11.randr.GetCrtcInfo.reply.num_possible_outputs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_outputs, { "outputs", "x11.randr.GetCrtcInfo.reply.outputs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_outputs_item, { "outputs", "x11.randr.GetCrtcInfo.reply.outputs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_possible, { "possible", "x11.randr.GetCrtcInfo.reply.possible", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcInfo_reply_possible_item, { "possible", "x11.randr.GetCrtcInfo.reply.possible", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_crtc, { "crtc", "x11.randr.SetCrtcConfig.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_timestamp, { "timestamp", "x11.randr.SetCrtcConfig.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_config_timestamp, { "config_timestamp", "x11.randr.SetCrtcConfig.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_x, { "x", "x11.randr.SetCrtcConfig.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_y, { "y", "x11.randr.SetCrtcConfig.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_mode, { "mode", "x11.randr.SetCrtcConfig.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_rotation, { "rotation", "x11.randr.SetCrtcConfig.rotation", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_outputs, { "outputs", "x11.randr.SetCrtcConfig.outputs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_outputs_item, { "outputs", "x11.randr.SetCrtcConfig.outputs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_reply_status, { "status", "x11.randr.SetCrtcConfig.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcConfig_reply_timestamp, { "timestamp", "x11.randr.SetCrtcConfig.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGammaSize_crtc, { "crtc", "x11.randr.GetCrtcGammaSize.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGammaSize_reply_size, { "size", "x11.randr.GetCrtcGammaSize.reply.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_crtc, { "crtc", "x11.randr.GetCrtcGamma.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_size, { "size", "x11.randr.GetCrtcGamma.reply.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_red, { "red", "x11.randr.GetCrtcGamma.reply.red", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_red_item, { "red", "x11.randr.GetCrtcGamma.reply.red", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_green, { "green", "x11.randr.GetCrtcGamma.reply.green", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_green_item, { "green", "x11.randr.GetCrtcGamma.reply.green", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_blue, { "blue", "x11.randr.GetCrtcGamma.reply.blue", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcGamma_reply_blue_item, { "blue", "x11.randr.GetCrtcGamma.reply.blue", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_crtc, { "crtc", "x11.randr.SetCrtcGamma.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_size, { "size", "x11.randr.SetCrtcGamma.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_red, { "red", "x11.randr.SetCrtcGamma.red", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_red_item, { "red", "x11.randr.SetCrtcGamma.red", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_green, { "green", "x11.randr.SetCrtcGamma.green", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_green_item, { "green", "x11.randr.SetCrtcGamma.green", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_blue, { "blue", "x11.randr.SetCrtcGamma.blue", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcGamma_blue_item, { "blue", "x11.randr.SetCrtcGamma.blue", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_window, { "window", "x11.randr.GetScreenResourcesCurrent.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_timestamp, { "timestamp", "x11.randr.GetScreenResourcesCurrent.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_config_timestamp, { "config_timestamp", "x11.randr.GetScreenResourcesCurrent.reply.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_num_crtcs, { "num_crtcs", "x11.randr.GetScreenResourcesCurrent.reply.num_crtcs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_num_outputs, { "num_outputs", "x11.randr.GetScreenResourcesCurrent.reply.num_outputs", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_num_modes, { "num_modes", "x11.randr.GetScreenResourcesCurrent.reply.num_modes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_names_len, { "names_len", "x11.randr.GetScreenResourcesCurrent.reply.names_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs, { "crtcs", "x11.randr.GetScreenResourcesCurrent.reply.crtcs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs_item, { "crtcs", "x11.randr.GetScreenResourcesCurrent.reply.crtcs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_outputs, { "outputs", "x11.randr.GetScreenResourcesCurrent.reply.outputs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_outputs_item, { "outputs", "x11.randr.GetScreenResourcesCurrent.reply.outputs", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_modes, { "modes", "x11.randr.GetScreenResourcesCurrent.reply.modes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_modes_item, { "modes", "x11.randr.GetScreenResourcesCurrent.reply.modes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetScreenResourcesCurrent_reply_names, { "names", "x11.randr.GetScreenResourcesCurrent.reply.names", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcTransform_crtc, { "crtc", "x11.randr.SetCrtcTransform.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcTransform_transform, { "transform", "x11.randr.SetCrtcTransform.transform", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcTransform_filter_len, { "filter_len", "x11.randr.SetCrtcTransform.filter_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcTransform_filter_name, { "filter_name", "x11.randr.SetCrtcTransform.filter_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcTransform_filter_params, { "filter_params", "x11.randr.SetCrtcTransform.filter_params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetCrtcTransform_filter_params_item, { "filter_params", "x11.randr.SetCrtcTransform.filter_params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_crtc, { "crtc", "x11.randr.GetCrtcTransform.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_pending_transform, { "pending_transform", "x11.randr.GetCrtcTransform.reply.pending_transform", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_has_transforms, { "has_transforms", "x11.randr.GetCrtcTransform.reply.has_transforms", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_current_transform, { "current_transform", "x11.randr.GetCrtcTransform.reply.current_transform", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_pending_len, { "pending_len", "x11.randr.GetCrtcTransform.reply.pending_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_pending_nparams, { "pending_nparams", "x11.randr.GetCrtcTransform.reply.pending_nparams", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_current_len, { "current_len", "x11.randr.GetCrtcTransform.reply.current_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_current_nparams, { "current_nparams", "x11.randr.GetCrtcTransform.reply.current_nparams", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_pending_filter_name, { "pending_filter_name", "x11.randr.GetCrtcTransform.reply.pending_filter_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_pending_params, { "pending_params", "x11.randr.GetCrtcTransform.reply.pending_params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_pending_params_item, { "pending_params", "x11.randr.GetCrtcTransform.reply.pending_params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_current_filter_name, { "current_filter_name", "x11.randr.GetCrtcTransform.reply.current_filter_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_current_params, { "current_params", "x11.randr.GetCrtcTransform.reply.current_params", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetCrtcTransform_reply_current_params_item, { "current_params", "x11.randr.GetCrtcTransform.reply.current_params", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_crtc, { "crtc", "x11.randr.GetPanning.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_status, { "status", "x11.randr.GetPanning.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_timestamp, { "timestamp", "x11.randr.GetPanning.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_left, { "left", "x11.randr.GetPanning.reply.left", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_top, { "top", "x11.randr.GetPanning.reply.top", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_width, { "width", "x11.randr.GetPanning.reply.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_height, { "height", "x11.randr.GetPanning.reply.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_track_left, { "track_left", "x11.randr.GetPanning.reply.track_left", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_track_top, { "track_top", "x11.randr.GetPanning.reply.track_top", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_track_width, { "track_width", "x11.randr.GetPanning.reply.track_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_track_height, { "track_height", "x11.randr.GetPanning.reply.track_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_border_left, { "border_left", "x11.randr.GetPanning.reply.border_left", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_border_top, { "border_top", "x11.randr.GetPanning.reply.border_top", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_border_right, { "border_right", "x11.randr.GetPanning.reply.border_right", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetPanning_reply_border_bottom, { "border_bottom", "x11.randr.GetPanning.reply.border_bottom", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_crtc, { "crtc", "x11.randr.SetPanning.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_timestamp, { "timestamp", "x11.randr.SetPanning.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_left, { "left", "x11.randr.SetPanning.left", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_top, { "top", "x11.randr.SetPanning.top", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_width, { "width", "x11.randr.SetPanning.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_height, { "height", "x11.randr.SetPanning.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_track_left, { "track_left", "x11.randr.SetPanning.track_left", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_track_top, { "track_top", "x11.randr.SetPanning.track_top", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_track_width, { "track_width", "x11.randr.SetPanning.track_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_track_height, { "track_height", "x11.randr.SetPanning.track_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_border_left, { "border_left", "x11.randr.SetPanning.border_left", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_border_top, { "border_top", "x11.randr.SetPanning.border_top", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_border_right, { "border_right", "x11.randr.SetPanning.border_right", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_border_bottom, { "border_bottom", "x11.randr.SetPanning.border_bottom", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_reply_status, { "status", "x11.randr.SetPanning.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetPanning_reply_timestamp, { "timestamp", "x11.randr.SetPanning.reply.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetOutputPrimary_window, { "window", "x11.randr.SetOutputPrimary.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_SetOutputPrimary_output, { "output", "x11.randr.SetOutputPrimary.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputPrimary_window, { "window", "x11.randr.GetOutputPrimary.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_GetOutputPrimary_reply_output, { "output", "x11.randr.GetOutputPrimary.reply.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_rotation, { "rotation", "x11.randr.ScreenChangeNotify.rotation", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_timestamp, { "timestamp", "x11.randr.ScreenChangeNotify.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_config_timestamp, { "config_timestamp", "x11.randr.ScreenChangeNotify.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_root, { "root", "x11.randr.ScreenChangeNotify.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_request_window, { "request_window", "x11.randr.ScreenChangeNotify.request_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_sizeID, { "sizeID", "x11.randr.ScreenChangeNotify.sizeID", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_subpixel_order, { "subpixel_order", "x11.randr.ScreenChangeNotify.subpixel_order", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_width, { "width", "x11.randr.ScreenChangeNotify.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_height, { "height", "x11.randr.ScreenChangeNotify.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_mwidth, { "mwidth", "x11.randr.ScreenChangeNotify.mwidth", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_ScreenChangeNotify_mheight, { "mheight", "x11.randr.ScreenChangeNotify.mheight", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange, { "CrtcChange", "x11.struct.CrtcChange", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_timestamp, { "timestamp", "x11.struct.CrtcChange.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_window, { "window", "x11.struct.CrtcChange.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_crtc, { "crtc", "x11.struct.CrtcChange.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_mode, { "mode", "x11.struct.CrtcChange.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_rotation, { "rotation", "x11.struct.CrtcChange.rotation", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_x, { "x", "x11.struct.CrtcChange.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_y, { "y", "x11.struct.CrtcChange.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_width, { "width", "x11.struct.CrtcChange.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_CrtcChange_height, { "height", "x11.struct.CrtcChange.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange, { "OutputChange", "x11.struct.OutputChange", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_timestamp, { "timestamp", "x11.struct.OutputChange.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_config_timestamp, { "config_timestamp", "x11.struct.OutputChange.config_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_window, { "window", "x11.struct.OutputChange.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_output, { "output", "x11.struct.OutputChange.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_crtc, { "crtc", "x11.struct.OutputChange.crtc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_mode, { "mode", "x11.struct.OutputChange.mode", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_rotation, { "rotation", "x11.struct.OutputChange.rotation", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_connection, { "connection", "x11.struct.OutputChange.connection", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputChange_subpixel_order, { "subpixel_order", "x11.struct.OutputChange.subpixel_order", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputProperty, { "OutputProperty", "x11.struct.OutputProperty", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputProperty_window, { "window", "x11.struct.OutputProperty.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputProperty_output, { "output", "x11.struct.OutputProperty.output", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputProperty_atom, { "atom", "x11.struct.OutputProperty.atom", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputProperty_timestamp, { "timestamp", "x11.struct.OutputProperty.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_OutputProperty_status, { "status", "x11.struct.OutputProperty.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_union_NotifyData, { "NotifyData", "x11.union.NotifyData", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_Notify_subCode, { "subCode", "x11.randr.Notify.subCode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_Notify_u, { "u", "x11.randr.Notify.u", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_randr_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(randr_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_Range8, { "Range8", "x11.struct.Range8", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range8_first, { "first", "x11.struct.Range8.first", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range8_last, { "last", "x11.struct.Range8.last", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range16, { "Range16", "x11.struct.Range16", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range16_first, { "first", "x11.struct.Range16.first", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range16_last, { "last", "x11.struct.Range16.last", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ExtRange, { "ExtRange", "x11.struct.ExtRange", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ExtRange_major, { "major", "x11.struct.ExtRange.major", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ExtRange_minor, { "minor", "x11.struct.ExtRange.minor", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range, { "Range", "x11.struct.Range", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_core_requests, { "core_requests", "x11.struct.Range.core_requests", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_core_replies, { "core_replies", "x11.struct.Range.core_replies", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_ext_requests, { "ext_requests", "x11.struct.Range.ext_requests", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_ext_replies, { "ext_replies", "x11.struct.Range.ext_replies", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_delivered_events, { "delivered_events", "x11.struct.Range.delivered_events", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_device_events, { "device_events", "x11.struct.Range.device_events", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_errors, { "errors", "x11.struct.Range.errors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_client_started, { "client_started", "x11.struct.Range.client_started", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Range_client_died, { "client_died", "x11.struct.Range.client_died", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ClientInfo, { "ClientInfo", "x11.struct.ClientInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ClientInfo_client_resource, { "client_resource", "x11.struct.ClientInfo.client_resource", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ClientInfo_num_ranges, { "num_ranges", "x11.struct.ClientInfo.num_ranges", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ClientInfo_ranges, { "ranges", "x11.struct.ClientInfo.ranges", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ClientInfo_ranges_item, { "ranges", "x11.struct.ClientInfo.ranges", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_QueryVersion_major_version, { "major_version", "x11.record.QueryVersion.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_QueryVersion_minor_version, { "minor_version", "x11.record.QueryVersion.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_QueryVersion_reply_major_version, { "major_version", "x11.record.QueryVersion.reply.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_QueryVersion_reply_minor_version, { "minor_version", "x11.record.QueryVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_context, { "context", "x11.record.CreateContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_element_header, { "element_header", "x11.record.CreateContext.element_header", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_num_client_specs, { "num_client_specs", "x11.record.CreateContext.num_client_specs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_num_ranges, { "num_ranges", "x11.record.CreateContext.num_ranges", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_client_specs, { "client_specs", "x11.record.CreateContext.client_specs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_client_specs_item, { "client_specs", "x11.record.CreateContext.client_specs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_ranges, { "ranges", "x11.record.CreateContext.ranges", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_CreateContext_ranges_item, { "ranges", "x11.record.CreateContext.ranges", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_context, { "context", "x11.record.RegisterClients.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_element_header, { "element_header", "x11.record.RegisterClients.element_header", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_num_client_specs, { "num_client_specs", "x11.record.RegisterClients.num_client_specs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_num_ranges, { "num_ranges", "x11.record.RegisterClients.num_ranges", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_client_specs, { "client_specs", "x11.record.RegisterClients.client_specs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_client_specs_item, { "client_specs", "x11.record.RegisterClients.client_specs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_ranges, { "ranges", "x11.record.RegisterClients.ranges", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_RegisterClients_ranges_item, { "ranges", "x11.record.RegisterClients.ranges", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_UnregisterClients_context, { "context", "x11.record.UnregisterClients.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_UnregisterClients_num_client_specs, { "num_client_specs", "x11.record.UnregisterClients.num_client_specs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_UnregisterClients_client_specs, { "client_specs", "x11.record.UnregisterClients.client_specs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_UnregisterClients_client_specs_item, { "client_specs", "x11.record.UnregisterClients.client_specs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_GetContext_context, { "context", "x11.record.GetContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_GetContext_reply_enabled, { "enabled", "x11.record.GetContext.reply.enabled", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_GetContext_reply_element_header, { "element_header", "x11.record.GetContext.reply.element_header", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_GetContext_reply_num_intercepted_clients, { "num_intercepted_clients", "x11.record.GetContext.reply.num_intercepted_clients", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_GetContext_reply_intercepted_clients, { "intercepted_clients", "x11.record.GetContext.reply.intercepted_clients", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_context, { "context", "x11.record.EnableContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_category, { "category", "x11.record.EnableContext.reply.category", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_element_header, { "element_header", "x11.record.EnableContext.reply.element_header", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_client_swapped, { "client_swapped", "x11.record.EnableContext.reply.client_swapped", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_xid_base, { "xid_base", "x11.record.EnableContext.reply.xid_base", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_server_time, { "server_time", "x11.record.EnableContext.reply.server_time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_rec_sequence_num, { "rec_sequence_num", "x11.record.EnableContext.reply.rec_sequence_num", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_EnableContext_reply_data, { "data", "x11.record.EnableContext.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_DisableContext_context, { "context", "x11.record.DisableContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_FreeContext_context, { "context", "x11.record.FreeContext.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_record_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(record_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_render_QueryVersion_client_major_version, { "client_major_version", "x11.render.QueryVersion.client_major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryVersion_client_minor_version, { "client_minor_version", "x11.render.QueryVersion.client_minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryVersion_reply_major_version, { "major_version", "x11.render.QueryVersion.reply.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryVersion_reply_minor_version, { "minor_version", "x11.render.QueryVersion.reply.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_num_formats, { "num_formats", "x11.render.QueryPictFormats.reply.num_formats", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_num_screens, { "num_screens", "x11.render.QueryPictFormats.reply.num_screens", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_num_depths, { "num_depths", "x11.render.QueryPictFormats.reply.num_depths", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_num_visuals, { "num_visuals", "x11.render.QueryPictFormats.reply.num_visuals", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_num_subpixel, { "num_subpixel", "x11.render.QueryPictFormats.reply.num_subpixel", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_formats, { "formats", "x11.render.QueryPictFormats.reply.formats", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_formats_item, { "formats", "x11.render.QueryPictFormats.reply.formats", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_screens, { "screens", "x11.render.QueryPictFormats.reply.screens", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_subpixels, { "subpixels", "x11.render.QueryPictFormats.reply.subpixels", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictFormats_reply_subpixels_item, { "subpixels", "x11.render.QueryPictFormats.reply.subpixels", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictIndexValues_format, { "format", "x11.render.QueryPictIndexValues.format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictIndexValues_reply_num_values, { "num_values", "x11.render.QueryPictIndexValues.reply.num_values", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictIndexValues_reply_values, { "values", "x11.render.QueryPictIndexValues.reply.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryPictIndexValues_reply_values_item, { "values", "x11.render.QueryPictIndexValues.reply.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreatePicture_pid, { "pid", "x11.render.CreatePicture.pid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreatePicture_drawable, { "drawable", "x11.render.CreatePicture.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreatePicture_format, { "format", "x11.render.CreatePicture.format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_ChangePicture_picture, { "picture", "x11.render.ChangePicture.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureClipRectangles_picture, { "picture", "x11.render.SetPictureClipRectangles.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureClipRectangles_clip_x_origin, { "clip_x_origin", "x11.render.SetPictureClipRectangles.clip_x_origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureClipRectangles_clip_y_origin, { "clip_y_origin", "x11.render.SetPictureClipRectangles.clip_y_origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureClipRectangles_rectangles, { "rectangles", "x11.render.SetPictureClipRectangles.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureClipRectangles_rectangles_item, { "rectangles", "x11.render.SetPictureClipRectangles.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FreePicture_picture, { "picture", "x11.render.FreePicture.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_op, { "op", "x11.render.Composite.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_src, { "src", "x11.render.Composite.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_mask, { "mask", "x11.render.Composite.mask", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_dst, { "dst", "x11.render.Composite.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_src_x, { "src_x", "x11.render.Composite.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_src_y, { "src_y", "x11.render.Composite.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_mask_x, { "mask_x", "x11.render.Composite.mask_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_mask_y, { "mask_y", "x11.render.Composite.mask_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_dst_x, { "dst_x", "x11.render.Composite.dst_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_dst_y, { "dst_y", "x11.render.Composite.dst_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_width, { "width", "x11.render.Composite.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Composite_height, { "height", "x11.render.Composite.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_op, { "op", "x11.render.Trapezoids.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_src, { "src", "x11.render.Trapezoids.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_dst, { "dst", "x11.render.Trapezoids.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_mask_format, { "mask_format", "x11.render.Trapezoids.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_src_x, { "src_x", "x11.render.Trapezoids.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_src_y, { "src_y", "x11.render.Trapezoids.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_traps, { "traps", "x11.render.Trapezoids.traps", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Trapezoids_traps_item, { "traps", "x11.render.Trapezoids.traps", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_op, { "op", "x11.render.Triangles.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_src, { "src", "x11.render.Triangles.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_dst, { "dst", "x11.render.Triangles.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_mask_format, { "mask_format", "x11.render.Triangles.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_src_x, { "src_x", "x11.render.Triangles.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_src_y, { "src_y", "x11.render.Triangles.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_triangles, { "triangles", "x11.render.Triangles.triangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_Triangles_triangles_item, { "triangles", "x11.render.Triangles.triangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_op, { "op", "x11.render.TriStrip.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_src, { "src", "x11.render.TriStrip.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_dst, { "dst", "x11.render.TriStrip.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_mask_format, { "mask_format", "x11.render.TriStrip.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_src_x, { "src_x", "x11.render.TriStrip.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_src_y, { "src_y", "x11.render.TriStrip.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_points, { "points", "x11.render.TriStrip.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriStrip_points_item, { "points", "x11.render.TriStrip.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_op, { "op", "x11.render.TriFan.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_src, { "src", "x11.render.TriFan.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_dst, { "dst", "x11.render.TriFan.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_mask_format, { "mask_format", "x11.render.TriFan.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_src_x, { "src_x", "x11.render.TriFan.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_src_y, { "src_y", "x11.render.TriFan.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_points, { "points", "x11.render.TriFan.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_TriFan_points_item, { "points", "x11.render.TriFan.points", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateGlyphSet_gsid, { "gsid", "x11.render.CreateGlyphSet.gsid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateGlyphSet_format, { "format", "x11.render.CreateGlyphSet.format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_ReferenceGlyphSet_gsid, { "gsid", "x11.render.ReferenceGlyphSet.gsid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_ReferenceGlyphSet_existing, { "existing", "x11.render.ReferenceGlyphSet.existing", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FreeGlyphSet_glyphset, { "glyphset", "x11.render.FreeGlyphSet.glyphset", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_glyphset, { "glyphset", "x11.render.AddGlyphs.glyphset", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_glyphs_len, { "glyphs_len", "x11.render.AddGlyphs.glyphs_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_glyphids, { "glyphids", "x11.render.AddGlyphs.glyphids", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_glyphids_item, { "glyphids", "x11.render.AddGlyphs.glyphids", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_glyphs, { "glyphs", "x11.render.AddGlyphs.glyphs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_glyphs_item, { "glyphs", "x11.render.AddGlyphs.glyphs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddGlyphs_data, { "data", "x11.render.AddGlyphs.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FreeGlyphs_glyphset, { "glyphset", "x11.render.FreeGlyphs.glyphset", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FreeGlyphs_glyphs, { "glyphs", "x11.render.FreeGlyphs.glyphs", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FreeGlyphs_glyphs_item, { "glyphs", "x11.render.FreeGlyphs.glyphs", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_op, { "op", "x11.render.CompositeGlyphs8.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_src, { "src", "x11.render.CompositeGlyphs8.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_dst, { "dst", "x11.render.CompositeGlyphs8.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_mask_format, { "mask_format", "x11.render.CompositeGlyphs8.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_glyphset, { "glyphset", "x11.render.CompositeGlyphs8.glyphset", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_src_x, { "src_x", "x11.render.CompositeGlyphs8.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_src_y, { "src_y", "x11.render.CompositeGlyphs8.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs8_glyphcmds, { "glyphcmds", "x11.render.CompositeGlyphs8.glyphcmds", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_op, { "op", "x11.render.CompositeGlyphs16.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_src, { "src", "x11.render.CompositeGlyphs16.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_dst, { "dst", "x11.render.CompositeGlyphs16.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_mask_format, { "mask_format", "x11.render.CompositeGlyphs16.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_glyphset, { "glyphset", "x11.render.CompositeGlyphs16.glyphset", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_src_x, { "src_x", "x11.render.CompositeGlyphs16.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_src_y, { "src_y", "x11.render.CompositeGlyphs16.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs16_glyphcmds, { "glyphcmds", "x11.render.CompositeGlyphs16.glyphcmds", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_op, { "op", "x11.render.CompositeGlyphs32.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_src, { "src", "x11.render.CompositeGlyphs32.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_dst, { "dst", "x11.render.CompositeGlyphs32.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_mask_format, { "mask_format", "x11.render.CompositeGlyphs32.mask_format", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_glyphset, { "glyphset", "x11.render.CompositeGlyphs32.glyphset", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_src_x, { "src_x", "x11.render.CompositeGlyphs32.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_src_y, { "src_y", "x11.render.CompositeGlyphs32.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CompositeGlyphs32_glyphcmds, { "glyphcmds", "x11.render.CompositeGlyphs32.glyphcmds", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FillRectangles_op, { "op", "x11.render.FillRectangles.op", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FillRectangles_dst, { "dst", "x11.render.FillRectangles.dst", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FillRectangles_color, { "color", "x11.render.FillRectangles.color", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FillRectangles_rects, { "rects", "x11.render.FillRectangles.rects", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_FillRectangles_rects_item, { "rects", "x11.render.FillRectangles.rects", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateCursor_cid, { "cid", "x11.render.CreateCursor.cid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateCursor_source, { "source", "x11.render.CreateCursor.source", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateCursor_x, { "x", "x11.render.CreateCursor.x", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateCursor_y, { "y", "x11.render.CreateCursor.y", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureTransform_picture, { "picture", "x11.render.SetPictureTransform.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureTransform_transform, { "transform", "x11.render.SetPictureTransform.transform", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryFilters_drawable, { "drawable", "x11.render.QueryFilters.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryFilters_reply_num_aliases, { "num_aliases", "x11.render.QueryFilters.reply.num_aliases", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryFilters_reply_num_filters, { "num_filters", "x11.render.QueryFilters.reply.num_filters", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryFilters_reply_aliases, { "aliases", "x11.render.QueryFilters.reply.aliases", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryFilters_reply_aliases_item, { "aliases", "x11.render.QueryFilters.reply.aliases", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_QueryFilters_reply_filters, { "filters", "x11.render.QueryFilters.reply.filters", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureFilter_picture, { "picture", "x11.render.SetPictureFilter.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureFilter_filter_len, { "filter_len", "x11.render.SetPictureFilter.filter_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureFilter_filter, { "filter", "x11.render.SetPictureFilter.filter", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureFilter_values, { "values", "x11.render.SetPictureFilter.values", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_SetPictureFilter_values_item, { "values", "x11.render.SetPictureFilter.values", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateAnimCursor_cid, { "cid", "x11.render.CreateAnimCursor.cid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateAnimCursor_cursors, { "cursors", "x11.render.CreateAnimCursor.cursors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateAnimCursor_cursors_item, { "cursors", "x11.render.CreateAnimCursor.cursors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddTraps_picture, { "picture", "x11.render.AddTraps.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddTraps_x_off, { "x_off", "x11.render.AddTraps.x_off", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddTraps_y_off, { "y_off", "x11.render.AddTraps.y_off", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddTraps_traps, { "traps", "x11.render.AddTraps.traps", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_AddTraps_traps_item, { "traps", "x11.render.AddTraps.traps", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateSolidFill_picture, { "picture", "x11.render.CreateSolidFill.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateSolidFill_color, { "color", "x11.render.CreateSolidFill.color", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_picture, { "picture", "x11.render.CreateLinearGradient.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_p1, { "p1", "x11.render.CreateLinearGradient.p1", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_p2, { "p2", "x11.render.CreateLinearGradient.p2", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_num_stops, { "num_stops", "x11.render.CreateLinearGradient.num_stops", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_stops, { "stops", "x11.render.CreateLinearGradient.stops", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_stops_item, { "stops", "x11.render.CreateLinearGradient.stops", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_colors, { "colors", "x11.render.CreateLinearGradient.colors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateLinearGradient_colors_item, { "colors", "x11.render.CreateLinearGradient.colors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_picture, { "picture", "x11.render.CreateRadialGradient.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_inner, { "inner", "x11.render.CreateRadialGradient.inner", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_outer, { "outer", "x11.render.CreateRadialGradient.outer", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_inner_radius, { "inner_radius", "x11.render.CreateRadialGradient.inner_radius", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_outer_radius, { "outer_radius", "x11.render.CreateRadialGradient.outer_radius", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_num_stops, { "num_stops", "x11.render.CreateRadialGradient.num_stops", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_stops, { "stops", "x11.render.CreateRadialGradient.stops", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_stops_item, { "stops", "x11.render.CreateRadialGradient.stops", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_colors, { "colors", "x11.render.CreateRadialGradient.colors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateRadialGradient_colors_item, { "colors", "x11.render.CreateRadialGradient.colors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_picture, { "picture", "x11.render.CreateConicalGradient.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_center, { "center", "x11.render.CreateConicalGradient.center", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_angle, { "angle", "x11.render.CreateConicalGradient.angle", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_num_stops, { "num_stops", "x11.render.CreateConicalGradient.num_stops", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_stops, { "stops", "x11.render.CreateConicalGradient.stops", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_stops_item, { "stops", "x11.render.CreateConicalGradient.stops", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_colors, { "colors", "x11.render.CreateConicalGradient.colors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_CreateConicalGradient_colors_item, { "colors", "x11.render.CreateConicalGradient.colors", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_render_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(render_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_Client, { "Client", "x11.struct.Client", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Client_resource_base, { "resource_base", "x11.struct.Client.resource_base", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Client_resource_mask, { "resource_mask", "x11.struct.Client.resource_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Type, { "Type", "x11.struct.Type", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Type_resource_type, { "resource_type", "x11.struct.Type.resource_type", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Type_count, { "count", "x11.struct.Type.count", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryVersion_client_major, { "client_major", "x11.res.QueryVersion.client_major", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryVersion_client_minor, { "client_minor", "x11.res.QueryVersion.client_minor", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryVersion_reply_server_major, { "server_major", "x11.res.QueryVersion.reply.server_major", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryVersion_reply_server_minor, { "server_minor", "x11.res.QueryVersion.reply.server_minor", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClients_reply_num_clients, { "num_clients", "x11.res.QueryClients.reply.num_clients", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClients_reply_clients, { "clients", "x11.res.QueryClients.reply.clients", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClients_reply_clients_item, { "clients", "x11.res.QueryClients.reply.clients", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientResources_xid, { "xid", "x11.res.QueryClientResources.xid", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientResources_reply_num_types, { "num_types", "x11.res.QueryClientResources.reply.num_types", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientResources_reply_types, { "types", "x11.res.QueryClientResources.reply.types", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientResources_reply_types_item, { "types", "x11.res.QueryClientResources.reply.types", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientPixmapBytes_xid, { "xid", "x11.res.QueryClientPixmapBytes.xid", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientPixmapBytes_reply_bytes, { "bytes", "x11.res.QueryClientPixmapBytes.reply.bytes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_QueryClientPixmapBytes_reply_bytes_overflow, { "bytes_overflow", "x11.res.QueryClientPixmapBytes.reply.bytes_overflow", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_res_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(res_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_screensaver_QueryVersion_client_major_version, { "client_major_version", "x11.screensaver.QueryVersion.client_major_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryVersion_client_minor_version, { "client_minor_version", "x11.screensaver.QueryVersion.client_minor_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryVersion_reply_server_major_version, { "server_major_version", "x11.screensaver.QueryVersion.reply.server_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryVersion_reply_server_minor_version, { "server_minor_version", "x11.screensaver.QueryVersion.reply.server_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_drawable, { "drawable", "x11.screensaver.QueryInfo.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_reply_state, { "state", "x11.screensaver.QueryInfo.reply.state", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_reply_saver_window, { "saver_window", "x11.screensaver.QueryInfo.reply.saver_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_reply_ms_until_server, { "ms_until_server", "x11.screensaver.QueryInfo.reply.ms_until_server", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_reply_ms_since_user_input, { "ms_since_user_input", "x11.screensaver.QueryInfo.reply.ms_since_user_input", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_reply_event_mask, { "event_mask", "x11.screensaver.QueryInfo.reply.event_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_QueryInfo_reply_kind, { "kind", "x11.screensaver.QueryInfo.reply.kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SelectInput_drawable, { "drawable", "x11.screensaver.SelectInput.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SelectInput_event_mask, { "event_mask", "x11.screensaver.SelectInput.event_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_drawable, { "drawable", "x11.screensaver.SetAttributes.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_x, { "x", "x11.screensaver.SetAttributes.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_y, { "y", "x11.screensaver.SetAttributes.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_width, { "width", "x11.screensaver.SetAttributes.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_height, { "height", "x11.screensaver.SetAttributes.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_border_width, { "border_width", "x11.screensaver.SetAttributes.border_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_class, { "class", "x11.screensaver.SetAttributes.class", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_depth, { "depth", "x11.screensaver.SetAttributes.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_SetAttributes_visual, { "visual", "x11.screensaver.SetAttributes.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_UnsetAttributes_drawable, { "drawable", "x11.screensaver.UnsetAttributes.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Suspend_suspend, { "suspend", "x11.screensaver.Suspend.suspend", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_code, { "code", "x11.screensaver.Notify.code", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_state, { "state", "x11.screensaver.Notify.state", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_sequence_number, { "sequence_number", "x11.screensaver.Notify.sequence_number", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_time, { "time", "x11.screensaver.Notify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_root, { "root", "x11.screensaver.Notify.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_window, { "window", "x11.screensaver.Notify.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_kind, { "kind", "x11.screensaver.Notify.kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_Notify_forced, { "forced", "x11.screensaver.Notify.forced", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_screensaver_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(screensaver_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_shape_Notify_shape_kind, { "shape_kind", "x11.shape.Notify.shape_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_affected_window, { "affected_window", "x11.shape.Notify.affected_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_extents_x, { "extents_x", "x11.shape.Notify.extents_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_extents_y, { "extents_y", "x11.shape.Notify.extents_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_extents_width, { "extents_width", "x11.shape.Notify.extents_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_extents_height, { "extents_height", "x11.shape.Notify.extents_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_server_time, { "server_time", "x11.shape.Notify.server_time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Notify_shaped, { "shaped", "x11.shape.Notify.shaped", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryVersion_reply_major_version, { "major_version", "x11.shape.QueryVersion.reply.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryVersion_reply_minor_version, { "minor_version", "x11.shape.QueryVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_operation, { "operation", "x11.shape.Rectangles.operation", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_destination_kind, { "destination_kind", "x11.shape.Rectangles.destination_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_ordering, { "ordering", "x11.shape.Rectangles.ordering", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_destination_window, { "destination_window", "x11.shape.Rectangles.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_x_offset, { "x_offset", "x11.shape.Rectangles.x_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_y_offset, { "y_offset", "x11.shape.Rectangles.y_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_rectangles, { "rectangles", "x11.shape.Rectangles.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Rectangles_rectangles_item, { "rectangles", "x11.shape.Rectangles.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Mask_operation, { "operation", "x11.shape.Mask.operation", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Mask_destination_kind, { "destination_kind", "x11.shape.Mask.destination_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Mask_destination_window, { "destination_window", "x11.shape.Mask.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Mask_x_offset, { "x_offset", "x11.shape.Mask.x_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Mask_y_offset, { "y_offset", "x11.shape.Mask.y_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Mask_source_bitmap, { "source_bitmap", "x11.shape.Mask.source_bitmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_operation, { "operation", "x11.shape.Combine.operation", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_destination_kind, { "destination_kind", "x11.shape.Combine.destination_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_source_kind, { "source_kind", "x11.shape.Combine.source_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_destination_window, { "destination_window", "x11.shape.Combine.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_x_offset, { "x_offset", "x11.shape.Combine.x_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_y_offset, { "y_offset", "x11.shape.Combine.y_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Combine_source_window, { "source_window", "x11.shape.Combine.source_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Offset_destination_kind, { "destination_kind", "x11.shape.Offset.destination_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Offset_destination_window, { "destination_window", "x11.shape.Offset.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Offset_x_offset, { "x_offset", "x11.shape.Offset.x_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_Offset_y_offset, { "y_offset", "x11.shape.Offset.y_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_destination_window, { "destination_window", "x11.shape.QueryExtents.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_bounding_shaped, { "bounding_shaped", "x11.shape.QueryExtents.reply.bounding_shaped", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_clip_shaped, { "clip_shaped", "x11.shape.QueryExtents.reply.clip_shaped", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_bounding_shape_extents_x, { "bounding_shape_extents_x", "x11.shape.QueryExtents.reply.bounding_shape_extents_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_bounding_shape_extents_y, { "bounding_shape_extents_y", "x11.shape.QueryExtents.reply.bounding_shape_extents_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_bounding_shape_extents_width, { "bounding_shape_extents_width", "x11.shape.QueryExtents.reply.bounding_shape_extents_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_bounding_shape_extents_height, { "bounding_shape_extents_height", "x11.shape.QueryExtents.reply.bounding_shape_extents_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_clip_shape_extents_x, { "clip_shape_extents_x", "x11.shape.QueryExtents.reply.clip_shape_extents_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_clip_shape_extents_y, { "clip_shape_extents_y", "x11.shape.QueryExtents.reply.clip_shape_extents_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_clip_shape_extents_width, { "clip_shape_extents_width", "x11.shape.QueryExtents.reply.clip_shape_extents_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_QueryExtents_reply_clip_shape_extents_height, { "clip_shape_extents_height", "x11.shape.QueryExtents.reply.clip_shape_extents_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_SelectInput_destination_window, { "destination_window", "x11.shape.SelectInput.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_SelectInput_enable, { "enable", "x11.shape.SelectInput.enable", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_InputSelected_destination_window, { "destination_window", "x11.shape.InputSelected.destination_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_InputSelected_reply_enabled, { "enabled", "x11.shape.InputSelected.reply.enabled", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_GetRectangles_window, { "window", "x11.shape.GetRectangles.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_GetRectangles_source_kind, { "source_kind", "x11.shape.GetRectangles.source_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_GetRectangles_reply_ordering, { "ordering", "x11.shape.GetRectangles.reply.ordering", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_GetRectangles_reply_rectangles_len, { "rectangles_len", "x11.shape.GetRectangles.reply.rectangles_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_GetRectangles_reply_rectangles, { "rectangles", "x11.shape.GetRectangles.reply.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_GetRectangles_reply_rectangles_item, { "rectangles", "x11.shape.GetRectangles.reply.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shape_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(shape_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_shm_Completion_drawable, { "drawable", "x11.shm.Completion.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Completion_minor_event, { "minor_event", "x11.shm.Completion.minor_event", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Completion_major_event, { "major_event", "x11.shm.Completion.major_event", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Completion_shmseg, { "shmseg", "x11.shm.Completion.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Completion_offset, { "offset", "x11.shm.Completion.offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_QueryVersion_reply_shared_pixmaps, { "shared_pixmaps", "x11.shm.QueryVersion.reply.shared_pixmaps", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_QueryVersion_reply_major_version, { "major_version", "x11.shm.QueryVersion.reply.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_QueryVersion_reply_minor_version, { "minor_version", "x11.shm.QueryVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_QueryVersion_reply_uid, { "uid", "x11.shm.QueryVersion.reply.uid", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_QueryVersion_reply_gid, { "gid", "x11.shm.QueryVersion.reply.gid", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_QueryVersion_reply_pixmap_format, { "pixmap_format", "x11.shm.QueryVersion.reply.pixmap_format", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Attach_shmseg, { "shmseg", "x11.shm.Attach.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Attach_shmid, { "shmid", "x11.shm.Attach.shmid", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Attach_read_only, { "read_only", "x11.shm.Attach.read_only", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_Detach_shmseg, { "shmseg", "x11.shm.Detach.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_drawable, { "drawable", "x11.shm.PutImage.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_gc, { "gc", "x11.shm.PutImage.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_total_width, { "total_width", "x11.shm.PutImage.total_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_total_height, { "total_height", "x11.shm.PutImage.total_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_src_x, { "src_x", "x11.shm.PutImage.src_x", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_src_y, { "src_y", "x11.shm.PutImage.src_y", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_src_width, { "src_width", "x11.shm.PutImage.src_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_src_height, { "src_height", "x11.shm.PutImage.src_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_dst_x, { "dst_x", "x11.shm.PutImage.dst_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_dst_y, { "dst_y", "x11.shm.PutImage.dst_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_depth, { "depth", "x11.shm.PutImage.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_format, { "format", "x11.shm.PutImage.format", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_send_event, { "send_event", "x11.shm.PutImage.send_event", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_shmseg, { "shmseg", "x11.shm.PutImage.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_PutImage_offset, { "offset", "x11.shm.PutImage.offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_drawable, { "drawable", "x11.shm.GetImage.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_x, { "x", "x11.shm.GetImage.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_y, { "y", "x11.shm.GetImage.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_width, { "width", "x11.shm.GetImage.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_height, { "height", "x11.shm.GetImage.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_plane_mask, { "plane_mask", "x11.shm.GetImage.plane_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_format, { "format", "x11.shm.GetImage.format", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_shmseg, { "shmseg", "x11.shm.GetImage.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_offset, { "offset", "x11.shm.GetImage.offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_reply_depth, { "depth", "x11.shm.GetImage.reply.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_reply_visual, { "visual", "x11.shm.GetImage.reply.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_GetImage_reply_size, { "size", "x11.shm.GetImage.reply.size", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_pid, { "pid", "x11.shm.CreatePixmap.pid", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_drawable, { "drawable", "x11.shm.CreatePixmap.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_width, { "width", "x11.shm.CreatePixmap.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_height, { "height", "x11.shm.CreatePixmap.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_depth, { "depth", "x11.shm.CreatePixmap.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_shmseg, { "shmseg", "x11.shm.CreatePixmap.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_CreatePixmap_offset, { "offset", "x11.shm.CreatePixmap.offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_shm_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(shm_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_INT64, { "INT64", "x11.struct.INT64", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INT64_hi, { "hi", "x11.struct.INT64.hi", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_INT64_lo, { "lo", "x11.struct.INT64.lo", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SYSTEMCOUNTER, { "SYSTEMCOUNTER", "x11.struct.SYSTEMCOUNTER", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SYSTEMCOUNTER_counter, { "counter", "x11.struct.SYSTEMCOUNTER.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SYSTEMCOUNTER_resolution, { "resolution", "x11.struct.SYSTEMCOUNTER.resolution", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SYSTEMCOUNTER_name_len, { "name_len", "x11.struct.SYSTEMCOUNTER.name_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SYSTEMCOUNTER_name, { "name", "x11.struct.SYSTEMCOUNTER.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIGGER, { "TRIGGER", "x11.struct.TRIGGER", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIGGER_counter, { "counter", "x11.struct.TRIGGER.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIGGER_wait_type, { "wait_type", "x11.struct.TRIGGER.wait_type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIGGER_wait_value, { "wait_value", "x11.struct.TRIGGER.wait_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_TRIGGER_test_type, { "test_type", "x11.struct.TRIGGER.test_type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_WAITCONDITION, { "WAITCONDITION", "x11.struct.WAITCONDITION", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_WAITCONDITION_trigger, { "trigger", "x11.struct.WAITCONDITION.trigger", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_WAITCONDITION_event_threshold, { "event_threshold", "x11.struct.WAITCONDITION.event_threshold", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_Initialize_desired_major_version, { "desired_major_version", "x11.sync.Initialize.desired_major_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_Initialize_desired_minor_version, { "desired_minor_version", "x11.sync.Initialize.desired_minor_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_Initialize_reply_major_version, { "major_version", "x11.sync.Initialize.reply.major_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_Initialize_reply_minor_version, { "minor_version", "x11.sync.Initialize.reply.minor_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_ListSystemCounters_reply_counters_len, { "counters_len", "x11.sync.ListSystemCounters.reply.counters_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_ListSystemCounters_reply_counters, { "counters", "x11.sync.ListSystemCounters.reply.counters", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CreateCounter_id, { "id", "x11.sync.CreateCounter.id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CreateCounter_initial_value, { "initial_value", "x11.sync.CreateCounter.initial_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_DestroyCounter_counter, { "counter", "x11.sync.DestroyCounter.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryCounter_counter, { "counter", "x11.sync.QueryCounter.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryCounter_reply_counter_value, { "counter_value", "x11.sync.QueryCounter.reply.counter_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_Await_wait_list, { "wait_list", "x11.sync.Await.wait_list", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_Await_wait_list_item, { "wait_list", "x11.sync.Await.wait_list", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_ChangeCounter_counter, { "counter", "x11.sync.ChangeCounter.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_ChangeCounter_amount, { "amount", "x11.sync.ChangeCounter.amount", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_SetCounter_counter, { "counter", "x11.sync.SetCounter.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_SetCounter_value, { "value", "x11.sync.SetCounter.value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CreateAlarm_id, { "id", "x11.sync.CreateAlarm.id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_ChangeAlarm_id, { "id", "x11.sync.ChangeAlarm.id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_DestroyAlarm_alarm, { "alarm", "x11.sync.DestroyAlarm.alarm", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryAlarm_alarm, { "alarm", "x11.sync.QueryAlarm.alarm", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryAlarm_reply_trigger, { "trigger", "x11.sync.QueryAlarm.reply.trigger", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryAlarm_reply_delta, { "delta", "x11.sync.QueryAlarm.reply.delta", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryAlarm_reply_events, { "events", "x11.sync.QueryAlarm.reply.events", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_QueryAlarm_reply_state, { "state", "x11.sync.QueryAlarm.reply.state", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_SetPriority_id, { "id", "x11.sync.SetPriority.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_SetPriority_priority, { "priority", "x11.sync.SetPriority.priority", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_GetPriority_id, { "id", "x11.sync.GetPriority.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_GetPriority_reply_priority, { "priority", "x11.sync.GetPriority.reply.priority", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_kind, { "kind", "x11.sync.CounterNotify.kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_counter, { "counter", "x11.sync.CounterNotify.counter", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_wait_value, { "wait_value", "x11.sync.CounterNotify.wait_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_counter_value, { "counter_value", "x11.sync.CounterNotify.counter_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_timestamp, { "timestamp", "x11.sync.CounterNotify.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_count, { "count", "x11.sync.CounterNotify.count", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_CounterNotify_destroyed, { "destroyed", "x11.sync.CounterNotify.destroyed", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_AlarmNotify_kind, { "kind", "x11.sync.AlarmNotify.kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_AlarmNotify_alarm, { "alarm", "x11.sync.AlarmNotify.alarm", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_AlarmNotify_counter_value, { "counter_value", "x11.sync.AlarmNotify.counter_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_AlarmNotify_alarm_value, { "alarm_value", "x11.sync.AlarmNotify.alarm_value", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_AlarmNotify_timestamp, { "timestamp", "x11.sync.AlarmNotify.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_AlarmNotify_state, { "state", "x11.sync.AlarmNotify.state", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_sync_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(sync_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xc_misc_GetVersion_client_major_version, { "client_major_version", "x11.xc_misc.GetVersion.client_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetVersion_client_minor_version, { "client_minor_version", "x11.xc_misc.GetVersion.client_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetVersion_reply_server_major_version, { "server_major_version", "x11.xc_misc.GetVersion.reply.server_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetVersion_reply_server_minor_version, { "server_minor_version", "x11.xc_misc.GetVersion.reply.server_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetXIDRange_reply_start_id, { "start_id", "x11.xc_misc.GetXIDRange.reply.start_id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetXIDRange_reply_count, { "count", "x11.xc_misc.GetXIDRange.reply.count", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetXIDList_count, { "count", "x11.xc_misc.GetXIDList.count", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetXIDList_reply_ids_len, { "ids_len", "x11.xc_misc.GetXIDList.reply.ids_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetXIDList_reply_ids, { "ids", "x11.xc_misc.GetXIDList.reply.ids", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_GetXIDList_reply_ids_item, { "ids", "x11.xc_misc.GetXIDList.reply.ids", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xc_misc_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xc_misc_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xevie_QueryVersion_client_major_version, { "client_major_version", "x11.xevie.QueryVersion.client_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_QueryVersion_client_minor_version, { "client_minor_version", "x11.xevie.QueryVersion.client_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_QueryVersion_reply_server_major_version, { "server_major_version", "x11.xevie.QueryVersion.reply.server_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_QueryVersion_reply_server_minor_version, { "server_minor_version", "x11.xevie.QueryVersion.reply.server_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_Start_screen, { "screen", "x11.xevie.Start.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_End_cmap, { "cmap", "x11.xevie.End.cmap", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Event, { "Event", "x11.struct.Event", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_Send_event, { "event", "x11.xevie.Send.event", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_Send_data_type, { "data_type", "x11.xevie.Send.data_type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_SelectInput_event_mask, { "event_mask", "x11.xevie.SelectInput.event_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xevie_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xevie_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_DrmClipRect, { "DrmClipRect", "x11.struct.DrmClipRect", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DrmClipRect_x1, { "x1", "x11.struct.DrmClipRect.x1", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DrmClipRect_y1, { "y1", "x11.struct.DrmClipRect.y1", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DrmClipRect_x2, { "x2", "x11.struct.DrmClipRect.x2", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DrmClipRect_x3, { "x3", "x11.struct.DrmClipRect.x3", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_QueryVersion_reply_dri_major_version, { "dri_major_version", "x11.xf86dri.QueryVersion.reply.dri_major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_QueryVersion_reply_dri_minor_version, { "dri_minor_version", "x11.xf86dri.QueryVersion.reply.dri_minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_QueryVersion_reply_dri_minor_patch, { "dri_minor_patch", "x11.xf86dri.QueryVersion.reply.dri_minor_patch", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_QueryDirectRenderingCapable_screen, { "screen", "x11.xf86dri.QueryDirectRenderingCapable.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_QueryDirectRenderingCapable_reply_is_capable, { "is_capable", "x11.xf86dri.QueryDirectRenderingCapable.reply.is_capable", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_screen, { "screen", "x11.xf86dri.OpenConnection.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_reply_drm_client_key_low, { "drm_client_key_low", "x11.xf86dri.OpenConnection.reply.drm_client_key_low", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_reply_drm_client_key_high, { "drm_client_key_high", "x11.xf86dri.OpenConnection.reply.drm_client_key_high", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_reply_sarea_handle_low, { "sarea_handle_low", "x11.xf86dri.OpenConnection.reply.sarea_handle_low", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_reply_sarea_handle_high, { "sarea_handle_high", "x11.xf86dri.OpenConnection.reply.sarea_handle_high", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_reply_bus_id_len, { "bus_id_len", "x11.xf86dri.OpenConnection.reply.bus_id_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_OpenConnection_reply_bus_id, { "bus_id", "x11.xf86dri.OpenConnection.reply.bus_id", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CloseConnection_screen, { "screen", "x11.xf86dri.CloseConnection.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetClientDriverName_screen, { "screen", "x11.xf86dri.GetClientDriverName.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetClientDriverName_reply_client_driver_major_version, { "client_driver_major_version", "x11.xf86dri.GetClientDriverName.reply.client_driver_major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetClientDriverName_reply_client_driver_minor_version, { "client_driver_minor_version", "x11.xf86dri.GetClientDriverName.reply.client_driver_minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetClientDriverName_reply_client_driver_patch_version, { "client_driver_patch_version", "x11.xf86dri.GetClientDriverName.reply.client_driver_patch_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name_len, { "client_driver_name_len", "x11.xf86dri.GetClientDriverName.reply.client_driver_name_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name, { "client_driver_name", "x11.xf86dri.GetClientDriverName.reply.client_driver_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateContext_visual, { "visual", "x11.xf86dri.CreateContext.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateContext_screen, { "screen", "x11.xf86dri.CreateContext.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateContext_context, { "context", "x11.xf86dri.CreateContext.context", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateContext_reply_hw_context, { "hw_context", "x11.xf86dri.CreateContext.reply.hw_context", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_DestroyContext_screen, { "screen", "x11.xf86dri.DestroyContext.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_DestroyContext_context, { "context", "x11.xf86dri.DestroyContext.context", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateDrawable_screen, { "screen", "x11.xf86dri.CreateDrawable.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateDrawable_drawable, { "drawable", "x11.xf86dri.CreateDrawable.drawable", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_CreateDrawable_reply_hw_drawable_handle, { "hw_drawable_handle", "x11.xf86dri.CreateDrawable.reply.hw_drawable_handle", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_DestroyDrawable_screen, { "screen", "x11.xf86dri.DestroyDrawable.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_DestroyDrawable_drawable, { "drawable", "x11.xf86dri.DestroyDrawable.drawable", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_screen, { "screen", "x11.xf86dri.GetDrawableInfo.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_drawable, { "drawable", "x11.xf86dri.GetDrawableInfo.drawable", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_index, { "drawable_table_index", "x11.xf86dri.GetDrawableInfo.reply.drawable_table_index", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_stamp, { "drawable_table_stamp", "x11.xf86dri.GetDrawableInfo.reply.drawable_table_stamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_X, { "drawable_origin_X", "x11.xf86dri.GetDrawableInfo.reply.drawable_origin_X", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_Y, { "drawable_origin_Y", "x11.xf86dri.GetDrawableInfo.reply.drawable_origin_Y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_W, { "drawable_size_W", "x11.xf86dri.GetDrawableInfo.reply.drawable_size_W", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_H, { "drawable_size_H", "x11.xf86dri.GetDrawableInfo.reply.drawable_size_H", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_num_clip_rects, { "num_clip_rects", "x11.xf86dri.GetDrawableInfo.reply.num_clip_rects", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_clip_rects, { "clip_rects", "x11.xf86dri.GetDrawableInfo.reply.clip_rects", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDrawableInfo_reply_clip_rects_item, { "clip_rects", "x11.xf86dri.GetDrawableInfo.reply.clip_rects", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_screen, { "screen", "x11.xf86dri.GetDeviceInfo.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_low, { "framebuffer_handle_low", "x11.xf86dri.GetDeviceInfo.reply.framebuffer_handle_low", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_high, { "framebuffer_handle_high", "x11.xf86dri.GetDeviceInfo.reply.framebuffer_handle_high", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_origin_offset, { "framebuffer_origin_offset", "x11.xf86dri.GetDeviceInfo.reply.framebuffer_origin_offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_size, { "framebuffer_size", "x11.xf86dri.GetDeviceInfo.reply.framebuffer_size", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_stride, { "framebuffer_stride", "x11.xf86dri.GetDeviceInfo.reply.framebuffer_stride", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_device_private_size, { "device_private_size", "x11.xf86dri.GetDeviceInfo.reply.device_private_size", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_device_private, { "device_private", "x11.xf86dri.GetDeviceInfo.reply.device_private", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_GetDeviceInfo_reply_device_private_item, { "device_private", "x11.xf86dri.GetDeviceInfo.reply.device_private", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_AuthConnection_screen, { "screen", "x11.xf86dri.AuthConnection.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_AuthConnection_magic, { "magic", "x11.xf86dri.AuthConnection.magic", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_AuthConnection_reply_authenticated, { "authenticated", "x11.xf86dri.AuthConnection.reply.authenticated", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86dri_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xf86dri_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xf86vidmode_QueryVersion_reply_major_version, { "major_version", "x11.xf86vidmode.QueryVersion.reply.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_QueryVersion_reply_minor_version, { "minor_version", "x11.xf86vidmode.QueryVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_screen, { "screen", "x11.xf86vidmode.GetModeLine.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_dotclock, { "dotclock", "x11.xf86vidmode.GetModeLine.reply.dotclock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_hdisplay, { "hdisplay", "x11.xf86vidmode.GetModeLine.reply.hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_hsyncstart, { "hsyncstart", "x11.xf86vidmode.GetModeLine.reply.hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_hsyncend, { "hsyncend", "x11.xf86vidmode.GetModeLine.reply.hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_htotal, { "htotal", "x11.xf86vidmode.GetModeLine.reply.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_hskew, { "hskew", "x11.xf86vidmode.GetModeLine.reply.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_vdisplay, { "vdisplay", "x11.xf86vidmode.GetModeLine.reply.vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_vsyncstart, { "vsyncstart", "x11.xf86vidmode.GetModeLine.reply.vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_vsyncend, { "vsyncend", "x11.xf86vidmode.GetModeLine.reply.vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_vtotal, { "vtotal", "x11.xf86vidmode.GetModeLine.reply.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_flags, { "flags", "x11.xf86vidmode.GetModeLine.reply.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_privsize, { "privsize", "x11.xf86vidmode.GetModeLine.reply.privsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetModeLine_reply_private, { "private", "x11.xf86vidmode.GetModeLine.reply.private", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_screen, { "screen", "x11.xf86vidmode.ModModeLine.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_hdisplay, { "hdisplay", "x11.xf86vidmode.ModModeLine.hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_hsyncstart, { "hsyncstart", "x11.xf86vidmode.ModModeLine.hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_hsyncend, { "hsyncend", "x11.xf86vidmode.ModModeLine.hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_htotal, { "htotal", "x11.xf86vidmode.ModModeLine.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_hskew, { "hskew", "x11.xf86vidmode.ModModeLine.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_vdisplay, { "vdisplay", "x11.xf86vidmode.ModModeLine.vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_vsyncstart, { "vsyncstart", "x11.xf86vidmode.ModModeLine.vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_vsyncend, { "vsyncend", "x11.xf86vidmode.ModModeLine.vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_vtotal, { "vtotal", "x11.xf86vidmode.ModModeLine.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_flags, { "flags", "x11.xf86vidmode.ModModeLine.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_privsize, { "privsize", "x11.xf86vidmode.ModModeLine.privsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ModModeLine_private, { "private", "x11.xf86vidmode.ModModeLine.private", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchMode_screen, { "screen", "x11.xf86vidmode.SwitchMode.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchMode_zoom, { "zoom", "x11.xf86vidmode.SwitchMode.zoom", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_screen, { "screen", "x11.xf86vidmode.GetMonitor.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_vendor_length, { "vendor_length", "x11.xf86vidmode.GetMonitor.reply.vendor_length", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_model_length, { "model_length", "x11.xf86vidmode.GetMonitor.reply.model_length", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_num_hsync, { "num_hsync", "x11.xf86vidmode.GetMonitor.reply.num_hsync", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_num_vsync, { "num_vsync", "x11.xf86vidmode.GetMonitor.reply.num_vsync", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_hsync, { "hsync", "x11.xf86vidmode.GetMonitor.reply.hsync", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_hsync_item, { "hsync", "x11.xf86vidmode.GetMonitor.reply.hsync", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_vsync, { "vsync", "x11.xf86vidmode.GetMonitor.reply.vsync", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_vsync_item, { "vsync", "x11.xf86vidmode.GetMonitor.reply.vsync", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_vendor, { "vendor", "x11.xf86vidmode.GetMonitor.reply.vendor", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_alignment_pad, { "alignment_pad", "x11.xf86vidmode.GetMonitor.reply.alignment_pad", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetMonitor_reply_model, { "model", "x11.xf86vidmode.GetMonitor.reply.model", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_LockModeSwitch_screen, { "screen", "x11.xf86vidmode.LockModeSwitch.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_LockModeSwitch_lock, { "lock", "x11.xf86vidmode.LockModeSwitch.lock", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetAllModeLines_screen, { "screen", "x11.xf86vidmode.GetAllModeLines.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetAllModeLines_reply_modecount, { "modecount", "x11.xf86vidmode.GetAllModeLines.reply.modecount", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetAllModeLines_reply_modeinfo, { "modeinfo", "x11.xf86vidmode.GetAllModeLines.reply.modeinfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetAllModeLines_reply_modeinfo_item, { "modeinfo", "x11.xf86vidmode.GetAllModeLines.reply.modeinfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_screen, { "screen", "x11.xf86vidmode.AddModeLine.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_dotclock, { "dotclock", "x11.xf86vidmode.AddModeLine.dotclock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_hdisplay, { "hdisplay", "x11.xf86vidmode.AddModeLine.hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_hsyncstart, { "hsyncstart", "x11.xf86vidmode.AddModeLine.hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_hsyncend, { "hsyncend", "x11.xf86vidmode.AddModeLine.hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_htotal, { "htotal", "x11.xf86vidmode.AddModeLine.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_hskew, { "hskew", "x11.xf86vidmode.AddModeLine.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_vdisplay, { "vdisplay", "x11.xf86vidmode.AddModeLine.vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_vsyncstart, { "vsyncstart", "x11.xf86vidmode.AddModeLine.vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_vsyncend, { "vsyncend", "x11.xf86vidmode.AddModeLine.vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_vtotal, { "vtotal", "x11.xf86vidmode.AddModeLine.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_flags, { "flags", "x11.xf86vidmode.AddModeLine.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_privsize, { "privsize", "x11.xf86vidmode.AddModeLine.privsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_dotclock, { "after_dotclock", "x11.xf86vidmode.AddModeLine.after_dotclock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_hdisplay, { "after_hdisplay", "x11.xf86vidmode.AddModeLine.after_hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_hsyncstart, { "after_hsyncstart", "x11.xf86vidmode.AddModeLine.after_hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_hsyncend, { "after_hsyncend", "x11.xf86vidmode.AddModeLine.after_hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_htotal, { "after_htotal", "x11.xf86vidmode.AddModeLine.after_htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_hskew, { "after_hskew", "x11.xf86vidmode.AddModeLine.after_hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_vdisplay, { "after_vdisplay", "x11.xf86vidmode.AddModeLine.after_vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_vsyncstart, { "after_vsyncstart", "x11.xf86vidmode.AddModeLine.after_vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_vsyncend, { "after_vsyncend", "x11.xf86vidmode.AddModeLine.after_vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_vtotal, { "after_vtotal", "x11.xf86vidmode.AddModeLine.after_vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_after_flags, { "after_flags", "x11.xf86vidmode.AddModeLine.after_flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_AddModeLine_private, { "private", "x11.xf86vidmode.AddModeLine.private", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_screen, { "screen", "x11.xf86vidmode.DeleteModeLine.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_dotclock, { "dotclock", "x11.xf86vidmode.DeleteModeLine.dotclock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_hdisplay, { "hdisplay", "x11.xf86vidmode.DeleteModeLine.hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_hsyncstart, { "hsyncstart", "x11.xf86vidmode.DeleteModeLine.hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_hsyncend, { "hsyncend", "x11.xf86vidmode.DeleteModeLine.hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_htotal, { "htotal", "x11.xf86vidmode.DeleteModeLine.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_hskew, { "hskew", "x11.xf86vidmode.DeleteModeLine.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_vdisplay, { "vdisplay", "x11.xf86vidmode.DeleteModeLine.vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_vsyncstart, { "vsyncstart", "x11.xf86vidmode.DeleteModeLine.vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_vsyncend, { "vsyncend", "x11.xf86vidmode.DeleteModeLine.vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_vtotal, { "vtotal", "x11.xf86vidmode.DeleteModeLine.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_flags, { "flags", "x11.xf86vidmode.DeleteModeLine.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_privsize, { "privsize", "x11.xf86vidmode.DeleteModeLine.privsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_DeleteModeLine_private, { "private", "x11.xf86vidmode.DeleteModeLine.private", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_screen, { "screen", "x11.xf86vidmode.ValidateModeLine.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_dotclock, { "dotclock", "x11.xf86vidmode.ValidateModeLine.dotclock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_hdisplay, { "hdisplay", "x11.xf86vidmode.ValidateModeLine.hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_hsyncstart, { "hsyncstart", "x11.xf86vidmode.ValidateModeLine.hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_hsyncend, { "hsyncend", "x11.xf86vidmode.ValidateModeLine.hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_htotal, { "htotal", "x11.xf86vidmode.ValidateModeLine.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_hskew, { "hskew", "x11.xf86vidmode.ValidateModeLine.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_vdisplay, { "vdisplay", "x11.xf86vidmode.ValidateModeLine.vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_vsyncstart, { "vsyncstart", "x11.xf86vidmode.ValidateModeLine.vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_vsyncend, { "vsyncend", "x11.xf86vidmode.ValidateModeLine.vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_vtotal, { "vtotal", "x11.xf86vidmode.ValidateModeLine.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_flags, { "flags", "x11.xf86vidmode.ValidateModeLine.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_privsize, { "privsize", "x11.xf86vidmode.ValidateModeLine.privsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_private, { "private", "x11.xf86vidmode.ValidateModeLine.private", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_ValidateModeLine_reply_status, { "status", "x11.xf86vidmode.ValidateModeLine.reply.status", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_screen, { "screen", "x11.xf86vidmode.SwitchToMode.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_dotclock, { "dotclock", "x11.xf86vidmode.SwitchToMode.dotclock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_hdisplay, { "hdisplay", "x11.xf86vidmode.SwitchToMode.hdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_hsyncstart, { "hsyncstart", "x11.xf86vidmode.SwitchToMode.hsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_hsyncend, { "hsyncend", "x11.xf86vidmode.SwitchToMode.hsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_htotal, { "htotal", "x11.xf86vidmode.SwitchToMode.htotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_hskew, { "hskew", "x11.xf86vidmode.SwitchToMode.hskew", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_vdisplay, { "vdisplay", "x11.xf86vidmode.SwitchToMode.vdisplay", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_vsyncstart, { "vsyncstart", "x11.xf86vidmode.SwitchToMode.vsyncstart", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_vsyncend, { "vsyncend", "x11.xf86vidmode.SwitchToMode.vsyncend", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_vtotal, { "vtotal", "x11.xf86vidmode.SwitchToMode.vtotal", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_flags, { "flags", "x11.xf86vidmode.SwitchToMode.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_privsize, { "privsize", "x11.xf86vidmode.SwitchToMode.privsize", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SwitchToMode_private, { "private", "x11.xf86vidmode.SwitchToMode.private", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetViewPort_screen, { "screen", "x11.xf86vidmode.GetViewPort.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetViewPort_reply_x, { "x", "x11.xf86vidmode.GetViewPort.reply.x", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetViewPort_reply_y, { "y", "x11.xf86vidmode.GetViewPort.reply.y", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetViewPort_screen, { "screen", "x11.xf86vidmode.SetViewPort.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetViewPort_x, { "x", "x11.xf86vidmode.SetViewPort.x", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetViewPort_y, { "y", "x11.xf86vidmode.SetViewPort.y", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetDotClocks_screen, { "screen", "x11.xf86vidmode.GetDotClocks.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetDotClocks_reply_flags, { "flags", "x11.xf86vidmode.GetDotClocks.reply.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetDotClocks_reply_clocks, { "clocks", "x11.xf86vidmode.GetDotClocks.reply.clocks", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetDotClocks_reply_maxclocks, { "maxclocks", "x11.xf86vidmode.GetDotClocks.reply.maxclocks", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetDotClocks_reply_clock, { "clock", "x11.xf86vidmode.GetDotClocks.reply.clock", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetDotClocks_reply_clock_item, { "clock", "x11.xf86vidmode.GetDotClocks.reply.clock", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetClientVersion_major, { "major", "x11.xf86vidmode.SetClientVersion.major", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetClientVersion_minor, { "minor", "x11.xf86vidmode.SetClientVersion.minor", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGamma_screen, { "screen", "x11.xf86vidmode.SetGamma.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGamma_red, { "red", "x11.xf86vidmode.SetGamma.red", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGamma_green, { "green", "x11.xf86vidmode.SetGamma.green", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGamma_blue, { "blue", "x11.xf86vidmode.SetGamma.blue", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGamma_screen, { "screen", "x11.xf86vidmode.GetGamma.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGamma_reply_red, { "red", "x11.xf86vidmode.GetGamma.reply.red", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGamma_reply_green, { "green", "x11.xf86vidmode.GetGamma.reply.green", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGamma_reply_blue, { "blue", "x11.xf86vidmode.GetGamma.reply.blue", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_screen, { "screen", "x11.xf86vidmode.GetGammaRamp.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_size, { "size", "x11.xf86vidmode.GetGammaRamp.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_size, { "size", "x11.xf86vidmode.GetGammaRamp.reply.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_red, { "red", "x11.xf86vidmode.GetGammaRamp.reply.red", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_red_item, { "red", "x11.xf86vidmode.GetGammaRamp.reply.red", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_green, { "green", "x11.xf86vidmode.GetGammaRamp.reply.green", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_green_item, { "green", "x11.xf86vidmode.GetGammaRamp.reply.green", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_blue, { "blue", "x11.xf86vidmode.GetGammaRamp.reply.blue", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRamp_reply_blue_item, { "blue", "x11.xf86vidmode.GetGammaRamp.reply.blue", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_screen, { "screen", "x11.xf86vidmode.SetGammaRamp.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_size, { "size", "x11.xf86vidmode.SetGammaRamp.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_red, { "red", "x11.xf86vidmode.SetGammaRamp.red", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_red_item, { "red", "x11.xf86vidmode.SetGammaRamp.red", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_green, { "green", "x11.xf86vidmode.SetGammaRamp.green", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_green_item, { "green", "x11.xf86vidmode.SetGammaRamp.green", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_blue, { "blue", "x11.xf86vidmode.SetGammaRamp.blue", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_SetGammaRamp_blue_item, { "blue", "x11.xf86vidmode.SetGammaRamp.blue", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRampSize_screen, { "screen", "x11.xf86vidmode.GetGammaRampSize.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetGammaRampSize_reply_size, { "size", "x11.xf86vidmode.GetGammaRampSize.reply.size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetPermissions_screen, { "screen", "x11.xf86vidmode.GetPermissions.screen", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_GetPermissions_reply_permissions, { "permissions", "x11.xf86vidmode.GetPermissions.reply.permissions", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xf86vidmode_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xf86vidmode_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xfixes_QueryVersion_client_major_version, { "client_major_version", "x11.xfixes.QueryVersion.client_major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_QueryVersion_client_minor_version, { "client_minor_version", "x11.xfixes.QueryVersion.client_minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_QueryVersion_reply_major_version, { "major_version", "x11.xfixes.QueryVersion.reply.major_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_QueryVersion_reply_minor_version, { "minor_version", "x11.xfixes.QueryVersion.reply.minor_version", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeSaveSet_mode, { "mode", "x11.xfixes.ChangeSaveSet.mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeSaveSet_target, { "target", "x11.xfixes.ChangeSaveSet.target", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeSaveSet_map, { "map", "x11.xfixes.ChangeSaveSet.map", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeSaveSet_window, { "window", "x11.xfixes.ChangeSaveSet.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectionNotify_subtype, { "subtype", "x11.xfixes.SelectionNotify.subtype", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectionNotify_window, { "window", "x11.xfixes.SelectionNotify.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectionNotify_owner, { "owner", "x11.xfixes.SelectionNotify.owner", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectionNotify_selection, { "selection", "x11.xfixes.SelectionNotify.selection", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectionNotify_timestamp, { "timestamp", "x11.xfixes.SelectionNotify.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectionNotify_selection_timestamp, { "selection_timestamp", "x11.xfixes.SelectionNotify.selection_timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectSelectionInput_window, { "window", "x11.xfixes.SelectSelectionInput.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectSelectionInput_selection, { "selection", "x11.xfixes.SelectSelectionInput.selection", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectSelectionInput_event_mask, { "event_mask", "x11.xfixes.SelectSelectionInput.event_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CursorNotify_subtype, { "subtype", "x11.xfixes.CursorNotify.subtype", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CursorNotify_window, { "window", "x11.xfixes.CursorNotify.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CursorNotify_cursor_serial, { "cursor_serial", "x11.xfixes.CursorNotify.cursor_serial", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CursorNotify_timestamp, { "timestamp", "x11.xfixes.CursorNotify.timestamp", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CursorNotify_name, { "name", "x11.xfixes.CursorNotify.name", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectCursorInput_window, { "window", "x11.xfixes.SelectCursorInput.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SelectCursorInput_event_mask, { "event_mask", "x11.xfixes.SelectCursorInput.event_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_x, { "x", "x11.xfixes.GetCursorImage.reply.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_y, { "y", "x11.xfixes.GetCursorImage.reply.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_width, { "width", "x11.xfixes.GetCursorImage.reply.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_height, { "height", "x11.xfixes.GetCursorImage.reply.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_xhot, { "xhot", "x11.xfixes.GetCursorImage.reply.xhot", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_yhot, { "yhot", "x11.xfixes.GetCursorImage.reply.yhot", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_cursor_serial, { "cursor_serial", "x11.xfixes.GetCursorImage.reply.cursor_serial", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_cursor_image, { "cursor_image", "x11.xfixes.GetCursorImage.reply.cursor_image", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImage_reply_cursor_image_item, { "cursor_image", "x11.xfixes.GetCursorImage.reply.cursor_image", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegion_region, { "region", "x11.xfixes.CreateRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegion_rectangles, { "rectangles", "x11.xfixes.CreateRegion.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegion_rectangles_item, { "rectangles", "x11.xfixes.CreateRegion.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromBitmap_region, { "region", "x11.xfixes.CreateRegionFromBitmap.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromBitmap_bitmap, { "bitmap", "x11.xfixes.CreateRegionFromBitmap.bitmap", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromWindow_region, { "region", "x11.xfixes.CreateRegionFromWindow.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromWindow_window, { "window", "x11.xfixes.CreateRegionFromWindow.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromWindow_kind, { "kind", "x11.xfixes.CreateRegionFromWindow.kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromGC_region, { "region", "x11.xfixes.CreateRegionFromGC.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromGC_gc, { "gc", "x11.xfixes.CreateRegionFromGC.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromPicture_region, { "region", "x11.xfixes.CreateRegionFromPicture.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CreateRegionFromPicture_picture, { "picture", "x11.xfixes.CreateRegionFromPicture.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_DestroyRegion_region, { "region", "x11.xfixes.DestroyRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetRegion_region, { "region", "x11.xfixes.SetRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetRegion_rectangles, { "rectangles", "x11.xfixes.SetRegion.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetRegion_rectangles_item, { "rectangles", "x11.xfixes.SetRegion.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CopyRegion_source, { "source", "x11.xfixes.CopyRegion.source", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_CopyRegion_destination, { "destination", "x11.xfixes.CopyRegion.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_UnionRegion_source1, { "source1", "x11.xfixes.UnionRegion.source1", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_UnionRegion_source2, { "source2", "x11.xfixes.UnionRegion.source2", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_UnionRegion_destination, { "destination", "x11.xfixes.UnionRegion.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_IntersectRegion_source1, { "source1", "x11.xfixes.IntersectRegion.source1", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_IntersectRegion_source2, { "source2", "x11.xfixes.IntersectRegion.source2", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_IntersectRegion_destination, { "destination", "x11.xfixes.IntersectRegion.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SubtractRegion_source1, { "source1", "x11.xfixes.SubtractRegion.source1", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SubtractRegion_source2, { "source2", "x11.xfixes.SubtractRegion.source2", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SubtractRegion_destination, { "destination", "x11.xfixes.SubtractRegion.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_InvertRegion_source, { "source", "x11.xfixes.InvertRegion.source", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_InvertRegion_bounds, { "bounds", "x11.xfixes.InvertRegion.bounds", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_InvertRegion_destination, { "destination", "x11.xfixes.InvertRegion.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_TranslateRegion_region, { "region", "x11.xfixes.TranslateRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_TranslateRegion_dx, { "dx", "x11.xfixes.TranslateRegion.dx", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_TranslateRegion_dy, { "dy", "x11.xfixes.TranslateRegion.dy", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_RegionExtents_source, { "source", "x11.xfixes.RegionExtents.source", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_RegionExtents_destination, { "destination", "x11.xfixes.RegionExtents.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_FetchRegion_region, { "region", "x11.xfixes.FetchRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_FetchRegion_reply_extents, { "extents", "x11.xfixes.FetchRegion.reply.extents", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_FetchRegion_reply_rectangles, { "rectangles", "x11.xfixes.FetchRegion.reply.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_FetchRegion_reply_rectangles_item, { "rectangles", "x11.xfixes.FetchRegion.reply.rectangles", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetGCClipRegion_gc, { "gc", "x11.xfixes.SetGCClipRegion.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetGCClipRegion_region, { "region", "x11.xfixes.SetGCClipRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetGCClipRegion_x_origin, { "x_origin", "x11.xfixes.SetGCClipRegion.x_origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetGCClipRegion_y_origin, { "y_origin", "x11.xfixes.SetGCClipRegion.y_origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetWindowShapeRegion_dest, { "dest", "x11.xfixes.SetWindowShapeRegion.dest", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetWindowShapeRegion_dest_kind, { "dest_kind", "x11.xfixes.SetWindowShapeRegion.dest_kind", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetWindowShapeRegion_x_offset, { "x_offset", "x11.xfixes.SetWindowShapeRegion.x_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetWindowShapeRegion_y_offset, { "y_offset", "x11.xfixes.SetWindowShapeRegion.y_offset", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetWindowShapeRegion_region, { "region", "x11.xfixes.SetWindowShapeRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetPictureClipRegion_picture, { "picture", "x11.xfixes.SetPictureClipRegion.picture", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetPictureClipRegion_region, { "region", "x11.xfixes.SetPictureClipRegion.region", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetPictureClipRegion_x_origin, { "x_origin", "x11.xfixes.SetPictureClipRegion.x_origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetPictureClipRegion_y_origin, { "y_origin", "x11.xfixes.SetPictureClipRegion.y_origin", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetCursorName_cursor, { "cursor", "x11.xfixes.SetCursorName.cursor", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetCursorName_nbytes, { "nbytes", "x11.xfixes.SetCursorName.nbytes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_SetCursorName_name, { "name", "x11.xfixes.SetCursorName.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorName_cursor, { "cursor", "x11.xfixes.GetCursorName.cursor", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorName_reply_atom, { "atom", "x11.xfixes.GetCursorName.reply.atom", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorName_reply_nbytes, { "nbytes", "x11.xfixes.GetCursorName.reply.nbytes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorName_reply_name, { "name", "x11.xfixes.GetCursorName.reply.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_x, { "x", "x11.xfixes.GetCursorImageAndName.reply.x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_y, { "y", "x11.xfixes.GetCursorImageAndName.reply.y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_width, { "width", "x11.xfixes.GetCursorImageAndName.reply.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_height, { "height", "x11.xfixes.GetCursorImageAndName.reply.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_xhot, { "xhot", "x11.xfixes.GetCursorImageAndName.reply.xhot", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_yhot, { "yhot", "x11.xfixes.GetCursorImageAndName.reply.yhot", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_cursor_serial, { "cursor_serial", "x11.xfixes.GetCursorImageAndName.reply.cursor_serial", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_cursor_atom, { "cursor_atom", "x11.xfixes.GetCursorImageAndName.reply.cursor_atom", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_nbytes, { "nbytes", "x11.xfixes.GetCursorImageAndName.reply.nbytes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_name, { "name", "x11.xfixes.GetCursorImageAndName.reply.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image, { "cursor_image", "x11.xfixes.GetCursorImageAndName.reply.cursor_image", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image_item, { "cursor_image", "x11.xfixes.GetCursorImageAndName.reply.cursor_image", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeCursor_source, { "source", "x11.xfixes.ChangeCursor.source", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeCursor_destination, { "destination", "x11.xfixes.ChangeCursor.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeCursorByName_src, { "src", "x11.xfixes.ChangeCursorByName.src", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeCursorByName_nbytes, { "nbytes", "x11.xfixes.ChangeCursorByName.nbytes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ChangeCursorByName_name, { "name", "x11.xfixes.ChangeCursorByName.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ExpandRegion_source, { "source", "x11.xfixes.ExpandRegion.source", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ExpandRegion_destination, { "destination", "x11.xfixes.ExpandRegion.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ExpandRegion_left, { "left", "x11.xfixes.ExpandRegion.left", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ExpandRegion_right, { "right", "x11.xfixes.ExpandRegion.right", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ExpandRegion_top, { "top", "x11.xfixes.ExpandRegion.top", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ExpandRegion_bottom, { "bottom", "x11.xfixes.ExpandRegion.bottom", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_HideCursor_window, { "window", "x11.xfixes.HideCursor.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_ShowCursor_window, { "window", "x11.xfixes.ShowCursor.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xfixes_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xfixes_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_ScreenInfo, { "ScreenInfo", "x11.struct.ScreenInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenInfo_x_org, { "x_org", "x11.struct.ScreenInfo.x_org", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenInfo_y_org, { "y_org", "x11.struct.ScreenInfo.y_org", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenInfo_width, { "width", "x11.struct.ScreenInfo.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ScreenInfo_height, { "height", "x11.struct.ScreenInfo.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryVersion_major, { "major", "x11.xinerama.QueryVersion.major", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryVersion_minor, { "minor", "x11.xinerama.QueryVersion.minor", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryVersion_reply_major, { "major", "x11.xinerama.QueryVersion.reply.major", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryVersion_reply_minor, { "minor", "x11.xinerama.QueryVersion.reply.minor", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetState_window, { "window", "x11.xinerama.GetState.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetState_reply_state, { "state", "x11.xinerama.GetState.reply.state", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetState_reply_window, { "window", "x11.xinerama.GetState.reply.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenCount_window, { "window", "x11.xinerama.GetScreenCount.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenCount_reply_screen_count, { "screen_count", "x11.xinerama.GetScreenCount.reply.screen_count", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenCount_reply_window, { "window", "x11.xinerama.GetScreenCount.reply.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenSize_window, { "window", "x11.xinerama.GetScreenSize.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenSize_screen, { "screen", "x11.xinerama.GetScreenSize.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenSize_reply_width, { "width", "x11.xinerama.GetScreenSize.reply.width", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenSize_reply_height, { "height", "x11.xinerama.GetScreenSize.reply.height", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenSize_reply_window, { "window", "x11.xinerama.GetScreenSize.reply.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_GetScreenSize_reply_screen, { "screen", "x11.xinerama.GetScreenSize.reply.screen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_IsActive_reply_state, { "state", "x11.xinerama.IsActive.reply.state", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryScreens_reply_number, { "number", "x11.xinerama.QueryScreens.reply.number", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryScreens_reply_screen_info, { "screen_info", "x11.xinerama.QueryScreens.reply.screen_info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_QueryScreens_reply_screen_info_item, { "screen_info", "x11.xinerama.QueryScreens.reply.screen_info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinerama_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xinerama_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xinput_GetExtensionVersion_name_len, { "name_len", "x11.xinput.GetExtensionVersion.name_len", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetExtensionVersion_name, { "name", "x11.xinput.GetExtensionVersion.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetExtensionVersion_reply_server_major, { "server_major", "x11.xinput.GetExtensionVersion.reply.server_major", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetExtensionVersion_reply_server_minor, { "server_minor", "x11.xinput.GetExtensionVersion.reply.server_minor", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetExtensionVersion_reply_present, { "present", "x11.xinput.GetExtensionVersion.reply.present", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DeviceInfo, { "DeviceInfo", "x11.struct.DeviceInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DeviceInfo_device_type, { "device_type", "x11.struct.DeviceInfo.device_type", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DeviceInfo_device_id, { "device_id", "x11.struct.DeviceInfo.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DeviceInfo_num_class_info, { "num_class_info", "x11.struct.DeviceInfo.num_class_info", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_DeviceInfo_device_use, { "device_use", "x11.struct.DeviceInfo.device_use", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ListInputDevices_reply_devices_len, { "devices_len", "x11.xinput.ListInputDevices.reply.devices_len", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ListInputDevices_reply_devices, { "devices", "x11.xinput.ListInputDevices.reply.devices", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ListInputDevices_reply_devices_item, { "devices", "x11.xinput.ListInputDevices.reply.devices", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_InputClassInfo, { "InputClassInfo", "x11.struct.InputClassInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_InputClassInfo_class_id, { "class_id", "x11.struct.InputClassInfo.class_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_InputClassInfo_event_type_base, { "event_type_base", "x11.struct.InputClassInfo.event_type_base", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_OpenDevice_device_id, { "device_id", "x11.xinput.OpenDevice.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_OpenDevice_reply_num_classes, { "num_classes", "x11.xinput.OpenDevice.reply.num_classes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_OpenDevice_reply_class_info, { "class_info", "x11.xinput.OpenDevice.reply.class_info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_OpenDevice_reply_class_info_item, { "class_info", "x11.xinput.OpenDevice.reply.class_info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_CloseDevice_device_id, { "device_id", "x11.xinput.CloseDevice.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceMode_device_id, { "device_id", "x11.xinput.SetDeviceMode.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceMode_mode, { "mode", "x11.xinput.SetDeviceMode.mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceMode_reply_status, { "status", "x11.xinput.SetDeviceMode.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SelectExtensionEvent_window, { "window", "x11.xinput.SelectExtensionEvent.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SelectExtensionEvent_num_classes, { "num_classes", "x11.xinput.SelectExtensionEvent.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SelectExtensionEvent_classes, { "classes", "x11.xinput.SelectExtensionEvent.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SelectExtensionEvent_classes_item, { "classes", "x11.xinput.SelectExtensionEvent.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_window, { "window", "x11.xinput.GetSelectedExtensionEvents.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_reply_num_this_classes, { "num_this_classes", "x11.xinput.GetSelectedExtensionEvents.reply.num_this_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_reply_num_all_classes, { "num_all_classes", "x11.xinput.GetSelectedExtensionEvents.reply.num_all_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes, { "this_classes", "x11.xinput.GetSelectedExtensionEvents.reply.this_classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes_item, { "this_classes", "x11.xinput.GetSelectedExtensionEvents.reply.this_classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes, { "all_classes", "x11.xinput.GetSelectedExtensionEvents.reply.all_classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes_item, { "all_classes", "x11.xinput.GetSelectedExtensionEvents.reply.all_classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceDontPropagateList_window, { "window", "x11.xinput.ChangeDeviceDontPropagateList.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceDontPropagateList_num_classes, { "num_classes", "x11.xinput.ChangeDeviceDontPropagateList.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceDontPropagateList_mode, { "mode", "x11.xinput.ChangeDeviceDontPropagateList.mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceDontPropagateList_classes, { "classes", "x11.xinput.ChangeDeviceDontPropagateList.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceDontPropagateList_classes_item, { "classes", "x11.xinput.ChangeDeviceDontPropagateList.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceDontPropagateList_window, { "window", "x11.xinput.GetDeviceDontPropagateList.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceDontPropagateList_reply_num_classes, { "num_classes", "x11.xinput.GetDeviceDontPropagateList.reply.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceDontPropagateList_reply_classes, { "classes", "x11.xinput.GetDeviceDontPropagateList.reply.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceDontPropagateList_reply_classes_item, { "classes", "x11.xinput.GetDeviceDontPropagateList.reply.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceMotionEvents_start, { "start", "x11.xinput.GetDeviceMotionEvents.start", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceMotionEvents_stop, { "stop", "x11.xinput.GetDeviceMotionEvents.stop", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceMotionEvents_device_id, { "device_id", "x11.xinput.GetDeviceMotionEvents.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceMotionEvents_reply_num_coords, { "num_coords", "x11.xinput.GetDeviceMotionEvents.reply.num_coords", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceMotionEvents_reply_num_axes, { "num_axes", "x11.xinput.GetDeviceMotionEvents.reply.num_axes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceMotionEvents_reply_device_mode, { "device_mode", "x11.xinput.GetDeviceMotionEvents.reply.device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeKeyboardDevice_device_id, { "device_id", "x11.xinput.ChangeKeyboardDevice.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeKeyboardDevice_reply_status, { "status", "x11.xinput.ChangeKeyboardDevice.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangePointerDevice_x_axis, { "x_axis", "x11.xinput.ChangePointerDevice.x_axis", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangePointerDevice_y_axis, { "y_axis", "x11.xinput.ChangePointerDevice.y_axis", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangePointerDevice_device_id, { "device_id", "x11.xinput.ChangePointerDevice.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangePointerDevice_reply_status, { "status", "x11.xinput.ChangePointerDevice.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_grab_window, { "grab_window", "x11.xinput.GrabDevice.grab_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_time, { "time", "x11.xinput.GrabDevice.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_num_classes, { "num_classes", "x11.xinput.GrabDevice.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_this_device_mode, { "this_device_mode", "x11.xinput.GrabDevice.this_device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_other_device_mode, { "other_device_mode", "x11.xinput.GrabDevice.other_device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_owner_events, { "owner_events", "x11.xinput.GrabDevice.owner_events", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_device_id, { "device_id", "x11.xinput.GrabDevice.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_classes, { "classes", "x11.xinput.GrabDevice.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_classes_item, { "classes", "x11.xinput.GrabDevice.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDevice_reply_status, { "status", "x11.xinput.GrabDevice.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDevice_time, { "time", "x11.xinput.UngrabDevice.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDevice_device_id, { "device_id", "x11.xinput.UngrabDevice.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_grab_window, { "grab_window", "x11.xinput.GrabDeviceKey.grab_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_num_classes, { "num_classes", "x11.xinput.GrabDeviceKey.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_modifiers, { "modifiers", "x11.xinput.GrabDeviceKey.modifiers", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_modifier_device, { "modifier_device", "x11.xinput.GrabDeviceKey.modifier_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_grabbed_device, { "grabbed_device", "x11.xinput.GrabDeviceKey.grabbed_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_key, { "key", "x11.xinput.GrabDeviceKey.key", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_this_device_mode, { "this_device_mode", "x11.xinput.GrabDeviceKey.this_device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_other_device_mode, { "other_device_mode", "x11.xinput.GrabDeviceKey.other_device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_owner_events, { "owner_events", "x11.xinput.GrabDeviceKey.owner_events", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_classes, { "classes", "x11.xinput.GrabDeviceKey.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceKey_classes_item, { "classes", "x11.xinput.GrabDeviceKey.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceKey_grabWindow, { "grabWindow", "x11.xinput.UngrabDeviceKey.grabWindow", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceKey_modifiers, { "modifiers", "x11.xinput.UngrabDeviceKey.modifiers", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceKey_modifier_device, { "modifier_device", "x11.xinput.UngrabDeviceKey.modifier_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceKey_key, { "key", "x11.xinput.UngrabDeviceKey.key", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceKey_grabbed_device, { "grabbed_device", "x11.xinput.UngrabDeviceKey.grabbed_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_grab_window, { "grab_window", "x11.xinput.GrabDeviceButton.grab_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_grabbed_device, { "grabbed_device", "x11.xinput.GrabDeviceButton.grabbed_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_modifier_device, { "modifier_device", "x11.xinput.GrabDeviceButton.modifier_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_num_classes, { "num_classes", "x11.xinput.GrabDeviceButton.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_modifiers, { "modifiers", "x11.xinput.GrabDeviceButton.modifiers", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_this_device_mode, { "this_device_mode", "x11.xinput.GrabDeviceButton.this_device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_other_device_mode, { "other_device_mode", "x11.xinput.GrabDeviceButton.other_device_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_button, { "button", "x11.xinput.GrabDeviceButton.button", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_owner_events, { "owner_events", "x11.xinput.GrabDeviceButton.owner_events", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_classes, { "classes", "x11.xinput.GrabDeviceButton.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GrabDeviceButton_classes_item, { "classes", "x11.xinput.GrabDeviceButton.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceButton_grab_window, { "grab_window", "x11.xinput.UngrabDeviceButton.grab_window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceButton_modifiers, { "modifiers", "x11.xinput.UngrabDeviceButton.modifiers", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceButton_modifier_device, { "modifier_device", "x11.xinput.UngrabDeviceButton.modifier_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceButton_button, { "button", "x11.xinput.UngrabDeviceButton.button", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_UngrabDeviceButton_grabbed_device, { "grabbed_device", "x11.xinput.UngrabDeviceButton.grabbed_device", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_AllowDeviceEvents_time, { "time", "x11.xinput.AllowDeviceEvents.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_AllowDeviceEvents_mode, { "mode", "x11.xinput.AllowDeviceEvents.mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_AllowDeviceEvents_device_id, { "device_id", "x11.xinput.AllowDeviceEvents.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceFocus_device_id, { "device_id", "x11.xinput.GetDeviceFocus.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceFocus_reply_focus, { "focus", "x11.xinput.GetDeviceFocus.reply.focus", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceFocus_reply_time, { "time", "x11.xinput.GetDeviceFocus.reply.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceFocus_reply_revert_to, { "revert_to", "x11.xinput.GetDeviceFocus.reply.revert_to", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceFocus_focus, { "focus", "x11.xinput.SetDeviceFocus.focus", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceFocus_time, { "time", "x11.xinput.SetDeviceFocus.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceFocus_revert_to, { "revert_to", "x11.xinput.SetDeviceFocus.revert_to", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceFocus_device_id, { "device_id", "x11.xinput.SetDeviceFocus.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetFeedbackControl_device_id, { "device_id", "x11.xinput.GetFeedbackControl.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetFeedbackControl_reply_num_feedback, { "num_feedback", "x11.xinput.GetFeedbackControl.reply.num_feedback", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceKeyMapping_device_id, { "device_id", "x11.xinput.GetDeviceKeyMapping.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceKeyMapping_first_keycode, { "first_keycode", "x11.xinput.GetDeviceKeyMapping.first_keycode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceKeyMapping_count, { "count", "x11.xinput.GetDeviceKeyMapping.count", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_per_keycode, { "keysyms_per_keycode", "x11.xinput.GetDeviceKeyMapping.reply.keysyms_per_keycode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms, { "keysyms", "x11.xinput.GetDeviceKeyMapping.reply.keysyms", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_item, { "keysyms", "x11.xinput.GetDeviceKeyMapping.reply.keysyms", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceKeyMapping_device_id, { "device_id", "x11.xinput.ChangeDeviceKeyMapping.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceKeyMapping_first_keycode, { "first_keycode", "x11.xinput.ChangeDeviceKeyMapping.first_keycode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_per_keycode, { "keysyms_per_keycode", "x11.xinput.ChangeDeviceKeyMapping.keysyms_per_keycode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceKeyMapping_keycode_count, { "keycode_count", "x11.xinput.ChangeDeviceKeyMapping.keycode_count", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceKeyMapping_keysyms, { "keysyms", "x11.xinput.ChangeDeviceKeyMapping.keysyms", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_item, { "keysyms", "x11.xinput.ChangeDeviceKeyMapping.keysyms", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceModifierMapping_device_id, { "device_id", "x11.xinput.GetDeviceModifierMapping.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceModifierMapping_reply_keycodes_per_modifier, { "keycodes_per_modifier", "x11.xinput.GetDeviceModifierMapping.reply.keycodes_per_modifier", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceModifierMapping_reply_keymaps, { "keymaps", "x11.xinput.GetDeviceModifierMapping.reply.keymaps", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceModifierMapping_device_id, { "device_id", "x11.xinput.SetDeviceModifierMapping.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceModifierMapping_keycodes_per_modifier, { "keycodes_per_modifier", "x11.xinput.SetDeviceModifierMapping.keycodes_per_modifier", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceModifierMapping_keymaps, { "keymaps", "x11.xinput.SetDeviceModifierMapping.keymaps", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceModifierMapping_reply_status, { "status", "x11.xinput.SetDeviceModifierMapping.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceButtonMapping_device_id, { "device_id", "x11.xinput.GetDeviceButtonMapping.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceButtonMapping_reply_map_size, { "map_size", "x11.xinput.GetDeviceButtonMapping.reply.map_size", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceButtonMapping_reply_map, { "map", "x11.xinput.GetDeviceButtonMapping.reply.map", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceButtonMapping_device_id, { "device_id", "x11.xinput.SetDeviceButtonMapping.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceButtonMapping_map_size, { "map_size", "x11.xinput.SetDeviceButtonMapping.map_size", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceButtonMapping_map, { "map", "x11.xinput.SetDeviceButtonMapping.map", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceButtonMapping_reply_status, { "status", "x11.xinput.SetDeviceButtonMapping.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_QueryDeviceState_device_id, { "device_id", "x11.xinput.QueryDeviceState.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_QueryDeviceState_reply_num_classes, { "num_classes", "x11.xinput.QueryDeviceState.reply.num_classes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_destination, { "destination", "x11.xinput.SendExtensionEvent.destination", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_device_id, { "device_id", "x11.xinput.SendExtensionEvent.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_propagate, { "propagate", "x11.xinput.SendExtensionEvent.propagate", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_num_classes, { "num_classes", "x11.xinput.SendExtensionEvent.num_classes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_num_events, { "num_events", "x11.xinput.SendExtensionEvent.num_events", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_events, { "events", "x11.xinput.SendExtensionEvent.events", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_classes, { "classes", "x11.xinput.SendExtensionEvent.classes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SendExtensionEvent_classes_item, { "classes", "x11.xinput.SendExtensionEvent.classes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceBell_device_id, { "device_id", "x11.xinput.DeviceBell.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceBell_feedback_id, { "feedback_id", "x11.xinput.DeviceBell.feedback_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceBell_feedback_class, { "feedback_class", "x11.xinput.DeviceBell.feedback_class", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceBell_percent, { "percent", "x11.xinput.DeviceBell.percent", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceValuators_device_id, { "device_id", "x11.xinput.SetDeviceValuators.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceValuators_first_valuator, { "first_valuator", "x11.xinput.SetDeviceValuators.first_valuator", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceValuators_num_valuators, { "num_valuators", "x11.xinput.SetDeviceValuators.num_valuators", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceValuators_valuators, { "valuators", "x11.xinput.SetDeviceValuators.valuators", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceValuators_valuators_item, { "valuators", "x11.xinput.SetDeviceValuators.valuators", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_SetDeviceValuators_reply_status, { "status", "x11.xinput.SetDeviceValuators.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceControl_control_id, { "control_id", "x11.xinput.GetDeviceControl.control_id", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceControl_device_id, { "device_id", "x11.xinput.GetDeviceControl.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_GetDeviceControl_reply_status, { "status", "x11.xinput.GetDeviceControl.reply.status", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceValuator_device_id, { "device_id", "x11.xinput.DeviceValuator.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceValuator_device_state, { "device_state", "x11.xinput.DeviceValuator.device_state", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceValuator_num_valuators, { "num_valuators", "x11.xinput.DeviceValuator.num_valuators", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceValuator_first_valuator, { "first_valuator", "x11.xinput.DeviceValuator.first_valuator", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceValuator_valuators, { "valuators", "x11.xinput.DeviceValuator.valuators", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceValuator_valuators_item, { "valuators", "x11.xinput.DeviceValuator.valuators", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_detail, { "detail", "x11.xinput.DeviceKeyPress.detail", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_time, { "time", "x11.xinput.DeviceKeyPress.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_root, { "root", "x11.xinput.DeviceKeyPress.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_event, { "event", "x11.xinput.DeviceKeyPress.event", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_child, { "child", "x11.xinput.DeviceKeyPress.child", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_root_x, { "root_x", "x11.xinput.DeviceKeyPress.root_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_root_y, { "root_y", "x11.xinput.DeviceKeyPress.root_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_event_x, { "event_x", "x11.xinput.DeviceKeyPress.event_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_event_y, { "event_y", "x11.xinput.DeviceKeyPress.event_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_state, { "state", "x11.xinput.DeviceKeyPress.state", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_same_screen, { "same_screen", "x11.xinput.DeviceKeyPress.same_screen", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyPress_device_id, { "device_id", "x11.xinput.DeviceKeyPress.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_FocusIn_detail, { "detail", "x11.xinput.FocusIn.detail", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_FocusIn_time, { "time", "x11.xinput.FocusIn.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_FocusIn_window, { "window", "x11.xinput.FocusIn.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_FocusIn_mode, { "mode", "x11.xinput.FocusIn.mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_FocusIn_device_id, { "device_id", "x11.xinput.FocusIn.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_device_id, { "device_id", "x11.xinput.DeviceStateNotify.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_time, { "time", "x11.xinput.DeviceStateNotify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_num_keys, { "num_keys", "x11.xinput.DeviceStateNotify.num_keys", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_num_buttons, { "num_buttons", "x11.xinput.DeviceStateNotify.num_buttons", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_num_valuators, { "num_valuators", "x11.xinput.DeviceStateNotify.num_valuators", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_classes_reported, { "classes_reported", "x11.xinput.DeviceStateNotify.classes_reported", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_buttons, { "buttons", "x11.xinput.DeviceStateNotify.buttons", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_keys, { "keys", "x11.xinput.DeviceStateNotify.keys", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_valuators, { "valuators", "x11.xinput.DeviceStateNotify.valuators", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceStateNotify_valuators_item, { "valuators", "x11.xinput.DeviceStateNotify.valuators", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceMappingNotify_device_id, { "device_id", "x11.xinput.DeviceMappingNotify.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceMappingNotify_request, { "request", "x11.xinput.DeviceMappingNotify.request", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceMappingNotify_first_keycode, { "first_keycode", "x11.xinput.DeviceMappingNotify.first_keycode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceMappingNotify_count, { "count", "x11.xinput.DeviceMappingNotify.count", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceMappingNotify_time, { "time", "x11.xinput.DeviceMappingNotify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceNotify_device_id, { "device_id", "x11.xinput.ChangeDeviceNotify.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceNotify_time, { "time", "x11.xinput.ChangeDeviceNotify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_ChangeDeviceNotify_request, { "request", "x11.xinput.ChangeDeviceNotify.request", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyStateNotify_device_id, { "device_id", "x11.xinput.DeviceKeyStateNotify.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceKeyStateNotify_keys, { "keys", "x11.xinput.DeviceKeyStateNotify.keys", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceButtonStateNotify_device_id, { "device_id", "x11.xinput.DeviceButtonStateNotify.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DeviceButtonStateNotify_buttons, { "buttons", "x11.xinput.DeviceButtonStateNotify.buttons", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DevicePresenceNotify_time, { "time", "x11.xinput.DevicePresenceNotify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DevicePresenceNotify_devchange, { "devchange", "x11.xinput.DevicePresenceNotify.devchange", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DevicePresenceNotify_device_id, { "device_id", "x11.xinput.DevicePresenceNotify.device_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_DevicePresenceNotify_control, { "control", "x11.xinput.DevicePresenceNotify.control", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xinput_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xinput_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_PRINTER, { "PRINTER", "x11.struct.PRINTER", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PRINTER_nameLen, { "nameLen", "x11.struct.PRINTER.nameLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PRINTER_name, { "name", "x11.struct.PRINTER.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PRINTER_descLen, { "descLen", "x11.struct.PRINTER.descLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_PRINTER_description, { "description", "x11.struct.PRINTER.description", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintQueryVersion_reply_major_version, { "major_version", "x11.xprint.PrintQueryVersion.reply.major_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintQueryVersion_reply_minor_version, { "minor_version", "x11.xprint.PrintQueryVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPrinterList_printerNameLen, { "printerNameLen", "x11.xprint.PrintGetPrinterList.printerNameLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPrinterList_localeLen, { "localeLen", "x11.xprint.PrintGetPrinterList.localeLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPrinterList_printer_name, { "printer_name", "x11.xprint.PrintGetPrinterList.printer_name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPrinterList_locale, { "locale", "x11.xprint.PrintGetPrinterList.locale", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPrinterList_reply_listCount, { "listCount", "x11.xprint.PrintGetPrinterList.reply.listCount", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPrinterList_reply_printers, { "printers", "x11.xprint.PrintGetPrinterList.reply.printers", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_CreateContext_context_id, { "context_id", "x11.xprint.CreateContext.context_id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_CreateContext_printerNameLen, { "printerNameLen", "x11.xprint.CreateContext.printerNameLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_CreateContext_localeLen, { "localeLen", "x11.xprint.CreateContext.localeLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_CreateContext_printerName, { "printerName", "x11.xprint.CreateContext.printerName", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_CreateContext_locale, { "locale", "x11.xprint.CreateContext.locale", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetContext_context, { "context", "x11.xprint.PrintSetContext.context", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetContext_reply_context, { "context", "x11.xprint.PrintGetContext.reply.context", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintDestroyContext_context, { "context", "x11.xprint.PrintDestroyContext.context", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetScreenOfContext_reply_root, { "root", "x11.xprint.PrintGetScreenOfContext.reply.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintStartJob_output_mode, { "output_mode", "x11.xprint.PrintStartJob.output_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintEndJob_cancel, { "cancel", "x11.xprint.PrintEndJob.cancel", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintStartDoc_driver_mode, { "driver_mode", "x11.xprint.PrintStartDoc.driver_mode", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintEndDoc_cancel, { "cancel", "x11.xprint.PrintEndDoc.cancel", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_drawable, { "drawable", "x11.xprint.PrintPutDocumentData.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_len_data, { "len_data", "x11.xprint.PrintPutDocumentData.len_data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_len_fmt, { "len_fmt", "x11.xprint.PrintPutDocumentData.len_fmt", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_len_options, { "len_options", "x11.xprint.PrintPutDocumentData.len_options", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_data, { "data", "x11.xprint.PrintPutDocumentData.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_doc_format, { "doc_format", "x11.xprint.PrintPutDocumentData.doc_format", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintPutDocumentData_options, { "options", "x11.xprint.PrintPutDocumentData.options", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetDocumentData_context, { "context", "x11.xprint.PrintGetDocumentData.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetDocumentData_max_bytes, { "max_bytes", "x11.xprint.PrintGetDocumentData.max_bytes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetDocumentData_reply_status_code, { "status_code", "x11.xprint.PrintGetDocumentData.reply.status_code", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetDocumentData_reply_finished_flag, { "finished_flag", "x11.xprint.PrintGetDocumentData.reply.finished_flag", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetDocumentData_reply_dataLen, { "dataLen", "x11.xprint.PrintGetDocumentData.reply.dataLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetDocumentData_reply_data, { "data", "x11.xprint.PrintGetDocumentData.reply.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintStartPage_window, { "window", "x11.xprint.PrintStartPage.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintEndPage_cancel, { "cancel", "x11.xprint.PrintEndPage.cancel", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSelectInput_context, { "context", "x11.xprint.PrintSelectInput.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintInputSelected_context, { "context", "x11.xprint.PrintInputSelected.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetAttributes_context, { "context", "x11.xprint.PrintGetAttributes.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetAttributes_pool, { "pool", "x11.xprint.PrintGetAttributes.pool", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetAttributes_reply_stringLen, { "stringLen", "x11.xprint.PrintGetAttributes.reply.stringLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetAttributes_reply_attributes, { "attributes", "x11.xprint.PrintGetAttributes.reply.attributes", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetOneAttributes_context, { "context", "x11.xprint.PrintGetOneAttributes.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetOneAttributes_nameLen, { "nameLen", "x11.xprint.PrintGetOneAttributes.nameLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetOneAttributes_pool, { "pool", "x11.xprint.PrintGetOneAttributes.pool", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetOneAttributes_name, { "name", "x11.xprint.PrintGetOneAttributes.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetOneAttributes_reply_valueLen, { "valueLen", "x11.xprint.PrintGetOneAttributes.reply.valueLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetOneAttributes_reply_value, { "value", "x11.xprint.PrintGetOneAttributes.reply.value", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetAttributes_context, { "context", "x11.xprint.PrintSetAttributes.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetAttributes_stringLen, { "stringLen", "x11.xprint.PrintSetAttributes.stringLen", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetAttributes_pool, { "pool", "x11.xprint.PrintSetAttributes.pool", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetAttributes_rule, { "rule", "x11.xprint.PrintSetAttributes.rule", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetAttributes_attributes, { "attributes", "x11.xprint.PrintSetAttributes.attributes", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_context, { "context", "x11.xprint.PrintGetPageDimensions.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_reply_width, { "width", "x11.xprint.PrintGetPageDimensions.reply.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_reply_height, { "height", "x11.xprint.PrintGetPageDimensions.reply.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_reply_offset_x, { "offset_x", "x11.xprint.PrintGetPageDimensions.reply.offset_x", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_reply_offset_y, { "offset_y", "x11.xprint.PrintGetPageDimensions.reply.offset_y", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_width, { "reproducible_width", "x11.xprint.PrintGetPageDimensions.reply.reproducible_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_height, { "reproducible_height", "x11.xprint.PrintGetPageDimensions.reply.reproducible_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintQueryScreens_reply_listCount, { "listCount", "x11.xprint.PrintQueryScreens.reply.listCount", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintQueryScreens_reply_roots, { "roots", "x11.xprint.PrintQueryScreens.reply.roots", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintQueryScreens_reply_roots_item, { "roots", "x11.xprint.PrintQueryScreens.reply.roots", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetImageResolution_context, { "context", "x11.xprint.PrintSetImageResolution.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetImageResolution_image_resolution, { "image_resolution", "x11.xprint.PrintSetImageResolution.image_resolution", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetImageResolution_reply_status, { "status", "x11.xprint.PrintSetImageResolution.reply.status", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintSetImageResolution_reply_previous_resolutions, { "previous_resolutions", "x11.xprint.PrintSetImageResolution.reply.previous_resolutions", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetImageResolution_context, { "context", "x11.xprint.PrintGetImageResolution.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_PrintGetImageResolution_reply_image_resolution, { "image_resolution", "x11.xprint.PrintGetImageResolution.reply.image_resolution", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_Notify_detail, { "detail", "x11.xprint.Notify.detail", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_Notify_context, { "context", "x11.xprint.Notify.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_Notify_cancel, { "cancel", "x11.xprint.Notify.cancel", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_AttributNotify_detail, { "detail", "x11.xprint.AttributNotify.detail", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_AttributNotify_context, { "context", "x11.xprint.AttributNotify.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xprint_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xprint_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xselinux_QueryVersion_client_major, { "client_major", "x11.xselinux.QueryVersion.client_major", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_QueryVersion_client_minor, { "client_minor", "x11.xselinux.QueryVersion.client_minor", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_QueryVersion_reply_server_major, { "server_major", "x11.xselinux.QueryVersion.reply.server_major", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_QueryVersion_reply_server_minor, { "server_minor", "x11.xselinux.QueryVersion.reply.server_minor", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetDeviceCreateContext_context_len, { "context_len", "x11.xselinux.SetDeviceCreateContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetDeviceCreateContext_context, { "context", "x11.xselinux.SetDeviceCreateContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetDeviceCreateContext_reply_context_len, { "context_len", "x11.xselinux.GetDeviceCreateContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetDeviceCreateContext_reply_context, { "context", "x11.xselinux.GetDeviceCreateContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetDeviceContext_device, { "device", "x11.xselinux.SetDeviceContext.device", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetDeviceContext_context_len, { "context_len", "x11.xselinux.SetDeviceContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetDeviceContext_context, { "context", "x11.xselinux.SetDeviceContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetDeviceContext_device, { "device", "x11.xselinux.GetDeviceContext.device", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetDeviceContext_reply_context_len, { "context_len", "x11.xselinux.GetDeviceContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetDeviceContext_reply_context, { "context", "x11.xselinux.GetDeviceContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetWindowCreateContext_context_len, { "context_len", "x11.xselinux.SetWindowCreateContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetWindowCreateContext_context, { "context", "x11.xselinux.SetWindowCreateContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetWindowCreateContext_reply_context_len, { "context_len", "x11.xselinux.GetWindowCreateContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetWindowCreateContext_reply_context, { "context", "x11.xselinux.GetWindowCreateContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetWindowContext_window, { "window", "x11.xselinux.GetWindowContext.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetWindowContext_reply_context_len, { "context_len", "x11.xselinux.GetWindowContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetWindowContext_reply_context, { "context", "x11.xselinux.GetWindowContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ListItem, { "ListItem", "x11.struct.ListItem", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ListItem_name, { "name", "x11.struct.ListItem.name", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ListItem_object_context_len, { "object_context_len", "x11.struct.ListItem.object_context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ListItem_data_context_len, { "data_context_len", "x11.struct.ListItem.data_context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ListItem_object_context, { "object_context", "x11.struct.ListItem.object_context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ListItem_data_context, { "data_context", "x11.struct.ListItem.data_context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetPropertyCreateContext_context_len, { "context_len", "x11.xselinux.SetPropertyCreateContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetPropertyCreateContext_context, { "context", "x11.xselinux.SetPropertyCreateContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyCreateContext_reply_context_len, { "context_len", "x11.xselinux.GetPropertyCreateContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyCreateContext_reply_context, { "context", "x11.xselinux.GetPropertyCreateContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetPropertyUseContext_context_len, { "context_len", "x11.xselinux.SetPropertyUseContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetPropertyUseContext_context, { "context", "x11.xselinux.SetPropertyUseContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyUseContext_reply_context_len, { "context_len", "x11.xselinux.GetPropertyUseContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyUseContext_reply_context, { "context", "x11.xselinux.GetPropertyUseContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyContext_window, { "window", "x11.xselinux.GetPropertyContext.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyContext_property, { "property", "x11.xselinux.GetPropertyContext.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyContext_reply_context_len, { "context_len", "x11.xselinux.GetPropertyContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyContext_reply_context, { "context", "x11.xselinux.GetPropertyContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyDataContext_window, { "window", "x11.xselinux.GetPropertyDataContext.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyDataContext_property, { "property", "x11.xselinux.GetPropertyDataContext.property", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyDataContext_reply_context_len, { "context_len", "x11.xselinux.GetPropertyDataContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetPropertyDataContext_reply_context, { "context", "x11.xselinux.GetPropertyDataContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_ListProperties_window, { "window", "x11.xselinux.ListProperties.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_ListProperties_reply_properties_len, { "properties_len", "x11.xselinux.ListProperties.reply.properties_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_ListProperties_reply_properties, { "properties", "x11.xselinux.ListProperties.reply.properties", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetSelectionCreateContext_context_len, { "context_len", "x11.xselinux.SetSelectionCreateContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetSelectionCreateContext_context, { "context", "x11.xselinux.SetSelectionCreateContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionCreateContext_reply_context_len, { "context_len", "x11.xselinux.GetSelectionCreateContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionCreateContext_reply_context, { "context", "x11.xselinux.GetSelectionCreateContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetSelectionUseContext_context_len, { "context_len", "x11.xselinux.SetSelectionUseContext.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_SetSelectionUseContext_context, { "context", "x11.xselinux.SetSelectionUseContext.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionUseContext_reply_context_len, { "context_len", "x11.xselinux.GetSelectionUseContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionUseContext_reply_context, { "context", "x11.xselinux.GetSelectionUseContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionContext_selection, { "selection", "x11.xselinux.GetSelectionContext.selection", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionContext_reply_context_len, { "context_len", "x11.xselinux.GetSelectionContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionContext_reply_context, { "context", "x11.xselinux.GetSelectionContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionDataContext_selection, { "selection", "x11.xselinux.GetSelectionDataContext.selection", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionDataContext_reply_context_len, { "context_len", "x11.xselinux.GetSelectionDataContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetSelectionDataContext_reply_context, { "context", "x11.xselinux.GetSelectionDataContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_ListSelections_reply_selections_len, { "selections_len", "x11.xselinux.ListSelections.reply.selections_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_ListSelections_reply_selections, { "selections", "x11.xselinux.ListSelections.reply.selections", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetClientContext_resource, { "resource", "x11.xselinux.GetClientContext.resource", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetClientContext_reply_context_len, { "context_len", "x11.xselinux.GetClientContext.reply.context_len", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_GetClientContext_reply_context, { "context", "x11.xselinux.GetClientContext.reply.context", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xselinux_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xselinux_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_xtest_GetVersion_major_version, { "major_version", "x11.xtest.GetVersion.major_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_GetVersion_minor_version, { "minor_version", "x11.xtest.GetVersion.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_GetVersion_reply_major_version, { "major_version", "x11.xtest.GetVersion.reply.major_version", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_GetVersion_reply_minor_version, { "minor_version", "x11.xtest.GetVersion.reply.minor_version", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_CompareCursor_window, { "window", "x11.xtest.CompareCursor.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_CompareCursor_cursor, { "cursor", "x11.xtest.CompareCursor.cursor", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_CompareCursor_reply_same, { "same", "x11.xtest.CompareCursor.reply.same", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_type, { "type", "x11.xtest.FakeInput.type", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_detail, { "detail", "x11.xtest.FakeInput.detail", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_time, { "time", "x11.xtest.FakeInput.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_root, { "root", "x11.xtest.FakeInput.root", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_rootX, { "rootX", "x11.xtest.FakeInput.rootX", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_rootY, { "rootY", "x11.xtest.FakeInput.rootY", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_FakeInput_deviceid, { "deviceid", "x11.xtest.FakeInput.deviceid", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_GrabControl_impervious, { "impervious", "x11.xtest.GrabControl.impervious", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xtest_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xtest_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_Rational, { "Rational", "x11.struct.Rational", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Rational_numerator, { "numerator", "x11.struct.Rational.numerator", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Rational_denominator, { "denominator", "x11.struct.Rational.denominator", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Format, { "Format", "x11.struct.Format", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Format_visual, { "visual", "x11.struct.Format.visual", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_Format_depth, { "depth", "x11.struct.Format.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo, { "AdaptorInfo", "x11.struct.AdaptorInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_base_id, { "base_id", "x11.struct.AdaptorInfo.base_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_name_size, { "name_size", "x11.struct.AdaptorInfo.name_size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_num_ports, { "num_ports", "x11.struct.AdaptorInfo.num_ports", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_num_formats, { "num_formats", "x11.struct.AdaptorInfo.num_formats", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_type, { "type", "x11.struct.AdaptorInfo.type", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_name, { "name", "x11.struct.AdaptorInfo.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_formats, { "formats", "x11.struct.AdaptorInfo.formats", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AdaptorInfo_formats_item, { "formats", "x11.struct.AdaptorInfo.formats", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo, { "EncodingInfo", "x11.struct.EncodingInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo_encoding, { "encoding", "x11.struct.EncodingInfo.encoding", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo_name_size, { "name_size", "x11.struct.EncodingInfo.name_size", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo_width, { "width", "x11.struct.EncodingInfo.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo_height, { "height", "x11.struct.EncodingInfo.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo_rate, { "rate", "x11.struct.EncodingInfo.rate", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_EncodingInfo_name, { "name", "x11.struct.EncodingInfo.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AttributeInfo, { "AttributeInfo", "x11.struct.AttributeInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AttributeInfo_flags, { "flags", "x11.struct.AttributeInfo.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AttributeInfo_min, { "min", "x11.struct.AttributeInfo.min", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AttributeInfo_max, { "max", "x11.struct.AttributeInfo.max", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AttributeInfo_size, { "size", "x11.struct.AttributeInfo.size", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_AttributeInfo_name, { "name", "x11.struct.AttributeInfo.name", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo, { "ImageFormatInfo", "x11.struct.ImageFormatInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_id, { "id", "x11.struct.ImageFormatInfo.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_type, { "type", "x11.struct.ImageFormatInfo.type", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_byte_order, { "byte_order", "x11.struct.ImageFormatInfo.byte_order", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_guid, { "guid", "x11.struct.ImageFormatInfo.guid", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_bpp, { "bpp", "x11.struct.ImageFormatInfo.bpp", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_num_planes, { "num_planes", "x11.struct.ImageFormatInfo.num_planes", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_depth, { "depth", "x11.struct.ImageFormatInfo.depth", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_red_mask, { "red_mask", "x11.struct.ImageFormatInfo.red_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_green_mask, { "green_mask", "x11.struct.ImageFormatInfo.green_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_blue_mask, { "blue_mask", "x11.struct.ImageFormatInfo.blue_mask", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_format, { "format", "x11.struct.ImageFormatInfo.format", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_y_sample_bits, { "y_sample_bits", "x11.struct.ImageFormatInfo.y_sample_bits", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_u_sample_bits, { "u_sample_bits", "x11.struct.ImageFormatInfo.u_sample_bits", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_v_sample_bits, { "v_sample_bits", "x11.struct.ImageFormatInfo.v_sample_bits", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vhorz_y_period, { "vhorz_y_period", "x11.struct.ImageFormatInfo.vhorz_y_period", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vhorz_u_period, { "vhorz_u_period", "x11.struct.ImageFormatInfo.vhorz_u_period", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vhorz_v_period, { "vhorz_v_period", "x11.struct.ImageFormatInfo.vhorz_v_period", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vvert_y_period, { "vvert_y_period", "x11.struct.ImageFormatInfo.vvert_y_period", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vvert_u_period, { "vvert_u_period", "x11.struct.ImageFormatInfo.vvert_u_period", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vvert_v_period, { "vvert_v_period", "x11.struct.ImageFormatInfo.vvert_v_period", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vcomp_order, { "vcomp_order", "x11.struct.ImageFormatInfo.vcomp_order", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_ImageFormatInfo_vscanline_order, { "vscanline_order", "x11.struct.ImageFormatInfo.vscanline_order", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_VideoNotify_reason, { "reason", "x11.xv.VideoNotify.reason", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_VideoNotify_time, { "time", "x11.xv.VideoNotify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_VideoNotify_drawable, { "drawable", "x11.xv.VideoNotify.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_VideoNotify_port, { "port", "x11.xv.VideoNotify.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PortNotify_time, { "time", "x11.xv.PortNotify.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PortNotify_port, { "port", "x11.xv.PortNotify.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PortNotify_attribute, { "attribute", "x11.xv.PortNotify.attribute", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PortNotify_value, { "value", "x11.xv.PortNotify.value", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryExtension_reply_major, { "major", "x11.xv.QueryExtension.reply.major", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryExtension_reply_minor, { "minor", "x11.xv.QueryExtension.reply.minor", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryAdaptors_window, { "window", "x11.xv.QueryAdaptors.window", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryAdaptors_reply_num_adaptors, { "num_adaptors", "x11.xv.QueryAdaptors.reply.num_adaptors", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryAdaptors_reply_info, { "info", "x11.xv.QueryAdaptors.reply.info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryEncodings_port, { "port", "x11.xv.QueryEncodings.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryEncodings_reply_num_encodings, { "num_encodings", "x11.xv.QueryEncodings.reply.num_encodings", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryEncodings_reply_info, { "info", "x11.xv.QueryEncodings.reply.info", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GrabPort_port, { "port", "x11.xv.GrabPort.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GrabPort_time, { "time", "x11.xv.GrabPort.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GrabPort_reply_result, { "result", "x11.xv.GrabPort.reply.result", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_UngrabPort_port, { "port", "x11.xv.UngrabPort.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_UngrabPort_time, { "time", "x11.xv.UngrabPort.time", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_port, { "port", "x11.xv.PutVideo.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_drawable, { "drawable", "x11.xv.PutVideo.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_gc, { "gc", "x11.xv.PutVideo.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_vid_x, { "vid_x", "x11.xv.PutVideo.vid_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_vid_y, { "vid_y", "x11.xv.PutVideo.vid_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_vid_w, { "vid_w", "x11.xv.PutVideo.vid_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_vid_h, { "vid_h", "x11.xv.PutVideo.vid_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_drw_x, { "drw_x", "x11.xv.PutVideo.drw_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_drw_y, { "drw_y", "x11.xv.PutVideo.drw_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_drw_w, { "drw_w", "x11.xv.PutVideo.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutVideo_drw_h, { "drw_h", "x11.xv.PutVideo.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_port, { "port", "x11.xv.PutStill.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_drawable, { "drawable", "x11.xv.PutStill.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_gc, { "gc", "x11.xv.PutStill.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_vid_x, { "vid_x", "x11.xv.PutStill.vid_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_vid_y, { "vid_y", "x11.xv.PutStill.vid_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_vid_w, { "vid_w", "x11.xv.PutStill.vid_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_vid_h, { "vid_h", "x11.xv.PutStill.vid_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_drw_x, { "drw_x", "x11.xv.PutStill.drw_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_drw_y, { "drw_y", "x11.xv.PutStill.drw_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_drw_w, { "drw_w", "x11.xv.PutStill.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutStill_drw_h, { "drw_h", "x11.xv.PutStill.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_port, { "port", "x11.xv.GetVideo.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_drawable, { "drawable", "x11.xv.GetVideo.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_gc, { "gc", "x11.xv.GetVideo.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_vid_x, { "vid_x", "x11.xv.GetVideo.vid_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_vid_y, { "vid_y", "x11.xv.GetVideo.vid_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_vid_w, { "vid_w", "x11.xv.GetVideo.vid_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_vid_h, { "vid_h", "x11.xv.GetVideo.vid_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_drw_x, { "drw_x", "x11.xv.GetVideo.drw_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_drw_y, { "drw_y", "x11.xv.GetVideo.drw_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_drw_w, { "drw_w", "x11.xv.GetVideo.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetVideo_drw_h, { "drw_h", "x11.xv.GetVideo.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_port, { "port", "x11.xv.GetStill.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_drawable, { "drawable", "x11.xv.GetStill.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_gc, { "gc", "x11.xv.GetStill.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_vid_x, { "vid_x", "x11.xv.GetStill.vid_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_vid_y, { "vid_y", "x11.xv.GetStill.vid_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_vid_w, { "vid_w", "x11.xv.GetStill.vid_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_vid_h, { "vid_h", "x11.xv.GetStill.vid_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_drw_x, { "drw_x", "x11.xv.GetStill.drw_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_drw_y, { "drw_y", "x11.xv.GetStill.drw_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_drw_w, { "drw_w", "x11.xv.GetStill.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetStill_drw_h, { "drw_h", "x11.xv.GetStill.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_StopVideo_port, { "port", "x11.xv.StopVideo.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_StopVideo_drawable, { "drawable", "x11.xv.StopVideo.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SelectVideoNotify_drawable, { "drawable", "x11.xv.SelectVideoNotify.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SelectVideoNotify_onoff, { "onoff", "x11.xv.SelectVideoNotify.onoff", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SelectPortNotify_port, { "port", "x11.xv.SelectPortNotify.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SelectPortNotify_onoff, { "onoff", "x11.xv.SelectPortNotify.onoff", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_port, { "port", "x11.xv.QueryBestSize.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_vid_w, { "vid_w", "x11.xv.QueryBestSize.vid_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_vid_h, { "vid_h", "x11.xv.QueryBestSize.vid_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_drw_w, { "drw_w", "x11.xv.QueryBestSize.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_drw_h, { "drw_h", "x11.xv.QueryBestSize.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_motion, { "motion", "x11.xv.QueryBestSize.motion", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_reply_actual_width, { "actual_width", "x11.xv.QueryBestSize.reply.actual_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryBestSize_reply_actual_height, { "actual_height", "x11.xv.QueryBestSize.reply.actual_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SetPortAttribute_port, { "port", "x11.xv.SetPortAttribute.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SetPortAttribute_attribute, { "attribute", "x11.xv.SetPortAttribute.attribute", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_SetPortAttribute_value, { "value", "x11.xv.SetPortAttribute.value", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetPortAttribute_port, { "port", "x11.xv.GetPortAttribute.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetPortAttribute_attribute, { "attribute", "x11.xv.GetPortAttribute.attribute", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_GetPortAttribute_reply_value, { "value", "x11.xv.GetPortAttribute.reply.value", FT_INT32, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryPortAttributes_port, { "port", "x11.xv.QueryPortAttributes.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryPortAttributes_reply_num_attributes, { "num_attributes", "x11.xv.QueryPortAttributes.reply.num_attributes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryPortAttributes_reply_text_size, { "text_size", "x11.xv.QueryPortAttributes.reply.text_size", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryPortAttributes_reply_attributes, { "attributes", "x11.xv.QueryPortAttributes.reply.attributes", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ListImageFormats_port, { "port", "x11.xv.ListImageFormats.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ListImageFormats_reply_num_formats, { "num_formats", "x11.xv.ListImageFormats.reply.num_formats", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ListImageFormats_reply_format, { "format", "x11.xv.ListImageFormats.reply.format", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ListImageFormats_reply_format_item, { "format", "x11.xv.ListImageFormats.reply.format", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_port, { "port", "x11.xv.QueryImageAttributes.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_id, { "id", "x11.xv.QueryImageAttributes.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_width, { "width", "x11.xv.QueryImageAttributes.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_height, { "height", "x11.xv.QueryImageAttributes.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_num_planes, { "num_planes", "x11.xv.QueryImageAttributes.reply.num_planes", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_data_size, { "data_size", "x11.xv.QueryImageAttributes.reply.data_size", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_width, { "width", "x11.xv.QueryImageAttributes.reply.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_height, { "height", "x11.xv.QueryImageAttributes.reply.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_pitches, { "pitches", "x11.xv.QueryImageAttributes.reply.pitches", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_pitches_item, { "pitches", "x11.xv.QueryImageAttributes.reply.pitches", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_offsets, { "offsets", "x11.xv.QueryImageAttributes.reply.offsets", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_QueryImageAttributes_reply_offsets_item, { "offsets", "x11.xv.QueryImageAttributes.reply.offsets", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_port, { "port", "x11.xv.PutImage.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_drawable, { "drawable", "x11.xv.PutImage.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_gc, { "gc", "x11.xv.PutImage.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_id, { "id", "x11.xv.PutImage.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_src_x, { "src_x", "x11.xv.PutImage.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_src_y, { "src_y", "x11.xv.PutImage.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_src_w, { "src_w", "x11.xv.PutImage.src_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_src_h, { "src_h", "x11.xv.PutImage.src_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_drw_x, { "drw_x", "x11.xv.PutImage.drw_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_drw_y, { "drw_y", "x11.xv.PutImage.drw_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_drw_w, { "drw_w", "x11.xv.PutImage.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_drw_h, { "drw_h", "x11.xv.PutImage.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_width, { "width", "x11.xv.PutImage.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_height, { "height", "x11.xv.PutImage.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_PutImage_data, { "data", "x11.xv.PutImage.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_port, { "port", "x11.xv.ShmPutImage.port", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_drawable, { "drawable", "x11.xv.ShmPutImage.drawable", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_gc, { "gc", "x11.xv.ShmPutImage.gc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_shmseg, { "shmseg", "x11.xv.ShmPutImage.shmseg", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_id, { "id", "x11.xv.ShmPutImage.id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_offset, { "offset", "x11.xv.ShmPutImage.offset", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_src_x, { "src_x", "x11.xv.ShmPutImage.src_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_src_y, { "src_y", "x11.xv.ShmPutImage.src_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_src_w, { "src_w", "x11.xv.ShmPutImage.src_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_src_h, { "src_h", "x11.xv.ShmPutImage.src_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_drw_x, { "drw_x", "x11.xv.ShmPutImage.drw_x", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_drw_y, { "drw_y", "x11.xv.ShmPutImage.drw_y", FT_INT16, BASE_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_drw_w, { "drw_w", "x11.xv.ShmPutImage.drw_w", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_drw_h, { "drw_h", "x11.xv.ShmPutImage.drw_h", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_width, { "width", "x11.xv.ShmPutImage.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_height, { "height", "x11.xv.ShmPutImage.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_ShmPutImage_send_event, { "send_event", "x11.xv.ShmPutImage.send_event", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xv_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xv_extension_minor), 0, "minor opcode", HFILL }}, + +{ &hf_x11_struct_SurfaceInfo, { "SurfaceInfo", "x11.struct.SurfaceInfo", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_id, { "id", "x11.struct.SurfaceInfo.id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_chroma_format, { "chroma_format", "x11.struct.SurfaceInfo.chroma_format", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_pad0, { "pad0", "x11.struct.SurfaceInfo.pad0", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_max_width, { "max_width", "x11.struct.SurfaceInfo.max_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_max_height, { "max_height", "x11.struct.SurfaceInfo.max_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_subpicture_max_width, { "subpicture_max_width", "x11.struct.SurfaceInfo.subpicture_max_width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_subpicture_max_height, { "subpicture_max_height", "x11.struct.SurfaceInfo.subpicture_max_height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_mc_type, { "mc_type", "x11.struct.SurfaceInfo.mc_type", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_struct_SurfaceInfo_flags, { "flags", "x11.struct.SurfaceInfo.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_QueryVersion_reply_major, { "major", "x11.xvmc.QueryVersion.reply.major", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_QueryVersion_reply_minor, { "minor", "x11.xvmc.QueryVersion.reply.minor", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSurfaceTypes_port_id, { "port_id", "x11.xvmc.ListSurfaceTypes.port_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSurfaceTypes_reply_num, { "num", "x11.xvmc.ListSurfaceTypes.reply.num", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSurfaceTypes_reply_surfaces, { "surfaces", "x11.xvmc.ListSurfaceTypes.reply.surfaces", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSurfaceTypes_reply_surfaces_item, { "surfaces", "x11.xvmc.ListSurfaceTypes.reply.surfaces", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_context_id, { "context_id", "x11.xvmc.CreateContext.context_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_port_id, { "port_id", "x11.xvmc.CreateContext.port_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_surface_id, { "surface_id", "x11.xvmc.CreateContext.surface_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_width, { "width", "x11.xvmc.CreateContext.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_height, { "height", "x11.xvmc.CreateContext.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_flags, { "flags", "x11.xvmc.CreateContext.flags", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_reply_width_actual, { "width_actual", "x11.xvmc.CreateContext.reply.width_actual", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_reply_height_actual, { "height_actual", "x11.xvmc.CreateContext.reply.height_actual", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_reply_flags_return, { "flags_return", "x11.xvmc.CreateContext.reply.flags_return", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_reply_priv_data, { "priv_data", "x11.xvmc.CreateContext.reply.priv_data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateContext_reply_priv_data_item, { "priv_data", "x11.xvmc.CreateContext.reply.priv_data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_DestroyContext_context_id, { "context_id", "x11.xvmc.DestroyContext.context_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSurface_surface_id, { "surface_id", "x11.xvmc.CreateSurface.surface_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSurface_context_id, { "context_id", "x11.xvmc.CreateSurface.context_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSurface_reply_priv_data, { "priv_data", "x11.xvmc.CreateSurface.reply.priv_data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSurface_reply_priv_data_item, { "priv_data", "x11.xvmc.CreateSurface.reply.priv_data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_DestroySurface_surface_id, { "surface_id", "x11.xvmc.DestroySurface.surface_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_subpicture_id, { "subpicture_id", "x11.xvmc.CreateSubpicture.subpicture_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_context, { "context", "x11.xvmc.CreateSubpicture.context", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_xvimage_id, { "xvimage_id", "x11.xvmc.CreateSubpicture.xvimage_id", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_width, { "width", "x11.xvmc.CreateSubpicture.width", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_height, { "height", "x11.xvmc.CreateSubpicture.height", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_width_actual, { "width_actual", "x11.xvmc.CreateSubpicture.reply.width_actual", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_height_actual, { "height_actual", "x11.xvmc.CreateSubpicture.reply.height_actual", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_num_palette_entries, { "num_palette_entries", "x11.xvmc.CreateSubpicture.reply.num_palette_entries", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_entry_bytes, { "entry_bytes", "x11.xvmc.CreateSubpicture.reply.entry_bytes", FT_UINT16, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_component_order, { "component_order", "x11.xvmc.CreateSubpicture.reply.component_order", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_priv_data, { "priv_data", "x11.xvmc.CreateSubpicture.reply.priv_data", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_CreateSubpicture_reply_priv_data_item, { "priv_data", "x11.xvmc.CreateSubpicture.reply.priv_data", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_DestroySubpicture_subpicture_id, { "subpicture_id", "x11.xvmc.DestroySubpicture.subpicture_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSubpictureTypes_port_id, { "port_id", "x11.xvmc.ListSubpictureTypes.port_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSubpictureTypes_surface_id, { "surface_id", "x11.xvmc.ListSubpictureTypes.surface_id", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSubpictureTypes_reply_num, { "num", "x11.xvmc.ListSubpictureTypes.reply.num", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSubpictureTypes_reply_types, { "types", "x11.xvmc.ListSubpictureTypes.reply.types", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_ListSubpictureTypes_reply_types_item, { "types", "x11.xvmc.ListSubpictureTypes.reply.types", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }}, +{ &hf_x11_xvmc_extension_minor, { "extension-minor", "x11.extension-minor", FT_UINT8, BASE_DEC, VALS(xvmc_extension_minor), 0, "minor opcode", HFILL }}, +