← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to xgcl-2/Events.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
xgcl-2/Events.c
 
1
/* Events.c           Hiep Huu Nguyen                         27 Aug 92 */
 
2
 
 
3
/*; Copyright (c) 1994 Hiep Huu Nguyen and The University of Texas at Austin.
 
4
 
 
5
; See the files gnu.license and dec.copyright .
 
6
 
 
7
; This program is free software; you can redistribute it and/or modify
 
8
; it under the terms of the GNU General Public License as published by
 
9
; the Free Software Foundation; either version 1, or (at your option)
 
10
; any later version.
 
11
 
 
12
; This program is distributed in the hope that it will be useful,
 
13
; but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
; GNU General Public License for more details.
 
16
 
 
17
; You should have received a copy of the GNU General Public License
 
18
; along with this program; if not, write to the Free Software
 
19
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
20
 
 
21
; Some of the files that interface to the Xlib are adapted from DEC/MIT files.
 
22
; See the file dec.copyright for details. */
 
23
 
 
24
#include <stdlib.h>
 
25
#include <X11/Xlib.h>
 
26
 
 
27
#include "include.h"
 
28
 
 
29
/********* XKeyEvent funcions *****/
 
30
 
 
31
int  make_XKeyEvent (){
 
32
          return ((int) calloc(1, sizeof(XKeyEvent)));
 
33
}
 
34
 
 
35
int  XKeyEvent_same_screen(i)
 
36
XKeyEvent* i;
 
37
{
 
38
          return(i->same_screen);
 
39
}
 
40
 
 
41
void set_XKeyEvent_same_screen(i, j)
 
42
XKeyEvent* i;
 
43
int j;
 
44
{
 
45
          i->same_screen = j;
 
46
}
 
47
 
 
48
int  XKeyEvent_keycode(i)
 
49
XKeyEvent* i;
 
50
{
 
51
          return(i->keycode);
 
52
}
 
53
 
 
54
void set_XKeyEvent_keycode(i, j)
 
55
XKeyEvent* i;
 
56
int j;
 
57
{
 
58
          i->keycode = j;
 
59
}
 
60
 
 
61
int  XKeyEvent_state(i)
 
62
XKeyEvent* i;
 
63
{
 
64
          return(i->state);
 
65
}
 
66
 
 
67
void set_XKeyEvent_state(i, j)
 
68
XKeyEvent* i;
 
69
int j;
 
70
{
 
71
          i->state = j;
 
72
}
 
73
 
 
74
int  XKeyEvent_y_root(i)
 
75
XKeyEvent* i;
 
76
{
 
77
          return(i->y_root);
 
78
}
 
79
 
 
80
void set_XKeyEvent_y_root(i, j)
 
81
XKeyEvent* i;
 
82
int j;
 
83
{
 
84
          i->y_root = j;
 
85
}
 
86
 
 
87
int  XKeyEvent_x_root(i)
 
88
XKeyEvent* i;
 
89
{
 
90
          return(i->x_root);
 
91
}
 
92
 
 
93
void set_XKeyEvent_x_root(i, j)
 
94
XKeyEvent* i;
 
95
int j;
 
96
{
 
97
          i->x_root = j;
 
98
}
 
99
 
 
100
int  XKeyEvent_y(i)
 
101
XKeyEvent* i;
 
102
{
 
103
          return(i->y);
 
104
}
 
105
 
 
106
void set_XKeyEvent_y(i, j)
 
107
XKeyEvent* i;
 
108
int j;
 
109
{
 
110
          i->y = j;
 
111
}
 
112
 
 
113
int  XKeyEvent_x(i)
 
114
XKeyEvent* i;
 
115
{
 
116
          return(i->x);
 
117
}
 
118
 
 
119
void set_XKeyEvent_x(i, j)
 
120
XKeyEvent* i;
 
121
int j;
 
122
{
 
123
          i->x = j;
 
124
}
 
125
 
 
126
int  XKeyEvent_time(i)
 
127
XKeyEvent* i;
 
128
{
 
129
          return(i->time);
 
130
}
 
131
 
 
132
void set_XKeyEvent_time(i, j)
 
133
XKeyEvent* i;
 
134
int j;
 
135
{
 
136
          i->time = j;
 
137
}
 
138
 
 
139
int  XKeyEvent_subwindow(i)
 
140
XKeyEvent* i;
 
141
{
 
142
          return(i->subwindow);
 
143
}
 
144
 
 
145
void set_XKeyEvent_subwindow(i, j)
 
146
XKeyEvent* i;
 
147
int j;
 
148
{
 
149
          i->subwindow = j;
 
150
}
 
151
 
 
152
int  XKeyEvent_root(i)
 
153
XKeyEvent* i;
 
154
{
 
155
          return(i->root);
 
156
}
 
157
 
 
158
void set_XKeyEvent_root(i, j)
 
159
XKeyEvent* i;
 
160
int j;
 
161
{
 
162
          i->root = j;
 
163
}
 
164
 
 
165
int  XKeyEvent_window(i)
 
166
XKeyEvent* i;
 
167
{
 
168
          return(i->window);
 
169
}
 
170
 
 
171
void set_XKeyEvent_window(i, j)
 
172
XKeyEvent* i;
 
173
int j;
 
174
{
 
175
          i->window = j;
 
176
}
 
177
 
 
178
Display *XKeyEvent_display(i)
 
179
XKeyEvent* i;
 
180
{
 
181
          return(i->display);
 
182
}
 
183
 
 
184
void set_XKeyEvent_display(i, j)
 
185
XKeyEvent* i;
 
186
Display *j;
 
187
{
 
188
          i->display = j;
 
189
}
 
190
 
 
191
int  XKeyEvent_send_event(i)
 
192
XKeyEvent* i;
 
193
{
 
194
          return(i->send_event);
 
195
}
 
196
 
 
197
void set_XKeyEvent_send_event(i, j)
 
198
XKeyEvent* i;
 
199
int j;
 
200
{
 
201
          i->send_event = j;
 
202
}
 
203
 
 
204
int  XKeyEvent_serial(i)
 
205
XKeyEvent* i;
 
206
{
 
207
          return(i->serial);
 
208
}
 
209
 
 
210
void set_XKeyEvent_serial(i, j)
 
211
XKeyEvent* i;
 
212
int j;
 
213
{
 
214
          i->serial = j;
 
215
}
 
216
 
 
217
int  XKeyEvent_type(i)
 
218
XKeyEvent* i;
 
219
{
 
220
          return(i->type);
 
221
}
 
222
 
 
223
void set_XKeyEvent_type(i, j)
 
224
XKeyEvent* i;
 
225
int j;
 
226
{
 
227
          i->type = j;
 
228
}
 
229
 
 
230
 
 
231
/********* XButtonEvent funcions *****/
 
232
 
 
233
int  make_XButtonEvent (){
 
234
          return ((int) calloc(1, sizeof(XButtonEvent)));
 
235
}
 
236
 
 
237
int  XButtonEvent_same_screen(i)
 
238
XButtonEvent* i;
 
239
{
 
240
          return(i->same_screen);
 
241
}
 
242
 
 
243
void set_XButtonEvent_same_screen(i, j)
 
244
XButtonEvent* i;
 
245
int j;
 
246
{
 
247
          i->same_screen = j;
 
248
}
 
249
 
 
250
int  XButtonEvent_button(i)
 
251
XButtonEvent* i;
 
252
{
 
253
          return(i->button);
 
254
}
 
255
 
 
256
void set_XButtonEvent_button(i, j)
 
257
XButtonEvent* i;
 
258
int j;
 
259
{
 
260
          i->button = j;
 
261
}
 
262
 
 
263
int  XButtonEvent_state(i)
 
264
XButtonEvent* i;
 
265
{
 
266
          return(i->state);
 
267
}
 
268
 
 
269
void set_XButtonEvent_state(i, j)
 
270
XButtonEvent* i;
 
271
int j;
 
272
{
 
273
          i->state = j;
 
274
}
 
275
 
 
276
int  XButtonEvent_y_root(i)
 
277
XButtonEvent* i;
 
278
{
 
279
          return(i->y_root);
 
280
}
 
281
 
 
282
void set_XButtonEvent_y_root(i, j)
 
283
XButtonEvent* i;
 
284
int j;
 
285
{
 
286
          i->y_root = j;
 
287
}
 
288
 
 
289
int  XButtonEvent_x_root(i)
 
290
XButtonEvent* i;
 
291
{
 
292
          return(i->x_root);
 
293
}
 
294
 
 
295
void set_XButtonEvent_x_root(i, j)
 
296
XButtonEvent* i;
 
297
int j;
 
298
{
 
299
          i->x_root = j;
 
300
}
 
301
 
 
302
int  XButtonEvent_y(i)
 
303
XButtonEvent* i;
 
304
{
 
305
          return(i->y);
 
306
}
 
307
 
 
308
void set_XButtonEvent_y(i, j)
 
309
XButtonEvent* i;
 
310
int j;
 
311
{
 
312
          i->y = j;
 
313
}
 
314
 
 
315
int  XButtonEvent_x(i)
 
316
XButtonEvent* i;
 
317
{
 
318
          return(i->x);
 
319
}
 
320
 
 
321
void set_XButtonEvent_x(i, j)
 
322
XButtonEvent* i;
 
323
int j;
 
324
{
 
325
          i->x = j;
 
326
}
 
327
 
 
328
int  XButtonEvent_time(i)
 
329
XButtonEvent* i;
 
330
{
 
331
          return(i->time);
 
332
}
 
333
 
 
334
void set_XButtonEvent_time(i, j)
 
335
XButtonEvent* i;
 
336
int j;
 
337
{
 
338
          i->time = j;
 
339
}
 
340
 
 
341
int  XButtonEvent_subwindow(i)
 
342
XButtonEvent* i;
 
343
{
 
344
          return(i->subwindow);
 
345
}
 
346
 
 
347
void set_XButtonEvent_subwindow(i, j)
 
348
XButtonEvent* i;
 
349
int j;
 
350
{
 
351
          i->subwindow = j;
 
352
}
 
353
 
 
354
int  XButtonEvent_root(i)
 
355
XButtonEvent* i;
 
356
{
 
357
          return(i->root);
 
358
}
 
359
 
 
360
void set_XButtonEvent_root(i, j)
 
361
XButtonEvent* i;
 
362
int j;
 
363
{
 
364
          i->root = j;
 
365
}
 
366
 
 
367
int  XButtonEvent_window(i)
 
368
XButtonEvent* i;
 
369
{
 
370
          return(i->window);
 
371
}
 
372
 
 
373
void set_XButtonEvent_window(i, j)
 
374
XButtonEvent* i;
 
375
int j;
 
376
{
 
377
          i->window = j;
 
378
}
 
379
 
 
380
Display *XButtonEvent_display(i)
 
381
XButtonEvent* i;
 
382
{
 
383
          return(i->display);
 
384
}
 
385
 
 
386
void set_XButtonEvent_display(i, j)
 
387
XButtonEvent* i;
 
388
Display *j;
 
389
{
 
390
          i->display = j;
 
391
}
 
392
 
 
393
int  XButtonEvent_send_event(i)
 
394
XButtonEvent* i;
 
395
{
 
396
          return(i->send_event);
 
397
}
 
398
 
 
399
void set_XButtonEvent_send_event(i, j)
 
400
XButtonEvent* i;
 
401
int j;
 
402
{
 
403
          i->send_event = j;
 
404
}
 
405
 
 
406
int  XButtonEvent_serial(i)
 
407
XButtonEvent* i;
 
408
{
 
409
          return(i->serial);
 
410
}
 
411
 
 
412
void set_XButtonEvent_serial(i, j)
 
413
XButtonEvent* i;
 
414
int j;
 
415
{
 
416
          i->serial = j;
 
417
}
 
418
 
 
419
int  XButtonEvent_type(i)
 
420
XButtonEvent* i;
 
421
{
 
422
          return(i->type);
 
423
}
 
424
 
 
425
void set_XButtonEvent_type(i, j)
 
426
XButtonEvent* i;
 
427
int j;
 
428
{
 
429
          i->type = j;
 
430
}
 
431
 
 
432
 
 
433
/********* XMotionEvent funcions *****/
 
434
 
 
435
int  make_XMotionEvent (){
 
436
          return ((int) calloc(1, sizeof(XMotionEvent)));
 
437
}
 
438
 
 
439
int  XMotionEvent_same_screen(i)
 
440
XMotionEvent* i;
 
441
{
 
442
          return(i->same_screen);
 
443
}
 
444
 
 
445
void set_XMotionEvent_same_screen(i, j)
 
446
XMotionEvent* i;
 
447
int j;
 
448
{
 
449
          i->same_screen = j;
 
450
}
 
451
 
 
452
char XMotionEvent_is_hint(i)
 
453
XMotionEvent* i;
 
454
{
 
455
          return(i->is_hint);
 
456
}
 
457
 
 
458
void set_XMotionEvent_is_hint(i, j)
 
459
XMotionEvent* i;
 
460
char j;
 
461
{
 
462
          i->is_hint = j;
 
463
}
 
464
 
 
465
int  XMotionEvent_state(i)
 
466
XMotionEvent* i;
 
467
{
 
468
          return(i->state);
 
469
}
 
470
 
 
471
void set_XMotionEvent_state(i, j)
 
472
XMotionEvent* i;
 
473
int j;
 
474
{
 
475
          i->state = j;
 
476
}
 
477
 
 
478
int  XMotionEvent_y_root(i)
 
479
XMotionEvent* i;
 
480
{
 
481
          return(i->y_root);
 
482
}
 
483
 
 
484
void set_XMotionEvent_y_root(i, j)
 
485
XMotionEvent* i;
 
486
int j;
 
487
{
 
488
          i->y_root = j;
 
489
}
 
490
 
 
491
int  XMotionEvent_x_root(i)
 
492
XMotionEvent* i;
 
493
{
 
494
          return(i->x_root);
 
495
}
 
496
 
 
497
void set_XMotionEvent_x_root(i, j)
 
498
XMotionEvent* i;
 
499
int j;
 
500
{
 
501
          i->x_root = j;
 
502
}
 
503
 
 
504
int  XMotionEvent_y(i)
 
505
XMotionEvent* i;
 
506
{
 
507
          return(i->y);
 
508
}
 
509
 
 
510
void set_XMotionEvent_y(i, j)
 
511
XMotionEvent* i;
 
512
int j;
 
513
{
 
514
          i->y = j;
 
515
}
 
516
 
 
517
int  XMotionEvent_x(i)
 
518
XMotionEvent* i;
 
519
{
 
520
          return(i->x);
 
521
}
 
522
 
 
523
void set_XMotionEvent_x(i, j)
 
524
XMotionEvent* i;
 
525
int j;
 
526
{
 
527
          i->x = j;
 
528
}
 
529
 
 
530
int  XMotionEvent_time(i)
 
