← Back to branch summary

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

« back to all changes in this revision

Viewing changes to xgcl-2/XStruct-2.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/XStruct-2.c
 
1
/* XStruct-2.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
 
 
25
/********* _XQEvent funcions *****/
 
26
#define NEED_EVENTS
 
27
#include <X11/Xlib.h>
 
28
#include <X11/Xutil.h>
 
29
#include <X11/Xlibint.h>
 
30
 
 
31
 
 
32
int  make__XQEvent (){
 
33
          return ((int) calloc(1, sizeof(_XQEvent)));
 
34
}
 
35
 
 
36
XEvent _XQEvent_event(i)
 
37
_XQEvent* i;
 
38
{
 
39
          return(i->event);
 
40
}
 
41
 
 
42
void set__XQEvent_event(i, j)
 
43
_XQEvent* i;
 
44
XEvent j;
 
45
{
 
46
          i->event = j;
 
47
}
 
48
 
 
49
_XQEvent *_XQEvent_next(i)
 
50
_XQEvent* i;
 
51
{
 
52
          return(i->next);
 
53
}
 
54
 
 
55
void set__XQEvent_next(i, j)
 
56
_XQEvent* i;
 
57
_XQEvent *j;
 
58
{
 
59
          i->next = j;
 
60
}
 
61
 
 
62
 
 
63
/********* XCharStruct funcions *****/
 
64
 
 
65
int  make_XCharStruct (){
 
66
          return ((int) calloc(1, sizeof(XCharStruct)));
 
67
}
 
68
 
 
69
int  XCharStruct_attributes(i)
 
70
XCharStruct* i;
 
71
{
 
72
          return(i->attributes);
 
73
}
 
74
 
 
75
void set_XCharStruct_attributes(i, j)
 
76
XCharStruct* i;
 
77
int j;
 
78
{
 
79
          i->attributes = j;
 
80
}
 
81
 
 
82
int  XCharStruct_descent(i)
 
83
XCharStruct* i;
 
84
{
 
85
          return(i->descent);
 
86
}
 
87
 
 
88
void set_XCharStruct_descent(i, j)
 
89
XCharStruct* i;
 
90
int j;
 
91
{
 
92
          i->descent = j;
 
93
}
 
94
 
 
95
int  XCharStruct_ascent(i)
 
96
XCharStruct* i;
 
97
{
 
98
          return(i->ascent);
 
99
}
 
100
 
 
101
void set_XCharStruct_ascent(i, j)
 
102
XCharStruct* i;
 
103
int j;
 
104
{
 
105
          i->ascent = j;
 
106
}
 
107
 
 
108
int  XCharStruct_width(i)
 
109
XCharStruct* i;
 
110
{
 
111
          return(i->width);
 
112
}
 
113
 
 
114
void set_XCharStruct_width(i, j)
 
115
XCharStruct* i;
 
116
int j;
 
117
{
 
118
          i->width = j;
 
119
}
 
120
 
 
121
int  XCharStruct_rbearing(i)
 
122
XCharStruct* i;
 
123
{
 
124
          return(i->rbearing);
 
125
}
 
126
 
 
127
void set_XCharStruct_rbearing(i, j)
 
128
XCharStruct* i;
 
129
int j;
 
130
{
 
131
          i->rbearing = j;
 
132
}
 
133
 
 
134
int  XCharStruct_lbearing(i)
 
135
XCharStruct* i;
 
136
{
 
137
          return(i->lbearing);
 
138
}
 
139
 
 
140
void set_XCharStruct_lbearing(i, j)
 
141
XCharStruct* i;
 
142
int j;
 
143
{
 
144
          i->lbearing = j;
 
145
}
 
146
 
 
147
 
 
148
/********* XFontProp funcions *****/
 
149
 
 
150
int  make_XFontProp (){
 
151
          return ((int) calloc(1, sizeof(XFontProp)));
 
152
}
 
153
 
 
154
int  XFontProp_card32(i)
 
155
XFontProp* i;
 
156
{
 
157
          return(i->card32);
 
158
}
 
159
 
 
160
void set_XFontProp_card32(i, j)
 
161
XFontProp* i;
 
162
int j;
 
163
{
 
164
          i->card32 = j;
 
165
}
 
166
 
 
167
int  XFontProp_name(i)
 
168
XFontProp* i;
 
169
{
 
170
          return(i->name);
 
171
}
 
172
 
 
173
void set_XFontProp_name(i, j)
 
174
XFontProp* i;
 
175
int j;
 
176
{
 
177
          i->name = j;
 
178
}
 
179
 
 
180
 
 
181
/********* XFontStruct funcions *****/
 
182
 
 
183
int  make_XFontStruct (){
 
184
          return ((int) calloc(1, sizeof(XFontStruct)));
 
185
}
 
186
 
 
187
int  XFontStruct_descent(i)
 
188
XFontStruct* i;
 
189
{
 
190
          return(i->descent);
 
191
}
 
192
 
 
193
void set_XFontStruct_descent(i, j)
 
194
XFontStruct* i;
 
195
int j;
 
196
{
 
197
          i->descent = j;
 
198
}
 
199
 
 
200
int  XFontStruct_ascent(i)
 
201
XFontStruct* i;
 
202
{
 
203
          return(i->ascent);
 
204
}
 
