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 }}, +