531
XMotionEvent* i;
 
532
{
 
533
          return(i->time);
 
534
}
 
535
 
 
536
void set_XMotionEvent_time(i, j)
 
537
XMotionEvent* i;
 
538
int j;
 
539
{
 
540
          i->time = j;
 
541
}
 
542
 
 
543
int  XMotionEvent_subwindow(i)
 
544
XMotionEvent* i;
 
545
{
 
546
          return(i->subwindow);
 
547
}
 
548
 
 
549
void set_XMotionEvent_subwindow(i, j)
 
550
XMotionEvent* i;
 
551
int j;
 
552
{
 
553
          i->subwindow = j;
 
554
}
 
555
 
 
556
int  XMotionEvent_root(i)
 
557
XMotionEvent* i;
 
558
{
 
559
          return(i->root);
 
560
}
 
561
 
 
562
void set_XMotionEvent_root(i, j)
 
563
XMotionEvent* i;
 
564
int j;
 
565
{
 
566
          i->root = j;
 
567
}
 
568
 
 
569
int  XMotionEvent_window(i)
 
570
XMotionEvent* i;
 
571
{
 
572
          return(i->window);
 
573
}
 
574
 
 
575
void set_XMotionEvent_window(i, j)
 
576
XMotionEvent* i;
 
577
int j;
 
578
{
 
579
          i->window = j;
 
580
}
 
581
 
 
582
Display *XMotionEvent_display(i)
 
583
XMotionEvent* i;
 
584
{
 
585
          return(i->display);
 
586
}
 
587
 
 
588
void set_XMotionEvent_display(i, j)
 
589
XMotionEvent* i;
 
590
Display *j;
 
591
{
 
592
          i->display = j;
 
593
}
 
594
 
 
595
int  XMotionEvent_send_event(i)
 
596
XMotionEvent* i;
 
597
{
 
598
          return(i->send_event);
 
599
}
 
600
 
 
601
void set_XMotionEvent_send_event(i, j)
 
602
XMotionEvent* i;
 
603
int j;
 
604
{
 
605
          i->send_event = j;
 
606
}
 
607
 
 
608
int  XMotionEvent_serial(i)
 
609
XMotionEvent* i;
 
610
{
 
611
          return(i->serial);
 
612
}
 
613
 
 
614
void set_XMotionEvent_serial(i, j)
 
615
XMotionEvent* i;
 
616
int j;
 
617
{
 
618
          i->serial = j;
 
619
}
 
620
 
 
621
int  XMotionEvent_type(i)
 
622
XMotionEvent* i;
 
623
{
 
624
          return(i->type);
 
625
}
 
626
 
 
627
void set_XMotionEvent_type(i, j)
 
628
XMotionEvent* i;
 
629
int j;
 
630
{
 
631
          i->type = j;
 
632
}
 
633
 
 
634
 
 
635
/********* XCrossingEvent funcions *****/
 
636
 
 
637
int  make_XCrossingEvent (){
 
638
          return ((int) calloc(1, sizeof(XCrossingEvent)));
 
639
}
 
640
 
 
641
int  XCrossingEvent_state(i)
 
642
XCrossingEvent* i;
 
643
{
 
644
          return(i->state);
 
645
}
 
646
 
 
647
void set_XCrossingEvent_state(i, j)
 
648
XCrossingEvent* i;
 
649
int j;
 
650
{
 
651
          i->state = j;
 
652
}
 
653
 
 
654
int  XCrossingEvent_focus(i)
 
655
XCrossingEvent* i;
 
656
{
 
657
          return(i->focus);
 
658
}
 
659
 
 
660
void set_XCrossingEvent_focus(i, j)
 
661
XCrossingEvent* i;
 
662
int j;
 
663
{
 
664
          i->focus = j;
 
665
}
 
666
 
 
667
int  XCrossingEvent_same_screen(i)
 
668
XCrossingEvent* i;
 
669
{
 
670
          return(i->same_screen);
 
671
}
 
672
 
 
673
void set_XCrossingEvent_same_screen(i, j)
 
674
XCrossingEvent* i;
 
675
int j;
 
676
{
 
677
          i->same_screen = j;
 
678
}
 
679
 
 
680
int  XCrossingEvent_detail(i)
 
681
XCrossingEvent* i;
 
682
{
 
683
          return(i->detail);
 
684
}
 
685
 
 
686
void set_XCrossingEvent_detail(i, j)
 
687
XCrossingEvent* i;
 
688
int j;
 
689
{
 
690
          i->detail = j;
 
691
}
 
692
 
 
693
int  XCrossingEvent_mode(i)
 
694
XCrossingEvent* i;
 
695
{
 
696
          return(i->mode);
 
697
}
 
698
 
 
699
void set_XCrossingEvent_mode(i, j)
 
700
XCrossingEvent* i;
 
701
int j;
 
702
{
 
703
          i->mode = j;
 
704
}
 
705
 
 
706
int  XCrossingEvent_y_root(i)
 
707
XCrossingEvent* i;
 
708
{
 
709
          return(i->y_root);
 
710
}
 
711
 
 
712
void set_XCrossingEvent_y_root(i, j)
 
713
XCrossingEvent* i;
 
714
int j;
 
715
{
 
716
          i->y_root = j;
 
717
}
 
718
 
 
719
int  XCrossingEvent_x_root(i)
 
720
XCrossingEvent* i;
 
721
{
 
722
          return(i->x_root);
 
723
}
 
724
 
 
725
void set_XCrossingEvent_x_root(i, j)
 
726
XCrossingEvent* i;
 
727
int j;
 
728
{
 
729
          i->x_root = j;
 
730
}
 
731
 
 
732
int  XCrossingEvent_y(i)
 
733
XCrossingEvent* i;
 
734
{
 
735
          return(i->y);
 
736
}
 
737
 
 
738
void set_XCrossingEvent_y(i, j)
 
739
XCrossingEvent* i;
 
740
int j;
 
741
{
 
742
          i->y = j;
 
743
}
 
744
 
 
745
int  XCrossingEvent_x(i)
 
746
XCrossingEvent* i;
 
747
{
 
748
          return(i->x);
 
749
}
 
750
 
 
751
void set_XCrossingEvent_x(i, j)
 
752
XCrossingEvent* i;
 
753
int j;
 
754
{
 
755
          i->x = j;
 
756
}
 
757
 
 
758
int  XCrossingEvent_time(i)
 
759
XCrossingEvent* i;
 
760
{
 
761
          return(i->time);
 
762
}
 
763
 
 
764
void set_XCrossingEvent_time(i, j)
 
765
XCrossingEvent* i;
 
766
int j;
 
767
{
 
768
          i->time = j;
 
769
}
 
770
 
 
771
int  XCrossingEvent_subwindow(i)
 
772
XCrossingEvent* i;
 
773
{
 
774
          return(i->subwindow);
 
775
}
 
776
 
 
777
void set_XCrossingEvent_subwindow(i, j)
 
778
XCrossingEvent* i;
 
779
int j;
 
780
{
 
781
          i->subwindow = j;
 
782
}
 
783
 
 
784
int  XCrossingEvent_root(i)
 
785
XCrossingEvent* i;
 
786
{
 
787
          return(i->root);
 
788
}
 
789
 
 
790
void set_XCrossingEvent_root(i, j)
 
791
XCrossingEvent* i;
 
792
int j;
 
793
{
 
794
          i->root = j;
 
795
}
 
796
 
 
797
int  XCrossingEvent_window(i)
 
798
XCrossingEvent* i;
 
799
{
 
800
          return(i->window);
 
801
}
 
802
 
 
803
void set_XCrossingEvent_window(i, j)
 
804
XCrossingEvent* i;
 
805
int j;
 
806
{
 
807
          i->window = j;
 
808
}
 
809
 
 
810
Display *XCrossingEvent_display(i)
 
811
XCrossingEvent* i;
 
812
{
 
813
          return(i->display);
 
814
}
 
815
 
 
816
void set_XCrossingEvent_display(i, j)
 
817
XCrossingEvent* i;
 
818
Display *j;
 
819
{
 
820
          i->display = j;
 
821
}
 
822
 
 
823
int  XCrossingEvent_send_event(i)
 
824
XCrossingEvent* i;
 
825
{
 
826
          return(i->send_event);
 
827
}
 
828
 
 
829
void set_XCrossingEvent_send_event(i, j)
 
830
XCrossingEvent* i;
 
831
int j;
 
832
{
 
833
          i->send_event = j;
 
834
}
 
835
 
 
836
int  XCrossingEvent_serial(i)
 
837
XCrossingEvent* i;
 
838
{
 
839
          return(i->serial);
 
840
}
 
841
 
 
842
void set_XCrossingEvent_serial(i, j)
 
843
XCrossingEvent* i;
 
844
int j;
 
845
{
 
846
          i->serial = j;
 
847
}
 
848
 
 
849
int  XCrossingEvent_type(i)
 
850
XCrossingEvent* i;
 
851
{
 
852
          return(i->type);
 
853
}
 
854
 
 
855
void set_XCrossingEvent_type(i, j)
 
856
XCrossingEvent* i;
 
857
int j;
 
858
{
 
859
          i->type = j;
 
860
}
 
861
 
 
862
 
 
863
/********* XFocusChangeEvent funcions *****/
 
864
 
 
865
int  make_XFocusChangeEvent (){
 
866
          return ((int) calloc(1, sizeof(XFocusChangeEvent)));
 
867
}
 
868
 
 
869
int  XFocusChangeEvent_detail(i)
 
870
XFocusChangeEvent* i;
 
871
{
 
872
          return(i->detail);
 
873
}
 
874
 
 
875
void set_XFocusChangeEvent_detail(i, j)
 
876
XFocusChangeEvent* i;
 
877
int j;
 
878
{
 
879
          i->detail = j;
 
880
}
 
881
 
 
882
int  XFocusChangeEvent_mode(i)
 
883
XFocusChangeEvent* i;
 
884
{
 
885
          return(i->mode);
 
886
}
 
887
 
 
888
void set_XFocusChangeEvent_mode(i, j)
 
889
XFocusChangeEvent* i;
 
890
int j;
 
891
{
 
892
          i->mode = j;
 
893
}
 
894
 
 
895
int  XFocusChangeEvent_window(i)
 
896
XFocusChangeEvent* i;
 
897
{
 
898
          return(i->window);
 
899
}
 
900
 
 
901
void set_XFocusChangeEvent_window(i, j)
 
902
XFocusChangeEvent* i;
 
903
int j;
 
904
{
 
905
          i->window = j;
 
906
}
 
907
 
 
908
Display *XFocusChangeEvent_display(i)
 
909
XFocusChangeEvent* i;
 
910
{
 
911
          return(i->display);
 
912
}
 
913
 
 
914
void set_XFocusChangeEvent_display(i, j)
 
915
XFocusChangeEvent* i;
 
916
Display *j;
 
917
{
 
918
          i->display = j;
 
919
}
 
920
 
 
921
int  XFocusChangeEvent_send_event(i)
 
922
XFocusChangeEvent* i;
 
923
{
 
924
          return(i->send_event);
 
925
}
 
926
 
 
927
void set_XFocusChangeEvent_send_event(i, j)
 
928
XFocusChangeEvent* i;
 
929
int j;
 
930
{
 
931
          i->send_event = j;
 
932
}
 
933
 
 
934
int  XFocusChangeEvent_serial(i)
 
935
XFocusChangeEvent* i;
 
936
{
 
937
          return(i->serial);
 
938
}
 
939
 
 
940
void set_XFocusChangeEvent_serial(i, j)
 
941
XFocusChangeEvent* i;
 
942
int j;
 
943
{
 
944
          i->serial = j;
 
945
}
 
946
 
 
947
int  XFocusChangeEvent_type(i)
 
948
XFocusChangeEvent* i;
 
949
{
 
950
          return(i->type);
 
951
}
 
952
 
 
953
void set_XFocusChangeEvent_type(i, j)
 
954
XFocusChangeEvent* i;
 
955
int j;
 
956
{
 
957
          i->type = j;
 
958
}
 
959
 
 
960
 
 
961
/********* XKeymapEvent funcions *****/
 
962
 
 
963
int  make_XKeymapEvent (){
 
964
          return ((int) calloc(1, sizeof(XKeymapEvent)));
 
965
}
 
966
 
 
967
char* XKeymapEvent_key_vector(i)
 
968
XKeymapEvent* i;
 
969
{
 
970
          return(i->key_vector);
 
971
}
 
972
int  XKeymapEvent_window(i)
 
973
XKeymapEvent* i;
 
974
{
 
975
          return(i->window);
 
976
}
 
977
 
 
978
void set_XKeymapEvent_window(i, j)
 
979
XKeymapEvent* i;
 
980
int j;
 
981
{
 
982
          i->window = j;
 
983
}
 
984
 
 
985
Display * XKeymapEvent_display(i)
 
986
XKeymapEvent* i;
 
987
{
 
988
          return(i->display);
 
989
}
 
990
 
 
991
void set_XKeymapEvent_display(i, j)
 
992
XKeymapEvent* i;
 
993
Display *j;
 
994
{
 
995
          i->display = j;
 
996
}
 
997
 
 
998
int  XKeymapEvent_send_event(i)
 
999
XKeymapEvent* i;
 
1000
{
 
1001
          return(i->send_event);
 
1002
}
 
1003
 
 
1004
void set_XKeymapEvent_send_event(i, j)
 
1005
XKeymapEvent* i;
 
1006
int j;
 
1007
{
 
1008
          i->send_event = j;
 
1009
}
 
1010
 
 
1011
int  XKeymapEvent_serial(i)
 
1012
XKeymapEvent* i;
 
1013
{
 
1014
          return(i->serial);
 
1015
}
 
1016
 
 
1017
void set_XKeymapEvent_serial(i, j)
 
1018
XKeymapEvent* i;
 
1019
int j;
 
1020
{
 
1021
          i->serial = j;
 
1022
}
 
1023
 
 
1024
int  XKeymapEvent_type(i)
 
1025
XKeymapEvent* i;
 
1026
{
 
1027
          return(i->type);
 
1028
}
 
1029
 
 
1030
void set_XKeymapEvent_type(i, j)
 
1031
XKeymapEvent* i;
 
1032
int j;
 
1033
{
 
1034
          i->type = j;
 
1035
}
 
1036
 
 
1037
 
 
1038
/********* XExposeEvent funcions *****/
 
1039
 
 
1040
int  make_XExposeEvent (){
 
1041
          return ((int) calloc(1, sizeof(XExposeEvent)));
 
1042
}
 
1043
 
 
1044
int  XExposeEvent_count(i)
 
1045
XExposeEvent* i;
 
1046
{
 
1047
          return(i->count);
 
1048
}
 
1049
 
 
1050
void set_XExposeEvent_count(i, j)
 
1051
XExposeEvent* i;
 
1052
int j;
 