205
 
 
206
void set_XFontStruct_ascent(i, j)
 
207
XFontStruct* i;
 
208
int j;
 
209
{
 
210
          i->ascent = j;
 
211
}
 
212
 
 
213
XCharStruct *XFontStruct_per_char(i)
 
214
XFontStruct* i;
 
215
{
 
216
          return(i->per_char);
 
217
}
 
218
 
 
219
void set_XFontStruct_per_char(i, j)
 
220
XFontStruct* i;
 
221
XCharStruct *j;
 
222
{
 
223
          i->per_char = j;
 
224
}
 
225
 
 
226
XCharStruct *XFontStruct_max_bounds(i)
 
227
XFontStruct* i;
 
228
{
 
229
          return(&i->max_bounds);
 
230
}
 
231
XCharStruct *XFontStruct_min_bounds(i)
 
232
XFontStruct* i;
 
233
{
 
234
          return(&i->min_bounds);
 
235
}
 
236
void set_XFontStruct_max_bounds(i, j)
 
237
XFontStruct* i;
 
238
XCharStruct j;
 
239
{
 
240
          i->max_bounds = j;
 
241
}
 
242
void set_XFontStruct_min_bounds(i, j)
 
243
XFontStruct* i;
 
244
XCharStruct j;
 
245
{
 
246
          i->min_bounds = j;
 
247
}
 
248
 
 
249
XFontProp *XFontStruct_properties(i)
 
250
XFontStruct* i;
 
251
{
 
252
          return(i->properties);
 
253
}
 
254
 
 
255
void set_XFontStruct_properties(i, j)
 
256
XFontStruct* i;
 
257
XFontProp *j;
 
258
{
 
259
          i->properties = j;
 
260
}
 
261
 
 
262
int  XFontStruct_n_properties(i)
 
263
XFontStruct* i;
 
264
{
 
265
          return(i->n_properties);
 
266
}
 
267
 
 
268
void set_XFontStruct_n_properties(i, j)
 
269
XFontStruct* i;
 
270
int j;
 
271
{
 
272
          i->n_properties = j;
 
273
}
 
274
 
 
275
int  XFontStruct_default_char(i)
 
276
XFontStruct* i;
 
277
{
 
278
          return(i->default_char);
 
279
}
 
280
 
 
281
void set_XFontStruct_default_char(i, j)
 
282
XFontStruct* i;
 
283
int j;
 
284
{
 
285
          i->default_char = j;
 
286
}
 
287
 
 
288
int  XFontStruct_all_chars_exist(i)
 
289
XFontStruct* i;
 
290
{
 
291
          return(i->all_chars_exist);
 
292
}
 
293
 
 
294
void set_XFontStruct_all_chars_exist(i, j)
 
295
XFontStruct* i;
 
296
int j;
 
297
{
 
298
          i->all_chars_exist = j;
 
299
}
 
300
 
 
301
int  XFontStruct_max_byte1(i)
 
302
XFontStruct* i;
 
303
{
 
304
          return(i->max_byte1);
 
305
}
 
306
 
 
307
void set_XFontStruct_max_byte1(i, j)
 
308
XFontStruct* i;
 
309
int j;
 
310
{
 
311
          i->max_byte1 = j;
 
312
}
 
313
 
 
314
int  XFontStruct_min_byte1(i)
 
315
XFontStruct* i;
 
316
{
 
317
          return(i->min_byte1);
 
318
}
 
319
 
 
320
void set_XFontStruct_min_byte1(i, j)
 
321
XFontStruct* i;
 
322
int j;
 
323
{
 
324
          i->min_byte1 = j;
 
325
}
 
326
 
 
327
int  XFontStruct_max_char_or_byte2(i)
 
328
XFontStruct* i;
 
329
{
 
330
          return(i->max_char_or_byte2);
 
331
}
 
332
 
 
333
void set_XFontStruct_max_char_or_byte2(i, j)
 
334
XFontStruct* i;
 
335
int j;
 
336
{
 
337
          i->max_char_or_byte2 = j;
 
338
}
 
339
 
 
340
int  XFontStruct_min_char_or_byte2(i)
 
341
XFontStruct* i;
 
342
{
 
343
          return(i->min_char_or_byte2);
 
344
}
 
345
 
 
346
void set_XFontStruct_min_char_or_byte2(i, j)
 
347
XFontStruct* i;
 
348
int j;
 
349
{
 
350
          i->min_char_or_byte2 = j;
 
351
}
 
352
 
 
353
int  XFontStruct_direction(i)
 
354
XFontStruct* i;
 
355
{
 
356
          return(i->direction);
 
357
}
 
358
 
 
359
void set_XFontStruct_direction(i, j)
 
360
XFontStruct* i;
 
361
int j;
 
362
{
 
363
          i->direction = j;
 
364
}
 
365
 
 
366
int  XFontStruct_fid(i)
 
367
XFontStruct* i;
 
368
{
 
369
          return(i->fid);
 
370
}
 
371
 
 
372
void set_XFontStruct_fid(i, j)
 
373
XFontStruct* i;
 
374
int j;
 
375
{
 
376
          i->fid = j;
 
377
}
 
378
 
 
379
XExtData * XFontStruct_ext_data(i)
 
380
XFontStruct* i;
 
381
{
 
382
          return(i->ext_data);
 
383
}
 
