← Back to branch summary

~smspillaz/xig/xig.disconnect-signals

« back to all changes in this revision

Viewing changes to src/xig-client-codec.c

  • Committer: Robert Ancell
  • Date: 2012-01-06 01:25:12 UTC
  • Revision ID: robert.ancell@canonical.com-20120106012512-gy8rmb2e3hxz9bbh
Make a common XigCodec class

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xig-client-codec.c
 
1
/*
 
2
 * Copyright (C) 2011 Canonical Ltd.
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or modify it under
 
5
 * the terms of the GNU Lesser General Public License version 3 as published by
 
6
 * the Free Software Foundation. See http://www.gnu.org/copyleft/lgpl.html the
 
7
 * full text of the license.
 
8
 */
 
9
 
 
10
#include <string.h>
 
11
 
 
12
#include "xig/xig-client-codec.h"
 
13
#include "xig-common.h" // FIXME: Rename to xig-codec.h
 
14
 
 
15
G_DEFINE_TYPE (XigClientCodec, xig_client_codec, xig_codec_get_type ());
 
16
 
 
17
struct XigClientCodecPrivate
 
18
{
 
19
    /* TRUE if client has connected */
 
20
    gboolean connected;
 
21
 
 
22
    /* Byte order client is using */
 
23
    ByteOrder byte_order;
 
24
 
 
25
    /* TRUE if client can send big requests */
 
26
    gboolean BIGREQ_enabled;
 
27
};
 
28
 
 
29
XigClientCodec *
 
30
xig_client_codec_new (void)
 
31
{
 
32
    return g_object_new (xig_client_codec_get_type (), NULL);
 
33
}
 
34
 
 
35
void
 
36
xig_client_codec_set_BIGREQ_enabled (XigClientCodec *codec, gboolean BIGREQ_enabled)
 
37
{
 
38
    g_return_if_fail (codec != NULL);
 
39
    codec->priv->BIGREQ_enabled = BIGREQ_enabled;
 
40
}
 
41
 
 
42
static void
 
43
decode_success (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length)
 
44
{
 
45
    XigSuccess reply;
 
46
    gsize offset = 0;
 
47
    guint16 vendor_length;
 
48
    int i;
 
49
 
 
50
    read_padding (1, &offset);
 
51
    reply.protocol_major_version = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
52
    reply.protocol_minor_version = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
53
    /*n =*/ read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
54
    reply.release_number = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
55
    reply.resource_id_base = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
56
    reply.resource_id_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
57
    reply.motion_buffer_size = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
58
    vendor_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
59
    reply.maximum_request_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
60
    reply.screens_length = read_card8 (buffer, buffer_length, &offset);
 
61
    reply.pixmap_formats_length = read_card8 (buffer, buffer_length, &offset);
 
62
    reply.image_byte_order = read_card8 (buffer, buffer_length, &offset);
 
63
    reply.bitmap_format_bit_order = read_card8 (buffer, buffer_length, &offset);
 
64
    reply.bitmap_format_scanline_unit = read_card8 (buffer, buffer_length, &offset);
 
65
    reply.bitmap_format_scanline_pad = read_card8 (buffer, buffer_length, &offset);
 
66
    reply.min_keycode = read_card8 (buffer, buffer_length, &offset);
 
67
    reply.max_keycode = read_card8 (buffer, buffer_length, &offset);
 
68
    read_padding (4, &offset);
 
69
    reply.vendor = read_padded_string (buffer, buffer_length, vendor_length, &offset);
 
70
 
 
71
    reply.pixmap_formats = calloc (reply.pixmap_formats_length, sizeof (XigFORMAT));
 
72
    for (i = 0; i < reply.pixmap_formats_length; i++)
 
73
    {
 
74
         reply.pixmap_formats[i].depth = read_card8 (buffer, buffer_length, &offset);
 
75
         reply.pixmap_formats[i].bits_per_pixel = read_card8 (buffer, buffer_length, &offset);
 
76
         reply.pixmap_formats[i].scanline_pad = read_card8 (buffer, buffer_length, &offset);
 
77
         read_padding (5, &offset);
 
78
    }
 
79
 
 
80
    reply.screens = calloc (reply.screens_length, sizeof (XigSCREEN));  
 
81
    for (i = 0; i < reply.screens_length; i++)
 
82
    {
 
83
        XigSCREEN *screen = &reply.screens[i];
 
84
        int j;
 
85
 
 
86
        screen->root = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
87
        screen->default_colormap = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
88
        screen->white_pixel = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
89
        screen->black_pixel = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
90
        screen->current_input_masks = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
91
        screen->width_in_pixels = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
92
        screen->height_in_pixels = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
93
        screen->width_in_millimeters = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
94
        screen->height_in_millimeters = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
95
        screen->min_installed_maps = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
96
        screen->max_installed_maps = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
97
        screen->root_visual = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
98
        screen->backing_stores = read_card8 (buffer, buffer_length, &offset);
 
99
        screen->save_unders = read_card8 (buffer, buffer_length, &offset) != 0;
 
100
        screen->root_visual = read_card8 (buffer, buffer_length, &offset);
 
101
        screen->allowed_depths_length = read_card8 (buffer, buffer_length, &offset);
 
102
 
 
103
        screen->allowed_depths = calloc (screen->allowed_depths_length, sizeof (XigDEPTH));
 
104
        for (j = 0; j < screen->allowed_depths_length; j++)
 
105
        {
 
106
            XigDEPTH *depth = &screen->allowed_depths[j];
 
107
            int k;
 
108
 
 
109
            depth->depth = read_card8 (buffer, buffer_length, &offset);
 
110
            read_padding (1, &offset);
 
111
            depth->visuals_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
112
            read_padding (4, &offset);
 
113
            depth->visuals = calloc (depth->visuals_length, sizeof (XigVISUALTYPE));
 
114
            for (k = 0; k < depth->visuals_length; k++)
 
115
            {
 
116
                XigVISUALTYPE *visual = &depth->visuals[k];
 
117
 
 
118
                visual->visual_id = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
119
                visual->class = read_card8 (buffer, buffer_length, &offset);
 
120
                visual->bits_per_rgb_value = read_card8 (buffer, buffer_length, &offset);
 
121
                visual->colormap_entries = read_card16 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
122
                visual->red_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
123
                visual->green_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
124
                visual->blue_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, &offset);
 
125
                read_padding (4, &offset);
 
126
            }
 
127
        }
 
128
    }
 
129
 
 
130
    xig_codec_feed_success (XIG_CODEC (codec), &reply);
 
131
 
 
132
    g_free (reply.pixmap_formats);
 
133
    for (i = 0; i < reply.screens_length; i++)
 
134
    {
 
135
        int j;
 
136
        for (j = 0; j < reply.screens[i].allowed_depths_length; j++)
 
137
            g_free (reply.screens[i].allowed_depths[j].visuals);
 
138
        g_free (reply.screens[i].allowed_depths);
 
139
    }
 
140
    g_free (reply.screens);
 
141
}
 
142
 
 
143
static void
 
144
decode_get_window_attributes_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
145
{
 
146
    XigGetWindowAttributesReply reply;
 
147
 
 
148
    reply.sequence_number = 0; // FIXME
 
149
    reply.backing_store = data;
 
150
    reply.visual = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
151
    reply.class = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
152
    reply.bit_gravity = read_card8 (buffer, buffer_length, offset);
 
153
    reply.win_gravity = read_card8 (buffer, buffer_length, offset);
 
154
    reply.backing_planes = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
155
    reply.backing_pixel = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
156
    reply.save_under = read_card8 (buffer, buffer_length, offset) != 0;
 
157
    reply.map_is_installed = read_card8 (buffer, buffer_length, offset) != 0;
 
158
    reply.map_state = read_card8 (buffer, buffer_length, offset);
 
159
    reply.override_redirect = read_card8 (buffer, buffer_length, offset) != 0;
 
160
    reply.colormap = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
161
    reply.all_event_masks = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
162
    reply.your_event_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
163
    reply.do_not_propagate_mask = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
164
    read_padding (2, offset);
 
165
 
 
166
    xig_codec_feed_get_window_attributes_reply (XIG_CODEC (codec), &reply);
 
167
}
 
168
 
 
169
static void
 
170
decode_get_geometry_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
171
{
 
172
    XigGetGeometryReply reply;
 
173
 
 
174
    reply.sequence_number = 0; // FIXME
 
175
    reply.depth = data;
 
176
    reply.root = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
177
    reply.x = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
178
    reply.y = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
179
    reply.width = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
180
    reply.height = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
181
    reply.border_width = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
182
    read_padding (2, offset);
 
183
 
 
184
    xig_codec_feed_get_geometry_reply (XIG_CODEC (codec), &reply);
 
185
}
 
186
 
 
187
static void
 