1053
{
 
1054
          i->count = j;
 
1055
}
 
1056
 
 
1057
int  XExposeEvent_height(i)
 
1058
XExposeEvent* i;
 
1059
{
 
1060
          return(i->height);
 
1061
}
 
1062
 
 
1063
void set_XExposeEvent_height(i, j)
 
1064
XExposeEvent* i;
 
1065
int j;
 
1066
{
 
1067
          i->height = j;
 
1068
}
 
1069
 
 
1070
int  XExposeEvent_width(i)
 
1071
XExposeEvent* i;
 
1072
{
 
1073
          return(i->width);
 
1074
}
 
1075
 
 
1076
void set_XExposeEvent_width(i, j)
 
1077
XExposeEvent* i;
 
1078
int j;
 
1079
{
 
1080
          i->width = j;
 
1081
}
 
1082
 
 
1083
int  XExposeEvent_y(i)
 
1084
XExposeEvent* i;
 
1085
{
 
1086
          return(i->y);
 
1087
}
 
1088
 
 
1089
void set_XExposeEvent_y(i, j)
 
1090
XExposeEvent* i;
 
1091
int j;
 
1092
{
 
1093
          i->y = j;
 
1094
}
 
1095
 
 
1096
int  XExposeEvent_x(i)
 
1097
XExposeEvent* i;
 
1098
{
 
1099
          return(i->x);
 
1100
}
 
1101
 
 
1102
void set_XExposeEvent_x(i, j)
 
1103
XExposeEvent* i;
 
1104
int j;
 
1105
{
 
1106
          i->x = j;
 
1107
}
 
1108
 
 
1109
int  XExposeEvent_window(i)
 
1110
XExposeEvent* i;
 
1111
{
 
1112
          return(i->window);
 
1113
}
 
1114
 
 
1115
void set_XExposeEvent_window(i, j)
 
1116
XExposeEvent* i;
 
1117
int j;
 
1118
{
 
1119
          i->window = j;
 
1120
}
 
1121
 
 
1122
Display *XExposeEvent_display(i)
 
1123
XExposeEvent* i;
 
1124
{
 
1125
          return(i->display);
 
1126
}
 
1127
 
 
1128
void set_XExposeEvent_display(i, j)
 
1129
XExposeEvent* i;
 
1130
Display *j;
 
1131
{
 
1132
          i->display = j;
 
1133
}
 
1134
 
 
1135
int  XExposeEvent_send_event(i)
 
1136
XExposeEvent* i;
 
1137
{
 
1138
          return(i->send_event);
 
1139
}
 
1140
 
 
1141
void set_XExposeEvent_send_event(i, j)
 
1142
XExposeEvent* i;
 
1143
int j;
 
1144
{
 
1145
          i->send_event = j;
 
1146
}
 
1147
 
 
1148
int  XExposeEvent_serial(i)
 
1149
XExposeEvent* i;
 
1150
{
 
1151
          return(i->serial);
 
1152
}
 
1153
 
 
1154
void set_XExposeEvent_serial(i, j)
 
1155
XExposeEvent* i;
 
1156
int j;
 
1157
{
 
1158
          i->serial = j;
 
1159
}
 
1160
 
 
1161
int  XExposeEvent_type(i)
 
1162
XExposeEvent* i;
 
1163
{
 
1164
          return(i->type);
 
1165
}
 
1166
 
 
1167
void set_XExposeEvent_type(i, j)
 
1168
XExposeEvent* i;
 
1169
int j;
 
1170
{
 
1171
          i->type = j;
 
1172
}
 
1173
 
 
1174
 
 
1175
/********* XGraphicsExposeEvent funcions *****/
 
1176
 
 
1177
int  make_XGraphicsExposeEvent (){
 
1178
          return ((int) calloc(1, sizeof(XGraphicsExposeEvent)));
 
1179
}
 
1180
 
 
1181
int  XGraphicsExposeEvent_minor_code(i)
 
1182
XGraphicsExposeEvent* i;
 
1183
{
 
1184
          return(i->minor_code);
 
1185
}
 
1186
 
 
1187
void set_XGraphicsExposeEvent_minor_code(i, j)
 
1188
XGraphicsExposeEvent* i;
 
1189
int j;
 
1190
{
 
1191
          i->minor_code = j;
 
1192
}
 
1193
 
 
1194
int  XGraphicsExposeEvent_major_code(i)
 
1195
XGraphicsExposeEvent* i;
 
1196
{
 
1197
          return(i->major_code);
 
1198
}
 
1199
 
 
1200
void set_XGraphicsExposeEvent_major_code(i, j)
 
1201
XGraphicsExposeEvent* i;
 
1202
int j;
 
1203
{
 
1204
          i->major_code = j;
 
1205
}
 
1206
 
 
1207
int  XGraphicsExposeEvent_count(i)
 
1208
XGraphicsExposeEvent* i;
 
1209
{
 
1210
          return(i->count);
 
1211
}
 
1212
 
 
1213
void set_XGraphicsExposeEvent_count(i, j)
 
1214
XGraphicsExposeEvent* i;
 
1215
int j;
 
1216
{
 
1217
          i->count = j;
 
1218
}
 
1219
 
 
1220
int  XGraphicsExposeEvent_height(i)
 
1221
XGraphicsExposeEvent* i;
 
1222
{
 
1223
          return(i->height);
 
1224
}
 
1225
 
 
1226
void set_XGraphicsExposeEvent_height(i, j)
 
1227
XGraphicsExposeEvent* i;
 
1228
int j;
 
1229
{
 
1230
          i->height = j;
 
1231
}
 
1232
 
 
1233
int  XGraphicsExposeEvent_width(i)
 
1234
XGraphicsExposeEvent* i;
 
1235
{
 
1236
          return(i->width);
 
1237
}
 
1238
 
 
1239
void set_XGraphicsExposeEvent_width(i, j)
 
1240
XGraphicsExposeEvent* i;
 
1241
int j;
 
1242
{
 
1243
          i->width = j;
 
1244
}
 
1245
 
 
1246
int  XGraphicsExposeEvent_y(i)
 
1247
XGraphicsExposeEvent* i;
 
1248
{
 
1249
          return(i->y);
 
1250
}
 
1251
 
 
1252
void set_XGraphicsExposeEvent_y(i, j)
 
1253
XGraphicsExposeEvent* i;
 
1254
int j;
 
1255
{
 
1256
          i->y = j;
 
1257
}
 
1258
 
 
1259
int  XGraphicsExposeEvent_x(i)
 
1260
XGraphicsExposeEvent* i;
 
1261
{
 
1262
          return(i->x);
 
1263
}
 
1264
 
 
1265
void set_XGraphicsExposeEvent_x(i, j)
 
1266
XGraphicsExposeEvent* i;
 
1267
int j;
 
1268
{
 
1269
          i->x = j;
 
1270
}
 
1271
 
 
1272
Drawable XGraphicsExposeEvent_drawable(i)
 
1273
XGraphicsExposeEvent* i;
 
1274
{
 
1275
          return(i->drawable);
 
1276
}
 
1277
 
 
1278
void set_XGraphicsExposeEvent_drawable(i, j)
 
1279
XGraphicsExposeEvent* i;
 
1280
Drawable j;
 
1281
{
 
1282
          i->drawable = j;
 
1283
}
 
1284
 
 
1285
Display * XGraphicsExposeEvent_display(i)
 
1286
XGraphicsExposeEvent* i;
 
1287
{
 
1288
          return(i->display);
 
1289
}
 
1290
 
 
1291
void set_XGraphicsExposeEvent_display(i, j)
 
1292
XGraphicsExposeEvent* i;
 
1293
Display *j;
 
1294
{
 
1295
          i->display = j;
 
1296
}
 
1297
 
 
1298
int  XGraphicsExposeEvent_send_event(i)
 
1299
XGraphicsExposeEvent* i;
 
1300
{
 
1301
          return(i->send_event);
 
1302
}
 
1303
 
 
1304
void set_XGraphicsExposeEvent_send_event(i, j)
 
1305
XGraphicsExposeEvent* i;
 
1306
int j;
 
1307
{
 
1308
          i->send_event = j;
 
1309
}
 
1310
 
 
1311
int  XGraphicsExposeEvent_serial(i)
 
1312
XGraphicsExposeEvent* i;
 
1313
{
 
1314
          return(i->serial);
 
1315
}
 
1316
 
 
1317
void set_XGraphicsExposeEvent_serial(i, j)
 
1318
XGraphicsExposeEvent* i;
 
1319
int j;
 
1320
{
 
1321
          i->serial = j;
 
1322
}
 
1323
 
 
1324
int  XGraphicsExposeEvent_type(i)
 
1325
XGraphicsExposeEvent* i;
 
1326
{
 
1327
          return(i->type);
 
1328
}
 
1329
 
 
1330
void set_XGraphicsExposeEvent_type(i, j)
 
1331
XGraphicsExposeEvent* i;
 
1332
int j;
 
1333
{
 
1334
          i->type = j;
 
1335
}
 
1336
 
 
1337
 
 
1338
/********* XNoExposeEvent funcions *****/
 
1339
 
 
1340
int  make_XNoExposeEvent (){
 
1341
          return ((int) calloc(1, sizeof(XNoExposeEvent)));
 
1342
}
 
1343
 
 
1344
int  XNoExposeEvent_minor_code(i)
 
1345
XNoExposeEvent* i;
 
1346
{
 
1347
          return(i->minor_code);
 
1348
}
 
1349
 
 
1350
void set_XNoExposeEvent_minor_code(i, j)
 
1351
XNoExposeEvent* i;
 
1352
int j;
 
1353
{
 
1354
          i->minor_code = j;
 
1355
}
 
1356
 
 
1357
int  XNoExposeEvent_major_code(i)
 
1358
XNoExposeEvent* i;
 
1359
{
 
1360
          return(i->major_code);
 
1361
}
 
1362
 
 
1363
void set_XNoExposeEvent_major_code(i, j)
 
1364
XNoExposeEvent* i;
 
1365
int j;
 
1366
{
 
1367
          i->major_code = j;
 
1368
}
 
1369
 
 
1370
Drawable XNoExposeEvent_drawable(i)
 
1371
XNoExposeEvent* i;
 
1372
{
 
1373
          return(i->drawable);
 
1374
}
 
1375
 
 
1376
void set_XNoExposeEvent_drawable(i, j)
 
1377
XNoExposeEvent* i;
 
1378
Drawable j;
 
1379
{
 
1380
          i->drawable = j;
 
1381
}
 
1382
 
 
1383
Display *XNoExposeEvent_display(i)
 
1384
XNoExposeEvent* i;
 
1385
{
 
1386
          return(i->display);
 
1387
}
 
1388
 
 
1389
void set_XNoExposeEvent_display(i, j)
 
1390
XNoExposeEvent* i;
 
1391
Display *j;
 
1392
{
 
1393
          i->display = j;
 
1394
}
 
1395
 
 
1396
int  XNoExposeEvent_send_event(i)
 
1397
XNoExposeEvent* i;
 
1398
{
 
1399
          return(i->send_event);
 
1400
}
 
1401
 
 
1402
void set_XNoExposeEvent_send_event(i, j)
 
1403
XNoExposeEvent* i;
 
1404
int j;
 
1405
{
 
1406
          i->send_event = j;
 
1407
}
 
1408
 
 
1409
int  XNoExposeEvent_serial(i)
 
1410
XNoExposeEvent* i;
 
1411
{
 
1412
          return(i->serial);
 
1413
}
 
1414
 
 
1415
void set_XNoExposeEvent_serial(i, j)
 
1416
XNoExposeEvent* i;
 
1417
int j;
 
1418
{
 
1419
          i->serial = j;
 
1420
}
 
1421
 
 
1422
int  XNoExposeEvent_type(i)
 
1423
XNoExposeEvent* i;
 
1424
{
 
1425
          return(i->type);
 
1426
}
 
1427
 
 
1428
void set_XNoExposeEvent_type(i, j)
 
1429
XNoExposeEvent* i;
 
1430
int j;
 
1431
{
 
1432
          i->type = j;
 
1433
}
 
1434
 
 
1435
 
 
1436
/********* XVisibilityEvent funcions *****/
 
1437
 
 
1438
int  make_XVisibilityEvent (){
 
1439
          return ((int) calloc(1, sizeof(XVisibilityEvent)));
 
1440
}
 
1441
 
 
1442
int  XVisibilityEvent_state(i)
 
1443
XVisibilityEvent* i;
 
1444
{
 
1445
          return(i->state);
 
1446
}
 
1447
 
 
1448
void set_XVisibilityEvent_state(i, j)
 
1449
XVisibilityEvent* i;
 
1450
int j;
 
1451
{
 
1452
          i->state = j;
 
1453
}
 
1454
 
 
1455
int  XVisibilityEvent_window(i)
 
1456
XVisibilityEvent* i;
 
1457
{
 
1458
          return(i->window);
 
1459
}
 
1460
 
 
1461
void set_XVisibilityEvent_window(i, j)
 
1462
XVisibilityEvent* i;
 
1463
int j;
 
1464
{
 
1465
          i->window = j;
 
1466
}
 
1467
 
 
1468
Display *XVisibilityEvent_display(i)
 
1469
XVisibilityEvent* i;
 
1470
{
 
1471
          return(i->display);
 
1472
}
 
1473
 
 
1474
void set_XVisibilityEvent_display(i, j)
 
1475
XVisibilityEvent* i;
 
1476
Display *j;
 
1477
{
 
1478
          i->display = j;
 
1479
}
 
1480
 
 
1481
int  XVisibilityEvent_send_event(i)
 
1482
XVisibilityEvent* i;
 
1483
{
 
1484
          return(i->send_event);
 
1485
}
 
1486
 
 
1487
void set_XVisibilityEvent_send_event(i, j)
 
1488
XVisibilityEvent* i;
 
1489
int j;
 
1490
{
 
1491
          i->send_event = j;
 
1492
}
 
1493
 
 
1494
int  XVisibilityEvent_serial(i)
 
1495
XVisibilityEvent* i;
 
1496
{
 
1497
          return(i->serial);
 
1498
}
 
1499
 
 
1500
void set_XVisibilityEvent_serial(i, j)
 
1501
XVisibilityEvent* i;
 
1502
int j;
 
1503
{
 
1504
          i->serial = j;
 
1505
}
 
1506
 
 
1507
int  XVisibilityEvent_type(i)
 
1508
XVisibilityEvent* i;
 
1509
{
 
1510
          return(i->type);
 
1511
}
 
1512
 
 
1513
void set_XVisibilityEvent_type(i, j)
 
1514
XVisibilityEvent* i;
 
1515
int j;
 
1516
{
 
1517
          i->type = j;
 
1518
}
 
1519
 
 
1520
 
 
1521
/********* XCreateWindowEvent funcions *****/
 