384
 
 
385
void set_XFontStruct_ext_data(i, j)
 
386
XFontStruct* i;
 
387
XExtData *j;
 
388
{
 
389
          i->ext_data = j;
 
390
}
 
391
 
 
392
 
 
393
/********* XTextItem funcions *****/
 
394
 
 
395
int  make_XTextItem (){
 
396
          return ((int) calloc(1, sizeof(XTextItem)));
 
397
}
 
398
 
 
399
int  XTextItem_font(i)
 
400
XTextItem* i;
 
401
{
 
402
          return(i->font);
 
403
}
 
404
 
 
405
void set_XTextItem_font(i, j)
 
406
XTextItem* i;
 
407
int j;
 
408
{
 
409
          i->font = j;
 
410
}
 
411
 
 
412
int  XTextItem_delta(i)
 
413
XTextItem* i;
 
414
{
 
415
          return(i->delta);
 
416
}
 
417
 
 
418
void set_XTextItem_delta(i, j)
 
419
XTextItem* i;
 
420
int j;
 
421
{
 
422
          i->delta = j;
 
423
}
 
424
 
 
425
int  XTextItem_nchars(i)
 
426
XTextItem* i;
 
427
{
 
428
          return(i->nchars);
 
429
}
 
430
 
 
431
void set_XTextItem_nchars(i, j)
 
432
XTextItem* i;
 
433
int j;
 
434
{
 
435
          i->nchars = j;
 
436
}
 
437
 
 
438
char * XTextItem_chars(i)
 
439
XTextItem* i;
 
440
{
 
441
          return(i->chars);
 
442
}
 
443
 
 
444
void set_XTextItem_chars(i, j)
 
445
XTextItem* i;
 
446
char *j;
 
447
{
 
448
          i->chars = j;
 
449
}
 
450
 
 
451
 
 
452
/********* XChar2b funcions *****/
 
453
 
 
454
int  make_XChar2b (){
 
455
          return ((int) calloc(1, sizeof(XChar2b)));
 
456
}
 
457
 
 
458
char XChar2b_byte2(i)
 
459
XChar2b* i;
 
460
{
 
461
          return(i->byte2);
 
462
}
 
463
 
 
464
void set_XChar2b_byte2(i, j)
 
465
XChar2b* i;
 
466
char j;
 
467
{
 
468
          i->byte2 = j;
 
469
}
 
470
 
 
471
char XChar2b_byte1(i)
 
472
XChar2b* i;
 
473
{
 
474
          return(i->byte1);
 
475
}
 
476
 
 
477
void set_XChar2b_byte1(i, j)
 
478
XChar2b* i;
 
479
char j;
 
480
{
 
481
          i->byte1 = j;
 
482
}
 
483
 
 
484
 
 
485
/********* XTextItem16 funcions *****/
 
486
 
 
487
int  make_XTextItem16 (){
 
488
          return ((int) calloc(1, sizeof(XTextItem16)));
 
489
}
 
490
 
 
491
int  XTextItem16_font(i)
 
492
XTextItem16* i;
 
493
{
 
494
          return(i->font);
 
495
}
 
496
 
 
497
void set_XTextItem16_font(i, j)
 
498
XTextItem16* i;
 
499
int j;
 
500
{
 
501
          i->font = j;
 
502
}
 
503
 
 
504
int  XTextItem16_delta(i)
 
505
XTextItem16* i;
 
506
{
 
507
          return(i->delta);
 
508
}
 
509
 
 
510
void set_XTextItem16_delta(i, j)
 
511
XTextItem16* i;
 
512
int j;
 
513
{
 
514
          i->delta = j;
 
515
}
 
516
 
 
517
int  XTextItem16_nchars(i)
 
518
XTextItem16* i;
 
519
{
 
520
          return(i->nchars);
 
521
}
 
522
 
 
523
void set_XTextItem16_nchars(i, j)
 
524
XTextItem16* i;
 
525
int j;
 
526
{
 
527
          i->nchars = j;
 
528
}
 
529
 
 
530
XChar2b * XTextItem16_chars(i)
 
531
XTextItem16* i;
 
532
{
 
533
          return(i->chars);
 
534
}
 
535
 
 
536
void set_XTextItem16_chars(i, j)
 
537
XTextItem16* i;
 
538
XChar2b *j;
 
539
{
 
540
          i->chars = j;
 
541
}
 
542
 
 
543
 
 
544
/********* XEDataObject funcions *****/
 
545
 
 
546
int  make_XEDataObject (){
 
547
          return ((int) calloc(1, sizeof(XEDataObject)));
 
548
}
 
549
 
 
550
XFontStruct *XEDataObject_font(i)
 
551
XEDataObject* i;
 
552
{
 
553
          return(i->font);
 
554
}
 
555
 
 
556
void set_XEDataObject_font(i, j)
 
557
XEDataObject* i;
 
558
XFontStruct *j;
 
559
{
 
560
          i->font = j;
 
561
}
 
562
 
 
563
ScreenFormat *XEDataObject_pixmap_format(i)
 
564
XEDataObject* i;
 
565
{
 
566
          return(i->pixmap_format);
 
567
}
 
568
 
 
569
void set_XEDataObject_pixmap_format(i, j)
 
570
XEDataObject* i;
 
571
ScreenFormat *j;
 