188
decode_query_tree_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
189
{
 
190
    XigQueryTreeReply reply;
 
191
    int i;
 
192
 
 
193
    reply.sequence_number = 0; // FIXME
 
194
    reply.root = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
195
    reply.parent = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
196
    reply.children_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
197
    read_padding (14, offset);
 
198
    reply.children = calloc (reply.children_length, sizeof (guint32));
 
199
    for (i = 0; i < reply.children_length; i++)
 
200
        reply.children[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
201
 
 
202
    xig_codec_feed_query_tree_reply (XIG_CODEC (codec), &reply);
 
203
 
 
204
    g_free (reply.children);
 
205
}
 
206
 
 
207
static void
 
208
decode_intern_atom_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
209
{
 
210
    XigInternAtomReply reply;
 
211
 
 
212
    reply.sequence_number = 0; // FIXME
 
213
    reply.atom = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
214
 
 
215
    xig_codec_feed_intern_atom_reply (XIG_CODEC (codec), &reply);
 
216
}
 
217
 
 
218
static void
 
219
decode_get_atom_name_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
220
{
 
221
    XigGetAtomNameReply reply;
 
222
    gsize name_length;
 
223
 
 
224
    reply.sequence_number = 0; // FIXME
 
225
    name_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
226
    read_padding (22, offset);
 
227
    reply.name = read_padded_string (buffer, buffer_length, name_length, offset);
 
228
 
 
229
    xig_codec_feed_get_atom_name_reply (XIG_CODEC (codec), &reply);
 
230
 
 
231
    g_free (reply.name);
 
232
}
 
233
 
 
234
static void
 
235
decode_get_property_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
236
{
 
237
    XigGetPropertyReply reply;
 
238
    guint8 *value8;
 
239
    guint16 *value16;
 
240
    guint32 *value32;
 
241
    int i;
 
242
 
 
243
    reply.sequence_number = 0; // FIXME
 
244
    reply.value_format = data;
 
245
    reply.type = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
246
    reply.bytes_after = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
247
    reply.value_length = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
248
    read_padding (12, offset);
 
249
    switch (reply.value_format)
 
250
    {
 
251
    case 8:
 
252
        value8 = reply.value = calloc (reply.value_length, sizeof (guint8));
 
253
        for (i = 0; i < reply.value_length; i++)
 
254
            value8[i] = read_card8 (buffer, buffer_length, offset);
 
255
        break;
 
256
    case 16:
 
257
        value16 = reply.value = calloc (reply.value_length, sizeof (guint16));
 
258
        for (i = 0; i < reply.value_length; i++)
 
259
            value16[i] = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
260
        break;
 
261
    case 32:
 
262
        value32 = reply.value = calloc (reply.value_length, sizeof (guint32));
 
263
        for (i = 0; i < reply.value_length; i++)
 
264
            value32[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
265
        break;
 
266
    default:
 
267
        reply.value = NULL;
 
268
        break;
 
269
    }
 
270
 
 
271
    xig_codec_feed_get_property_reply (XIG_CODEC (codec), &reply);
 
272
 
 
273
    g_free (reply.value);
 
274
}
 
275
 
 
276
static void
 
277
decode_list_properties_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
278
{
 
279
    XigListPropertiesReply reply;
 
280
    int i;
 
281
 
 
282
    reply.sequence_number = 0; // FIXME
 
283
    reply.atoms_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
284
    read_padding (22, offset);
 
285
    reply.atoms = calloc (reply.atoms_length, sizeof (guint32));
 
286
    for (i = 0; i < reply.atoms_length; i++)
 
287
        reply.atoms[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
288
 
 
289
    xig_codec_feed_list_properties_reply (XIG_CODEC (codec), &reply);
 
290
 
 
291
    g_free (reply.atoms);
 
292
}
 
293
 
 
294
static void
 
295
decode_get_selection_owner_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
296
{
 
297
    XigGetSelectionOwnerReply reply;
 
298
 
 
299
    reply.sequence_number = 0; // FIXME
 
300
    reply.owner = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
301
 
 
302
    xig_codec_feed_get_selection_owner_reply (XIG_CODEC (codec), &reply);
 
303
}
 
304
 
 
305
static void
 
306
decode_grab_pointer_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
307
{
 
308
    XigGrabPointerReply reply;
 
309
 
 
310
    reply.sequence_number = 0; // FIXME
 
311
    reply.status = data;
 
312
 
 
313
    xig_codec_feed_grab_pointer_reply (XIG_CODEC (codec), &reply);
 
314
}
 
315
 
 
316
static void
 
317
decode_grab_keyboard_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
318
{
 
319
    XigGrabKeyboardReply reply;
 
320
 
 
321
    reply.sequence_number = 0; // FIXME
 
322
    reply.status = data;
 
323
 
 
324
    xig_codec_feed_grab_keyboard_reply (XIG_CODEC (codec), &reply);
 
325
}
 
326
 
 
327
static void
 
328
decode_query_pointer_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
329
{
 
330
    XigQueryPointerReply reply;
 
331
 
 
332
    reply.sequence_number = 0; // FIXME
 
333
    reply.same_screen = data != 0;
 
334
    reply.root = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
335
    reply.child = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
336
    reply.root_x = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
337
    reply.root_y = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
338
    reply.win_x = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
339
    reply.win_y = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
340
    reply.mask = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
341
    read_padding (2, offset);
 
342
 
 
343
    xig_codec_feed_query_pointer_reply (XIG_CODEC (codec), &reply);
 
344
}
 
345
 
 
346
static void
 
347
decode_TIMECOORD (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length, gsize *offset, XigTIMECOORD *value)
 
348
{
 
349
    value->time = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
350
    value->x = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
351
    value->y = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
352
}
 
353
 
 
354
static void
 
355
decode_get_motion_events_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
356
{
 
357
    XigGetMotionEventsReply reply;
 
358
    int i;
 
359
 
 
360
    reply.sequence_number = 0; // FIXME
 
361
    reply.events_length = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
362
    read_padding (20, offset);
 
363
    reply.events = calloc (reply.events_length, sizeof (XigTIMECOORD));
 
364
    for (i = 0; i < reply.events_length; i++)
 
365
        decode_TIMECOORD (codec, buffer, buffer_length, offset, &reply.events[i]);
 
366
 
 
367
    xig_codec_feed_get_motion_events_reply (XIG_CODEC (codec), &reply);
 
368
 
 
369
    g_free (reply.events);
 
370
}
 
371
 
 
372
static void
 
373
decode_translate_coordinates_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
374
{
 
375
    XigTranslateCoordinatesReply reply;
 
376
 
 
377
    reply.sequence_number = 0; // FIXME
 
378
    reply.same_screen = data != 0;
 
379
    reply.child = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
380
    reply.dst_x = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
381
    reply.dst_y = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
382
 
 
383
    xig_codec_feed_translate_coordinates_reply (XIG_CODEC (codec), &reply);
 
384
}
 
385
 
 
386
static void
 
387
decode_get_input_focus_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
388
{
 
389
    XigGetInputFocusReply reply;
 
390
 
 
391
    reply.sequence_number = 0; // FIXME
 
392
    reply.revert_to = data;
 
393
    reply.focus = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
394
 
 
395
    xig_codec_feed_get_input_focus_reply (XIG_CODEC (codec), &reply);
 
396
}
 
397
 
 
398
static void
 
399
decode_query_keymap_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
400
{
 
401
    XigQueryKeymapReply reply;
 
402
    int i;
 
403
 
 
404
    for (i = 0; i < 32; i++)
 
405
        reply.keys[i] = read_card8 (buffer, buffer_length, offset);
 
406
 
 
407
    xig_codec_feed_query_keymap_reply (XIG_CODEC (codec), &reply);
 
408
}
 
409
 
 
410
static void
 
411
decode_FONTPROP (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length, gsize *offset, XigFONTPROP *value)
 
412
{
 
413
    value->name = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
414
    value->value = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
415
}
 
416
 
 
417
static void
 
418
decode_CHARINFO (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length, gsize *offset, XigCHARINFO *value)
 
419
{
 
420
    value->left_side_bearing = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
421
    value->right_side_bearing = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
422
    value->character_width = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
423
    value->ascent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
424
    value->descent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
425
    value->attributes = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
426
}
 
427
 
 
428
static void
 
429
decode_query_font_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
430
{
 
431
    XigQueryFontReply reply;
 
432
    int i;
 
433
 
 
434
    reply.sequence_number = 0; // FIXME
 
435
    decode_CHARINFO (codec, buffer, buffer_length, offset, &reply.min_bounds);
 
436
    read_padding (4, offset);
 
437
    decode_CHARINFO (codec, buffer, buffer_length, offset, &reply.max_bounds);
 
438
    read_padding (4, offset);
 
439
    reply.min_char_or_byte2 = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
440
    reply.max_char_or_byte2 = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
441
    reply.default_char = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
442
    reply.properties_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
443
    reply.draw_direction = read_card8 (buffer, buffer_length, offset);
 
444
    reply.min_byte1 = read_card8 (buffer, buffer_length, offset);
 
445
    reply.max_byte1 = read_card8 (buffer, buffer_length, offset);
 
446
    reply.all_chars_exist = read_card8 (buffer, buffer_length, offset) != 0;
 
447
    reply.font_ascent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
448
    reply.font_descent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
449
    reply.char_infos_length = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
450
    reply.properties = calloc (reply.properties_length, sizeof (XigFONTPROP));
 
451
    for (i = 0; i < reply.properties_length; i++)
 
452
        decode_FONTPROP (codec, buffer, buffer_length, offset, &reply.properties[i]);
 
453
    reply.char_infos = calloc (reply.char_infos_length, sizeof (XigCHARINFO));
 
454
    for (i = 0; i < reply.char_infos_length; i++)
 
455
        decode_CHARINFO (codec, buffer, buffer_length, offset, &reply.char_infos[i]);
 
456
 
 
457
    xig_codec_feed_query_font_reply (XIG_CODEC (codec), &reply);
 
458
 
 
459
    g_free (reply.properties);
 
460
    g_free (reply.char_infos);
 
461
}
 
462
 
 
463
static void
 
464
decode_query_text_extents_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
465
{
 
466
    XigQueryTextExtentsReply reply;
 
467
 
 
468
    reply.sequence_number = 0; // FIXME
 
469
    reply.draw_direction = data;
 
470
    reply.font_ascent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
471
    reply.font_descent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
472
    reply.overall_ascent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
473
    reply.overall_descent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
474
    reply.overall_width = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
475
    reply.overall_left = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
476
    reply.overall_right = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
477
 
 
478
    xig_codec_feed_query_text_extents_reply (XIG_CODEC (codec), &reply);
 
479
}
 
480
 
 
481
static void
 
482
decode_list_fonts_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
483
{
 
484
    XigListFontsReply reply;
 
485
    int i;
 
486
    gsize names_length;
 
487
 
 
488
    reply.sequence_number = 0; // FIXME
 
489
    names_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
490
    read_padding (22, offset);
 
491
    reply.names = calloc (names_length + 1, sizeof (gchar *));
 
492
    for (i = 0; i < names_length; i++)
 
493
        reply.names[i] = read_string (buffer, buffer_length, read_card8 (buffer, buffer_length, offset), offset);
 
494
    reply.names[i] = NULL;
 
495
 
 
496
    xig_codec_feed_list_fonts_reply (XIG_CODEC (codec), &reply);
 
497
 
 
498
    g_strfreev (reply.names);
 
499
}
 
500
 
 
501
static void
 
502
decode_list_fonts_with_info_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
503
{
 
504
    XigListFontsWithInfoReply reply;
 
505
    int i;
 
506
    gsize name_length;
 
507
 
 
508
    reply.sequence_number = 0; // FIXME
 
509
    name_length = data;
 
510
    decode_CHARINFO (codec, buffer, buffer_length, offset, &reply.min_bounds);
 
511
    read_padding (4, offset);
 
512
    decode_CHARINFO (codec, buffer, buffer_length, offset, &reply.max_bounds);
 
513
    read_padding (4, offset);
 
514
    reply.min_char_or_byte2 = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
515
    reply.max_char_or_byte2 = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
516
    reply.default_char = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
517
    reply.properties_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
518
    reply.draw_direction = read_card8 (buffer, buffer_length, offset);
 
519
    reply.min_byte1 = read_card8 (buffer, buffer_length, offset);
 
520
    reply.max_byte1 = read_card8 (buffer, buffer_length, offset);
 
521
    reply.all_chars_exist = read_card8 (buffer, buffer_length, offset) != 0;
 
522
    reply.font_ascent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
523
    reply.font_descent = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
524
    reply.replies_hint = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
525
    reply.properties = calloc (reply.properties_length, sizeof (XigFONTPROP));
 
526
    for (i = 0; i < reply.properties_length; i++)
 
527
        decode_FONTPROP (codec, buffer, buffer_length, offset, &reply.properties[i]);
 
528
    reply.name = read_padded_string (buffer, buffer_length, name_length, offset);
 
529
 
 
530
    xig_codec_feed_list_fonts_with_info_reply (XIG_CODEC (codec), &reply);
 
531
 
 
532
    g_free (reply.properties);
 
533
    g_free (reply.name);
 
534
}
 
535
 
 
536
static void
 
537
decode_get_font_path_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
538
{
 
539
    XigGetFontPathReply reply;
 
540
    int i;
 
541
    gsize path_length;
 
542
 
 
543
    reply.sequence_number = 0; // FIXME
 
544
    path_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
545
    read_padding (22, offset);
 
546
    reply.path = calloc (path_length + 1, sizeof (gchar *));
 
547
    for (i = 0; i < path_length; i++)
 
548
        reply.path[i] = read_string (buffer, buffer_length, read_card8 (buffer, buffer_length, offset), offset);
 
549
    reply.path[i] = NULL;
 
550
 
 
551
    xig_codec_feed_get_font_path_reply (XIG_CODEC (codec), &reply);
 
552
 
 
553
    g_free (reply.path);
 
554
}
 
555
 
 
556
static void
 
557
decode_get_image_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
558
{
 
559
    XigGetImageReply reply;
 
560
    int i;
 
561
 
 
562
    reply.sequence_number = 0; // FIXME
 
563
    reply.depth = data;
 
564
    reply.visual = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
565
    read_padding (20, offset);
 
566
    reply.data = calloc (reply.data_length, sizeof (guint8));
 
567
    for (i = 0; i < reply.data_length; i++)
 
568
        reply.data[i] = read_card8 (buffer, buffer_length, offset);
 
569
 
 
570
    xig_codec_feed_get_image_reply (XIG_CODEC (codec), &reply);
 
571
 
 
572
    g_free (reply.data);
 
573
}
 
574
 
 
575
static void
 
576
decode_list_installed_colormaps_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
577
{
 
578
    XigListInstalledColormapsReply reply;
 
579
    int i;
 
580
 
 
581
    reply.sequence_number = 0; // FIXME
 
582
    reply.cmaps_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
583
    read_padding (22, offset);
 
584
    reply.cmaps = calloc (reply.cmaps_length, sizeof (guint32));
 
585
    for (i = 0; i < reply.cmaps_length; i++)
 
586
        reply.cmaps[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
587
 
 
588
    xig_codec_feed_list_installed_colormaps_reply (XIG_CODEC (codec), &reply);
 
589
 
 
590
    g_free (reply.cmaps);
 
591
}
 
592
 
 
593
static void
 
594
decode_alloc_color_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
595
{
 
596
    XigAllocColorReply reply;
 
597
 
 
598
    reply.sequence_number = 0; // FIXME
 
599
    reply.red = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
600
    reply.green = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
601
    reply.blue = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
602
    read_padding (2, offset);
 
603
    reply.pixel = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
604
 
 
605
    xig_codec_feed_alloc_color_reply (XIG_CODEC (codec), &reply);
 
606
}
 
607
 
 
608
static void
 
609
decode_alloc_named_color_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
610
{
 
611
    XigAllocNamedColorReply reply;
 
612
 
 
613
    reply.sequence_number = 0; // FIXME
 
614
    reply.pixel = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
615
    reply.exact_red = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
616
    reply.exact_green = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
617
    reply.exact_blue = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
618
    reply.visual_red = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
619
    reply.visual_green = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
620
    reply.visual_blue = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
621
 
 
622
    xig_codec_feed_alloc_named_color_reply (XIG_CODEC (codec), &reply);
 
623
}
 
624
 
 
625
static void
 
626
decode_alloc_color_cells_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
627
{
 
628
    XigAllocColorCellsReply reply;
 
629
    int i;
 
630
 
 
631
    reply.sequence_number = 0; // FIXME
 
632
    reply.pixels_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
633
    reply.masks_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
634
    read_padding (20, offset);
 
635
    reply.pixels = calloc (reply.pixels_length, sizeof (guint32));
 
636
    for (i = 0; i < reply.pixels_length; i++)
 
637
        reply.pixels[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
638
    reply.masks = calloc (reply.masks_length, sizeof (guint32));
 
639
    for (i = 0; i < reply.masks_length; i++)
 
640
        reply.masks[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
641
 
 
642
    xig_codec_feed_alloc_color_cells_reply (XIG_CODEC (codec), &reply);
 
643
 
 
644
    g_free (reply.pixels);
 
645
    g_free (reply.masks);
 
646
}
 
647
 
 
648
static void
 
649
decode_alloc_color_planes_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
650
{
 
651
    XigAllocColorPlanesReply reply;
 
652
    int i;
 
653
 
 
654
    reply.sequence_number = 0; // FIXME
 
655
    reply.pixels_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
656
    read_padding (2, offset);
 
657
    reply.red_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
658
    reply.green_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
659
    reply.blue_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
660
    read_padding (8, offset);
 
661
    reply.pixels = calloc (reply.pixels_length, sizeof (guint32));
 
662
    for (i = 0; i < reply.pixels_length; i++)
 
663
        reply.pixels[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
664
 
 
665
    xig_codec_feed_alloc_color_planes_reply (XIG_CODEC (codec), &reply);
 
666
 
 
667
    g_free (reply.pixels);
 
668
}
 
669
 
 
670
static void
 
671
decode_RGB (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length, gsize *offset, XigRGB *value)
 
672
{
 
673
    value->red = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
674
    value->green = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
675
    value->blue = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
676
    read_padding (2, offset);
 
677
}
 
678
 
 
679
static void
 
680
decode_query_colors_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
681
{
 
682
    XigQueryColorsReply reply;
 
683
    int i;
 
684
 
 
685
    reply.sequence_number = 0; // FIXME
 
686
    reply.colors_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
687
    read_padding (22, offset);
 
688
    reply.colors = calloc (reply.colors_length, sizeof (XigRGB));
 
689
    for (i = 0; i < reply.colors_length; i++)
 
690
        decode_RGB (codec, buffer, buffer_length, offset, &reply.colors[i]);
 
691
 
 
692
    xig_codec_feed_query_colors_reply (XIG_CODEC (codec), &reply);
 
693
 
 
694
    g_free (reply.colors);
 
695
}
 
696
 
 
697
static void
 
698
decode_lookup_color_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
699
{
 
700
    XigLookupColorReply reply;
 
701
 
 
702
    reply.sequence_number = 0; // FIXME
 
703
    reply.exact_red = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
704
    reply.exact_green = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
705
    reply.exact_blue = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
706
    reply.visual_red = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
707
    reply.visual_green = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
708
    reply.visual_blue = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
709
 
 
710
    xig_codec_feed_lookup_color_reply (XIG_CODEC (codec), &reply);
 
711
}
 
712
 
 
713
static void
 
714
decode_query_best_size_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
715
{
 
716
    XigQueryBestSizeReply reply;
 
717
 
 
718
    reply.sequence_number = 0; // FIXME
 
719
    reply.width = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
720
    reply.height = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
721
 
 
722
    xig_codec_feed_query_best_size_reply (XIG_CODEC (codec), &reply);
 
723
}
 
724
 
 
725
static void
 
726
decode_query_extension_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
727
{
 
728
    XigQueryExtensionReply reply;
 
729
 
 
730
    reply.sequence_number = 0; // FIXME
 
731
    reply.present = read_card8 (buffer, buffer_length, offset) != 0;
 
732
    reply.major_opcode = read_card8 (buffer, buffer_length, offset);
 
733
    reply.first_event = read_card8 (buffer, buffer_length, offset);
 
734
    reply.first_error = read_card8 (buffer, buffer_length, offset);
 
735
 
 
736
    xig_codec_feed_query_extension_reply (XIG_CODEC (codec), &reply);
 
737
}
 
738
 
 
739
static void
 
740
decode_list_extensions_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
741
{
 
742
    XigListExtensionsReply reply;
 
743
    int i;
 
744
    gsize names_length;
 
745
 
 
746
    reply.sequence_number = 0; // FIXME
 
747
    names_length = data;
 
748
    read_padding (24, offset);
 
749
    reply.names = calloc (names_length + 1, sizeof (gchar *));
 
750
    for (i = 0; i < names_length; i++)
 
751
        reply.names[i] = read_string (buffer, buffer_length, read_card8 (buffer, buffer_length, offset), offset);
 
752
    reply.names[i] = NULL;
 
753
 
 
754
    xig_codec_feed_list_extensions_reply (XIG_CODEC (codec), &reply);
 
755
 
 
756
    g_strfreev (reply.names);
 
757
}
 
758
 
 
759
static void
 
760
decode_get_keyboard_mapping_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
761
{
 
762
    XigGetKeyboardMappingReply reply;
 
763
    int i;
 
764
 
 
765
    reply.sequence_number = 0; // FIXME
 
766
    reply.keysyms_per_keycode = data;
 
767
    read_padding (24, offset);
 
768
    reply.keysyms = calloc (reply.keysyms_length, sizeof (guint32));
 
769
    for (i = 0; i < reply.keysyms_length; i++)
 
770
        reply.keysyms[i] = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
771
 
 
772
    xig_codec_feed_get_keyboard_mapping_reply (XIG_CODEC (codec), &reply);
 
773
 
 
774
    g_free (reply.keysyms);
 
775
}
 
776
 
 
777
static void
 
778
decode_get_keyboard_control_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
779
{
 
780
    XigGetKeyboardControlReply reply;
 
781
    int i;
 
782
 
 
783
    reply.sequence_number = 0; // FIXME
 
784
    reply.global_auto_repeat = data;
 
785
    reply.led_mask = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
786
    reply.key_click_percent = read_card8 (buffer, buffer_length, offset);
 
787
    reply.bell_percent = read_card8 (buffer, buffer_length, offset);
 
788
    reply.bell_pitch = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
789
    reply.bell_duration = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
790
    read_padding (2, offset);
 
791
    for (i = 0; i < 32; i++)
 
792
        reply.auto_repeats[i] = read_card8 (buffer, buffer_length, offset);
 
793
 
 
794
    xig_codec_feed_get_keyboard_control_reply (XIG_CODEC (codec), &reply);
 
795
}
 
796
 
 
797
static void
 
798
decode_get_pointer_control_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
799
{
 
800
    XigGetPointerControlReply reply;
 
801
 
 
802
    reply.sequence_number = 0; // FIXME
 
803
    reply.acceleration_numerator = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
804
    reply.acceleration_denominator = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
805
    reply.threshold = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
806
    read_padding (18, offset);
 
807
 
 
808
    xig_codec_feed_get_pointer_control_reply (XIG_CODEC (codec), &reply);
 
809
}
 
810
 
 
811
static void
 
812
decode_get_screen_saver_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
813
{
 
814
    XigGetScreenSaverReply reply;
 
815
 
 
816
    reply.sequence_number = 0; // FIXME
 
817
    reply.timeout = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
818
    reply.interval = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
819
    reply.prefer_blanking = read_card8 (buffer, buffer_length, offset);
 
820
    reply.allow_exposures = read_card8 (buffer, buffer_length, offset);
 
821
    read_padding (18, offset);
 
822
 
 
823
    xig_codec_feed_get_screen_saver_reply (XIG_CODEC (codec), &reply);
 
824
}
 
825
 
 
826
static void
 
827
decode_HOST (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length, gsize *offset, XigHOST *value)
 
828
{
 
829
    int i;
 
830
    value->family = read_card8 (buffer, buffer_length, offset);
 
831
    read_padding (1, offset);
 
832
    value->address_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
833
    value->address = calloc (value->address_length, sizeof (guint8));
 
834
    for (i = 0; i < value->address_length; i++)
 
835
        value->address[i] = read_card8 (buffer, buffer_length, offset);
 
836
    read_padding (pad (value->address_length), offset);
 
837
}
 
838
 
 
839
static void
 
840
decode_list_hosts_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
841
{
 
842
    XigListHostsReply reply;
 
843
    int i;
 
844
 
 
845
    reply.sequence_number = 0; // FIXME
 
846
    reply.mode = data;
 
847
    reply.hosts_length = read_card16 (buffer, buffer_length, codec->priv->byte_order, offset);
 
848
    read_padding (22, offset);
 
849
    reply.hosts = calloc (reply.hosts_length, sizeof (XigHOST));
 
850
    for (i = 0; i < reply.hosts_length; i++)
 
851
        decode_HOST (codec, buffer, buffer_length, offset, &reply.hosts[i]);
 
852
 
 
853
    xig_codec_feed_list_hosts_reply (XIG_CODEC (codec), &reply);
 
854
 
 
855
    for (i = 0; i < reply.hosts_length; i++)
 
856
        g_free (reply.hosts[i].address);
 
857
    g_free (reply.hosts);
 
858
}
 
859
 
 
860
static void
 
861
decode_set_pointer_mapping_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
862
{
 
863
    XigSetPointerMappingReply reply;
 
864
 
 
865
    reply.sequence_number = 0; // FIXME
 
866
    reply.status = data;
 
867
 
 
868
    xig_codec_feed_set_pointer_mapping_reply (XIG_CODEC (codec), &reply);
 
869
}
 
870
 
 
871
static void
 
872
decode_get_pointer_mapping_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
873
{
 
874
    XigGetPointerMappingReply reply;
 
875
    int i;
 
876
 
 
877
    reply.sequence_number = 0; // FIXME
 
878
    reply.map_length = data;
 
879
    read_padding (24, offset);
 
880
    reply.map = calloc (reply.map_length, sizeof (guint8));
 
881
    for (i = 0; i < reply.map_length; i++)
 
882
        reply.map[i] = read_card8 (buffer, buffer_length, offset);
 
883
 
 
884
    xig_codec_feed_get_pointer_mapping_reply (XIG_CODEC (codec), &reply);
 
885
 
 
886
    g_free (reply.map);
 
887
}
 
888
 
 
889
static void
 
890
decode_set_modifier_mapping_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
891
{
 
892
    XigSetModifierMappingReply reply;
 
893
 
 
894
    reply.sequence_number = 0; // FIXME
 
895
    reply.status = data;
 
896
 
 
897
    xig_codec_feed_set_modifier_mapping_reply (XIG_CODEC (codec), &reply);
 
898
}
 
899
 
 
900
static void
 
901
decode_get_modifier_mapping_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
902
{
 
903
    XigGetModifierMappingReply reply;
 
904
    int i;
 
905
 
 
906
    reply.sequence_number = 0; // FIXME
 
907
    reply.keycodes_per_modifier = data;
 
908
    read_padding (24, offset);
 
909
    reply.keycodes = calloc (reply.keycodes_length, sizeof (guint8));
 
910
    for (i = 0; i < reply.keycodes_length; i++)
 
911
        reply.keycodes[i] = read_card8 (buffer, buffer_length, offset);
 
912
 
 
913
    xig_codec_feed_get_modifier_mapping_reply (XIG_CODEC (codec), &reply);
 
914
 
 
915
    g_free (reply.keycodes);
 
916
}
 
917
 
 
918
static void
 
919
decode_BIGREQ_enable_reply (XigClientCodec *codec, guint8 data, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
920
{
 
921
    XigBIGREQEnableReply reply;
 
922
 
 
923
    reply.sequence_number = 0; // FIXME
 
924
    reply.maximum_request_length = read_card32 (buffer, buffer_length, codec->priv->byte_order, offset);
 
925
 
 
926
    xig_codec_feed_BIGREQ_enable_reply (XIG_CODEC (codec), &reply);
 
927
}
 
928
 
 
929
static void
 
930
decode_reply (XigClientCodec *codec, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
931
{
 
932
    guint8 opcode = 0; // FIXME
 
933
    guint8 data = 0; // FIXME
 
934
 
 
935
    switch (opcode)
 
936
    {
 
937
    case XIG_REQUEST_GetWindowAttributes:
 
938
        decode_get_window_attributes_reply (codec, data, buffer, buffer_length, offset);
 
939
        break;
 
940
    case XIG_REQUEST_GetGeometry:
 
941
        decode_get_geometry_reply (codec, data, buffer, buffer_length, offset);
 
942
        break;
 
943
    case XIG_REQUEST_QueryTree:
 
944
        decode_query_tree_reply (codec, data, buffer, buffer_length, offset);
 
945
        break;
 
946
    case XIG_REQUEST_InternAtom:
 
947
        decode_intern_atom_reply (codec, data, buffer, buffer_length, offset);
 
948
        break;
 
949
    case XIG_REQUEST_GetAtomName:
 
950
        decode_get_atom_name_reply (codec, data, buffer, buffer_length, offset);
 
951
        break;
 
952
    case XIG_REQUEST_GetProperty:
 
953
        decode_get_property_reply (codec, data, buffer, buffer_length, offset);
 
954
        break;
 
955
    case XIG_REQUEST_ListProperties:
 
956
        decode_list_properties_reply (codec, data, buffer, buffer_length, offset);
 
957
        break;
 
958
    case XIG_REQUEST_GetSelectionOwner:
 
959
        decode_get_selection_owner_reply (codec, data, buffer, buffer_length, offset);
 
960
        break;
 
961
    case XIG_REQUEST_GrabPointer:
 
962
        decode_grab_pointer_reply (codec, data, buffer, buffer_length, offset);
 
963
        break;
 
964
    case XIG_REQUEST_GrabKeyboard:
 
965
        decode_grab_keyboard_reply (codec, data, buffer, buffer_length, offset);
 
966
        break;
 
967
    case XIG_REQUEST_QueryPointer:
 
968
        decode_query_pointer_reply (codec, data, buffer, buffer_length, offset);
 
969
        break;
 
970
    case XIG_REQUEST_GetMotionEvents:
 
971
        decode_get_motion_events_reply (codec, data, buffer, buffer_length, offset);
 
972
        break;
 
973
    case XIG_REQUEST_TranslateCoordinates:
 
974
        decode_translate_coordinates_reply (codec, data, buffer, buffer_length, offset);
 
975
        break;
 
976
    case XIG_REQUEST_GetInputFocus:
 
977
        decode_get_input_focus_reply (codec, data, buffer, buffer_length, offset);
 
978
        break;
 
979
    case XIG_REQUEST_QueryKeymap:
 
980
        decode_query_keymap_reply (codec, data, buffer, buffer_length, offset);
 
981
        break;
 
982
    case XIG_REQUEST_QueryFont:
 
983
        decode_query_font_reply (codec, data, buffer, buffer_length, offset);
 
984
        break;
 
985
    case XIG_REQUEST_QueryTextExtents:
 
986
        decode_query_text_extents_reply (codec, data, buffer, buffer_length, offset);
 
987
        break;
 
988
    case XIG_REQUEST_ListFonts:
 
989
        decode_list_fonts_reply (codec, data, buffer, buffer_length, offset);
 
990
        break;
 
991
    case XIG_REQUEST_ListFontsWithInfo:
 
992
        decode_list_fonts_with_info_reply (codec, data, buffer, buffer_length, offset);
 
993
        break;
 
994
    case XIG_REQUEST_GetFontPath:
 
995
        decode_get_font_path_reply (codec, data, buffer, buffer_length, offset);
 
996
        break;
 
997
    case XIG_REQUEST_GetImage:
 
998
        decode_get_image_reply (codec, data, buffer, buffer_length, offset);
 
999
        break;
 
1000
    case XIG_REQUEST_ListInstalledColormaps:
 
1001
        decode_list_installed_colormaps_reply (codec, data, buffer, buffer_length, offset);
 
1002
        break;
 
1003
    case XIG_REQUEST_AllocColor:
 
1004
        decode_alloc_color_reply (codec, data, buffer, buffer_length, offset);
 
1005
        break;
 
1006
    case XIG_REQUEST_AllocNamedColor:
 
1007
        decode_alloc_named_color_reply (codec, data, buffer, buffer_length, offset);
 
1008
        break;
 
1009
    case XIG_REQUEST_AllocColorCells:
 
1010
        decode_alloc_color_cells_reply (codec, data, buffer, buffer_length, offset);
 
1011
        break;
 
1012
    case XIG_REQUEST_AllocColorPlanes:
 
1013
        decode_alloc_color_planes_reply (codec, data, buffer, buffer_length, offset);
 
1014
        break;
 
1015
    case XIG_REQUEST_QueryColors:
 
1016
        decode_query_colors_reply (codec, data, buffer, buffer_length, offset);
 
1017
        break;
 
1018
    case XIG_REQUEST_LookupColor:
 
1019
        decode_lookup_color_reply (codec, data, buffer, buffer_length, offset);
 
1020
        break;
 
1021
    case XIG_REQUEST_QueryBestSize:
 
1022
        decode_query_best_size_reply (codec, data, buffer, buffer_length, offset);
 
1023
        break;
 
1024
    case XIG_REQUEST_QueryExtension:
 
1025
        decode_query_extension_reply (codec, data, buffer, buffer_length, offset);
 
1026
        break;
 
1027
    case XIG_REQUEST_ListExtensions:
 
1028
        decode_list_extensions_reply (codec, data, buffer, buffer_length, offset);
 
1029
        break;
 
1030
    case XIG_REQUEST_GetKeyboardMapping:
 
1031
        decode_get_keyboard_mapping_reply (codec, data, buffer, buffer_length, offset);
 
1032
        break;
 
1033
    case XIG_REQUEST_GetKeyboardControl:
 
1034
        decode_get_keyboard_control_reply (codec, data, buffer, buffer_length, offset);
 
1035
        break;
 
1036
    case XIG_REQUEST_GetPointerControl:
 
1037
        decode_get_pointer_control_reply (codec, data, buffer, buffer_length, offset);
 
1038
        break;
 
1039
    case XIG_REQUEST_GetScreenSaver:
 
1040
        decode_get_screen_saver_reply (codec, data, buffer, buffer_length, offset);
 
1041
        break;
 
1042
    case XIG_REQUEST_ListHosts:
 
1043
        decode_list_hosts_reply (codec, data, buffer, buffer_length, offset);
 
1044
        break;
 
1045
    case XIG_REQUEST_SetPointerMapping:
 
1046
        decode_set_pointer_mapping_reply (codec, data, buffer, buffer_length, offset);
 
1047
        break;
 
1048
    case XIG_REQUEST_GetPointerMapping:
 
1049
        decode_get_pointer_mapping_reply (codec, data, buffer, buffer_length, offset);
 
1050
        break;
 
1051
    case XIG_REQUEST_SetModifierMapping:
 
1052
        decode_set_modifier_mapping_reply (codec, data, buffer, buffer_length, offset);
 
1053
        break;
 
1054
    case XIG_REQUEST_GetModifierMapping:
 
1055
        decode_get_modifier_mapping_reply (codec, data, buffer, buffer_length, offset);
 
1056
        break;
 
1057
    case XIG_REQUEST_BIGREQ:
 
1058
        decode_BIGREQ_enable_reply (codec, data, buffer, buffer_length, offset);
 
1059
        break;
 
1060
    default:
 
1061
        break;
 
1062
    }
 
1063
}
 
1064
 
 
1065
static gboolean
 
1066
decode_response (XigClientCodec *codec, guint8 opcode, guint8 value, const guint8 *buffer, gsize buffer_length, gsize *offset)
 
1067
{
 
1068
    guint8 response_code;
 
1069
 
 
1070
    response_code = read_card8 (buffer, buffer_length, offset);
 
1071
 
 
1072
    if (!codec->priv->connected)
 
1073
    {
 
1074
        switch (response_code)
 
1075
        {
 
1076
        case Success:
 
1077
            decode_success (codec, buffer + *offset, buffer_length - *offset);
 
1078
            break;
 
1079
        }
 
1080
 
 
1081
        return TRUE;
 
1082
    }
 
1083
 
 
1084
    switch (response_code)
 
1085
    {
 
1086
    case XIG_RESPONSE_Error:
 
1087
        break;
 
1088
    case XIG_RESPONSE_Reply:
 
1089
        decode_reply (codec, buffer, buffer_length, offset);
 
1090
        break;
 
1091
    case XIG_RESPONSE_KeyPress:
 
1092
    case XIG_RESPONSE_KeyRelease:
 
1093
    case XIG_RESPONSE_ButtonPress:
 
1094
    case XIG_RESPONSE_ButtonRelease:
 
1095
    case XIG_RESPONSE_MotionNotify:
 
1096
    case XIG_RESPONSE_EnterNotify:
 
1097
    case XIG_RESPONSE_LeaveNotify:
 
1098
    case XIG_RESPONSE_FocusIn:
 
1099
    case XIG_RESPONSE_FocusOut:
 
1100
    case XIG_RESPONSE_KeymapNotify:
 
1101
    case XIG_RESPONSE_Expose:
 
1102
    case XIG_RESPONSE_GraphicsExposure:
 
1103
    case XIG_RESPONSE_NoExposure:
 
1104
    case XIG_RESPONSE_VisibilityNotify:
 
1105
    case XIG_RESPONSE_CreateNotify:
 
1106
    case XIG_RESPONSE_DestroyNotify:
 
1107
    case XIG_RESPONSE_UnmapNotify:
 
1108
    case XIG_RESPONSE_MapNotify:
 
1109
    case XIG_RESPONSE_MapRequest:
 
1110
    case XIG_RESPONSE_ReparentNotify:
 
1111
    case XIG_RESPONSE_ConfigureNotify:
 
1112
    case XIG_RESPONSE_ConfigureRequest:
 
1113
    case XIG_RESPONSE_GravityNotify:
 
1114
    case XIG_RESPONSE_ResizeRequest:
 
1115
    case XIG_RESPONSE_CirculateNotify:
 
1116
    case XIG_RESPONSE_CirculateRequest:
 
1117
    case XIG_RESPONSE_PropertyNotify:
 
1118
    case XIG_RESPONSE_SelectionClear:
 
1119
    case XIG_RESPONSE_SelectionRequest:
 
1120
    case XIG_RESPONSE_SelectionNotify:
 
1121
    case XIG_RESPONSE_ColormapNotify:
 
1122
    case XIG_RESPONSE_ClientMessage:
 
1123
    case XIG_RESPONSE_MappingNotify:
 
1124
        break;
 
1125
    }
 
1126
 
 
1127
    return TRUE;
 
1128
}
 
1129
 
 
1130
static void
 
1131
xig_client_codec_real_feed_data (XigCodec *codec, const guint8 *data, gsize data_length)
 
1132
{
 
1133
    XigClientCodec *client_codec = XIG_CLIENT_CODEC (codec);
 
1134
    int opcode;
 
1135
    gsize offset = 0;
 
1136
 
 
1137
    if (!client_codec->priv->connected)
 
1138
    {
 
1139
        decode_success (client_codec, data, data_length);
 
1140
        return;
 
1141
    }
 
1142
 
 
1143
    while (offset < data_length)
 
1144
    {
 
1145
        guint8 value;
 
1146
        /*guint16 sequence_number;*/
 
1147
        guint32 reply_length;
 
1148
        //guint8 opcode = 0; // FIXME
 
1149
 
 
1150
        value = read_card8 (data, data_length, &offset);
 
1151
        /*sequence_number = */read_card16 (data, data_length, client_codec->priv->byte_order, &offset);
 
1152
        reply_length = read_card32 (data, data_length, client_codec->priv->byte_order, &offset);
 
1153
 
 
1154
        decode_response (client_codec, opcode, value, data, offset + reply_length, &offset);
 
1155
 
 
1156
        //offset = start_offset + length;
 
1157
    }
 
1158
}
 
1159
 
 
1160
static void
 
1161
xig_client_codec_real_connect (XigCodec *codec, XigConnect *message)
 
1162
{
 
1163
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1164
    gsize n_written = 0;
 
1165
 
 
1166
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->byte_order, &n_written);
 
1167
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1168
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->protocol_major_version, &n_written);
 
1169
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->protocol_minor_version, &n_written);
 
1170
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->authorization_protocol_name), &n_written);
 
1171
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->authorization_protocol_data_length, &n_written);
 
1172
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1173
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->authorization_protocol_name, &n_written);
 
1174
    write_string8 (buffer, MAXIMUM_REQUEST_LENGTH, message->authorization_protocol_data, message->authorization_protocol_data_length, &n_written);
 
1175
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, pad (message->authorization_protocol_data_length), &n_written);
 
1176
 
 
1177
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1178
}
 
1179
 
 
1180
static void
 
1181
xig_client_codec_real_create_window (XigCodec *codec, XigCreateWindow *message)
 
1182
{
 
1183
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1184
    gsize n_written = 0;
 
1185
 
 
1186
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CreateWindow, &n_written);
 
1187
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1188
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1189
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->depth, &n_written);
 