1522
 
 
1523
int  make_XCreateWindowEvent (){
 
1524
          return ((int) calloc(1, sizeof(XCreateWindowEvent)));
 
1525
}
 
1526
 
 
1527
int  XCreateWindowEvent_override_redirect(i)
 
1528
XCreateWindowEvent* i;
 
1529
{
 
1530
          return(i->override_redirect);
 
1531
}
 
1532
 
 
1533
void set_XCreateWindowEvent_override_redirect(i, j)
 
1534
XCreateWindowEvent* i;
 
1535
int j;
 
1536
{
 
1537
          i->override_redirect = j;
 
1538
}
 
1539
 
 
1540
int  XCreateWindowEvent_border_width(i)
 
1541
XCreateWindowEvent* i;
 
1542
{
 
1543
          return(i->border_width);
 
1544
}
 
1545
 
 
1546
void set_XCreateWindowEvent_border_width(i, j)
 
1547
XCreateWindowEvent* i;
 
1548
int j;
 
1549
{
 
1550
          i->border_width = j;
 
1551
}
 
1552
 
 
1553
int  XCreateWindowEvent_height(i)
 
1554
XCreateWindowEvent* i;
 
1555
{
 
1556
          return(i->height);
 
1557
}
 
1558
 
 
1559
void set_XCreateWindowEvent_height(i, j)
 
1560
XCreateWindowEvent* i;
 
1561
int j;
 
1562
{
 
1563
          i->height = j;
 
1564
}
 
1565
 
 
1566
int  XCreateWindowEvent_width(i)
 
1567
XCreateWindowEvent* i;
 
1568
{
 
1569
          return(i->width);
 
1570
}
 
1571
 
 
1572
void set_XCreateWindowEvent_width(i, j)
 
1573
XCreateWindowEvent* i;
 
1574
int j;
 
1575
{
 
1576
          i->width = j;
 
1577
}
 
1578
 
 
1579
int  XCreateWindowEvent_y(i)
 
1580
XCreateWindowEvent* i;
 
1581
{
 
1582
          return(i->y);
 
1583
}
 
1584
 
 
1585
void set_XCreateWindowEvent_y(i, j)
 
1586
XCreateWindowEvent* i;
 
1587
int j;
 
1588
{
 
1589
          i->y = j;
 
1590
}
 
1591
 
 
1592
int  XCreateWindowEvent_x(i)
 
1593
XCreateWindowEvent* i;
 
1594
{
 
1595
          return(i->x);
 
1596
}
 
1597
 
 
1598
void set_XCreateWindowEvent_x(i, j)
 
1599
XCreateWindowEvent* i;
 
1600
int j;
 
1601
{
 
1602
          i->x = j;
 
1603
}
 
1604
 
 
1605
int  XCreateWindowEvent_window(i)
 
1606
XCreateWindowEvent* i;
 
1607
{
 
1608
          return(i->window);
 
1609
}
 
1610
 
 
1611
void set_XCreateWindowEvent_window(i, j)
 
1612
XCreateWindowEvent* i;
 
1613
int j;
 
1614
{
 
1615
          i->window = j;
 
1616
}
 
1617
 
 
1618
int  XCreateWindowEvent_parent(i)
 
1619
XCreateWindowEvent* i;
 
1620
{
 
1621
          return(i->parent);
 
1622
}
 
1623
 
 
1624
void set_XCreateWindowEvent_parent(i, j)
 
1625
XCreateWindowEvent* i;
 
1626
int j;
 
1627
{
 
1628
          i->parent = j;
 
1629
}
 
1630
 
 
1631
Display *XCreateWindowEvent_display(i)
 
1632
XCreateWindowEvent* i;
 
1633
{
 
1634
          return(i->display);
 
1635
}
 
1636
 
 
1637
void set_XCreateWindowEvent_display(i, j)
 
1638
XCreateWindowEvent* i;
 
1639
Display *j;
 
1640
{
 
1641
          i->display = j;
 
1642
}
 
1643
 
 
1644
int  XCreateWindowEvent_send_event(i)
 
1645
XCreateWindowEvent* i;
 
1646
{
 
1647
          return(i->send_event);
 
1648
}
 
1649
 
 
1650
void set_XCreateWindowEvent_send_event(i, j)
 
1651
XCreateWindowEvent* i;
 
1652
int j;
 
1653
{
 
1654
          i->send_event = j;
 
1655
}
 
1656
 
 
1657
int  XCreateWindowEvent_serial(i)
 
1658
XCreateWindowEvent* i;
 
1659
{
 
1660
          return(i->serial);
 
1661
}
 
1662
 
 
1663
void set_XCreateWindowEvent_serial(i, j)
 
1664
XCreateWindowEvent* i;
 
1665
int j;
 
1666
{
 
1667
          i->serial = j;
 
1668
}
 
1669
 
 
1670
int  XCreateWindowEvent_type(i)
 
1671
XCreateWindowEvent* i;
 
1672
{
 
1673
          return(i->type);
 
1674
}
 
1675
 
 
1676
void set_XCreateWindowEvent_type(i, j)
 
1677
XCreateWindowEvent* i;
 
1678
int j;
 
1679
{
 
1680
          i->type = j;
 
1681
}
 
1682
 
 
1683
 
 
1684
/********* XDestroyWindowEvent funcions *****/
 
1685
 
 
1686
int  make_XDestroyWindowEvent (){
 
1687
          return ((int) calloc(1, sizeof(XDestroyWindowEvent)));
 
1688
}
 
1689
 
 
1690
int  XDestroyWindowEvent_window(i)
 
1691
XDestroyWindowEvent* i;
 
1692
{
 
1693
          return(i->window);
 
1694
}
 
1695
 
 
1696
void set_XDestroyWindowEvent_window(i, j)
 
1697
XDestroyWindowEvent* i;
 
1698
int j;
 
1699
{
 
1700
          i->window = j;
 
1701
}
 
1702
 
 
1703
int  XDestroyWindowEvent_event(i)
 
1704
XDestroyWindowEvent* i;
 
1705
{
 
1706
          return(i->event);
 
1707
}
 
1708
 
 
1709
void set_XDestroyWindowEvent_event(i, j)
 
1710
XDestroyWindowEvent* i;
 
1711
int j;
 
1712
{
 
1713
          i->event = j;
 
1714
}
 
1715
 
 
1716
Display *XDestroyWindowEvent_display(i)
 
1717
XDestroyWindowEvent* i;
 
1718
{
 
1719
          return(i->display);
 
1720
}
 
1721
 
 
1722
void set_XDestroyWindowEvent_display(i, j)
 
1723
XDestroyWindowEvent* i;
 
1724
Display *j;
 
1725
{
 
1726
          i->display = j;
 
1727
}
 
1728
 
 
1729
int  XDestroyWindowEvent_send_event(i)
 
1730
XDestroyWindowEvent* i;
 
1731
{
 
1732
          return(i->send_event);
 
1733
}
 
1734
 
 
1735
void set_XDestroyWindowEvent_send_event(i, j)
 
1736
XDestroyWindowEvent* i;
 
1737
int j;
 
1738
{
 
1739
          i->send_event = j;
 
1740
}
 
1741
 
 
1742
int  XDestroyWindowEvent_serial(i)
 
1743
XDestroyWindowEvent* i;
 
1744
{
 
1745
          return(i->serial);
 
1746
}
 
1747
 
 
1748
void set_XDestroyWindowEvent_serial(i, j)
 
1749
XDestroyWindowEvent* i;
 
1750
int j;
 
1751
{
 
1752
          i->serial = j;
 
1753
}
 
1754
 
 
1755
int  XDestroyWindowEvent_type(i)
 
1756
XDestroyWindowEvent* i;
 
1757
{
 
1758
          return(i->type);
 
1759
}
 
1760
 
 
1761
void set_XDestroyWindowEvent_type(i, j)
 
1762
XDestroyWindowEvent* i;
 
1763
int j;
 
1764
{
 
1765
          i->type = j;
 
1766
}
 
1767
 
 
1768
 
 
1769
/********* XUnmapEvent funcions *****/
 
1770
 
 
1771
int  make_XUnmapEvent (){
 
1772
          return ((int) calloc(1, sizeof(XUnmapEvent)));
 
1773
}
 
1774
 
 
1775
int  XUnmapEvent_from_configure(i)
 
1776
XUnmapEvent* i;
 
1777
{
 
1778
          return(i->from_configure);
 
1779
}
 
1780
 
 
1781
void set_XUnmapEvent_from_configure(i, j)
 
1782
XUnmapEvent* i;
 
1783
int j;
 
1784
{
 
1785
          i->from_configure = j;
 
1786
}
 
1787
 
 
1788
int  XUnmapEvent_window(i)
 
1789
XUnmapEvent* i;
 
1790
{
 
1791
          return(i->window);
 
1792
}
 
1793
 
 
1794
void set_XUnmapEvent_window(i, j)
 
1795
XUnmapEvent* i;
 
1796
int j;
 
1797
{
 
1798
          i->window = j;
 
1799
}
 
1800
 
 
1801
int  XUnmapEvent_event(i)
 
1802
XUnmapEvent* i;
 
1803
{
 
1804
          return(i->event);
 
1805
}
 
1806
 
 
1807
void set_XUnmapEvent_event(i, j)
 
1808
XUnmapEvent* i;
 
1809
int j;
 
1810
{
 
1811
          i->event = j;
 
1812
}
 
1813
 
 
1814
Display *XUnmapEvent_display(i)
 
1815
XUnmapEvent* i;
 
1816
{
 
1817
          return(i->display);
 
1818
}
 
1819
 
 
1820
void set_XUnmapEvent_display(i, j)
 
1821
XUnmapEvent* i;
 
1822
Display *j;
 
1823
{
 
1824
          i->display = j;
 
1825
}
 
1826
 
 
1827
int  XUnmapEvent_send_event(i)
 
1828
XUnmapEvent* i;
 
1829
{
 
1830
          return(i->send_event);
 
1831
}
 
1832
 
 
1833
void set_XUnmapEvent_send_event(i, j)
 
1834
XUnmapEvent* i;
 
1835
int j;
 
1836
{
 
1837
          i->send_event = j;
 
1838
}
 
1839
 
 
1840
int  XUnmapEvent_serial(i)
 
1841
XUnmapEvent* i;
 
1842
{
 
1843
          return(i->serial);
 
1844
}
 
1845
 
 
1846
void set_XUnmapEvent_serial(i, j)
 
1847
XUnmapEvent* i;
 
1848
int j;
 
1849
{
 
1850
          i->serial = j;
 
1851
}
 
1852
 
 
1853
int  XUnmapEvent_type(i)
 
1854
XUnmapEvent* i;
 
1855
{
 
1856
          return(i->type);
 
1857
}
 
1858
 
 
1859
void set_XUnmapEvent_type(i, j)
 
1860
XUnmapEvent* i;
 
1861
int j;
 
1862
{
 
1863
          i->type = j;
 
1864
}
 
1865
 
 
1866
 
 
1867
/********* XMapEvent funcions *****/
 
1868
 
 
1869
int  make_XMapEvent (){
 
1870
          return ((int) calloc(1, sizeof(XMapEvent)));
 
1871
}
 
1872
 
 
1873
int  XMapEvent_override_redirect(i)
 
1874
XMapEvent* i;
 
1875
{
 
1876
          return(i->override_redirect);
 
1877
}
 
1878
 
 
1879
void set_XMapEvent_override_redirect(i, j)
 
1880
XMapEvent* i;
 
1881
int j;
 
1882
{
 
1883
          i->override_redirect = j;
 
1884
}
 
1885
 
 
1886
int  XMapEvent_window(i)
 
1887
XMapEvent* i;
 
1888
{
 
1889
          return(i->window);
 
1890
}
 
1891
 
 
1892
void set_XMapEvent_window(i, j)
 
1893
XMapEvent* i;
 
1894
int j;
 
1895
{
 
1896
          i->window = j;
 
1897
}
 
1898
 
 
1899
int  XMapEvent_event(i)
 
1900
XMapEvent* i;
 
1901
{
 
1902
          return(i->event);
 
1903
}
 
1904
 
 
1905
void set_XMapEvent_event(i, j)
 
1906
XMapEvent* i;
 
1907
int j;
 
1908
{
 
1909
          i->event = j;
 
1910
}
 
1911
 
 
1912
Display *XMapEvent_display(i)
 
1913
XMapEvent* i;
 
1914
{
 
1915
          return(i->display);
 
1916
}
 
1917
 
 
1918
void set_XMapEvent_display(i, j)
 
1919
XMapEvent* i;
 
1920
Display *j;
 
1921
{
 
1922
          i->display = j;
 
1923
}
 
1924
 
 
1925
int  XMapEvent_send_event(i)
 
1926
XMapEvent* i;
 
1927
{
 
1928
          return(i->send_event);
 
1929
}
 
1930
 
 
1931
void set_XMapEvent_send_event(i, j)
 
1932
XMapEvent* i;
 
1933
int j;
 
1934
{
 
1935
          i->send_event = j;
 
1936
}
 
1937
 
 
1938
int  XMapEvent_serial(i)
 
1939
XMapEvent* i;
 
1940
{
 
1941
          return(i->serial);
 
1942
}
 
1943
 
 
1944
void set_XMapEvent_serial(i, j)
 
1945
XMapEvent* i;
 
1946
int j;
 
1947
{
 
1948
          i->serial = j;
 
1949
}
 
1950
 
 
1951
int  XMapEvent_type(i)
 
1952
XMapEvent* i;
 
1953
{
 
1954
          return(i->type);
 
1955
}
 
1956
 
 
1957
void set_XMapEvent_type(i, j)
 
1958
XMapEvent* i;
 
1959
int j;
 
1960
{
 
1961
          i->type = j;
 
1962
}
 
1963
 
 
1964
 
 
1965
/********* XMapRequestEvent funcions *****/
 
1966
 
 
1967
int  make_XMapRequestEvent (){
 
1968
          return ((int) calloc(1, sizeof(XMapRequestEvent)));
 
1969
}
 
1970
 
 
1971
int  XMapRequestEvent_window(i)
 
1972
XMapRequestEvent* i;
 
1973
{
 
1974
          return(i->window);
 
1975
}
 
1976
 
 
1977
void set_XMapRequestEvent_window(i, j)
 
1978
XMapRequestEvent* i;
 
1979
int j;
 
1980
{
 
1981
          i->window = j;
 
1982
}
 
1983
 
 
1984
int  XMapRequestEvent_parent(i)
 
1985
XMapRequestEvent* i;
 
1986
{
 
1987
          return(i->parent);
 
1988
}
 
1989
 
 
1990
void set_XMapRequestEvent_parent(i, j)
 
1991
XMapRequestEvent* i;
 
1992
int j;
 
1993
{
 
1994
          i->parent = j;
 
1995
}
 
1996
 
 
1997
Display *XMapRequestEvent_display(i)
 