572
{
 
573
          i->pixmap_format = j;
 
574
}
 
575
 
 
576
Screen *XEDataObject_screen(i)
 
577
XEDataObject* i;
 
578
{
 
579
          return(i->screen);
 
580
}
 
581
 
 
582
void set_XEDataObject_screen(i, j)
 
583
XEDataObject* i;
 
584
Screen *j;
 
585
{
 
586
          i->screen = j;
 
587
}
 
588
 
 
589
Visual *XEDataObject_visual(i)
 
590
XEDataObject* i;
 
591
{
 
592
          return(i->visual);
 
593
}
 
594
 
 
595
void set_XEDataObject_visual(i, j)
 
596
XEDataObject* i;
 
597
Visual *j;
 
598
{
 
599
          i->visual = j;
 
600
}
 
601
 
 
602
GC   XEDataObject_gc(i)
 
603
XEDataObject* i;
 
604
{
 
605
          return(i->gc);
 
606
}
 
607
 
 
608
void set_XEDataObject_gc(i, j)
 
609
XEDataObject* i;
 
610
GC j;
 
611
{
 
612
          i->gc = j;
 
613
}
 
614
 
 
615
 
 
616
/********* XSizeHints funcions *****/
 
617
 
 
618
int  make_XSizeHints (){
 
619
          return ((int) calloc(1, sizeof(XSizeHints)));
 
620
}
 
621
 
 
622
int  XSizeHints_win_gravity(i)
 
623
XSizeHints *i;
 
624
{
 
625
          return(i->win_gravity);
 
626
}
 
627
 
 
628
void set_XSizeHints_win_gravity(i, j)
 
629
XSizeHints *i;
 
630
int j;
 
631
{
 
632
          i->win_gravity = j;
 
633
}
 
634
 
 
635
int  XSizeHints_base_height(i)
 
636
XSizeHints* i;
 
637
{
 
638
          return(i->base_height);
 
639
}
 
640
 
 
641
void set_XSizeHints_base_height(i, j)
 
642
XSizeHints* i;
 
643
int j;
 
644
{
 
645
          i->base_height = j;
 
646
}
 
647
 
 
648
int  XSizeHints_base_width(i)
 
649
XSizeHints* i;
 
650
{
 
651
          return(i->base_width);
 
652
}
 
653
 
 
654
void set_XSizeHints_base_width(i, j)
 
655
XSizeHints* i;
 
656
int j;
 
657
{
 
658
          i->base_width = j;
 
659
}
 
660
 
 
661
int  XSizeHints_height_inc(i)
 
662
XSizeHints* i;
 
663
{
 
664
          return(i->height_inc);
 
665
}
 
666
 
 
667
void set_XSizeHints_height_inc(i, j)
 
668
XSizeHints* i;
 
669
int j;
 
670
{
 
671
          i->height_inc = j;
 
672
}
 
673
 
 
674
int  XSizeHints_width_inc(i)
 
675
XSizeHints* i;
 
676
{
 
677
          return(i->width_inc);
 
678
}
 
679
 
 
680
void set_XSizeHints_width_inc(i, j)
 
681
XSizeHints* i;
 
682
int j;
 
683
{
 
684
          i->width_inc = j;
 
685
}
 
686
 
 
687
int  XSizeHints_max_height(i)
 
688
XSizeHints* i;
 
689
{
 
690
          return(i->max_height);
 
691
}
 
692
 
 
693
void set_XSizeHints_max_height(i, j)
 
694
XSizeHints* i;
 
695
int j;
 
696
{
 
697
          i->max_height = j;
 
698
}
 
699
 
 
700
int  XSizeHints_max_width(i)
 
701
XSizeHints* i;
 
702
{
 
703
          return(i->max_width);
 
704
}
 
705
 
 
706
void set_XSizeHints_max_width(i, j)
 
707
XSizeHints* i;
 
708
int j;
 
709
{
 
710
          i->max_width = j;
 
711
}
 
712
 
 
713
int  XSizeHints_min_height(i)
 
714
XSizeHints* i;
 
715
{
 
716
          return(i->min_height);
 
717
}
 
718
 
 
719
void set_XSizeHints_min_height(i, j)
 
720
XSizeHints* i;
 
721
int j;
 
722
{
 
723
          i->min_height = j;
 
724
}
 
725
 
 
726
int  XSizeHints_min_width(i)
 
727
XSizeHints* i;
 
728
{
 
729
          return(i->min_width);
 
730
}
 
731
 
 
732
void set_XSizeHints_min_width(i, j)
 
733
XSizeHints* i;
 
734
int j;
 
735
{
 
736
          i->min_width = j;
 
737
}
 
738
 
 
739
int  XSizeHints_height(i)
 
740
XSizeHints* i;
 
741
{
 
742
          return(i->height);
 
743
}
 
744
 
 
745
void set_XSizeHints_height(i, j)
 
746
XSizeHints* i;
 
747
int j;
 
748
{
 
749
          i->height = j;
 
750
}
 
751
 
 
752
int  XSizeHints_width(i)
 
753
XSizeHints* i;
 
754
{
 
755
          return(i->width);
 
756
}
 
757
 
 
758
void set_XSizeHints_width(i, j)
 
759
XSizeHints* i;
 
760
int j;
 
761
{
 
762
          i->width = j;
 
763
}
 