1190
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->wid, &n_written);
 
1191
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->parent, &n_written);
 
1192
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
1193
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
1194
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
1195
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
1196
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->border_width, &n_written);
 
1197
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->class, &n_written);
 
1198
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->visual, &n_written);
 
1199
 
 
1200
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1201
}
 
1202
 
 
1203
static void
 
1204
xig_client_codec_real_change_window_attributes (XigCodec *codec, XigChangeWindowAttributes *message)
 
1205
{
 
1206
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1207
    gsize n_written = 0;
 
1208
 
 
1209
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeWindowAttributes, &n_written);
 
1210
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1211
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1212
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1213
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1214
 
 
1215
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1216
}
 
1217
 
 
1218
static void
 
1219
xig_client_codec_real_get_window_attributes (XigCodec *codec, XigGetWindowAttributes *message)
 
1220
{
 
1221
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1222
    gsize n_written = 0;
 
1223
 
 
1224
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetWindowAttributes, &n_written);
 
1225
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1226
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1227
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1228
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1229
 
 
1230
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1231
}
 
1232
 
 
1233
static void
 
1234
xig_client_codec_real_destroy_window (XigCodec *codec, XigDestroyWindow *message)
 
1235
{
 
1236
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1237
    gsize n_written = 0;
 
1238
 
 
1239
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_DestroyWindow, &n_written);
 