1998
XMapRequestEvent* i;
 
1999
{
 
2000
          return(i->display);
 
2001
}
 
2002
 
 
2003
void set_XMapRequestEvent_display(i, j)
 
2004
XMapRequestEvent* i;
 
2005
Display *j;
 
2006
{
 
2007
          i->display = j;
 
2008
}
 
2009
 
 
2010
int  XMapRequestEvent_send_event(i)
 
2011
XMapRequestEvent* i;
 
2012
{
 
2013
          return(i->send_event);
 
2014
}
 
2015
 
 
2016
void set_XMapRequestEvent_send_event(i, j)
 
2017
XMapRequestEvent* i;
 
2018
int j;
 
2019
{
 
2020
          i->send_event = j;
 
2021
}
 
2022
 
 
2023
int  XMapRequestEvent_serial(i)
 
2024
XMapRequestEvent* i;
 
2025
{
 
2026
          return(i->serial);
 
2027
}
 
2028
 
 
2029
void set_XMapRequestEvent_serial(i, j)
 
2030
XMapRequestEvent* i;
 
2031
int j;
 
2032
{
 
2033
          i->serial = j;
 
2034
}
 
2035
 
 
2036
int  XMapRequestEvent_type(i)
 
2037
XMapRequestEvent* i;
 
2038
{
 
2039
          return(i->type);
 
2040
}
 
2041
 
 
2042
void set_XMapRequestEvent_type(i, j)
 
2043
XMapRequestEvent* i;
 
2044
int j;
 
2045
{
 
2046
          i->type = j;
 
2047
}
 
2048
 
 
2049
 
 
2050
/********* XReparentEvent funcions *****/
 
2051
 
 
2052
int  make_XReparentEvent (){
 
2053
          return ((int) calloc(1, sizeof(XReparentEvent)));
 
2054
}
 
2055
 
 
2056
int  XReparentEvent_override_redirect(i)
 
2057
XReparentEvent* i;
 
2058
{
 
2059
          return(i->override_redirect);
 
2060
}
 
2061
 
 
2062
void set_XReparentEvent_override_redirect(i, j)
 
2063
XReparentEvent* i;
 
2064
int j;
 
2065
{
 
2066
          i->override_redirect = j;
 
2067
}
 
2068
 
 
2069
int  XReparentEvent_y(i)
 
2070
XReparentEvent* i;
 
2071
{
 
2072
          return(i->y);
 
2073
}
 
2074
 
 
2075
void set_XReparentEvent_y(i, j)
 
2076
XReparentEvent* i;
 
2077
int j;
 
2078
{
 
2079
          i->y = j;
 
2080
}
 
2081
 
 
2082
int  XReparentEvent_x(i)
 
2083
XReparentEvent* i;
 
2084
{
 
2085
          return(i->x);
 
2086
}
 
2087
 
 
2088
void set_XReparentEvent_x(i, j)
 
2089
XReparentEvent* i;
 
2090
int j;
 
2091
{
 
2092
          i->x = j;
 
2093
}
 
2094
 
 
2095
int  XReparentEvent_parent(i)
 
2096
XReparentEvent* i;
 
2097
{
 
2098
          return(i->parent);
 
2099
}
 
2100
 
 
2101
void set_XReparentEvent_parent(i, j)
 
2102
XReparentEvent* i;
 
2103
int j;
 
2104
{
 
2105
          i->parent = j;
 
2106
}
 
2107
 
 
2108
int  XReparentEvent_window(i)
 
2109
XReparentEvent* i;
 
2110
{
 
2111
          return(i->window);
 
2112
}
 
2113
 
 
2114
void set_XReparentEvent_window(i, j)
 
2115
XReparentEvent* i;
 
2116
int j;
 
2117
{
 
2118
          i->window = j;
 
2119
}
 
2120
 
 
2121
int  XReparentEvent_event(i)
 
2122
XReparentEvent* i;
 
2123
{
 
2124
          return(i->event);
 
2125
}
 
2126
 
 
2127
void set_XReparentEvent_event(i, j)
 
2128
XReparentEvent* i;
 
2129
int j;
 
2130
{
 
2131
          i->event = j;
 
2132
}
 
2133
 
 
2134
Display *XReparentEvent_display(i)
 
2135
XReparentEvent* i;
 
2136
{
 
2137
          return(i->display);
 
2138
}
 
2139
 
 
2140
void set_XReparentEvent_display(i, j)
 
2141
XReparentEvent* i;
 
2142
Display *j;
 
2143
{
 
2144
          i->display = j;
 
2145
}
 
2146
 
 
2147
int  XReparentEvent_send_event(i)
 
2148
XReparentEvent* i;
 
2149
{
 
2150
          return(i->send_event);
 
2151
}
 
2152
 
 
2153
void set_XReparentEvent_send_event(i, j)
 
2154
XReparentEvent* i;
 
2155
int j;
 
2156
{
 
2157
          i->send_event = j;
 
2158
}
 
2159
 
 
2160
int  XReparentEvent_serial(i)
 
2161
XReparentEvent* i;
 
2162
{
 
2163
          return(i->serial);
 
2164
}
 
2165
 
 
2166
void set_XReparentEvent_serial(i, j)
 
2167
XReparentEvent* i;
 
2168
int j;
 
2169
{
 
2170
          i->serial = j;
 
2171
}
 
2172
 
 
2173
int  XReparentEvent_type(i)
 
2174
XReparentEvent* i;
 
2175
{
 
2176
          return(i->type);
 
2177
}
 
2178
 
 
2179
void set_XReparentEvent_type(i, j)
 
2180
XReparentEvent* i;
 
2181
int j;
 
2182
{
 
2183
          i->type = j;
 
2184
}
 
2185
 
 
2186
 
 
2187
/********* XConfigureEvent funcions *****/
 
2188
 
 
2189
int  make_XConfigureEvent (){
 
2190
          return ((int) calloc(1, sizeof(XConfigureEvent)));
 
2191
}
 
2192
 
 
2193
int  XConfigureEvent_override_redirect(i)
 
2194
XConfigureEvent* i;
 
2195
{
 
2196
          return(i->override_redirect);
 
2197
}
 
2198
 
 
2199
void set_XConfigureEvent_override_redirect(i, j)
 
2200
XConfigureEvent* i;
 
2201
int j;
 
2202
{
 
2203
          i->override_redirect = j;
 
2204
}
 
2205
 
 
2206
int  XConfigureEvent_above(i)
 
2207
XConfigureEvent* i;
 
2208
{
 
2209
          return(i->above);
 
2210
}
 
2211
 
 
2212
void set_XConfigureEvent_above(i, j)
 
2213
XConfigureEvent* i;
 
2214
int j;
 
2215
{
 
2216
          i->above = j;
 
2217
}
 
2218
 
 
2219
int  XConfigureEvent_border_width(i)
 
2220
XConfigureEvent* i;
 
2221
{
 
2222
          return(i->border_width);
 
2223
}
 
2224
 
 
2225
void set_XConfigureEvent_border_width(i, j)
 
2226
XConfigureEvent* i;
 
2227
int j;
 
2228
{
 
2229
          i->border_width = j;
 
2230
}
 
2231
 
 
2232
int  XConfigureEvent_height(i)
 
2233
XConfigureEvent* i;
 
2234
{
 
2235
          return(i->height);
 
2236
}
 
2237
 
 
2238
void set_XConfigureEvent_height(i, j)
 
2239
XConfigureEvent* i;
 
2240
int j;
 
2241
{
 
2242
          i->height = j;
 
2243
}
 
2244
 
 
2245
int  XConfigureEvent_width(i)
 
2246
XConfigureEvent* i;
 
2247
{
 
2248
          return(i->width);
 
2249
}
 
2250
 
 
2251
void set_XConfigureEvent_width(i, j)
 
2252
XConfigureEvent* i;
 
2253
int j;
 
2254
{
 
2255
          i->width = j;
 
2256
}
 
2257
 
 
2258
int  XConfigureEvent_y(i)
 
2259
XConfigureEvent* i;
 
2260
{
 
2261
          return(i->y);
 
2262
}
 
2263
 
 
2264
void set_XConfigureEvent_y(i, j)
 
2265
XConfigureEvent* i;
 
2266
int j;
 
2267
{
 
2268
          i->y = j;
 
2269
}
 
2270
 
 
2271
int  XConfigureEvent_x(i)
 
2272
XConfigureEvent* i;
 
2273
{
 
2274
          return(i->x);
 
2275
}
 
2276
 
 
2277
void set_XConfigureEvent_x(i, j)
 
2278
XConfigureEvent* i;
 
2279
int j;
 
2280
{
 
2281
          i->x = j;
 
2282
}
 
2283
 
 
2284
int  XConfigureEvent_window(i)
 
2285
XConfigureEvent* i;
 
2286
{
 
2287
          return(i->window);
 
2288
}
 
2289
 
 
2290
void set_XConfigureEvent_window(i, j)
 
2291
XConfigureEvent* i;
 
2292
int j;
 
2293
{
 
2294
          i->window = j;
 
2295
}
 
2296
 
 
2297
int  XConfigureEvent_event(i)
 
2298
XConfigureEvent* i;
 
2299
{
 
2300
          return(i->event);
 
2301
}
 
2302
 
 
2303
void set_XConfigureEvent_event(i, j)
 
2304
XConfigureEvent* i;
 
2305
int j;
 
2306
{
 
2307
          i->event = j;
 
2308
}
 
2309
 
 
2310
Display *XConfigureEvent_display(i)
 
2311
XConfigureEvent* i;
 
2312
{
 
2313
          return(i->display);
 
2314
}
 
2315
 
 
2316
void set_XConfigureEvent_display(i, j)
 
2317
XConfigureEvent* i;
 
2318
Display *j;
 
2319
{
 
2320
          i->display = j;
 
2321
}
 
2322
 
 
2323
int  XConfigureEvent_send_event(i)
 
2324
XConfigureEvent* i;
 
2325
{
 
2326
          return(i->send_event);
 
2327
}
 
2328
 
 
2329
void set_XConfigureEvent_send_event(i, j)
 
2330
XConfigureEvent* i;
 
2331
int j;
 
2332
{
 
2333
          i->send_event = j;
 
2334
}
 
2335
 
 
2336
int  XConfigureEvent_serial(i)
 
2337
XConfigureEvent* i;
 
2338
{
 
2339
          return(i->serial);
 
2340
}
 
2341
 
 
2342
void set_XConfigureEvent_serial(i, j)
 
2343
XConfigureEvent* i;
 
2344
int j;
 
2345
{
 
2346
          i->serial = j;
 
2347
}
 
2348
 
 
2349
int  XConfigureEvent_type(i)
 
2350
XConfigureEvent* i;
 
2351
{
 
2352
          return(i->type);
 
2353
}
 
2354
 
 
2355
void set_XConfigureEvent_type(i, j)
 
2356
XConfigureEvent* i;
 
2357
int j;
 
2358
{
 
2359
          i->type = j;
 
2360
}
 
2361
 
 
2362
 
 
2363
/********* XGravityEvent funcions *****/
 
2364
 
 
2365
int  make_XGravityEvent (){
 
2366
          return ((int) calloc(1, sizeof(XGravityEvent)));
 
2367
}
 
2368
 
 
2369
int  XGravityEvent_y(i)
 
2370
XGravityEvent* i;
 
2371
{
 
2372
          return(i->y);
 
2373
}
 
2374
 
 
2375
void set_XGravityEvent_y(i, j)
 
2376
XGravityEvent* i;
 
2377
int j;
 
2378
{
 
2379
          i->y = j;
 
2380
}
 
2381
 
 
2382
int  XGravityEvent_x(i)
 
2383
XGravityEvent* i;
 
2384
{
 
2385
          return(i->x);
 
2386
}
 
2387
 
 
2388
void set_XGravityEvent_x(i, j)
 
2389
XGravityEvent* i;
 
2390
int j;
 
2391
{
 
2392
          i->x = j;
 
2393
}
 
2394
 
 
2395
int  XGravityEvent_window(i)
 
2396
XGravityEvent* i;
 
2397
{
 
2398
          return(i->window);
 
2399
}
 
2400
 
 
2401
void set_XGravityEvent_window(i, j)
 
2402
XGravityEvent* i;
 
2403
int j;
 
2404
{
 
2405
          i->window = j;
 
2406
}
 
2407
 
 
2408
int  XGravityEvent_event(i)
 
2409
XGravityEvent* i;
 
2410
{
 
2411
          return(i->event);
 
2412
}
 
2413
 
 
2414
void set_XGravityEvent_event(i, j)
 
2415
XGravityEvent* i;
 
2416
int j;
 
2417
{
 
2418
          i->event = j;
 
2419
}
 
2420
 
 
2421
Display *XGravityEvent_display(i)
 
2422
XGravityEvent* i;
 
2423
{
 
2424
          return(i->display);
 
2425
}
 
2426
 
 
2427
void set_XGravityEvent_display(i, j)
 
2428
XGravityEvent* i;
 
2429
Display *j;
 
2430
{
 
2431
          i->display = j;
 
2432
}
 
2433
 
 
2434
int  XGravityEvent_send_event(i)
 
2435
XGravityEvent* i;
 
2436
{
 
2437
          return(i->send_event);
 
2438
}
 
2439
 
 
2440
void set_XGravityEvent_send_event(i, j)
 
2441
XGravityEvent* i;
 
2442
int j;
 
2443
{
 
2444
          i->send_event = j;
 
2445
}
 
2446
 
 
2447
int  XGravityEvent_serial(i)
 
2448
XGravityEvent* i;
 
2449
{
 
2450
          return(i->serial);
 
2451
}
 
2452
 
 
2453
void set_XGravityEvent_serial(i, j)
 
2454
XGravityEvent* i;
 
2455
int j;
 
2456
{
 
2457
          i->serial = j;
 
2458
}
 
2459
 
 
2460
int  XGravityEvent_type(i)
 
2461
XGravityEvent* i;
 
2462
{
 
2463
          return(i->type);
 
2464
}
 
2465
 
 
2466
void set_XGravityEvent_type(i, j)
 
2467
XGravityEvent* i;
 
2468
int j;
 
2469
{
 
2470
          i->type = j;
 
2471
}
 
2472
 
 
2473
 
 
2474
/********* XResizeRequestEvent funcions *****/
 
2475
 
 
2476
int  make_XResizeRequestEvent (){
 
2477
          return ((int) calloc(1, sizeof(XResizeRequestEvent)));
 
2478
}
 
2479
 
 
2480
int  XResizeRequestEvent_height(i)
 
2481
XResizeRequestEvent* i;
 
2482
{
 
2483
          return(i->height);
 
2484
}
 
2485
 
 
2486
void set_XResizeRequestEvent_height(i, j)
 
2487
XResizeRequestEvent* i;
 
2488
int j;
 
2489
{
 
2490
          i->height = j;
 
2491
}
 