764
 
 
765
int  XSizeHints_y(i)
 
766
XSizeHints* i;
 
767
{
 
768
          return(i->y);
 
769
}
 
770
 
 
771
void set_XSizeHints_y(i, j)
 
772
XSizeHints* i;
 
773
int j;
 
774
{
 
775
          i->y = j;
 
776
}
 
777
 
 
778
int  XSizeHints_x(i)
 
779
XSizeHints* i;
 
780
{
 
781
          return(i->x);
 
782
}
 
783
 
 
784
void set_XSizeHints_x(i, j)
 
785
XSizeHints* i;
 
786
int j;
 
787
{
 
788
          i->x = j;
 
789
}
 
790
 
 
791
int  XSizeHints_flags(i)
 
792
XSizeHints* i;
 
793
{
 
794
          return(i->flags);
 
795
}
 
796
 
 
797
void set_XSizeHints_flags(i, j)
 
798
XSizeHints* i;
 
799
int j;
 
800
{
 
801
          i->flags = j;
 
802
}
 
803
 
 
804
 
 
805
int  XSizeHints_max_aspect_x(i)
 
806
XSizeHints* i;
 
807
{
 
808
          return(i->max_aspect.x);
 
809
}
 
810
 
 
811
void  set_XSizeHints_max_aspect_x(i, j)
 
812
XSizeHints* i;
 
813
int     j;
 
814
{
 
815
          i->max_aspect.x = j;
 
816
}
 
817
 
 
818
int  XSizeHints_max_aspect_y(i)
 
819
XSizeHints* i;
 
820
{
 
821
          return(i->max_aspect.y);
 
822
}
 
823
 
 
824
void  set_XSizeHints_max_aspect_y(i, j)
 
825
XSizeHints* i;
 
826
int     j;
 
827
{
 
828
          i->max_aspect.y = j;
 
829
}
 
830
 
 
831
int  XSizeHints_min_aspect_x(i)
 
832
XSizeHints* i;
 
833
{
 
834
          return(i->min_aspect.x);
 
835
}
 
836
 
 
837
void  set_XSizeHints_min_aspect_x(i, j)
 
838
XSizeHints* i;
 
839
int     j;
 
840
{
 
841
          i->min_aspect.x = j;
 
842
}
 
843
 
 
844
 
 
845
int  XSizeHints_min_aspect_y(i)
 
846
XSizeHints* i;
 
847
{
 
848
          return(i->min_aspect.y);
 
849
}
 
850
 
 
851
void  set_XSizeHints_min_aspect_y(i, j)
 
852
XSizeHints* i;
 
853
int     j;
 
854
{
 
855
          i->min_aspect.y = j;
 
856
}
 
857
 
 
858
 
 
859
/********* XWMHints funcions *****/
 
860
 
 
861
int  make_XWMHints (){
 
862
          return ((int) calloc(1, sizeof(XWMHints)));
 
863
}
 
864
 
 
865
int  XWMHints_window_group(i)
 
866
XWMHints* i;
 
867
{
 
868
          return(i->window_group);
 
869
}
 
870
 
 
871
void set_XWMHints_window_group(i, j)
 
872
XWMHints* i;
 
873
int j;
 
874
{
 
875
          i->window_group = j;
 
876
}
 
877
 
 
878
int  XWMHints_icon_mask(i)
 
879
XWMHints* i;
 
880
{
 
881
          return(i->icon_mask);
 
882
}
 
883
 
 
884
void set_XWMHints_icon_mask(i, j)
 
885
XWMHints* i;
 
886
int j;
 
887
{
 
888
          i->icon_mask = j;
 
889
}
 
890
 
 
891
int  XWMHints_icon_y(i)
 
892
XWMHints* i;
 
893
{
 
894
          return(i->icon_y);
 
895
}
 
896
 
 
897
void set_XWMHints_icon_y(i, j)
 
898
XWMHints* i;
 
899
int j;
 
900
{
 
901
          i->icon_y = j;
 
902
}
 
903
 
 
904
int  XWMHints_icon_x(i)
 
905
XWMHints* i;
 
906
{
 
907
          return(i->icon_x);
 
908
}
 
909
 
 
910
void set_XWMHints_icon_x(i, j)
 
911
XWMHints* i;
 
912
int j;
 
913
{
 
914
          i->icon_x = j;
 
915
}
 
916
 
 
917
int  XWMHints_icon_window(i)
 
918
XWMHints* i;
 
919
{
 
920
          return(i->icon_window);
 
921
}
 
922
 
 
923
void set_XWMHints_icon_window(i, j)
 
924
XWMHints* i;
 
925
int j;
 
926
{
 
927
          i->icon_window = j;
 
928
}
 
929
 
 
930
int  XWMHints_icon_pixmap(i)
 
931
XWMHints* i;
 
932
{
 
933
          return(i->icon_pixmap);
 
934
}
 
935
 
 
936
void set_XWMHints_icon_pixmap(i, j)
 
937
XWMHints* i;
 
938
int j;
 
939
{
 
940
          i->icon_pixmap = j;
 
941
}
 
942
 
 
943
int  XWMHints_initial_state(i)
 
944
XWMHints* i;
 
945
{
 
946
          return(i->initial_state);
 
947
}
 
948
 
 
949
void set_XWMHints_initial_state(i, j)
 