1240
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1241
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1242
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1243
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1244
 
 
1245
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1246
}
 
1247
 
 
1248
static void
 
1249
xig_client_codec_real_destroy_subwindows (XigCodec *codec, XigDestroySubwindows *message)
 
1250
{
 
1251
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1252
    gsize n_written = 0;
 
1253
 
 
1254
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_DestroySubwindows, &n_written);
 
1255
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1256
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1257
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1258
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1259
 
 
1260
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1261
}
 
1262
 
 
1263
static void
 
1264
xig_client_codec_real_change_save_set (XigCodec *codec, XigChangeSaveSet *message)
 
1265
{
 
1266
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1267
    gsize n_written = 0;
 
1268
 
 
1269
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeSaveSet, &n_written);
 
1270
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1271
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1272
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
1273
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1274
 
 
1275
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1276
}
 
1277
 
 
1278
static void
 
1279
xig_client_codec_real_reparent_window (XigCodec *codec, XigReparentWindow *message)
 
1280
{
 
1281
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1282
    gsize n_written = 0;
 
1283
 
 
1284
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ReparentWindow, &n_written);
 
1285
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1286
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1287
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1288
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1289
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->parent, &n_written);
 
1290
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
1291
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
1292
 
 
1293
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1294
}
 
1295
 
 
1296
static void
 
1297
xig_client_codec_real_map_window (XigCodec *codec, XigMapWindow *message)
 
1298
{
 
1299
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1300
    gsize n_written = 0;
 
1301
 
 
1302
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_MapWindow, &n_written);
 
1303
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1304
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1305
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1306
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1307
 
 
1308
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1309
}
 
1310
 
 
1311
static void
 
1312
xig_client_codec_real_map_subwindows (XigCodec *codec, XigMapSubwindows *message)
 
1313
{
 
1314
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1315
    gsize n_written = 0;
 
1316
 
 
1317
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_MapSubwindows, &n_written);
 
1318
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1319
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1320
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1321
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1322
 
 
1323
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1324
}
 
1325
 
 
1326
static void
 
1327
xig_client_codec_real_unmap_window (XigCodec *codec, XigUnmapWindow *message)
 
1328
{
 
1329
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1330
    gsize n_written = 0;
 
1331
 
 
1332
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UnmapWindow, &n_written);
 
1333
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1334
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1335
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1336
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1337
 
 
1338
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1339
}
 
1340
 
 
1341
static void
 
1342
xig_client_codec_real_unmap_subwindows (XigCodec *codec, XigUnmapSubwindows *message)
 
1343
{
 
1344
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1345
    gsize n_written = 0;
 
1346
 
 
1347
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UnmapSubwindows, &n_written);
 
1348
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1349
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1350
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1351
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1352
 
 
1353
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1354
}
 
1355
 
 
1356
static void
 
1357
xig_client_codec_real_configure_window (XigCodec *codec, XigConfigureWindow *message)
 
1358
{
 
1359
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1360
    gsize n_written = 0;
 
1361
 
 
1362
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ConfigureWindow, &n_written);
 
1363
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1364
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1365
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1366
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1367
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->value_mask, &n_written);
 
1368
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1369
 
 
1370
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1371
}
 
1372
 
 
1373
static void
 
1374
xig_client_codec_real_circulate_window (XigCodec *codec, XigCirculateWindow *message)
 
1375
{
 
1376
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1377
    gsize n_written = 0;
 
1378
 
 
1379
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CirculateWindow, &n_written);
 
1380
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1381
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1382
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->direction, &n_written);
 
1383
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1384
 
 
1385
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1386
}
 
1387
 
 
1388
static void
 
1389
xig_client_codec_real_get_geometry (XigCodec *codec, XigGetGeometry *message)
 
1390
{
 
1391
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1392
    gsize n_written = 0;
 
1393
 
 
1394
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetGeometry, &n_written);
 
1395
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1396
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1397
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1398
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
1399
 
 
1400
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1401
}
 
1402
 
 
1403
static void
 
1404
xig_client_codec_real_query_tree (XigCodec *codec, XigQueryTree *message)
 
1405
{
 
1406
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1407
    gsize n_written = 0;
 
1408
 
 
1409
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryTree, &n_written);
 
1410
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1411
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1412
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1413
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1414
 
 
1415
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1416
}
 
1417
 
 
1418
static void
 
1419
xig_client_codec_real_intern_atom (XigCodec *codec, XigInternAtom *message)
 
1420
{
 
1421
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1422
    gsize n_written = 0;
 
1423
 
 
1424
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_InternAtom, &n_written);
 
1425
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1426
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1427
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->only_if_exists ? 1 : 0, &n_written);
 
1428
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->name), &n_written);
 
1429
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1430
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->name, &n_written);
 
1431
 
 
1432
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1433
}
 
1434
 
 
1435
static void
 
1436
xig_client_codec_real_get_atom_name (XigCodec *codec, XigGetAtomName *message)
 
1437
{
 
1438
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1439
    gsize n_written = 0;
 
1440
 
 
1441
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetAtomName, &n_written);
 
1442
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1443
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1444
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1445
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->atom, &n_written);
 
1446
 
 
1447
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1448
}
 
1449
 
 
1450
static void
 
1451
xig_client_codec_real_change_property (XigCodec *codec, XigChangeProperty *message)
 
1452
{
 
1453
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1454
    gsize n_written = 0;
 
1455
    guint8 *data8;
 
1456
    guint16 *data16;
 
1457
    guint32 *data32;
 
1458
    int i;
 
1459
 
 
1460
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeProperty, &n_written);
 
1461
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1462
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1463
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
1464
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1465
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->property, &n_written);
 
1466
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->type, &n_written);
 
1467
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->data_format, &n_written);
 
1468
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 3, &n_written);
 
1469
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->data_length, &n_written);
 
1470
    switch (message->data_format)
 
1471
    {
 
1472
    case 8:
 
1473
        data8 = message->data;
 
1474
        for (i = 0; i < message->data_length; i++)
 
1475
            write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, data8[i], &n_written);
 
1476
        break;
 
1477
    case 16:
 
1478
        data16 = message->data;
 
1479
        for (i = 0; i < message->data_length; i++)
 
1480
            write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, data16[i], &n_written);
 
1481
        break;
 
1482
    case 32:
 
1483
        data32 = message->data;
 
1484
        for (i = 0; i < message->data_length; i++)
 
1485
            write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, data32[i], &n_written);
 
1486
        break;
 
1487
    }
 
1488
 
 
1489
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1490
}
 
1491
 
 
1492
static void
 
1493
xig_client_codec_real_delete_property (XigCodec *codec, XigDeleteProperty *message)
 
1494
{
 
1495
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1496
    gsize n_written = 0;
 
1497
 
 
1498
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_DeleteProperty, &n_written);
 
1499
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1500
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1501
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1502
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1503
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->property, &n_written);
 
1504
 
 
1505
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1506
}
 
1507
 
 
1508
static void
 
1509
xig_client_codec_real_get_property (XigCodec *codec, XigGetProperty *message)
 
1510
{
 
1511
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1512
    gsize n_written = 0;
 
1513
 
 
1514
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetProperty, &n_written);
 
1515
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1516
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1517
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->delete ? 1 : 0, &n_written);
 
1518
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1519
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->property, &n_written);
 
1520
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->type, &n_written);
 
1521
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->long_offset, &n_written);
 
1522
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->long_length, &n_written);
 
1523
 
 
1524
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1525
}
 
1526
 
 
1527
static void
 
1528
xig_client_codec_real_list_properties (XigCodec *codec, XigListProperties *message)
 
1529
{
 
1530
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1531
    gsize n_written = 0;
 
1532
 
 
1533
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ListProperties, &n_written);
 
1534
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1535
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1536
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1537
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1538
 
 
1539
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1540
}
 
1541
 
 
1542
static void
 
1543
xig_client_codec_real_set_selection_owner (XigCodec *codec, XigSetSelectionOwner *message)
 
1544
{
 
1545
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1546
    gsize n_written = 0;
 
1547
 
 
1548
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetSelectionOwner, &n_written);
 
1549
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1550
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1551
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1552
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->owner, &n_written);
 
1553
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->selection, &n_written);
 
1554
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1555
 
 
1556
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1557
}
 