2492
 
 
2493
int  XResizeRequestEvent_width(i)
 
2494
XResizeRequestEvent* i;
 
2495
{
 
2496
          return(i->width);
 
2497
}
 
2498
 
 
2499
void set_XResizeRequestEvent_width(i, j)
 
2500
XResizeRequestEvent* i;
 
2501
int j;
 
2502
{
 
2503
          i->width = j;
 
2504
}
 
2505
 
 
2506
int  XResizeRequestEvent_window(i)
 
2507
XResizeRequestEvent* i;
 
2508
{
 
2509
          return(i->window);
 
2510
}
 
2511
 
 
2512
void set_XResizeRequestEvent_window(i, j)
 
2513
XResizeRequestEvent* i;
 
2514
int j;
 
2515
{
 
2516
          i->window = j;
 
2517
}
 
2518
 
 
2519
Display *XResizeRequestEvent_display(i)
 
2520
XResizeRequestEvent* i;
 
2521
{
 
2522
          return(i->display);
 
2523
}
 
2524
 
 
2525
void set_XResizeRequestEvent_display(i, j)
 
2526
XResizeRequestEvent* i;
 
2527
Display *j;
 
2528
{
 
2529
          i->display = j;
 
2530
}
 
2531
 
 
2532
int  XResizeRequestEvent_send_event(i)
 
2533
XResizeRequestEvent* i;
 
2534
{
 
2535
          return(i->send_event);
 
2536
}
 
2537
 
 
2538
void set_XResizeRequestEvent_send_event(i, j)
 
2539
XResizeRequestEvent* i;
 
2540
int j;
 
2541
{
 
2542
          i->send_event = j;
 
2543
}
 
2544
 
 
2545
int  XResizeRequestEvent_serial(i)
 
2546
XResizeRequestEvent* i;
 
2547
{
 
2548
          return(i->serial);
 
2549
}
 
2550
 
 
2551
void set_XResizeRequestEvent_serial(i, j)
 
2552
XResizeRequestEvent* i;
 
2553
int j;
 
2554
{
 
2555
          i->serial = j;
 
2556
}
 
2557
 
 
2558
int  XResizeRequestEvent_type(i)
 
2559
XResizeRequestEvent* i;
 
2560
{
 
2561
          return(i->type);
 
2562
}
 
2563
 
 
2564
void set_XResizeRequestEvent_type(i, j)
 
2565
XResizeRequestEvent* i;
 
2566
int j;
 
2567
{
 
2568
          i->type = j;
 
2569
}
 
2570
 
 
2571
 
 
2572
/********* XConfigureRequestEvent funcions *****/
 
2573
 
 
2574
int  make_XConfigureRequestEvent (){
 
2575
          return ((int) calloc(1, sizeof(XConfigureRequestEvent)));
 
2576
}
 
2577
 
 
2578
int  XConfigureRequestEvent_value_mask(i)
 
2579
XConfigureRequestEvent* i;
 
2580
{
 
2581
          return(i->value_mask);
 
2582
}
 
2583
 
 
2584
void set_XConfigureRequestEvent_value_mask(i, j)
 
2585
XConfigureRequestEvent* i;
 
2586
int j;
 
2587
{
 
2588
          i->value_mask = j;
 
2589
}
 
2590
 
 
2591
int  XConfigureRequestEvent_detail(i)
 
2592
XConfigureRequestEvent* i;
 
2593
{
 
2594
          return(i->detail);
 
2595
}
 
2596
 
 
2597
void set_XConfigureRequestEvent_detail(i, j)
 
2598
XConfigureRequestEvent* i;
 
2599
int j;
 
2600
{
 
2601
          i->detail = j;
 
2602
}
 
2603
 
 
2604
int  XConfigureRequestEvent_above(i)
 
2605
XConfigureRequestEvent* i;
 
2606
{
 
2607
          return(i->above);
 
2608
}
 
2609
 
 
2610
void set_XConfigureRequestEvent_above(i, j)
 
2611
XConfigureRequestEvent* i;
 
2612
int j;
 
2613
{
 
2614
          i->above = j;
 
2615
}
 
2616
 
 
2617
int  XConfigureRequestEvent_border_width(i)
 
2618
XConfigureRequestEvent* i;
 
2619
{
 
2620
          return(i->border_width);
 
2621
}
 
2622
 
 
2623
void set_XConfigureRequestEvent_border_width(i, j)
 
2624
XConfigureRequestEvent* i;
 
2625
int j;
 
2626
{
 
2627
          i->border_width = j;
 
2628
}
 
2629
 
 
2630
int  XConfigureRequestEvent_height(i)
 
2631
XConfigureRequestEvent* i;
 
2632
{
 
2633
          return(i->height);
 
2634
}
 
2635
 
 
2636
void set_XConfigureRequestEvent_height(i, j)
 
2637
XConfigureRequestEvent* i;
 
2638
int j;
 
2639
{
 
2640
          i->height = j;
 
2641
}
 
2642
 
 
2643
int  XConfigureRequestEvent_width(i)
 
2644
XConfigureRequestEvent* i;
 
2645
{
 
2646
          return(i->width);
 
2647
}
 
2648
 
 
2649
void set_XConfigureRequestEvent_width(i, j)
 
2650
XConfigureRequestEvent* i;
 
2651
int j;
 
2652
{
 
2653
          i->width = j;
 
2654
}
 
2655
 
 
2656
int  XConfigureRequestEvent_y(i)
 
2657
XConfigureRequestEvent* i;
 
2658
{
 
2659
          return(i->y);
 
2660
}
 
2661
 
 
2662
void set_XConfigureRequestEvent_y(i, j)
 
2663
XConfigureRequestEvent* i;
 
2664
int j;
 
2665
{
 
2666
          i->y = j;
 
2667
}
 
2668
 
 
2669
int  XConfigureRequestEvent_x(i)
 
2670
XConfigureRequestEvent* i;
 
2671
{
 
2672
          return(i->x);
 
2673
}
 
2674
 
 
2675
void set_XConfigureRequestEvent_x(i, j)
 
2676
XConfigureRequestEvent* i;
 
2677
int j;
 
2678
{
 
2679
          i->x = j;
 
2680
}
 
2681
 
 
2682
int  XConfigureRequestEvent_window(i)
 
2683
XConfigureRequestEvent* i;
 
2684
{
 
2685
          return(i->window);
 
2686
}
 
2687
 
 
2688
void set_XConfigureRequestEvent_window(i, j)
 
2689
XConfigureRequestEvent* i;
 
2690
int j;
 
2691
{
 
2692
          i->window = j;
 
2693
}
 
2694
 
 
2695
int  XConfigureRequestEvent_parent(i)
 
2696
XConfigureRequestEvent* i;
 
2697
{
 
2698
          return(i->parent);
 
2699
}
 
2700
 
 
2701
void set_XConfigureRequestEvent_parent(i, j)
 
2702
XConfigureRequestEvent* i;
 
2703
int j;
 
2704
{
 
2705
          i->parent = j;
 
2706
}
 
2707
 
 
2708
Display *XConfigureRequestEvent_display(i)
 
2709
XConfigureRequestEvent* i;
 
2710
{
 
2711
          return(i->display);
 
2712
}
 
2713
 
 
2714
void set_XConfigureRequestEvent_display(i, j)
 
2715
XConfigureRequestEvent* i;
 
2716
Display *j;
 
2717
{
 
2718
          i->display = j;
 
2719
}
 
2720
 
 
2721
int  XConfigureRequestEvent_send_event(i)
 
2722
XConfigureRequestEvent* i;
 
2723
{
 
2724
          return(i->send_event);
 
2725
}
 
2726
 
 
2727
void set_XConfigureRequestEvent_send_event(i, j)
 
2728
XConfigureRequestEvent* i;
 
2729
int j;
 
2730
{
 
2731
          i->send_event = j;
 
2732
}
 
2733
 
 
2734
int  XConfigureRequestEvent_serial(i)
 
2735
XConfigureRequestEvent* i;
 
2736
{
 
2737
          return(i->serial);
 
2738
}
 
2739
 
 
2740
void set_XConfigureRequestEvent_serial(i, j)
 
2741
XConfigureRequestEvent* i;
 
2742
int j;
 
2743
{
 
2744
          i->serial = j;
 
2745
}
 
2746
 
 
2747
int  XConfigureRequestEvent_type(i)
 
2748
XConfigureRequestEvent* i;
 
2749
{
 
2750
          return(i->type);
 
2751
}
 
2752
 
 
2753
void set_XConfigureRequestEvent_type(i, j)
 
2754
XConfigureRequestEvent* i;
 
2755
int j;
 
2756
{
 
2757
          i->type = j;
 
2758
}
 
2759
 
 
2760
 
 
2761
/********* XCirculateEvent funcions *****/
 
2762
 
 
2763
int  make_XCirculateEvent (){
 
2764
          return ((int) calloc(1, sizeof(XCirculateEvent)));
 
2765
}
 
2766
 
 
2767
int  XCirculateEvent_place(i)
 
2768
XCirculateEvent* i;
 
2769
{
 
2770
          return(i->place);
 
2771
}
 
2772
 
 
2773
void set_XCirculateEvent_place(i, j)
 
2774
XCirculateEvent* i;
 
2775
int j;
 
2776
{
 
2777
          i->place = j;
 
2778
}
 
2779
 
 
2780
int  XCirculateEvent_window(i)
 
2781
XCirculateEvent* i;
 
2782
{
 
2783
          return(i->window);
 
2784
}
 
2785
 
 
2786
void set_XCirculateEvent_window(i, j)
 
2787
XCirculateEvent* i;
 
2788
int j;
 
2789
{
 
2790
          i->window = j;
 
2791
}
 
2792
 
 
2793
int  XCirculateEvent_event(i)
 
2794
XCirculateEvent* i;
 
2795
{
 
2796
          return(i->event);
 
2797
}
 
2798
 
 
2799
void set_XCirculateEvent_event(i, j)
 
2800
XCirculateEvent* i;
 
2801
int j;
 
2802
{
 
2803
          i->event = j;
 
2804
}
 
2805
 
 
2806
Display *XCirculateEvent_display(i)
 
2807
XCirculateEvent* i;
 
2808
{
 
2809
          return(i->display);
 
2810
}
 
2811
 
 
2812
void set_XCirculateEvent_display(i, j)
 
2813
XCirculateEvent* i;
 
2814
Display *j;
 
2815
{
 
2816
          i->display = j;
 
2817
}
 
2818
 
 
2819
int  XCirculateEvent_send_event(i)
 
2820
XCirculateEvent* i;
 
2821
{
 
2822
          return(i->send_event);
 
2823
}
 
2824
 
 
2825
void set_XCirculateEvent_send_event(i, j)
 
2826
XCirculateEvent* i;
 
2827
int j;
 
2828
{
 
2829
          i->send_event = j;
 
2830
}
 
2831
 
 
2832
int  XCirculateEvent_serial(i)
 
2833
XCirculateEvent* i;
 
2834
{
 
2835
          return(i->serial);
 
2836
}
 
2837
 
 
2838
void set_XCirculateEvent_serial(i, j)
 
2839
XCirculateEvent* i;
 
2840
int j;
 
2841
{
 
2842
          i->serial = j;
 
2843
}
 
2844
 
 
2845
int  XCirculateEvent_type(i)
 
2846
XCirculateEvent* i;
 
2847
{
 
2848
          return(i->type);
 
2849
}
 
2850
 
 
2851
void set_XCirculateEvent_type(i, j)
 
2852
XCirculateEvent* i;
 
2853
int j;
 
2854
{
 
2855
          i->type = j;
 
2856
}
 
2857
 
 
2858
 
 
2859
/********* XCirculateRequestEvent funcions *****/
 
2860
 
 
2861
int  make_XCirculateRequestEvent (){
 
2862
          return ((int) calloc(1, sizeof(XCirculateRequestEvent)));
 
2863
}
 
2864
 
 
2865
int  XCirculateRequestEvent_place(i)
 
2866
XCirculateRequestEvent* i;
 
2867
{
 
2868
          return(i->place);
 
2869
}
 
2870
 
 
2871
void set_XCirculateRequestEvent_place(i, j)
 
2872
XCirculateRequestEvent* i;
 
2873
int j;
 
2874
{
 
2875
          i->place = j;
 
2876
}
 
2877
 
 
2878
int  XCirculateRequestEvent_window(i)
 
2879
XCirculateRequestEvent* i;
 
2880
{
 
2881
          return(i->window);
 
2882
}
 
2883
 
 
2884
void set_XCirculateRequestEvent_window(i, j)
 
2885
XCirculateRequestEvent* i;
 
2886
int j;
 
2887
{
 
2888
          i->window = j;
 
2889
}
 
2890
 
 
2891
int  XCirculateRequestEvent_parent(i)
 
2892
XCirculateRequestEvent* i;
 
2893
{
 
2894
          return(i->parent);
 
2895
}
 
2896
 
 
2897
void set_XCirculateRequestEvent_parent(i, j)
 
2898
XCirculateRequestEvent* i;
 
2899
int j;
 
2900
{
 
2901
          i->parent = j;
 
2902
}
 
2903
 
 
2904
Display *XCirculateRequestEvent_display(i)
 
2905
XCirculateRequestEvent* i;
 
2906
{
 
2907
          return(i->display);
 
2908
}
 
2909
 
 
2910
void set_XCirculateRequestEvent_display(i, j)
 
2911
XCirculateRequestEvent* i;
 
2912
Display *j;
 
2913
{
 
2914
          i->display = j;
 
2915
}
 
2916
 
 
2917
int  XCirculateRequestEvent_send_event(i)
 
2918
XCirculateRequestEvent* i;
 
2919
{
 
2920
          return(i->send_event);
 
2921
}
 
2922
 
 
2923
void set_XCirculateRequestEvent_send_event(i, j)
 
2924
XCirculateRequestEvent* i;
 
2925
int j;
 
2926
{
 
2927
          i->send_event = j;
 
2928
}
 
2929
 
 
2930
int  XCirculateRequestEvent_serial(i)
 
2931
XCirculateRequestEvent* i;
 
2932
{
 
2933
          return(i->serial);
 
2934
}
 
2935
 
 
2936
void set_XCirculateRequestEvent_serial(i, j)
 
2937
XCirculateRequestEvent* i;
 
2938
int j;
 
2939
{
 
2940
          i->serial = j;
 
2941
}
 
2942
 
 
2943
int  XCirculateRequestEvent_type(i)
 
2944
XCirculateRequestEvent* i;
 
2945
{
 
2946
          return(i->type);
 
2947
}
 
2948
 
 
2949
void set_XCirculateRequestEvent_type(i, j)
 
2950
XCirculateRequestEvent* i;
 
2951
int j;
 
2952
{
 
2953
          i->type = j;
 
2954
}
 
2955
 
 
2956
 
 
2957
/********* XPropertyEvent funcions *****/
 