950
XWMHints* i;
 
951
int j;
 
952
{
 
953
          i->initial_state = j;
 
954
}
 
955
 
 
956
int  XWMHints_input(i)
 
957
XWMHints* i;
 
958
{
 
959
          return(i->input);
 
960
}
 
961
 
 
962
void set_XWMHints_input(i, j)
 
963
XWMHints* i;
 
964
int j;
 
965
{
 
966
          i->input = j;
 
967
}
 
968
 
 
969
int  XWMHints_flags(i)
 
970
XWMHints* i;
 
971
{
 
972
          return(i->flags);
 
973
}
 
974
 
 
975
void set_XWMHints_flags(i, j)
 
976
XWMHints* i;
 
977
int j;
 
978
{
 
979
          i->flags = j;
 
980
}
 
981
 
 
982
 
 
983
/********* XTextProperty funcions *****/
 
984
 
 
985
int  make_XTextProperty (){
 
986
          return ((int) calloc(1, sizeof(XTextProperty)));
 
987
}
 
988
 
 
989
int  XTextProperty_nitems(i)
 
990
XTextProperty *i;
 
991
{
 
992
          return(i->nitems);
 
993
}
 
994
 
 
995
void set_XTextProperty_nitems(i, j)
 
996
XTextProperty* i;
 
997
int j;
 
998
{
 
999
          i->nitems = j;
 
1000
}
 
1001
 
 
1002
int  XTextProperty_format(i)
 
1003
XTextProperty* i;
 
1004
{
 
1005
          return(i->format);
 
1006
}
 
1007
 
 
1008
void set_XTextProperty_format(i, j)
 
1009
XTextProperty* i;
 
1010
int j;
 
1011
{
 
1012
          i->format = j;
 
1013
}
 
1014
 
 
1015
int  XTextProperty_encoding(i)
 
1016
XTextProperty* i;
 
1017
{
 
1018
          return(i->encoding);
 
1019
}
 
1020
 
 
1021
void set_XTextProperty_encoding(i, j)
 
1022
XTextProperty* i;
 
1023
int j;
 
1024
{
 
1025
          i->encoding = j;
 
1026
}
 
1027
 
 
1028
unsigned char *XTextProperty_value(i)
 
1029
XTextProperty* i;
 
1030
{
 
1031
          return(i->value);
 
1032
}
 
1033
 
 
1034
void set_XTextProperty_value(i, j)
 
1035
XTextProperty* i;
 
1036
unsigned char *j;
 
1037
{
 
1038
          i->value = j;
 
1039
}
 
1040
 
 
1041
 
 
1042
/********* XIconSize funcions *****/
 
1043
 
 
1044
int  make_XIconSize (){
 
1045
          return ((int) calloc(1, sizeof(XIconSize)));
 
1046
}
 
1047
 
 
1048
int  XIconSize_height_inc(i)
 
1049
XIconSize* i;
 
1050
{
 
1051
          return(i->height_inc);
 
1052
}
 
1053
 
 
1054
void set_XIconSize_height_inc(i, j)
 
1055
XIconSize* i;
 
1056
int j;
 
1057
{
 
1058
          i->height_inc = j;
 
1059
}
 
1060
 
 
1061
int  XIconSize_width_inc(i)
 
1062
XIconSize* i;
 
1063
{
 
1064
          return(i->width_inc);
 
1065
}
 
1066
 
 
1067
void set_XIconSize_width_inc(i, j)
 
1068
XIconSize* i;
 
1069
int j;
 
1070
{
 
1071
          i->width_inc = j;
 
1072
}
 
1073
 
 
1074
int  XIconSize_max_height(i)
 
1075
XIconSize* i;
 
1076
{
 
1077
          return(i->max_height);
 
1078
}
 
1079
 
 
1080
void set_XIconSize_max_height(i, j)
 
1081
XIconSize* i;
 
1082
int j;
 
1083
{
 
1084
          i->max_height = j;
 
1085
}
 
1086
 
 
1087
int  XIconSize_max_width(i)
 
1088
XIconSize* i;
 
1089
{
 
1090
          return(i->max_width);
 
1091
}
 
1092
 
 
1093
void set_XIconSize_max_width(i, j)
 
1094
XIconSize* i;
 
1095
int j;
 
1096
{
 
1097
          i->max_width = j;
 
1098
}
 
1099
 
 
1100
int  XIconSize_min_height(i)
 
1101
XIconSize* i;
 
1102
{
 
1103
          return(i->min_height);
 
1104
}
 
1105
 
 
1106
void set_XIconSize_min_height(i, j)
 
1107
XIconSize* i;
 
1108
int j;
 
1109
{
 
1110
          i->min_height = j;
 
1111
}
 
1112
 
 
1113
int  XIconSize_min_width(i)
 
1114
XIconSize* i;
 
1115
{
 
1116
          return(i->min_width);
 
1117
}
 
1118
 
 
1119
void set_XIconSize_min_width(i, j)
 
1120
XIconSize* i;
 
1121
int j;
 
1122
{
 
1123
          i->min_width = j;
 
1124
}
 
1125
 
 
1126
 
 
1127
/********* XClassHint funcions *****/
 
1128
 
 
1129
int  make_XClassHint (){
 
1130
          return ((int) calloc(1, sizeof(XClassHint)));
 
1131
}
 