1558
 
 
1559
static void
 
1560
xig_client_codec_real_get_selection_owner (XigCodec *codec, XigGetSelectionOwner *message)
 
1561
{
 
1562
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1563
    gsize n_written = 0;
 
1564
 
 
1565
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetSelectionOwner, &n_written);
 
1566
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1567
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1568
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1569
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->selection, &n_written);
 
1570
 
 
1571
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1572
}
 
1573
 
 
1574
static void
 
1575
xig_client_codec_real_convert_selection (XigCodec *codec, XigConvertSelection *message)
 
1576
{
 
1577
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1578
    gsize n_written = 0;
 
1579
 
 
1580
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ConvertSelection, &n_written);
 
1581
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1582
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1583
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1584
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->requestor, &n_written);
 
1585
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->selection, &n_written);
 
1586
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->target, &n_written);
 
1587
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->property, &n_written);
 
1588
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1589
 
 
1590
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1591
}
 
1592
 
 
1593
static void
 
1594
xig_client_codec_real_send_event (XigCodec *codec, XigSendEvent *message)
 
1595
{
 
1596
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1597
    gsize n_written = 0;
 
1598
 
 
1599
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SendEvent, &n_written);
 
1600
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1601
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1602
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->propagate ? 1 : 0, &n_written);
 
1603
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->destination, &n_written);
 
1604
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->event_mask, &n_written);
 
1605
    //write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->event, &n_written);
 
1606
 
 
1607
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1608
}
 
1609
 
 
1610
static void
 
1611
xig_client_codec_real_grab_pointer (XigCodec *codec, XigGrabPointer *message)
 
1612
{
 
1613
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1614
    gsize n_written = 0;
 
1615
 
 
1616
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GrabPointer, &n_written);
 
1617
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1618
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1619
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->owner_events ? 1 : 0, &n_written);
 
1620
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->grab_window, &n_written);
 
1621
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->event_mask, &n_written);
 
1622
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->pointer_mode, &n_written);
 
1623
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keyboard_mode, &n_written);
 
1624
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->confine_to, &n_written);
 
1625
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cursor, &n_written);
 
1626
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1627
 
 
1628
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1629
}
 
1630
 
 
1631
static void
 
1632
xig_client_codec_real_ungrab_pointer (XigCodec *codec, XigUngrabPointer *message)
 
1633
{
 
1634
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1635
    gsize n_written = 0;
 
1636
 
 
1637
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UngrabPointer, &n_written);
 
1638
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1639
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1640
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1641
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1642
 
 
1643
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1644
}
 
1645
 
 
1646
static void
 
1647
xig_client_codec_real_grab_button (XigCodec *codec, XigGrabButton *message)
 
1648
{
 
1649
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1650
    gsize n_written = 0;
 
1651
 
 
1652
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GrabButton, &n_written);
 
1653
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1654
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1655
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->owner_events ? 1 : 0, &n_written);
 
1656
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->grab_window, &n_written);
 
1657
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->event_mask, &n_written);
 
1658
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->pointer_mode, &n_written);
 
1659
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keyboard_mode, &n_written);
 
1660
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->confine_to, &n_written);
 
1661
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cursor, &n_written);
 
1662
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->button, &n_written);
 
1663
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1664
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->modifiers, &n_written);
 
1665
 
 
1666
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1667
}
 
1668
 
 
1669
static void
 
1670
xig_client_codec_real_ungrab_button (XigCodec *codec, XigUngrabButton *message)
 
1671
{
 
1672
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1673
    gsize n_written = 0;
 
1674
 
 
1675
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UngrabButton, &n_written);
 
1676
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1677
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1678
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->button, &n_written);
 
1679
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->grab_window, &n_written);
 
1680
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->modifiers, &n_written);
 
1681
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1682
 
 
1683
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1684
}
 
1685
 
 
1686
static void
 
1687
xig_client_codec_real_change_active_pointer_grab (XigCodec *codec, XigChangeActivePointerGrab *message)
 
1688
{
 
1689
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1690
    gsize n_written = 0;
 
1691
 
 
1692
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeActivePointerGrab, &n_written);
 
1693
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1694
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1695
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1696
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cursor, &n_written);
 
1697
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1698
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->event_mask, &n_written);
 
1699
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1700
 
 
1701
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1702
}
 
1703
 
 
1704
static void
 
1705
xig_client_codec_real_grab_keyboard (XigCodec *codec, XigGrabKeyboard *message)
 
1706
{
 
1707
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1708
    gsize n_written = 0;
 
1709
 
 
1710
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GrabKeyboard, &n_written);
 
1711
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1712
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1713
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->owner_events ? 1 : 0, &n_written);
 
1714
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->grab_window, &n_written);
 
1715
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1716
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->pointer_mode, &n_written);
 
1717
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keyboard_mode, &n_written);
 
1718
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1719
 
 
1720
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1721
}
 
1722
 
 
1723
static void
 
1724
xig_client_codec_real_ungrab_keyboard (XigCodec *codec, XigUngrabKeyboard *message)
 
1725
{
 
1726
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1727
    gsize n_written = 0;
 
1728
 
 
1729
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UngrabKeyboard, &n_written);
 
1730
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1731
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1732
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1733
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1734
 
 
1735
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1736
}
 
1737
 
 
1738
static void
 
1739
xig_client_codec_real_grab_key (XigCodec *codec, XigGrabKey *message)
 
1740
{
 
1741
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1742
    gsize n_written = 0;
 
1743
 
 
1744
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GrabKey, &n_written);
 
1745
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1746
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1747
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->owner_events ? 1 : 0, &n_written);
 
1748
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->grab_window, &n_written);
 
1749
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->modifiers, &n_written);
 
1750
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->key, &n_written);
 
1751
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->pointer_mode, &n_written);
 
1752
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keyboard_mode, &n_written);
 
1753
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 3, &n_written);
 
1754
 
 
1755
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1756
}
 
1757
 
 
1758
static void
 
1759
xig_client_codec_real_ungrab_key (XigCodec *codec, XigUngrabKey *message)
 
1760
{
 
1761
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1762
    gsize n_written = 0;
 
1763
 
 
1764
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UngrabKey, &n_written);
 
1765
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1766
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1767
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->key, &n_written);
 
1768
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->grab_window, &n_written);
 
1769
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->modifiers, &n_written);
 
1770
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1771
 
 
1772
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1773
}
 
1774
 
 
1775
static void
 
1776
xig_client_codec_real_allow_events (XigCodec *codec, XigAllowEvents *message)
 
1777
{
 
1778
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1779
    gsize n_written = 0;
 
1780
 
 
1781
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_AllowEvents, &n_written);
 
1782
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1783
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1784
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
1785
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1786
 
 
1787
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1788
}
 
1789
 
 
1790
static void
 
1791
xig_client_codec_real_grab_server (XigCodec *codec, XigGrabServer *message)
 
1792
{
 
1793
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1794
    gsize n_written = 0;
 
1795
 
 
1796
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GrabServer, &n_written);
 
1797
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1798
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1799
 
 
1800
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1801
}
 
1802
 
 
1803
static void
 
1804
xig_client_codec_real_ungrab_server (XigCodec *codec, XigUngrabServer *message)
 
1805
{
 
1806
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1807
    gsize n_written = 0;
 
1808
 
 
1809
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UngrabServer, &n_written);
 
1810
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1811
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1812
 
 
1813
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1814
}
 
1815
 
 
1816
static void
 
1817
xig_client_codec_real_query_pointer (XigCodec *codec, XigQueryPointer *message)
 
1818
{
 
1819
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1820
    gsize n_written = 0;
 
1821
 
 
1822
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryPointer, &n_written);
 
1823
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1824
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1825
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1826
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1827
 
 
1828
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1829
}
 
1830
 
 
1831
static void
 
1832
xig_client_codec_real_get_motion_events (XigCodec *codec, XigGetMotionEvents *message)
 
1833
{
 
1834
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1835
    gsize n_written = 0;
 
1836
 
 
1837
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetMotionEvents, &n_written);
 
1838
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1839
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1840
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1841
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
1842
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->start, &n_written);
 
1843
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->stop, &n_written);
 
1844
 
 
1845
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1846
}
 
1847
 
 
1848
static void
 
1849
xig_client_codec_real_translate_coordinates (XigCodec *codec, XigTranslateCoordinates *message)
 
1850
{
 
1851
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1852
    gsize n_written = 0;
 
1853
 
 
1854
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_TranslateCoordinates, &n_written);
 
1855
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1856
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1857
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1858
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_window, &n_written);
 
1859
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_window, &n_written);
 
1860
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_x, &n_written);
 
1861
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_y, &n_written);
 
1862
 
 
1863
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1864
}
 
1865
 
 
1866
static void
 
1867
xig_client_codec_real_warp_pointer (XigCodec *codec, XigWarpPointer *message)
 
1868
{
 
1869
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1870
    gsize n_written = 0;
 
1871
 
 
1872
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_WarpPointer, &n_written);
 
1873
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1874
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1875
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1876
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_window, &n_written);
 
1877
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_window, &n_written);
 
1878
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_x, &n_written);
 
1879
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_y, &n_written);
 
1880
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_width, &n_written);
 
1881
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_height, &n_written);
 
1882
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_x, &n_written);
 
1883
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_y, &n_written);
 
1884
 
 
1885
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1886
}
 
1887
 
 
1888
static void
 
1889
xig_client_codec_real_set_input_focus (XigCodec *codec, XigSetInputFocus *message)
 
1890
{
 
1891
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1892
    gsize n_written = 0;
 
1893
 
 
1894
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetInputFocus, &n_written);
 
1895
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1896
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1897
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->revert_to, &n_written);
 
1898
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->focus, &n_written);
 
1899
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->time, &n_written);
 
1900
 
 
1901
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1902
}
 
1903
 
 
1904
static void
 
1905
xig_client_codec_real_get_input_focus (XigCodec *codec, XigGetInputFocus *message)
 
1906
{
 
1907
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1908
    gsize n_written = 0;
 
1909
 
 
1910
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetInputFocus, &n_written);
 
1911
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1912
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1913
 
 
1914
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1915
}
 
1916
 
 
1917
static void
 
1918
xig_client_codec_real_query_keymap (XigCodec *codec, XigQueryKeymap *message)
 
1919
{
 
1920
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1921
    gsize n_written = 0;
 
1922
 
 
1923
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryKeymap, &n_written);
 
1924
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1925
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1926
 
 
1927
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1928
}
 
1929
 
 
1930
static void
 
1931
xig_client_codec_real_open_font (XigCodec *codec, XigOpenFont *message)
 
1932
{
 
1933
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1934
    gsize n_written = 0;
 
1935
 
 
1936
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_OpenFont, &n_written);
 
1937
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1938
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1939
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1940
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fid, &n_written);
 
1941
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->name), &n_written);
 
1942
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
1943
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->name, &n_written);
 
1944
 
 
1945
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1946
}
 
1947
 
 
1948
static void
 
1949
xig_client_codec_real_close_font (XigCodec *codec, XigCloseFont *message)
 
1950
{
 
1951
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1952
    gsize n_written = 0;
 
1953
 
 
1954
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CloseFont, &n_written);
 
1955
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1956
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1957
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1958
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->font, &n_written);
 
1959
 
 
1960
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1961
}
 
1962
 
 
1963
static void
 
1964
xig_client_codec_real_query_font (XigCodec *codec, XigQueryFont *message)
 
1965
{
 
1966
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1967
    gsize n_written = 0;
 
1968
 
 
1969
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryFont, &n_written);
 
1970
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1971
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1972
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1973
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->font, &n_written);
 
1974
 
 
1975
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1976
}
 
1977
 
 
1978
static void
 
1979
xig_client_codec_real_query_text_extents (XigCodec *codec, XigQueryTextExtents *message)
 
1980
{
 
1981
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1982
    gsize n_written = 0;
 
1983
    int i;
 
1984
 
 
1985
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryTextExtents, &n_written);
 
1986
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
1987
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
1988
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->font, &n_written);
 
1989
    for (i = 0; i < message->string_length; i++)
 
1990
        write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->string[i], &n_written);
 
1991
 
 
1992
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
1993
}
 
1994
 
 
1995
static void
 
1996
xig_client_codec_real_list_fonts (XigCodec *codec, XigListFonts *message)
 
1997
{
 
1998
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
1999
    gsize n_written = 0;
 
2000
 
 
2001
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ListFonts, &n_written);
 
2002
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2003
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2004
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2005
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->max_names, &n_written);
 
2006
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->pattern), &n_written);
 
2007
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->pattern, &n_written);
 
2008
 
 
2009
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2010
}
 
2011
 
 
2012
static void
 
2013
xig_client_codec_real_list_fonts_with_info (XigCodec *codec, XigListFontsWithInfo *message)
 
2014
{
 
2015
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2016
    gsize n_written = 0;
 
2017
 
 
2018
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ListFontsWithInfo, &n_written);
 
2019
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2020
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2021
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2022
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->max_names, &n_written);
 
2023
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->pattern), &n_written);
 
2024
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->pattern, &n_written);
 
2025
 
 
2026
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2027
}
 
2028
 
 
2029
static void
 
2030
xig_client_codec_real_set_font_path (XigCodec *codec, XigSetFontPath *message)
 
2031
{
 
2032
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2033
    gsize n_written = 0;
 
2034
    gchar **s;
 
2035
 
 
2036
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetFontPath, &n_written);
 
2037
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2038
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2039
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2040
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, g_strv_length (message->path), &n_written);
 
2041
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2042
    for (s = message->path; *s; s++)
 
2043
    {
 
2044
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, strlen (*s), &n_written);
 
2045
        write_string (buffer, MAXIMUM_REQUEST_LENGTH, *s, &n_written);
 
2046
    }
 
2047
 
 
2048
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2049
}
 
2050
 
 
2051
static void
 
2052
xig_client_codec_real_get_font_path (XigCodec *codec, XigGetFontPath *message)
 
2053
{
 
2054
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2055
    gsize n_written = 0;
 
2056
 
 
2057
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetFontPath, &n_written);
 
2058
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2059
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2060
 
 
2061
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2062
}
 
2063
 
 
2064
static void
 
2065
xig_client_codec_real_create_pixmap (XigCodec *codec, XigCreatePixmap *message)
 
2066
{
 
2067
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2068
    gsize n_written = 0;
 
2069
 
 
2070
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CreatePixmap, &n_written);
 
2071
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2072
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2073
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->depth, &n_written);
 
2074
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->pid, &n_written);
 
2075
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2076
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2077
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2078
 
 
2079
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2080
}
 
2081
 
 
2082
static void
 
2083
xig_client_codec_real_free_pixmap (XigCodec *codec, XigFreePixmap *message)
 
2084
{
 
2085
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2086
    gsize n_written = 0;
 
2087
 
 
2088
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_FreePixmap, &n_written);
 
2089
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2090
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2091
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2092
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->pixmap, &n_written);
 
2093
 
 
2094
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2095
}
 