2958
 
 
2959
int  make_XPropertyEvent (){
 
2960
          return ((int) calloc(1, sizeof(XPropertyEvent)));
 
2961
}
 
2962
 
 
2963
int  XPropertyEvent_state(i)
 
2964
XPropertyEvent* i;
 
2965
{
 
2966
          return(i->state);
 
2967
}
 
2968
 
 
2969
void set_XPropertyEvent_state(i, j)
 
2970
XPropertyEvent* i;
 
2971
int j;
 
2972
{
 
2973
          i->state = j;
 
2974
}
 
2975
 
 
2976
int  XPropertyEvent_time(i)
 
2977
XPropertyEvent* i;
 
2978
{
 
2979
          return(i->time);
 
2980
}
 
2981
 
 
2982
void set_XPropertyEvent_time(i, j)
 
2983
XPropertyEvent* i;
 
2984
int j;
 
2985
{
 
2986
          i->time = j;
 
2987
}
 
2988
 
 
2989
int  XPropertyEvent_atom(i)
 
2990
XPropertyEvent* i;
 
2991
{
 
2992
          return(i->atom);
 
2993
}
 
2994
 
 
2995
void set_XPropertyEvent_atom(i, j)
 
2996
XPropertyEvent* i;
 
2997
int j;
 
2998
{
 
2999
          i->atom = j;
 
3000
}
 
3001
 
 
3002
int  XPropertyEvent_window(i)
 
3003
XPropertyEvent* i;
 
3004
{
 
3005
          return(i->window);
 
3006
}
 
3007
 
 
3008
void set_XPropertyEvent_window(i, j)
 
3009
XPropertyEvent* i;
 
3010
int j;
 
3011
{
 
3012
          i->window = j;
 
3013
}
 
3014
 
 
3015
Display *XPropertyEvent_display(i)
 
3016
XPropertyEvent* i;
 
3017
{
 
3018
          return(i->display);
 
3019
}
 
3020
 
 
3021
void set_XPropertyEvent_display(i, j)
 
3022
XPropertyEvent* i;
 
3023
Display *j;
 
3024
{
 
3025
          i->display = j;
 
3026
}
 
3027
 
 
3028
int  XPropertyEvent_send_event(i)
 
3029
XPropertyEvent* i;
 
3030
{
 
3031
          return(i->send_event);
 
3032
}
 
3033
 
 
3034
void set_XPropertyEvent_send_event(i, j)
 
3035
XPropertyEvent* i;
 
3036
int j;
 
3037
{
 
3038
          i->send_event = j;
 
3039
}
 
3040
 
 
3041
int  XPropertyEvent_serial(i)
 
3042
XPropertyEvent* i;
 
3043
{
 
3044
          return(i->serial);
 
3045
}
 
3046
 
 
3047
void set_XPropertyEvent_serial(i, j)
 
3048
XPropertyEvent* i;
 
3049
int j;
 
3050
{
 
3051
          i->serial = j;
 
3052
}
 
3053
 
 
3054
int  XPropertyEvent_type(i)
 
3055
XPropertyEvent* i;
 
3056
{
 
3057
          return(i->type);
 
3058
}
 
3059
 
 
3060
void set_XPropertyEvent_type(i, j)
 
3061
XPropertyEvent* i;
 
3062
int j;
 
3063
{
 
3064
          i->type = j;
 
3065
}
 
3066
 
 
3067
 
 
3068
/********* XSelectionClearEvent funcions *****/
 
3069
 
 
3070
int  make_XSelectionClearEvent (){
 
3071
          return ((int) calloc(1, sizeof(XSelectionClearEvent)));
 
3072
}
 
3073
 
 
3074
int  XSelectionClearEvent_time(i)
 
3075
XSelectionClearEvent* i;
 
3076
{
 
3077
          return(i->time);
 
3078
}
 
3079
 
 
3080
void set_XSelectionClearEvent_time(i, j)
 
3081
XSelectionClearEvent* i;
 
3082
int j;
 
3083
{
 
3084
          i->time = j;
 
3085
}
 
3086
 
 
3087
int  XSelectionClearEvent_selection(i)
 
3088
XSelectionClearEvent* i;
 
3089
{
 
3090
          return(i->selection);
 
3091
}
 
3092
 
 
3093
void set_XSelectionClearEvent_selection(i, j)
 
3094
XSelectionClearEvent* i;
 
3095
int j;
 
3096
{
 
3097
          i->selection = j;
 
3098
}
 
3099
 
 
3100
int  XSelectionClearEvent_window(i)
 
3101
XSelectionClearEvent* i;
 
3102
{
 
3103
          return(i->window);
 
3104
}
 
3105
 
 
3106
void set_XSelectionClearEvent_window(i, j)
 
3107
XSelectionClearEvent* i;
 
3108
int j;
 
3109
{
 
3110
          i->window = j;
 
3111
}
 
3112
 
 
3113
Display *XSelectionClearEvent_display(i)
 
3114
XSelectionClearEvent* i;
 
3115
{
 
3116
          return(i->display);
 
3117
}
 
3118
 
 
3119
void set_XSelectionClearEvent_display(i, j)
 
3120
XSelectionClearEvent* i;
 
3121
Display *j;
 
3122
{
 
3123
          i->display = j;
 
3124
}
 
3125
 
 
3126
int  XSelectionClearEvent_send_event(i)
 
3127
XSelectionClearEvent* i;
 
3128
{
 
3129
          return(i->send_event);
 
3130
}
 
3131
 
 
3132
void set_XSelectionClearEvent_send_event(i, j)
 
3133
XSelectionClearEvent* i;
 
3134
int j;
 
3135
{
 
3136
          i->send_event = j;
 
3137
}
 
3138
 
 
3139
int  XSelectionClearEvent_serial(i)
 
3140
XSelectionClearEvent* i;
 
3141
{
 
3142
          return(i->serial);
 
3143
}
 
3144
 
 
3145
void set_XSelectionClearEvent_serial(i, j)
 
3146
XSelectionClearEvent* i;
 
3147
int j;
 
3148
{
 
3149
          i->serial = j;
 
3150
}
 
3151
 
 
3152
int  XSelectionClearEvent_type(i)
 
3153
XSelectionClearEvent* i;
 
3154
{
 
3155
          return(i->type);
 
3156
}
 
3157
 
 
3158
void set_XSelectionClearEvent_type(i, j)
 
3159
XSelectionClearEvent* i;
 
3160
int j;
 
3161
{
 
3162
          i->type = j;
 
3163
}
 
3164
 
 
3165
 
 
3166
/********* XSelectionRequestEvent funcions *****/
 
3167
 
 
3168
int  make_XSelectionRequestEvent (){
 
3169
          return ((int) calloc(1, sizeof(XSelectionRequestEvent)));
 
3170
}
 
3171
 
 
3172
int  XSelectionRequestEvent_time(i)
 
3173
XSelectionRequestEvent* i;
 
3174
{
 
3175
          return(i->time);
 
3176
}
 
3177
 
 
3178
void set_XSelectionRequestEvent_time(i, j)
 
3179
XSelectionRequestEvent* i;
 
3180
int j;
 
3181
{
 
3182
          i->time = j;
 
3183
}
 
3184
 
 
3185
int  XSelectionRequestEvent_property(i)
 
3186
XSelectionRequestEvent* i;
 
3187
{
 
3188
          return(i->property);
 
3189
}
 
3190
 
 
3191
void set_XSelectionRequestEvent_property(i, j)
 
3192
XSelectionRequestEvent* i;
 
3193
int j;
 
3194
{
 
3195
          i->property = j;
 
3196
}
 
3197
 
 
3198
int  XSelectionRequestEvent_target(i)
 
3199
XSelectionRequestEvent* i;
 
3200
{
 
3201
          return(i->target);
 
3202
}
 
3203
 
 
3204
void set_XSelectionRequestEvent_target(i, j)
 
3205
XSelectionRequestEvent* i;
 
3206
int j;
 
3207
{
 
3208
          i->target = j;
 
3209
}
 
3210
 
 
3211
int  XSelectionRequestEvent_selection(i)
 
3212
XSelectionRequestEvent* i;
 
3213
{
 
3214
          return(i->selection);
 
3215
}
 
3216
 
 
3217
void set_XSelectionRequestEvent_selection(i, j)
 
3218
XSelectionRequestEvent* i;
 
3219
int j;
 
3220
{
 
3221
          i->selection = j;
 
3222
}
 
3223
 
 
3224
int  XSelectionRequestEvent_requestor(i)
 
3225
XSelectionRequestEvent* i;
 
3226
{
 
3227
          return(i->requestor);
 
3228
}
 
3229
 
 
3230
void set_XSelectionRequestEvent_requestor(i, j)
 
3231
XSelectionRequestEvent* i;
 
3232
int j;
 
3233
{
 
3234
          i->requestor = j;
 
3235
}
 
3236
 
 
3237
int  XSelectionRequestEvent_owner(i)
 
3238
XSelectionRequestEvent* i;
 
3239
{
 
3240
          return(i->owner);
 
3241
}
 
3242
 
 
3243
void set_XSelectionRequestEvent_owner(i, j)
 
3244
XSelectionRequestEvent* i;
 
3245
int j;
 
3246
{
 
3247
          i->owner = j;
 
3248
}
 
3249
 
 
3250
Display *XSelectionRequestEvent_display(i)
 
3251
XSelectionRequestEvent* i;
 
3252
{
 
3253
          return(i->display);
 
3254
}
 
3255
 
 
3256
void set_XSelectionRequestEvent_display(i, j)
 
3257
XSelectionRequestEvent* i;
 
3258
Display *j;
 
3259
{
 
3260
          i->display = j;
 
3261
}
 
3262
 
 
3263
int  XSelectionRequestEvent_send_event(i)
 
3264
XSelectionRequestEvent* i;
 
3265
{
 
3266
          return(i->send_event);
 
3267
}
 
3268
 
 
3269
void set_XSelectionRequestEvent_send_event(i, j)
 
3270
XSelectionRequestEvent* i;
 
3271
int j;
 
3272
{
 
3273
          i->send_event = j;
 
3274
}
 
3275
 
 
3276
int  XSelectionRequestEvent_serial(i)
 
3277
XSelectionRequestEvent* i;
 
3278
{
 
3279
          return(i->serial);
 
3280
}
 
3281
 
 
3282
void set_XSelectionRequestEvent_serial(i, j)
 
3283
XSelectionRequestEvent* i;
 
3284
int j;
 
3285
{
 
3286
          i->serial = j;
 
3287
}
 
3288
 
 
3289
int  XSelectionRequestEvent_type(i)
 
3290
XSelectionRequestEvent* i;
 
3291
{
 
3292
          return(i->type);
 
3293
}
 
3294
 
 
3295
void set_XSelectionRequestEvent_type(i, j)
 
3296
XSelectionRequestEvent* i;
 
3297
int j;
 
3298
{
 
3299
          i->type = j;
 
3300
}
 
3301
 
 
3302
 
 
3303
/********* XSelectionEvent funcions *****/
 
3304
 
 
3305
int  make_XSelectionEvent (){
 
3306
          return ((int) calloc(1, sizeof(XSelectionEvent)));
 
3307
}
 
3308
 
 
3309
int  XSelectionEvent_time(i)
 
3310
XSelectionEvent* i;
 
3311
{
 
3312
          return(i->time);
 
3313
}
 
3314
 
 
3315
void set_XSelectionEvent_time(i, j)
 
3316
XSelectionEvent* i;
 
3317
int j;
 
3318
{
 
3319
          i->time = j;
 
3320
}
 
3321
 
 
3322
int  XSelectionEvent_property(i)
 
3323
XSelectionEvent* i;
 
3324
{
 
3325
          return(i->property);
 
3326
}
 
3327
 
 
3328
void set_XSelectionEvent_property(i, j)
 
3329
XSelectionEvent* i;
 
3330
int j;
 
3331
{
 
3332
          i->property = j;
 
3333
}
 
3334
 
 
3335
int  XSelectionEvent_target(i)
 
3336
XSelectionEvent* i;
 
3337
{
 
3338
          return(i->target);
 
3339
}
 
3340
 
 
3341
void set_XSelectionEvent_target(i, j)
 
3342
XSelectionEvent* i;
 
3343
int j;
 
3344
{
 
3345
          i->target = j;
 
3346
}
 
3347
 
 
3348
int  XSelectionEvent_selection(i)
 
3349
XSelectionEvent* i;
 
3350
{
 
3351
          return(i->selection);
 
3352
}
 
3353
 
 
3354
void set_XSelectionEvent_selection(i, j)
 
3355
XSelectionEvent* i;
 
3356
int j;
 
3357
{
 
3358
          i->selection = j;
 
3359
}
 
3360
 
 
3361
int  XSelectionEvent_requestor(i)
 
3362
XSelectionEvent* i;
 
3363
{
 
3364
          return(i->requestor);
 
3365
}
 
3366
 
 
3367
void set_XSelectionEvent_requestor(i, j)
 
3368
XSelectionEvent* i;
 
3369
int j;
 
3370
{
 
3371
          i->requestor = j;
 
3372
}
 
3373
 
 
3374
Display *XSelectionEvent_display(i)
 
3375
XSelectionEvent* i;
 
3376
{
 
3377
          return(i->display);
 
3378
}
 
3379
 
 
3380
void set_XSelectionEvent_display(i, j)
 
3381
XSelectionEvent* i;
 
3382
Display *j;
 
3383
{
 
3384
          i->display = j;
 
3385
}
 
3386
 
 
3387
int  XSelectionEvent_send_event(i)
 
3388
XSelectionEvent* i;
 
3389
{
 
3390
          return(i->send_event);
 
3391
}
 
3392
 
 
3393
void set_XSelectionEvent_send_event(i, j)
 
3394
XSelectionEvent* i;
 
3395
int j;
 
3396
{
 
3397
          i->send_event = j;
 
3398
}
 
3399
 
 
3400
int  XSelectionEvent_serial(i)
 
3401
XSelectionEvent* i;
 
3402
{
 
3403
          return(i->serial);
 
3404
}
 
3405
 
 
3406
void set_XSelectionEvent_serial(i, j)
 
3407
XSelectionEvent* i;
 
3408
int j;
 
3409
{
 
3410
          i->serial = j;
 
3411
}
 
3412
 
 
3413
int  XSelectionEvent_type(i)
 
3414
XSelectionEvent* i;
 
3415
{
 
3416
          return(i->type);
 
3417
}
 
3418
 
 
3419
void set_XSelectionEvent_type(i, j)
 
3420
XSelectionEvent* i;
 
3421
int j;
 
3422
{
 
3423
          i->type = j;
 
3424
}
 
3425
 
 
3426
 
 
3427
/********* XColormapEvent funcions *****/
 