1132
 
 
1133
char *XClassHint_res_class(i)
 
1134
XClassHint* i;
 
1135
{
 
1136
          return(i->res_class);
 
1137
}
 
1138
 
 
1139
void set_XClassHint_res_class(i, j)
 
1140
XClassHint* i;
 
1141
char *j;
 
1142
{
 
1143
          i->res_class = j;
 
1144
}
 
1145
 
 
1146
char *XClassHint_res_name(i)
 
1147
XClassHint* i;
 
1148
{
 
1149
          return(i->res_name);
 
1150
}
 
1151
 
 
1152
void set_XClassHint_res_name(i, j)
 
1153
XClassHint* i;
 
1154
char *j;
 
1155
{
 
1156
          i->res_name = j;
 
1157
}
 
1158
 
 
1159
 
 
1160
/********* XComposeStatus funcions *****/
 
1161
 
 
1162
int  make_XComposeStatus (){
 
1163
          return ((int) calloc(1, sizeof(XComposeStatus)));
 
1164
}
 
1165
 
 
1166
int  XComposeStatus_chars_matched(i)
 
1167
XComposeStatus* i;
 
1168
{
 
1169
          return(i->chars_matched);
 
1170
}
 
1171
 
 
1172
void set_XComposeStatus_chars_matched(i, j)
 
1173
XComposeStatus* i;
 
1174
int j;
 
1175
{
 
1176
          i->chars_matched = j;
 
1177
}
 
1178
 
 
1179
XPointer  XComposeStatus_compose_ptr(i)
 
1180
XComposeStatus* i;
 
1181
{
 
1182
          return(i->compose_ptr);
 
1183
}
 
1184
 
 
1185
void set_XComposeStatus_compose_ptr(i, j)
 
1186
XComposeStatus* i;
 
1187
XPointer j;
 
1188
{
 
1189
          i->compose_ptr = j;
 
1190
}
 
1191
 
 
1192
 
 
1193
/********* XVisualInfo funcions *****/
 
1194
 
 
1195
int  make_XVisualInfo (){
 
1196
          return ((int) calloc(1, sizeof(XVisualInfo)));
 
1197
}
 
1198
 
 
1199
int  XVisualInfo_bits_per_rgb(i)
 
1200
XVisualInfo* i;
 
1201
{
 
1202
          return(i->bits_per_rgb);
 
1203
}
 
1204
 
 
1205
void set_XVisualInfo_bits_per_rgb(i, j)
 
1206
XVisualInfo* i;
 
1207
int j;
 
1208
{
 
1209
          i->bits_per_rgb = j;
 
1210
}
 
1211
 
 
1212
int  XVisualInfo_colormap_size(i)
 
1213
XVisualInfo* i;
 
1214
{
 
1215
          return(i->colormap_size);
 
1216
}
 
1217
 
 
1218
void set_XVisualInfo_colormap_size(i, j)
 
1219
XVisualInfo* i;
 
1220
int j;
 
1221
{
 
1222
          i->colormap_size = j;
 
1223
}
 
1224
 
 
1225
int  XVisualInfo_blue_mask(i)
 
1226
XVisualInfo* i;
 
1227
{
 
1228
          return(i->blue_mask);
 
1229
}
 
1230
 
 
1231
void set_XVisualInfo_blue_mask(i, j)
 
1232
XVisualInfo* i;
 
1233
int j;
 
1234
{
 
1235
          i->blue_mask = j;
 
1236
}
 
1237
 
 
1238
int  XVisualInfo_green_mask(i)
 
1239
XVisualInfo* i;
 
1240
{
 
1241
          return(i->green_mask);
 
1242
}
 
1243
 
 
1244
void set_XVisualInfo_green_mask(i, j)
 
1245
XVisualInfo* i;
 
1246
int j;
 
1247
{
 
1248
          i->green_mask = j;
 
1249
}
 
1250
 
 
1251
int  XVisualInfo_red_mask(i)
 
1252
XVisualInfo* i;
 
1253
{
 
1254
          return(i->red_mask);
 
1255
}
 
1256
 
 
1257
void set_XVisualInfo_red_mask(i, j)
 
1258
XVisualInfo* i;
 
1259
int j;
 
1260
{
 
1261
          i->red_mask = j;
 
1262
}
 
1263
 
 
1264
int  XVisualInfo_class(i)
 
1265
XVisualInfo* i;
 
1266
{
 
1267
          return(i->class);
 
1268
}
 
1269
 
 
1270
void set_XVisualInfo_class(i, j)
 
1271
XVisualInfo* i;
 
1272
int j;
 
1273
{
 
1274
          i->class = j;
 
1275
}
 
1276
 
 
1277
int  XVisualInfo_depth(i)
 
1278
XVisualInfo* i;
 
1279
{
 
1280
          return(i->depth);
 
1281
}
 
1282
 
 
1283
void set_XVisualInfo_depth(i, j)
 
1284
XVisualInfo* i;
 
1285
int j;
 
1286
{
 
1287
          i->depth = j;
 
1288
}
 
1289
 
 
1290
int  XVisualInfo_screen(i)
 
1291
XVisualInfo* i;
 
1292
{
 
1293
          return(i->screen);
 
1294
}
 
1295
 
 
1296
void set_XVisualInfo_screen(i, j)
 