2096
 
 
2097
static void
 
2098
xig_client_codec_real_create_gc (XigCodec *codec, XigCreateGC *message)
 
2099
{
 
2100
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2101
    gsize n_written = 0;
 
2102
 
 
2103
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CreateGC, &n_written);
 
2104
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2105
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2106
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2107
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cid, &n_written);
 
2108
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2109
 
 
2110
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2111
}
 
2112
 
 
2113
static void
 
2114
xig_client_codec_real_change_gc (XigCodec *codec, XigChangeGC *message)
 
2115
{
 
2116
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2117
    gsize n_written = 0;
 
2118
 
 
2119
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeGC, &n_written);
 
2120
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2121
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2122
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2123
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2124
 
 
2125
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2126
}
 
2127
 
 
2128
static void
 
2129
xig_client_codec_real_copy_gc (XigCodec *codec, XigCopyGC *message)
 
2130
{
 
2131
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2132
    gsize n_written = 0;
 
2133
 
 
2134
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CopyGC, &n_written);
 
2135
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2136
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2137
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2138
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_gc, &n_written);
 
2139
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_gc, &n_written);
 
2140
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->value_mask, &n_written);
 
2141
 
 
2142
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2143
}
 
2144
 
 
2145
static void
 
2146
xig_client_codec_real_set_dashes (XigCodec *codec, XigSetDashes *message)
 
2147
{
 
2148
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2149
    gsize n_written = 0;
 
2150
    int i;
 
2151
 
 
2152
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetDashes, &n_written);
 
2153
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2154
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2155
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2156
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2157
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dash_offset, &n_written);
 
2158
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dashes_length, &n_written);
 
2159
    for (i = 0; i < message->dashes_length; i++)
 
2160
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->dashes[i], &n_written);
 
2161
 
 
2162
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2163
}
 
2164
 
 
2165
static void
 
2166
xig_client_codec_real_set_clip_rectangles (XigCodec *codec, XigSetClipRectangles *message)
 
2167
{
 
2168
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2169
    gsize n_written = 0;
 
2170
    int i;
 
2171
 
 
2172
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetClipRectangles, &n_written);
 
2173
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2174
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2175
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->ordering, &n_written);
 
2176
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2177
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->clip_x_origin, &n_written);
 
2178
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->clip_y_origin, &n_written);
 
2179
    for (i = 0; i < message->rectangles_length; i++)
 
2180
        ;//write_RECTANGLE (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->rectangles[i], &n_written);
 
2181
 
 
2182
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2183
}
 
2184
 
 
2185
static void
 
2186
xig_client_codec_real_free_gc (XigCodec *codec, XigFreeGC *message)
 
2187
{
 
2188
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2189
    gsize n_written = 0;
 
2190
 
 
2191
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_FreeGC, &n_written);
 
2192
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2193
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2194
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2195
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2196
 
 
2197
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2198
}
 
2199
 
 
2200
static void
 
2201
xig_client_codec_real_clear_area (XigCodec *codec, XigClearArea *message)
 
2202
{
 
2203
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2204
    gsize n_written = 0;
 
2205
 
 
2206
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ClearArea, &n_written);
 
2207
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2208
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2209
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->exposures ? 1 : 0, &n_written);
 
2210
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
2211
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2212
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2213
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2214
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2215
 
 
2216
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2217
}
 
2218
 
 
2219
static void
 
2220
xig_client_codec_real_copy_area (XigCodec *codec, XigCopyArea *message)
 
2221
{
 
2222
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2223
    gsize n_written = 0;
 
2224
 
 
2225
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CopyArea, &n_written);
 
2226
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2227
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2228
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2229
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_drawable, &n_written);
 
2230
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_drawable, &n_written);
 
2231
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2232
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_x, &n_written);
 
2233
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_y, &n_written);
 
2234
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_x, &n_written);
 
2235
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_y, &n_written);
 
2236
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2237
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2238
 
 
2239
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2240
}
 
2241
 
 
2242
static void
 
2243
xig_client_codec_real_copy_plane (XigCodec *codec, XigCopyPlane *message)
 
2244
{
 
2245
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2246
    gsize n_written = 0;
 
2247
 
 
2248
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CopyPlane, &n_written);
 
2249
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2250
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2251
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2252
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_drawable, &n_written);
 
2253
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_drawable, &n_written);
 
2254
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2255
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_x, &n_written);
 
2256
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_y, &n_written);
 
2257
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_x, &n_written);
 
2258
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_y, &n_written);
 
2259
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2260
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2261
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->bit_plane, &n_written);
 
2262
 
 
2263
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2264
}
 
2265
 
 
2266
static void
 
2267
xig_client_codec_real_poly_point (XigCodec *codec, XigPolyPoint *message)
 
2268
{
 
2269
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2270
    gsize n_written = 0;
 
2271
    int i;
 
2272
 
 
2273
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyPoint, &n_written);
 
2274
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2275
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2276
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->coordinate_mode, &n_written);
 
2277
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2278
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2279
    for (i = 0; i < message->points_length; i++)
 
2280
        ;//write_POINT (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->points[i], &n_written);
 
2281
 
 
2282
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2283
}
 
2284
 
 
2285
static void
 
2286
xig_client_codec_real_poly_line (XigCodec *codec, XigPolyLine *message)
 
2287
{
 
2288
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2289
    gsize n_written = 0;
 
2290
    int i;
 
2291
 
 
2292
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyLine, &n_written);
 
2293
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2294
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2295
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->coordinate_mode, &n_written);
 
2296
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2297
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2298
    for (i = 0; i < message->points_length; i++)
 
2299
        ;//write_POINT (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->points[i], &n_written);
 
2300
 
 
2301
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2302
}
 
2303
 
 
2304
static void
 
2305
xig_client_codec_real_poly_segment (XigCodec *codec, XigPolySegment *message)
 
2306
{
 
2307
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2308
    gsize n_written = 0;
 
2309
    int i;
 
2310
 
 
2311
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolySegment, &n_written);
 
2312
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2313
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2314
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2315
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2316
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2317
    for (i = 0; i < message->segments_length; i++)
 
2318
        ;//write_SEGMENT (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->segments[i], &n_written);
 
2319
 
 
2320
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2321
}
 
2322
 
 
2323
static void
 
2324
xig_client_codec_real_poly_rectangle (XigCodec *codec, XigPolyRectangle *message)
 
2325
{
 
2326
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2327
    gsize n_written = 0;
 
2328
    int i;
 
2329
 
 
2330
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyRectangle, &n_written);
 
2331
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2332
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2333
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2334
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2335
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2336
    for (i = 0; i < message->rectangles_length; i++)
 
2337
        ;//write_RECTANGLE (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->rectangles[i], &n_written);
 
2338
 
 
2339
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2340
}
 
2341
 
 
2342
static void
 
2343
xig_client_codec_real_poly_arc (XigCodec *codec, XigPolyArc *message)
 
2344
{
 
2345
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2346
    gsize n_written = 0;
 
2347
    int i;
 
2348
 
 
2349
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyArc, &n_written);
 
2350
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2351
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2352
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2353
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2354
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2355
    for (i = 0; i < message->arcs_length; i++)
 
2356
        ;//write_ARC (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->arcs[i], &n_written);
 
2357
 
 
2358
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2359
}
 
2360
 
 
2361
static void
 
2362
xig_client_codec_real_fill_poly (XigCodec *codec, XigFillPoly *message)
 
2363
{
 
2364
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2365
    gsize n_written = 0;
 
2366
    int i;
 
2367
 
 
2368
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_FillPoly, &n_written);
 
2369
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2370
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2371
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2372
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2373
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2374
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->shape, &n_written);
 
2375
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->coordinate_mode, &n_written);
 
2376
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2377
    for (i = 0; i < message->points_length; i++)
 
2378
        ;//write_POINT (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->points[i], &n_written);
 
2379
 
 
2380
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2381
}
 
2382
 
 
2383
static void
 
2384
xig_client_codec_real_poly_fill_rectangle (XigCodec *codec, XigPolyFillRectangle *message)
 
2385
{
 
2386
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2387
    gsize n_written = 0;
 
2388
    int i;
 
2389
 
 
2390
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyFillRectangle, &n_written);
 
2391
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2392
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2393
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2394
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2395
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2396
    for (i = 0; i < message->rectangles_length; i++)
 
2397
        ;//write_RECTANGLE (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->rectangles[i], &n_written);
 
2398
 
 
2399
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2400
}
 
2401
 
 
2402
static void
 
2403
xig_client_codec_real_poly_fill_arc (XigCodec *codec, XigPolyFillArc *message)
 
2404
{
 
2405
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2406
    gsize n_written = 0;
 
2407
    int i;
 
2408
 
 
2409
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyFillArc, &n_written);
 
2410
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2411
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2412
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2413
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2414
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2415
    for (i = 0; i < message->arcs_length; i++)
 
2416
        ;//write_ARC (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->arcs[i], &n_written);
 
2417
 
 
2418
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2419
}
 
2420
 
 
2421
static void
 
2422
xig_client_codec_real_put_image (XigCodec *codec, XigPutImage *message)
 
2423
{
 
2424
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2425
    gsize n_written = 0;
 
2426
    int i;
 
2427
 
 
2428
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PutImage, &n_written);
 
2429
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2430
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2431
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->format, &n_written);
 
2432
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2433
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2434
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2435
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2436
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_x, &n_written);
 
2437
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->dst_y, &n_written);
 
2438
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->left_pad, &n_written);
 
2439
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->depth, &n_written);
 
2440
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2441
    for (i = 0; i < message->data_length; i++)
 
2442
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->data[i], &n_written);
 
2443
 
 
2444
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2445
}
 
2446
 
 
2447
static void
 
2448
xig_client_codec_real_get_image (XigCodec *codec, XigGetImage *message)
 
2449
{
 
2450
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2451
    gsize n_written = 0;
 
2452
 
 
2453
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetImage, &n_written);
 
2454
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2455
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2456
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->format, &n_written);
 
2457
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2458
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2459
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2460
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2461
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2462
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->plane_mask, &n_written);
 
2463
 
 
2464
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2465
}
 
2466
 
 
2467
static void
 
2468
xig_client_codec_real_poly_text8 (XigCodec *codec, XigPolyText8 *message)
 
2469
{
 
2470
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2471
    gsize n_written = 0;
 
2472
    int i;
 
2473
 
 
2474
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyText8, &n_written);
 
2475
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2476
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2477
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2478
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2479
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2480
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2481
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2482
    for (i = 0; i < message->items_length; i++)
 
2483
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->items[i], &n_written);
 
2484
 
 
2485
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2486
}
 
2487
 
 
2488
static void
 
2489
xig_client_codec_real_poly_text16 (XigCodec *codec, XigPolyText16 *message)
 
2490
{
 
2491
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2492
    gsize n_written = 0;
 
2493
    int i;
 
2494
 
 
2495
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_PolyText16, &n_written);
 
2496
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2497
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2498
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2499
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2500
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2501
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2502
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2503
    for (i = 0; i < message->items_length; i++)
 
2504
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->items[i], &n_written);
 
2505
 
 
2506
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2507
}
 
2508
 
 
2509
static void
 
2510
xig_client_codec_real_image_text8 (XigCodec *codec, XigImageText8 *message)
 
2511
{
 
2512
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2513
    gsize n_written = 0;
 
2514
 
 
2515
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ImageText8, &n_written);
 
2516
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2517
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2518
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, strlen (message->string), &n_written);
 
2519
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2520
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2521
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2522
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2523
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->string, &n_written);
 
2524
 
 
2525
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2526
}
 
2527
 
 
2528
static void
 
2529
xig_client_codec_real_image_text16 (XigCodec *codec, XigImageText16 *message)
 
2530
{
 
2531
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2532
    gsize n_written = 0;
 
2533
    int i;
 
2534
 
 
2535
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ImageText16, &n_written);
 
2536
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2537
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2538
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->string_length, &n_written);
 
2539
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2540
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->gc, &n_written);
 
2541
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2542
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2543
    for (i = 0; i < message->string_length; i++)
 
2544
        write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->string[i], &n_written);
 
2545
 
 
2546
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2547
}
 
2548
 
 
2549
static void
 
2550
xig_client_codec_real_create_colormap (XigCodec *codec, XigCreateColormap *message)
 
2551
{
 
2552
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2553
    gsize n_written = 0;
 
2554
 
 
2555
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CreateColormap, &n_written);
 
2556
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2557
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2558
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->alloc, &n_written);
 
2559
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->mid, &n_written);
 
2560
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
2561
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->visual, &n_written);
 
2562
 
 
2563
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2564
}
 
2565
 
 
2566
static void
 
2567
xig_client_codec_real_free_colormap (XigCodec *codec, XigFreeColormap *message)
 
2568
{
 
2569
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2570
    gsize n_written = 0;
 
2571
 
 
2572
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_FreeColormap, &n_written);
 
2573
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2574
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2575
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2576
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2577
 
 
2578
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2579
}
 
2580
 
 
2581
static void
 
2582
xig_client_codec_real_copy_colormap_and_free (XigCodec *codec, XigCopyColormapAndFree *message)
 
2583
{
 
2584
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2585
    gsize n_written = 0;
 
2586
 
 
2587
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CopyColormapAndFree, &n_written);
 
2588
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2589
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2590
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2591
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->mid, &n_written);
 
2592
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->src_cmap, &n_written);
 
2593
 
 
2594
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2595
}
 
2596
 
 
2597
static void
 
2598
xig_client_codec_real_install_colormap (XigCodec *codec, XigInstallColormap *message)
 
2599
{
 
2600
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2601
    gsize n_written = 0;
 
2602
 
 
2603
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_InstallColormap, &n_written);
 
2604
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2605
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2606
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2607
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2608
 
 
2609
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2610
}
 
2611
 
 
2612
static void
 
2613
xig_client_codec_real_uninstall_colormap (XigCodec *codec, XigUninstallColormap *message)
 
2614
{
 
2615
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2616
    gsize n_written = 0;
 
2617
 
 
2618
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_UninstallColormap, &n_written);
 
2619
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2620
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2621
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2622
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2623
 
 
2624
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2625
}
 
2626
 
 
2627
static void
 
2628
xig_client_codec_real_list_installed_colormaps (XigCodec *codec, XigListInstalledColormaps *message)
 
2629
{
 
2630
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2631
    gsize n_written = 0;
 
2632
 
 
2633
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ListInstalledColormaps, &n_written);
 
2634
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2635
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2636
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2637
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
2638
 
 
2639
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2640
}
 
2641
 
 
2642
static void
 
2643
xig_client_codec_real_alloc_color (XigCodec *codec, XigAllocColor *message)
 
2644
{
 
2645
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2646
    gsize n_written = 0;
 
2647
 
 
2648
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_AllocColor, &n_written);
 
2649
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2650
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2651
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2652
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2653
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->red, &n_written);
 
2654
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->green, &n_written);
 
2655
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->blue, &n_written);
 