3428
 
 
3429
int  make_XColormapEvent (){
 
3430
          return ((int) calloc(1, sizeof(XColormapEvent)));
 
3431
}
 
3432
 
 
3433
int  XColormapEvent_state(i)
 
3434
XColormapEvent* i;
 
3435
{
 
3436
          return(i->state);
 
3437
}
 
3438
 
 
3439
void set_XColormapEvent_state(i, j)
 
3440
XColormapEvent* i;
 
3441
int j;
 
3442
{
 
3443
          i->state = j;
 
3444
}
 
3445
 
 
3446
int  XColormapEvent_new(i)
 
3447
XColormapEvent* i;
 
3448
{
 
3449
          return(i->new);
 
3450
}
 
3451
 
 
3452
void set_XColormapEvent_new(i, j)
 
3453
XColormapEvent* i;
 
3454
int j;
 
3455
{
 
3456
          i->new = j;
 
3457
}
 
3458
 
 
3459
int  XColormapEvent_colormap(i)
 
3460
XColormapEvent* i;
 
3461
{
 
3462
          return(i->colormap);
 
3463
}
 
3464
 
 
3465
void set_XColormapEvent_colormap(i, j)
 
3466
XColormapEvent* i;
 
3467
int j;
 
3468
{
 
3469
          i->colormap = j;
 
3470
}
 
3471
 
 
3472
int  XColormapEvent_window(i)
 
3473
XColormapEvent* i;
 
3474
{
 
3475
          return(i->window);
 
3476
}
 
3477
 
 
3478
void set_XColormapEvent_window(i, j)
 
3479
XColormapEvent* i;
 
3480
int j;
 
3481
{
 
3482
          i->window = j;
 
3483
}
 
3484
 
 
3485
Display *XColormapEvent_display(i)
 
3486
XColormapEvent* i;
 
3487
{
 
3488
          return(i->display);
 
3489
}
 
3490
 
 
3491
void set_XColormapEvent_display(i, j)
 
3492
XColormapEvent* i;
 
3493
Display *j;
 
3494
{
 
3495
          i->display = j;
 
3496
}
 
3497
 
 
3498
int  XColormapEvent_send_event(i)
 
3499
XColormapEvent* i;
 
3500
{
 
3501
          return(i->send_event);
 
3502
}
 
3503
 
 
3504
void set_XColormapEvent_send_event(i, j)
 
3505
XColormapEvent* i;
 
3506
int j;
 
3507
{
 
3508
          i->send_event = j;
 
3509
}
 
3510
 
 
3511
int  XColormapEvent_serial(i)
 
3512
XColormapEvent* i;
 
3513
{
 
3514
          return(i->serial);
 
3515
}
 
3516
 
 
3517
void set_XColormapEvent_serial(i, j)
 
3518
XColormapEvent* i;
 
3519
int j;
 
3520
{
 
3521
          i->serial = j;
 
3522
}
 
3523
 
 
3524
int  XColormapEvent_type(i)
 
3525
XColormapEvent* i;
 
3526
{
 
3527
          return(i->type);
 
3528
}
 
3529
 
 
3530
void set_XColormapEvent_type(i, j)
 
3531
XColormapEvent* i;
 
3532
int j;
 
3533
{
 
3534
          i->type = j;
 
3535
}
 
3536
 
 
3537
 
 
3538
/********* XClientMessageEvent funcions *****/
 
3539
 
 
3540
int  make_XClientMessageEvent (){
 
3541
          return ((int) calloc(1, sizeof(XClientMessageEvent)));
 
3542
}
 
3543
 
 
3544
int  XClientMessageEvent_format(i)
 
3545
XClientMessageEvent* i;
 
3546
{
 
3547
          return(i->format);
 
3548
}
 
3549
 
 
3550
void set_XClientMessageEvent_format(i, j)
 
3551
XClientMessageEvent* i;
 
3552
int j;
 
3553
{
 
3554
          i->format = j;
 
3555
}
 
3556
 
 
3557
int  XClientMessageEvent_message_type(i)
 
3558
XClientMessageEvent* i;
 
3559
{
 
3560
          return(i->message_type);
 
3561
}
 
3562
 
 
3563
void set_XClientMessageEvent_message_type(i, j)
 
3564
XClientMessageEvent* i;
 
3565
int j;
 
3566
{
 
3567
          i->message_type = j;
 
3568
}
 
3569
 
 
3570
 
 
3571
int  XClientMessageEvent_window(i)
 
3572
XClientMessageEvent* i;
 
3573
{
 
3574
          return(i->window);
 
3575
}
 
3576
 
 
3577
void set_XClientMessageEvent_window(i, j)
 
3578
XClientMessageEvent* i;
 
3579
int j;
 
3580
{
 
3581
          i->window = j;
 
3582
}
 
3583
 
 
3584
Display *XClientMessageEvent_display(i)
 
3585
XClientMessageEvent* i;
 
3586
{
 
3587
          return(i->display);
 
3588
}
 
3589
 
 
3590
void set_XClientMessageEvent_display(i, j)
 
3591
XClientMessageEvent* i;
 
3592
Display *j;
 
3593
{
 
3594
          i->display = j;
 
3595
}
 
3596
 
 
3597
int  XClientMessageEvent_send_event(i)
 
3598
XClientMessageEvent* i;
 
3599
{
 
3600
          return(i->send_event);
 
3601
}
 
3602
 
 
3603
void set_XClientMessageEvent_send_event(i, j)
 
3604
XClientMessageEvent* i;
 
3605
int j;
 
3606
{
 
3607
          i->send_event = j;
 
3608
}
 
3609
 
 
3610
int  XClientMessageEvent_serial(i)
 
3611
XClientMessageEvent* i;
 
3612
{
 
3613
          return(i->serial);
 
3614
}
 
3615
 
 
3616
void set_XClientMessageEvent_serial(i, j)
 
3617
XClientMessageEvent* i;
 
3618
int j;
 
3619
{
 
3620
          i->serial = j;
 
3621
}
 
3622
 
 
3623
int  XClientMessageEvent_type(i)
 
3624
XClientMessageEvent* i;
 
3625
{
 
3626
          return(i->type);
 
3627
}
 
3628
 
 
3629
void set_XClientMessageEvent_type(i, j)
 
3630
XClientMessageEvent* i;
 
3631
int j;
 
3632
{
 
3633
          i->type = j;
 
3634
}
 
3635
 
 
3636
 
 
3637
/********* XMappingEvent funcions *****/
 
3638
 
 
3639
int  make_XMappingEvent (){
 
3640
          return ((int) calloc(1, sizeof(XMappingEvent)));
 
3641
}
 
3642
 
 
3643
int  XMappingEvent_count(i)
 
3644
XMappingEvent* i;
 
3645
{
 
3646
          return(i->count);
 
3647
}
 
3648
 
 
3649
void set_XMappingEvent_count(i, j)
 
3650
XMappingEvent* i;
 
3651
int j;
 
3652
{
 
3653
          i->count = j;
 
3654
}
 
3655
 
 
3656
int XMappingEvent_first_keycode(i)
 
3657
XMappingEvent* i;
 
3658
{
 
3659
          return(i->first_keycode);
 
3660
}
 
3661
 
 
3662
void set_XMappingEvent_first_keycode(i, j)
 
3663
XMappingEvent* i;
 
3664
int j;
 
3665
{
 
3666
          i->first_keycode = j;
 
3667
}
 
3668
 
 
3669
int  XMappingEvent_request(i)
 
3670
XMappingEvent* i;
 
3671
{
 
3672
          return(i->request);
 
3673
}
 
3674
 
 
3675
void set_XMappingEvent_request(i, j)
 
3676
XMappingEvent* i;
 
3677
int j;
 
3678
{
 
3679
          i->request = j;
 
3680
}
 
3681
 
 
3682
int  XMappingEvent_window(i)
 
3683
XMappingEvent* i;
 
3684
{
 
3685
          return(i->window);
 
3686
}
 
3687
 
 
3688
void set_XMappingEvent_window(i, j)
 
3689
XMappingEvent* i;
 
3690
int j;
 
3691
{
 
3692
          i->window = j;
 
3693
}
 
3694
 
 
3695
Display *XMappingEvent_display(i)
 
3696
XMappingEvent* i;
 
3697
{
 
3698
          return(i->display);
 
3699
}
 
3700
 
 
3701
void set_XMappingEvent_display(i, j)
 
3702
XMappingEvent* i;
 
3703
Display *j;
 
3704
{
 
3705
          i->display = j;
 
3706
}
 
3707
 
 
3708
int  XMappingEvent_send_event(i)
 
3709
XMappingEvent* i;
 
3710
{
 
3711
          return(i->send_event);
 
3712
}
 
3713
 
 
3714
void set_XMappingEvent_send_event(i, j)
 
3715
XMappingEvent* i;
 
3716
int j;
 
3717
{
 
3718
          i->send_event = j;
 
3719
}
 
3720
 
 
3721
int  XMappingEvent_serial(i)
 
3722
XMappingEvent* i;
 
3723
{
 
3724
          return(i->serial);
 
3725
}
 
3726
 
 
3727
void set_XMappingEvent_serial(i, j)
 
3728
XMappingEvent* i;
 
3729
int j;
 
3730
{
 
3731
          i->serial = j;
 
3732
}
 
3733
 
 
3734
int  XMappingEvent_type(i)
 
3735
XMappingEvent* i;
 
3736
{
 
3737
          return(i->type);
 
3738
}
 
3739
 
 
3740
void set_XMappingEvent_type(i, j)
 
3741
XMappingEvent* i;
 
3742
int j;
 
3743
{
 
3744
          i->type = j;
 
3745
}
 
3746
 
 
3747
 
 
3748
/********* XErrorEvent funcions *****/
 
3749
 
 
3750
int  make_XErrorEvent (){
 
3751
          return ((int) calloc(1, sizeof(XErrorEvent)));
 
3752
}
 
3753
 
 
3754
char XErrorEvent_minor_code(i)
 
3755
XErrorEvent* i;
 
3756
{
 
3757
          return(i->minor_code);
 
3758
}
 
3759
 
 
3760
void set_XErrorEvent_minor_code(i, j)
 
3761
XErrorEvent* i;
 
3762
char j;
 
3763
{
 
3764
          i->minor_code = j;
 
3765
}
 
3766
 
 
3767
char XErrorEvent_request_code(i)
 
3768
XErrorEvent* i;
 
3769
{
 
3770
          return(i->request_code);
 
3771
}
 
3772
 
 
3773
void set_XErrorEvent_request_code(i, j)
 
3774
XErrorEvent* i;
 
3775
char j;
 
3776
{
 
3777
          i->request_code = j;
 
3778
}
 
3779
 
 
3780
char XErrorEvent_error_code(i)
 
3781
XErrorEvent* i;
 
3782
{
 
3783
          return(i->error_code);
 
3784
}
 
3785
 
 
3786
void set_XErrorEvent_error_code(i, j)
 
3787
XErrorEvent* i;
 
3788
char j;
 
3789
{
 
3790
          i->error_code = j;
 
3791
}
 
3792
 
 
3793
int  XErrorEvent_serial(i)
 
3794
XErrorEvent* i;
 
3795
{
 
3796
          return(i->serial);
 
3797
}
 
3798
 
 
3799
void set_XErrorEvent_serial(i, j)
 
3800
XErrorEvent* i;
 
3801
int j;
 
3802
{
 
3803
          i->serial = j;
 
3804
}
 
3805
 
 
3806
int  XErrorEvent_resourceid(i)
 
3807
XErrorEvent* i;
 
3808
{
 
3809
          return(i->resourceid);
 
3810
}
 
3811
 
 
3812
void set_XErrorEvent_resourceid(i, j)
 
3813
XErrorEvent* i;
 
3814
int j;
 
3815
{
 
3816
          i->resourceid = j;
 
3817
}
 
3818
 
 
3819
Display *XErrorEvent_display(i)
 
3820
XErrorEvent* i;
 
3821
{
 
3822
          return(i->display);
 
3823
}
 
3824
 
 
3825
void set_XErrorEvent_display(i, j)
 
3826
XErrorEvent* i;
 
3827
Display *j;
 
3828
{
 
3829
          i->display = j;
 
3830
}
 
3831
 
 
3832
int  XErrorEvent_type(i)
 
3833
XErrorEvent* i;
 
3834
{
 
3835
          return(i->type);
 
3836
}
 
3837
 
 
3838
void set_XErrorEvent_type(i, j)
 
3839
XErrorEvent* i;
 
3840
int j;
 
3841
{
 
3842
          i->type = j;
 
3843
}
 
3844
 
 
3845
 
 
3846
/********* XAnyEvent funcions *****/
 
3847
 
 
3848
int  make_XAnyEvent (){
 
3849
          return ((int) calloc(1, sizeof(XAnyEvent)));
 
3850
}
 
3851
 
 
3852
int  XAnyEvent_window(i)
 
3853
XAnyEvent* i;
 
3854
{
 
3855
          return(i->window);
 
3856
}
 
3857
 
 
3858
void set_XAnyEvent_window(i, j)
 
3859
XAnyEvent* i;
 
3860
int j;
 
3861
{
 
3862
          i->window = j;
 
3863
}
 
3864
 
 
3865
Display *XAnyEvent_display(i)
 
3866
XAnyEvent* i;
 
3867
{
 
3868
          return(i->display);
 
3869
}
 
3870
 
 
3871
void set_XAnyEvent_display(i, j)
 
3872
XAnyEvent* i;
 
3873
Display *j;
 
3874
{
 
3875
          i->display = j;
 
3876
}
 
3877
 
 
3878
int  XAnyEvent_send_event(i)
 
3879
XAnyEvent* i;
 
3880
{
 
3881
          return(i->send_event);
 
3882
}
 
3883
 
 
3884
void set_XAnyEvent_send_event(i, j)
 
3885
XAnyEvent* i;
 
3886
int j;
 
3887
{
 
3888
          i->send_event = j;
 
3889
}
 
3890
 
 
3891
int  XAnyEvent_serial(i)
 
3892
XAnyEvent* i;
 
3893
{
 
3894
          return(i->serial);
 
3895
}
 
3896
 
 
3897
void set_XAnyEvent_serial(i, j)
 
3898
XAnyEvent* i;
 
3899
int j;
 
3900
{
 
3901
          i->serial = j;
 
3902
}
 
3903
 
 
3904
int  XAnyEvent_type(i)
 
3905
XAnyEvent* i;
 
3906
{
 
3907
          return(i->type);
 
3908
}
 
3909
 
 
3910
void set_XAnyEvent_type(i, j)
 
3911
XAnyEvent* i;
 
3912
int j;
 
3913
{
 
3914
          i->type = j;
 
3915
}
 
3916
 
 
3917
 
 
3918
/********* XEvent funcions *****/
 
3919
 
 
3920
int  make_XEvent (){
 
3921
          return ((int) calloc(1, sizeof(XEvent)));
 
3922
}