1297
XVisualInfo* i;
 
1298
int j;
 
1299
{
 
1300
          i->screen = j;
 
1301
}
 
1302
 
 
1303
int  XVisualInfo_visualid(i)
 
1304
XVisualInfo* i;
 
1305
{
 
1306
          return(i->visualid);
 
1307
}
 
1308
 
 
1309
void set_XVisualInfo_visualid(i, j)
 
1310
XVisualInfo* i;
 
1311
int j;
 
1312
{
 
1313
          i->visualid = j;
 
1314
}
 
1315
 
 
1316
Visual *XVisualInfo_visual(i)
 
1317
XVisualInfo* i;
 
1318
{
 
1319
          return(i->visual);
 
1320
}
 
1321
 
 
1322
void set_XVisualInfo_visual(i, j)
 
1323
XVisualInfo* i;
 
1324
Visual *j;
 
1325
{
 
1326
          i->visual = j;
 
1327
}
 
1328
 
 
1329
 
 
1330
/********* XStandardColormap funcions *****/
 
1331
 
 
1332
int  make_XStandardColormap (){
 
1333
          return ((int) calloc(1, sizeof(XStandardColormap)));
 
1334
}
 
1335
 
 
1336
int  XStandardColormap_killid(i)
 
1337
XStandardColormap* i;
 
1338
{
 
1339
          return(i->killid);
 
1340
}
 
1341
 
 
1342
void set_XStandardColormap_killid(i, j)
 
1343
XStandardColormap* i;
 
1344
int j;
 
1345
{
 
1346
          i->killid = j;
 
1347
}
 
1348
 
 
1349
int  XStandardColormap_visualid(i)
 
1350
XStandardColormap* i;
 
1351
{
 
1352
          return(i->visualid);
 
1353
}
 
1354
 
 
1355
void set_XStandardColormap_visualid(i, j)
 
1356
XStandardColormap* i;
 
1357
int j;
 
1358
{
 
1359
          i->visualid = j;
 
1360
}
 
1361
 
 
1362
int  XStandardColormap_base_pixel(i)
 
1363
XStandardColormap* i;
 
1364
{
 
1365
          return(i->base_pixel);
 
1366
}
 
1367
 
 
1368
void set_XStandardColormap_base_pixel(i, j)
 
1369
XStandardColormap* i;
 
1370
int j;
 
1371
{
 
1372
          i->base_pixel = j;
 
1373
}
 
1374
 
 
1375
int  XStandardColormap_blue_mult(i)
 
1376
XStandardColormap* i;
 
1377
{
 
1378
          return(i->blue_mult);
 
1379
}
 
1380
 
 
1381
void set_XStandardColormap_blue_mult(i, j)
 
1382
XStandardColormap* i;
 
1383
int j;
 
1384
{
 
1385
          i->blue_mult = j;
 
1386
}
 
1387
 
 
1388
int  XStandardColormap_blue_max(i)
 
1389
XStandardColormap* i;
 
1390
{
 
1391
          return(i->blue_max);
 
1392
}
 
1393
 
 
1394
void set_XStandardColormap_blue_max(i, j)
 
1395
XStandardColormap* i;
 
1396
int j;
 
1397
{
 
1398
          i->blue_max = j;
 
1399
}
 
1400
 
 
1401
int  XStandardColormap_green_mult(i)
 
1402
XStandardColormap* i;
 
1403
{
 
1404
          return(i->green_mult);
 
1405
}
 
1406
 
 
1407
void set_XStandardColormap_green_mult(i, j)
 
1408
XStandardColormap* i;
 
1409
int j;
 
1410
{
 
1411
          i->green_mult = j;
 
1412
}
 
1413
 
 
1414
int  XStandardColormap_green_max(i)
 
1415
XStandardColormap* i;
 
1416
{
 
1417
          return(i->green_max);
 
1418
}
 
1419
 
 
1420
void set_XStandardColormap_green_max(i, j)
 
1421
XStandardColormap* i;
 
1422
int j;
 
1423
{
 
1424
          i->green_max = j;
 
1425
}
 
1426
 
 
1427
int  XStandardColormap_red_mult(i)
 
1428
XStandardColormap* i;
 
1429
{
 
1430
          return(i->red_mult);
 
1431
}
 
1432
 
 
1433
void set_XStandardColormap_red_mult(i, j)
 
1434
XStandardColormap* i;
 
1435
int j;
 
1436
{
 
1437
          i->red_mult = j;
 
1438
}
 
1439
 
 
1440
int  XStandardColormap_red_max(i)
 
1441
XStandardColormap* i;
 
1442
{
 
1443
          return(i->red_max);
 
1444
}
 
1445
 
 
1446
void set_XStandardColormap_red_max(i, j)
 
1447
XStandardColormap* i;
 
1448
int j;
 
1449
{
 
1450
          i->red_max = j;
 
1451
}
 
1452
 
 
1453
int  XStandardColormap_colormap(i)
 
1454
XStandardColormap* i;
 
1455
{
 
1456
          return(i->colormap);
 
1457
}
 
1458
 
 
1459
void set_XStandardColormap_colormap(i, j)
 
1460
XStandardColormap* i;
 
1461
int j;
 
1462
{
 
1463
          i->colormap = j;
 
1464
}
 
1465