2656
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2657
 
 
2658
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2659
}
 
2660
 
 
2661
static void
 
2662
xig_client_codec_real_alloc_named_color (XigCodec *codec, XigAllocNamedColor *message)
 
2663
{
 
2664
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2665
    gsize n_written = 0;
 
2666
 
 
2667
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_AllocNamedColor, &n_written);
 
2668
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2669
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2670
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2671
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2672
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->name), &n_written);
 
2673
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2674
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->name, &n_written);
 
2675
 
 
2676
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2677
}
 
2678
 
 
2679
static void
 
2680
xig_client_codec_real_alloc_color_cells (XigCodec *codec, XigAllocColorCells *message)
 
2681
{
 
2682
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2683
    gsize n_written = 0;
 
2684
 
 
2685
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_AllocColorCells, &n_written);
 
2686
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2687
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2688
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->contiguous ? 1 : 0, &n_written);
 
2689
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2690
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->colors, &n_written);
 
2691
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->planes, &n_written);
 
2692
 
 
2693
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2694
}
 
2695
 
 
2696
static void
 
2697
xig_client_codec_real_alloc_color_planes (XigCodec *codec, XigAllocColorPlanes *message)
 
2698
{
 
2699
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2700
    gsize n_written = 0;
 
2701
 
 
2702
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_AllocColorPlanes, &n_written);
 
2703
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2704
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2705
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->contiguous ? 1 : 0, &n_written);
 
2706
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2707
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->colors, &n_written);
 
2708
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->reds, &n_written);
 
2709
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->greens, &n_written);
 
2710
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->blues, &n_written);
 
2711
 
 
2712
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2713
}
 
2714
 
 
2715
static void
 
2716
xig_client_codec_real_free_colors (XigCodec *codec, XigFreeColors *message)
 
2717
{
 
2718
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2719
    gsize n_written = 0;
 
2720
    int i;
 
2721
 
 
2722
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_FreeColors, &n_written);
 
2723
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2724
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2725
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2726
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2727
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->plane_mask, &n_written);
 
2728
    for (i = 0; i < message->pixels_length; i++)
 
2729
        write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->pixels[i], &n_written);
 
2730
 
 
2731
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2732
}
 
2733
 
 
2734
static void
 
2735
xig_client_codec_real_store_colors (XigCodec *codec, XigStoreColors *message)
 
2736
{
 
2737
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2738
    gsize n_written = 0;
 
2739
    int i;
 
2740
 
 
2741
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_StoreColors, &n_written);
 
2742
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2743
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2744
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2745
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2746
    for (i = 0; i < message->items_length; i++)
 
2747
        ;//write_COLORITEM (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->items[i], &n_written);
 
2748
 
 
2749
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2750
}
 
2751
 
 
2752
static void
 
2753
xig_client_codec_real_store_named_color (XigCodec *codec, XigStoreNamedColor *message)
 
2754
{
 
2755
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2756
    gsize n_written = 0;
 
2757
    guint8 flags = 0x00;
 
2758
 
 
2759
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_StoreNamedColor, &n_written);
 
2760
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2761
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2762
    if (message->do_red)
 
2763
        flags |= 0x01;
 
2764
    if (message->do_green)
 
2765
        flags |= 0x02;
 
2766
    if (message->do_blue)
 
2767
        flags |= 0x04;
 
2768
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, flags, &n_written);
 
2769
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2770
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->pixel, &n_written);
 
2771
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->name), &n_written);
 
2772
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2773
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->name, &n_written);
 
2774
 
 
2775
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2776
}
 
2777
 
 
2778
static void
 
2779
xig_client_codec_real_query_colors (XigCodec *codec, XigQueryColors *message)
 
2780
{
 
2781
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2782
    gsize n_written = 0;
 
2783
    int i;
 
2784
 
 
2785
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryColors, &n_written);
 
2786
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2787
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2788
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2789
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2790
    for (i = 0; i < message->pixels_length; i++)
 
2791
        write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->pixels[i], &n_written);
 
2792
 
 
2793
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2794
}
 
2795
 
 
2796
static void
 
2797
xig_client_codec_real_lookup_color (XigCodec *codec, XigLookupColor *message)
 
2798
{
 
2799
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2800
    gsize n_written = 0;
 
2801
 
 
2802
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_LookupColor, &n_written);
 
2803
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2804
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2805
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2806
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cmap, &n_written);
 
2807
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->name), &n_written);
 
2808
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2809
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->name, &n_written);
 
2810
 
 
2811
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2812
}
 
2813
 
 
2814
static void
 
2815
xig_client_codec_real_create_cursor (XigCodec *codec, XigCreateCursor *message)
 
2816
{
 
2817
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2818
    gsize n_written = 0;
 
2819
 
 
2820
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CreateCursor, &n_written);
 
2821
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2822
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2823
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2824
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cid, &n_written);
 
2825
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->source, &n_written);
 
2826
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->mask, &n_written);
 
2827
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_red, &n_written);
 
2828
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_green, &n_written);
 
2829
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_blue, &n_written);
 
2830
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_red, &n_written);
 
2831
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_green, &n_written);
 
2832
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_blue, &n_written);
 
2833
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->x, &n_written);
 
2834
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->y, &n_written);
 
2835
 
 
2836
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2837
}
 
2838
 
 
2839
static void
 
2840
xig_client_codec_real_create_glyph_cursor (XigCodec *codec, XigCreateGlyphCursor *message)
 
2841
{
 
2842
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2843
    gsize n_written = 0;
 
2844
 
 
2845
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_CreateGlyphCursor, &n_written);
 
2846
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2847
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2848
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2849
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cid, &n_written);
 
2850
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->source_font, &n_written);
 
2851
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->mask_font, &n_written);
 
2852
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->source_char, &n_written);
 
2853
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->mask_char, &n_written);
 
2854
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_red, &n_written);
 
2855
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_green, &n_written);
 
2856
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_blue, &n_written);
 
2857
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_red, &n_written);
 
2858
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_green, &n_written);
 
2859
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_blue, &n_written);
 
2860
 
 
2861
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2862
}
 
2863
 
 
2864
static void
 
2865
xig_client_codec_real_free_cursor (XigCodec *codec, XigFreeCursor *message)
 
2866
{
 
2867
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2868
    gsize n_written = 0;
 
2869
 
 
2870
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_FreeCursor, &n_written);
 
2871
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2872
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2873
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2874
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cursor, &n_written);
 
2875
 
 
2876
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2877
}
 
2878
 
 
2879
static void
 
2880
xig_client_codec_real_recolor_cursor (XigCodec *codec, XigRecolorCursor *message)
 
2881
{
 
2882
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2883
    gsize n_written = 0;
 
2884
 
 
2885
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_RecolorCursor, &n_written);
 
2886
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2887
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2888
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2889
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->cursor, &n_written);
 
2890
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_red, &n_written);
 
2891
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_green, &n_written);
 
2892
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->fore_blue, &n_written);
 
2893
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_red, &n_written);
 
2894
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_green, &n_written);
 
2895
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->back_blue, &n_written);
 
2896
 
 
2897
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2898
}
 
2899
 
 
2900
static void
 
2901
xig_client_codec_real_query_best_size (XigCodec *codec, XigQueryBestSize *message)
 
2902
{
 
2903
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2904
    gsize n_written = 0;
 
2905
 
 
2906
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryBestSize, &n_written);
 
2907
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2908
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2909
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->class, &n_written);
 
2910
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->drawable, &n_written);
 
2911
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->width, &n_written);
 
2912
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->height, &n_written);
 
2913
 
 
2914
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2915
}
 
2916
 
 
2917
static void
 
2918
xig_client_codec_real_query_extension (XigCodec *codec, XigQueryExtension *message)
 
2919
{
 
2920
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2921
    gsize n_written = 0;
 
2922
 
 
2923
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_QueryExtension, &n_written);
 
2924
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2925
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2926
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2927
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, strlen (message->name), &n_written);
 
2928
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2929
    write_padded_string (buffer, MAXIMUM_REQUEST_LENGTH, message->name, &n_written);
 
2930
 
 
2931
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2932
}
 
2933
 
 
2934
static void
 
2935
xig_client_codec_real_list_extensions (XigCodec *codec, XigListExtensions *message)
 
2936
{
 
2937
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2938
    gsize n_written = 0;
 
2939
 
 
2940
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ListExtensions, &n_written);
 
2941
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2942
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2943
 
 
2944
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2945
}
 
2946
 
 
2947
static void
 
2948
xig_client_codec_real_change_keyboard_mapping (XigCodec *codec, XigChangeKeyboardMapping *message)
 
2949
{
 
2950
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2951
    gsize n_written = 0;
 
2952
    int i;
 
2953
 
 
2954
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeKeyboardMapping, &n_written);
 
2955
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2956
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2957
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keycode_count, &n_written);
 
2958
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->first_keycode, &n_written);
 
2959
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keysyms_per_keycode, &n_written);
 
2960
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 2, &n_written);
 
2961
    for (i = 0; i < message->keysyms_length; i++)
 
2962
        write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->keysyms[i], &n_written);
 
2963
 
 
2964
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2965
}
 
2966
 
 
2967
static void
 
2968
xig_client_codec_real_get_keyboard_mapping (XigCodec *codec, XigGetKeyboardMapping *message)
 
2969
{
 
2970
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2971
    gsize n_written = 0;
 
2972
 
 
2973
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetKeyboardMapping, &n_written);
 
2974
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2975
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2976
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2977
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->first_keycode, &n_written);
 
2978
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->count, &n_written);
 
2979
 
 
2980
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2981
}
 
2982
 
 
2983
static void
 
2984
xig_client_codec_real_change_keyboard_control (XigCodec *codec, XigChangeKeyboardControl *message)
 
2985
{
 
2986
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
2987
    gsize n_written = 0;
 
2988
 
 
2989
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeKeyboardControl, &n_written);
 
2990
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2991
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
2992
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
2993
 
 
2994
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
2995
}
 
2996
 
 
2997
static void
 
2998
xig_client_codec_real_get_keyboard_control (XigCodec *codec, XigGetKeyboardControl *message)
 
2999
{
 
3000
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3001
    gsize n_written = 0;
 
3002
 
 
3003
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetKeyboardControl, &n_written);
 
3004
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3005
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3006
 
 
3007
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3008
}
 
3009
 
 
3010
static void
 
3011
xig_client_codec_real_bell (XigCodec *codec, XigBell *message)
 
3012
{
 
3013
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3014
    gsize n_written = 0;
 
3015
 
 
3016
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_Bell, &n_written);
 
3017
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3018
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3019
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->percent, &n_written);
 
3020
 
 
3021
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3022
}
 
3023
 
 
3024
static void
 
3025
xig_client_codec_real_change_pointer_control (XigCodec *codec, XigChangePointerControl *message)
 
3026
{
 
3027
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3028
    gsize n_written = 0;
 
3029
 
 
3030
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangePointerControl, &n_written);
 
3031
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3032
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3033
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3034
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->acceleration_numerator, &n_written);
 
3035
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->acceleration_denominator, &n_written);
 
3036
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->threshold, &n_written);
 
3037
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->do_acceleration ? 1 : 0, &n_written);
 
3038
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->do_threshold ? 1 : 0, &n_written);
 
3039
 
 
3040
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3041
}
 
3042
 
 
3043
static void
 
3044
xig_client_codec_real_get_pointer_control (XigCodec *codec, XigGetPointerControl *message)
 
3045
{
 
3046
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3047
    gsize n_written = 0;
 
3048
 
 
3049
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetPointerControl, &n_written);
 
3050
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3051
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3052
 
 
3053
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3054
}
 
3055
 
 
3056
static void
 
3057
xig_client_codec_real_set_screen_saver (XigCodec *codec, XigSetScreenSaver *message)
 
3058
{
 
3059
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3060
    gsize n_written = 0;
 
3061
 
 
3062
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetScreenSaver, &n_written);
 
3063
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3064
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3065
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3066
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->timeout, &n_written);
 
3067
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->interval, &n_written);
 
3068
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->prefer_blanking, &n_written);
 
3069
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->allow_exposures, &n_written);
 
3070
 
 
3071
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3072
}
 
3073
 
 
3074
static void
 
3075
xig_client_codec_real_get_screen_saver (XigCodec *codec, XigGetScreenSaver *message)
 
3076
{
 
3077
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3078
    gsize n_written = 0;
 
3079
 
 
3080
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetScreenSaver, &n_written);
 
3081
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3082
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3083
 
 
3084
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3085
}
 
3086
 
 
3087
static void
 
3088
xig_client_codec_real_change_hosts (XigCodec *codec, XigChangeHosts *message)
 
3089
{
 
3090
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3091
    gsize n_written = 0;
 
3092
    int i;
 
3093
 
 
3094
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ChangeHosts, &n_written);
 
3095
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3096
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3097
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
3098
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->family, &n_written);
 
3099
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3100
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->address_length, &n_written);
 
3101
    for (i = 0; i < message->address_length; i++)
 
3102
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->address[i], &n_written);
 
3103
 
 
3104
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3105
}
 
3106
 
 
3107
static void
 
3108
xig_client_codec_real_list_hosts (XigCodec *codec, XigListHosts *message)
 
3109
{
 
3110
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3111
    gsize n_written = 0;
 
3112
 
 
3113
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ListHosts, &n_written);
 
3114
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3115
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3116
 
 
3117
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3118
}
 
3119
 
 
3120
static void
 
3121
xig_client_codec_real_set_access_control (XigCodec *codec, XigSetAccessControl *message)
 
3122
{
 
3123
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3124
    gsize n_written = 0;
 
3125
 
 
3126
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetAccessControl, &n_written);
 
3127
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3128
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3129
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
3130
 
 
3131
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3132
}
 
3133
 
 
3134
static void
 
3135
xig_client_codec_real_set_close_down_mode (XigCodec *codec, XigSetCloseDownMode *message)
 
3136
{
 
3137
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3138
    gsize n_written = 0;
 
3139
 
 
3140
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetCloseDownMode, &n_written);
 
3141
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3142
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3143
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
3144
 
 
3145
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3146
}
 
3147
 
 
3148
static void
 
3149
xig_client_codec_real_kill_client (XigCodec *codec, XigKillClient *message)
 
3150
{
 
3151
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3152
    gsize n_written = 0;
 
3153
 
 
3154
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_KillClient, &n_written);
 
3155
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3156
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3157
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3158
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->resource, &n_written);
 
3159
 
 
3160
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3161
}
 
3162
 
 
3163
static void
 
3164
xig_client_codec_real_rotate_properties (XigCodec *codec, XigRotateProperties *message)
 
3165
{
 
3166
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3167
    gsize n_written = 0;
 
3168
    int i;
 
3169
 
 
3170
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_RotateProperties, &n_written);
 
3171
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3172
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3173
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3174
    write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->window, &n_written);
 
3175
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->properties_length, &n_written);
 
3176
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->delta, &n_written);
 
3177
    for (i = 0; i < message->properties_length; i++)
 
3178
        write_card32 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, message->properties[i], &n_written);
 
3179
 
 
3180
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3181
}
 
3182
 
 
3183
static void
 
3184
xig_client_codec_real_force_screen_saver (XigCodec *codec, XigForceScreenSaver *message)
 
3185
{
 
3186
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3187
    gsize n_written = 0;
 
3188
 
 
3189
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_ForceScreenSaver, &n_written);
 
3190
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3191
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3192
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->mode, &n_written);
 
3193
 
 
3194
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3195
}
 
3196
 
 
3197
static void
 
3198
xig_client_codec_real_set_pointer_mapping (XigCodec *codec, XigSetPointerMapping *message)
 
3199
{
 
3200
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3201
    gsize n_written = 0;
 
3202
    int i;
 
3203
 
 
3204
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetPointerMapping, &n_written);
 
3205
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3206
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3207
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->map_length, &n_written);
 
3208
    for (i = 0; i < message->map_length; i++)
 
3209
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->map[i], &n_written);
 
3210
 
 
3211
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3212
}
 
3213
 
 
3214
static void
 
3215
xig_client_codec_real_get_pointer_mapping (XigCodec *codec, XigGetPointerMapping *message)
 
3216
{
 
3217
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3218
    gsize n_written = 0;
 
3219
 
 
3220
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetPointerMapping, &n_written);
 
3221
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3222
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3223
 
 
3224
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3225
}
 
3226
 
 
3227
static void
 
3228
xig_client_codec_real_set_modifier_mapping (XigCodec *codec, XigSetModifierMapping *message)
 
3229
{
 
3230
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3231
    gsize n_written = 0;
 
3232
    int i;
 
3233
 
 
3234
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_SetModifierMapping, &n_written);
 
3235
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3236
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3237
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keycodes_per_modifier, &n_written);
 
3238
    for (i = 0; i < message->keycodes_length; i++)
 
3239
        write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, message->keycodes[i], &n_written);
 
3240
 
 
3241
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3242
}
 
3243
 
 
3244
static void
 
3245
xig_client_codec_real_get_modifier_mapping (XigCodec *codec, XigGetModifierMapping *message)
 
3246
{
 
3247
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3248
    gsize n_written = 0;
 
3249
 
 
3250
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_GetModifierMapping, &n_written);
 
3251
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3252
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3253
 
 
3254
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3255
}
 
3256
 
 
3257
static void
 
3258
xig_client_codec_real_no_operation (XigCodec *codec, XigNoOperation *message)
 
3259
{
 
3260
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3261
    gsize n_written = 0;
 
3262
 
 
3263
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_NoOperation, &n_written);
 
3264
    write_padding (buffer, MAXIMUM_REQUEST_LENGTH, 1, &n_written);
 
3265
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3266
 
 
3267
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3268
}
 
3269
 
 
3270
static void
 
3271
xig_client_codec_real_BIGREQ_enable (XigCodec *codec, XigBIGREQEnable *message)
 
3272
{
 
3273
    guint8 buffer[MAXIMUM_REQUEST_LENGTH];
 
3274
    gsize n_written = 0;
 
3275
 
 
3276
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_REQUEST_BIGREQ, &n_written);
 
3277
    write_card8 (buffer, MAXIMUM_REQUEST_LENGTH, 0, &n_written); // FIXME
 
3278
    write_card16 (buffer, MAXIMUM_REQUEST_LENGTH, XIG_CLIENT_CODEC (codec)->priv->byte_order, 0, &n_written);
 
3279
 
 
3280
    XIG_CODEC_GET_CLASS (codec)->write (codec, buffer, n_written);
 
3281
}
 
3282
 
 
3283
static void
 
3284
xig_client_codec_init (XigClientCodec *codec)
 
3285
{
 
3286
    codec->priv = G_TYPE_INSTANCE_GET_PRIVATE (codec, xig_client_codec_get_type (), XigClientCodecPrivate);
 
3287
}
 
3288
 
 
3289
static void
 
3290
xig_client_codec_class_init (XigClientCodecClass *klass)
 
3291
{
 
3292
    XigCodecClass *codec_class = XIG_CODEC_CLASS (klass);
 
3293
 
 
3294
    g_type_class_add_private (klass, sizeof (XigClientCodecPrivate));
 
3295
 
 
3296
    codec_class->feed_data = xig_client_codec_real_feed_data;
 
3297
    codec_class->connect = xig_client_codec_real_connect;
 
3298
    codec_class->create_window = xig_client_codec_real_create_window;
 
3299
    codec_class->change_window_attributes = xig_client_codec_real_change_window_attributes;
 
3300
    codec_class->get_window_attributes = xig_client_codec_real_get_window_attributes;
 
3301
    codec_class->destroy_window = xig_client_codec_real_destroy_window;
 
3302
    codec_class->destroy_subwindows = xig_client_codec_real_destroy_subwindows;
 
3303
    codec_class->change_save_set = xig_client_codec_real_change_save_set;
 
3304
    codec_class->reparent_window = xig_client_codec_real_reparent_window;
 
3305
    codec_class->map_window = xig_client_codec_real_map_window;
 
3306
    codec_class->map_subwindows = xig_client_codec_real_map_subwindows;
 
3307
    codec_class->unmap_window = xig_client_codec_real_unmap_window;
 
3308
    codec_class->unmap_subwindows = xig_client_codec_real_unmap_subwindows;
 
3309
    codec_class->configure_window = xig_client_codec_real_configure_window;
 
3310
    codec_class->circulate_window = xig_client_codec_real_circulate_window;
 
3311
    codec_class->get_geometry = xig_client_codec_real_get_geometry;
 
3312
    codec_class->query_tree = xig_client_codec_real_query_tree;
 
3313
    codec_class->intern_atom = xig_client_codec_real_intern_atom;
 
3314
    codec_class->get_atom_name = xig_client_codec_real_get_atom_name;
 
3315
    codec_class->change_property = xig_client_codec_real_change_property;
 
3316
    codec_class->delete_property = xig_client_codec_real_delete_property;
 
3317
    codec_class->get_property = xig_client_codec_real_get_property;
 
3318
    codec_class->list_properties = xig_client_codec_real_list_properties;
 
3319
    codec_class->set_selection_owner = xig_client_codec_real_set_selection_owner;
 
3320
    codec_class->get_selection_owner = xig_client_codec_real_get_selection_owner;
 
3321
    codec_class->convert_selection = xig_client_codec_real_convert_selection;
 
3322
    codec_class->send_event = xig_client_codec_real_send_event;
 
3323
    codec_class->grab_pointer = xig_client_codec_real_grab_pointer;
 
3324
    codec_class->ungrab_pointer = xig_client_codec_real_ungrab_pointer;
 
3325
    codec_class->grab_button = xig_client_codec_real_grab_button;
 
3326
    codec_class->ungrab_button = xig_client_codec_real_ungrab_button;
 
3327
    codec_class->change_active_pointer_grab = xig_client_codec_real_change_active_pointer_grab;
 
3328
    codec_class->grab_keyboard = xig_client_codec_real_grab_keyboard;
 
3329
    codec_class->ungrab_keyboard = xig_client_codec_real_ungrab_keyboard;
 
3330
    codec_class->grab_key = xig_client_codec_real_grab_key;
 
3331
    codec_class->ungrab_key = xig_client_codec_real_ungrab_key;
 
3332
    codec_class->allow_events = xig_client_codec_real_allow_events;
 
3333
    codec_class->grab_server = xig_client_codec_real_grab_server;
 
3334
    codec_class->ungrab_server = xig_client_codec_real_ungrab_server;
 
3335
    codec_class->query_pointer = xig_client_codec_real_query_pointer;
 
3336
    codec_class->get_motion_events = xig_client_codec_real_get_motion_events;
 
3337
    codec_class->translate_coordinates = xig_client_codec_real_translate_coordinates;
 
3338
    codec_class->warp_pointer = xig_client_codec_real_warp_pointer;
 
3339
    codec_class->set_input_focus = xig_client_codec_real_set_input_focus;
 
3340
    codec_class->get_input_focus = xig_client_codec_real_get_input_focus;
 
3341
    codec_class->query_keymap = xig_client_codec_real_query_keymap;
 
3342
    codec_class->open_font = xig_client_codec_real_open_font;
 
3343
    codec_class->close_font = xig_client_codec_real_close_font;
 
3344
    codec_class->query_font = xig_client_codec_real_query_font;
 
3345
    codec_class->query_text_extents = xig_client_codec_real_query_text_extents;
 
3346
    codec_class->list_fonts = xig_client_codec_real_list_fonts;
 
3347
    codec_class->list_fonts_with_info = xig_client_codec_real_list_fonts_with_info;
 
3348
    codec_class->set_font_path = xig_client_codec_real_set_font_path;
 
3349
    codec_class->get_font_path = xig_client_codec_real_get_font_path;
 
3350
    codec_class->create_pixmap = xig_client_codec_real_create_pixmap;
 
3351
    codec_class->free_pixmap = xig_client_codec_real_free_pixmap;
 
3352
    codec_class->create_gc = xig_client_codec_real_create_gc;
 
3353
    codec_class->change_gc = xig_client_codec_real_change_gc;
 
3354
    codec_class->copy_gc = xig_client_codec_real_copy_gc;
 
3355
    codec_class->set_dashes = xig_client_codec_real_set_dashes;
 
3356
    codec_class->set_clip_rectangles = xig_client_codec_real_set_clip_rectangles;
 
3357
    codec_class->free_gc = xig_client_codec_real_free_gc;
 
3358
    codec_class->clear_area = xig_client_codec_real_clear_area;
 
3359
    codec_class->copy_area = xig_client_codec_real_copy_area;
 
3360
    codec_class->copy_plane = xig_client_codec_real_copy_plane;
 
3361
    codec_class->poly_point = xig_client_codec_real_poly_point;
 
3362
    codec_class->poly_line = xig_client_codec_real_poly_line;
 
3363
    codec_class->poly_segment = xig_client_codec_real_poly_segment;
 
3364
    codec_class->poly_rectangle = xig_client_codec_real_poly_rectangle;
 
3365
    codec_class->poly_arc = xig_client_codec_real_poly_arc;
 
3366
    codec_class->fill_poly = xig_client_codec_real_fill_poly;
 
3367
    codec_class->poly_fill_rectangle = xig_client_codec_real_poly_fill_rectangle;
 
3368
    codec_class->poly_fill_arc = xig_client_codec_real_poly_fill_arc;
 
3369
    codec_class->put_image = xig_client_codec_real_put_image;
 
3370
    codec_class->get_image = xig_client_codec_real_get_image;
 
3371
    codec_class->poly_text8 = xig_client_codec_real_poly_text8;
 
3372
    codec_class->poly_text16 = xig_client_codec_real_poly_text16;
 
3373
    codec_class->image_text8 = xig_client_codec_real_image_text8;
 
3374
    codec_class->image_text16 = xig_client_codec_real_image_text16;
 
3375
    codec_class->create_colormap = xig_client_codec_real_create_colormap;
 
3376
    codec_class->free_colormap = xig_client_codec_real_free_colormap;
 
3377
    codec_class->copy_colormap_and_free = xig_client_codec_real_copy_colormap_and_free;
 
3378
    codec_class->install_colormap = xig_client_codec_real_install_colormap;
 
3379
    codec_class->uninstall_colormap = xig_client_codec_real_uninstall_colormap;
 
3380
    codec_class->list_installed_colormaps = xig_client_codec_real_list_installed_colormaps;
 
3381
    codec_class->alloc_color = xig_client_codec_real_alloc_color;
 
3382
    codec_class->alloc_named_color = xig_client_codec_real_alloc_named_color;
 
3383
    codec_class->alloc_color_cells = xig_client_codec_real_alloc_color_cells;
 
3384
    codec_class->alloc_color_planes = xig_client_codec_real_alloc_color_planes;
 
3385
    codec_class->free_colors = xig_client_codec_real_free_colors;
 
3386
    codec_class->store_colors = xig_client_codec_real_store_colors;
 
3387
    codec_class->store_named_color = xig_client_codec_real_store_named_color;
 
3388
    codec_class->query_colors = xig_client_codec_real_query_colors;
 
3389
    codec_class->lookup_color = xig_client_codec_real_lookup_color;
 
3390
    codec_class->create_cursor = xig_client_codec_real_create_cursor;
 
3391
    codec_class->create_glyph_cursor = xig_client_codec_real_create_glyph_cursor;
 
3392
    codec_class->free_cursor = xig_client_codec_real_free_cursor;
 
3393
    codec_class->recolor_cursor = xig_client_codec_real_recolor_cursor;
 
3394
    codec_class->query_best_size = xig_client_codec_real_query_best_size;
 
3395
    codec_class->query_extension = xig_client_codec_real_query_extension;
 
3396
    codec_class->list_extensions = xig_client_codec_real_list_extensions;
 
3397
    codec_class->change_keyboard_mapping = xig_client_codec_real_change_keyboard_mapping;
 
3398
    codec_class->get_keyboard_mapping = xig_client_codec_real_get_keyboard_mapping;
 
3399
    codec_class->change_keyboard_control = xig_client_codec_real_change_keyboard_control;
 
3400
    codec_class->get_keyboard_control = xig_client_codec_real_get_keyboard_control;
 
3401
    codec_class->bell = xig_client_codec_real_bell;
 
3402
    codec_class->change_pointer_control = xig_client_codec_real_change_pointer_control;
 
3403
    codec_class->get_pointer_control = xig_client_codec_real_get_pointer_control;
 
3404
    codec_class->set_screen_saver = xig_client_codec_real_set_screen_saver;
 
3405
    codec_class->get_screen_saver = xig_client_codec_real_get_screen_saver;
 
3406
    codec_class->change_hosts = xig_client_codec_real_change_hosts;
 
3407
    codec_class->list_hosts = xig_client_codec_real_list_hosts;
 
3408
    codec_class->set_access_control = xig_client_codec_real_set_access_control;
 
3409
    codec_class->set_close_down_mode = xig_client_codec_real_set_close_down_mode;
 
3410
    codec_class->kill_client = xig_client_codec_real_kill_client;
 
3411
    codec_class->rotate_properties = xig_client_codec_real_rotate_properties;
 
3412
    codec_class->force_screen_saver = xig_client_codec_real_force_screen_saver;
 
3413
    codec_class->set_pointer_mapping = xig_client_codec_real_set_pointer_mapping;
 
3414
    codec_class->get_pointer_mapping = xig_client_codec_real_get_pointer_mapping;
 
3415
    codec_class->set_modifier_mapping = xig_client_codec_real_set_modifier_mapping;
 
3416
    codec_class->get_modifier_mapping = xig_client_codec_real_get_modifier_mapping;
 
3417
    codec_class->no_operation = xig_client_codec_real_no_operation;
 
3418
    codec_class->BIGREQ_enable = xig_client_codec_real_BIGREQ_enable;
 
3419
}