← Back to branch summary

~ubuntu-branches/ubuntu/natty/libxi/natty-201011191114

« back to all changes in this revision

Viewing changes to src/XListDev.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien Cristau
  • Date: 2009-11-21 18:39:28 UTC
  • mfrom: (1.1.10 upstream) (0.1.6 experimental)
  • Revision ID: james.westby@ubuntu.com-20091121183928-ek2jwqx3rmhv3zjz
Tags: 2:1.3-1
* Bump Standards-Version to 3.8.3.
* Add build-deps on xmlto and asciidoc to build the manpages.
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/XListDev.c
1
 
/* $Xorg: XListDev.c,v 1.5 2001/02/09 02:03:51 xorgcvs Exp $ */
2
 
 
3
1
/************************************************************
4
2
 
5
3
Copyright 1989, 1998  The Open Group
45
43
SOFTWARE.
46
44
 
47
45
********************************************************/
48
 
/* $XFree86: xc/lib/Xi/XListDev.c,v 3.4 2001/12/14 19:55:19 dawes Exp $ */
49
46
 
50
47
/***********************************************************************
51
48
 *
63
60
#include <X11/extensions/extutil.h>
64
61
#include "XIint.h"
65
62
 
 
63
static int
 
64
SizeClassInfo(xAnyClassPtr *any, int num_classes)
 
65
{
 
66
    int size = 0;
 
67
    int j;
 
68
    for (j = 0; j < num_classes; j++) {
 
69
        switch ((*any)->class) {
 
70
            case KeyClass:
 
71
                size += sizeof(XKeyInfo);
 
72
                break;
 
73
            case ButtonClass:
 
74
                size += sizeof(XButtonInfo);
 
75
                break;
 
76
            case ValuatorClass:
 
77
                {
 
78
                    xValuatorInfoPtr v;
 
79
 
 
80
                    v = (xValuatorInfoPtr) *any;
 
81
                    size += sizeof(XValuatorInfo) +
 
82
                        (v->num_axes * sizeof(XAxisInfo));
 
83
                    break;
 
84
                }
 
85
            default:
 
86
                break;
 
87
        }
 
88
        *any = (xAnyClassPtr) ((char *)(*any) + (*any)->length);
 
89
    }
 
90
 
 
91
    return size;
 
92
}
 
93
 
 
94
static void
 
95
ParseClassInfo(xAnyClassPtr *any, XAnyClassPtr *Any, int num_classes)
 
96
{
 
97
    int j, k;
 
98
 
 
99
    for (j = 0; j < num_classes; j++) {
 
100
        switch ((*any)->class) {
 
101
            case KeyClass:
 
102
                {
 
103
                    XKeyInfoPtr K = (XKeyInfoPtr) *Any;
 
104
                    xKeyInfoPtr k = (xKeyInfoPtr) *any;
 
105
 
 
106
                    K->class = KeyClass;
 
107
                    K->length = sizeof(XKeyInfo);
 
108
                    K->min_keycode = k->min_keycode;
 
109
                    K->max_keycode = k->max_keycode;
 
110
                    K->num_keys = k->num_keys;
 
111
                    break;
 
112
                }
 
113
            case ButtonClass:
 
114
                {
 
115
                    XButtonInfoPtr B = (XButtonInfoPtr) *Any;
 
116
                    xButtonInfoPtr b = (xButtonInfoPtr) *any;
 
117
 
 
118
                    B->class = ButtonClass;
 
119
                    B->length = sizeof(XButtonInfo);
 
120
                    B->num_buttons = b->num_buttons;
 
121
                    break;
 
122
                }
 
123
            case ValuatorClass:
 
124
                {
 
125
                    XValuatorInfoPtr V = (XValuatorInfoPtr) *Any;
 
126
                    xValuatorInfoPtr v = (xValuatorInfoPtr) *any;
 
127
                    XAxisInfoPtr A;
 
128
                    xAxisInfoPtr a;
 
129
 
 
130
                    V->class = ValuatorClass;
 
131
                    V->length = sizeof(XValuatorInfo) +
 
132
                        (v->num_axes * sizeof(XAxisInfo));
 
133
                    V->num_axes = v->num_axes;
 
134
                    V->motion_buffer = v->motion_buffer_size;
 
135
                    V->mode = v->mode;
 
136
                    A = (XAxisInfoPtr) ((char *)V + sizeof(XValuatorInfo));
 
137
                    V->axes = A;
 
138
                    a = (xAxisInfoPtr) ((char *)(*any) + sizeof(xValuatorInfo));
 
139
                    for (k = 0; k < (int)v->num_axes; k++, a++, A++) {
 
140
                        A->min_value = a->min_value;
 
141
                        A->max_value = a->max_value;
 
142
                        A->resolution = a->resolution;
 
143
                    }
 
144
                    break;
 
145
                }
 
146
            default:
 
147
                break;
 
148
        }
 
149
        *any = (xAnyClassPtr) ((char *)(*any) + (*any)->length);
 
150
        *Any = (XAnyClassPtr) ((char *)(*Any) + (*Any)->length);
 
151
    }
 
152
}
 
153
 
66
154
XDeviceInfo *
67
 
XListInputDevices(dpy, ndevices)
68
 
    register Display *dpy;
69
 
    int *ndevices;
 
155
XListInputDevices(
 
156
    register Display    *dpy,
 
157
    int                 *ndevices)
70
158
{
71
159
    int size;
72
160
    xListInputDevicesReq *req;
77
165
    xAnyClassPtr any, sav_any;
78
166
    XAnyClassPtr Any;
79
167
    char *nptr, *Nptr;
80
 
    register int i, j, k;
81
 
    register long rlen;
 
168
    int i;
 
169
    long rlen;
82
170
    XExtDisplayInfo *info = XInput_find_display(dpy);
83
171
 
84
172
    LockDisplay(dpy);
111
199
        any = (xAnyClassPtr) ((char *)list + (*ndevices * sizeof(xDeviceInfo)));
112
200
        sav_any = any;
113
201
        for (i = 0; i < *ndevices; i++, list++) {
114
 
            for (j = 0; j < (int)list->num_classes; j++) {
115
 
                switch (any->class) {
116
 
                case KeyClass:
117
 
                    size += sizeof(XKeyInfo);
118
 
                    break;
119
 
                case ButtonClass:
120
 
                    size += sizeof(XButtonInfo);
121
 
                    break;
122
 
                case ValuatorClass:
123
 
                {
124
 
                    xValuatorInfoPtr v;
125
 
 
126
 
                    v = (xValuatorInfoPtr) any;
127
 
                    size += sizeof(XValuatorInfo) +
128
 
                        (v->num_axes * sizeof(XAxisInfo));
129
 
                    break;
130
 
                }
131
 
                default:
132
 
                    break;
133
 
                }
134
 
                any = (xAnyClassPtr) ((char *)any + any->length);
135
 
            }
 
202
            size += SizeClassInfo(&any, (int)list->num_classes);
136
203
        }
137
204
 
138
205
        for (i = 0, nptr = (char *)any; i < *ndevices; i++) {
158
225
            clist->use = list->use;
159
226
            clist->num_classes = list->num_classes;
160
227
            clist->inputclassinfo = Any;
161
 
            for (j = 0; j < (int)list->num_classes; j++) {
162
 
                switch (any->class) {
163
 
                case KeyClass:
164
 
                {
165
 
                    XKeyInfoPtr K = (XKeyInfoPtr) Any;
166
 
                    xKeyInfoPtr k = (xKeyInfoPtr) any;
167
 
 
168
 
                    K->class = KeyClass;
169
 
                    K->length = sizeof(XKeyInfo);
170
 
                    K->min_keycode = k->min_keycode;
171
 
                    K->max_keycode = k->max_keycode;
172
 
                    K->num_keys = k->num_keys;
173
 
                    break;
174
 
                }
175
 
                case ButtonClass:
176
 
                {
177
 
                    XButtonInfoPtr B = (XButtonInfoPtr) Any;
178
 
                    xButtonInfoPtr b = (xButtonInfoPtr) any;
179
 
 
180
 
                    B->class = ButtonClass;
181
 
                    B->length = sizeof(XButtonInfo);
182
 
                    B->num_buttons = b->num_buttons;
183
 
                    break;
184
 
                }
185
 
                case ValuatorClass:
186
 
                {
187
 
                    XValuatorInfoPtr V = (XValuatorInfoPtr) Any;
188
 
                    xValuatorInfoPtr v = (xValuatorInfoPtr) any;
189
 
                    XAxisInfoPtr A;
190
 
                    xAxisInfoPtr a;
191
 
 
192
 
                    V->class = ValuatorClass;
193
 
                    V->length = sizeof(XValuatorInfo) +
194
 
                        (v->num_axes * sizeof(XAxisInfo));
195
 
                    V->num_axes = v->num_axes;
196
 
                    V->motion_buffer = v->motion_buffer_size;
197
 
                    V->mode = v->mode;
198
 
                    A = (XAxisInfoPtr) ((char *)V + sizeof(XValuatorInfo));
199
 
                    V->axes = A;
200
 
                    a = (xAxisInfoPtr) ((char *)any + sizeof(xValuatorInfo));
201
 
                    for (k = 0; k < (int)v->num_axes; k++, a++, A++) {
202
 
                        A->min_value = a->min_value;
203
 
                        A->max_value = a->max_value;
204
 
                        A->resolution = a->resolution;
205
 
                    }
206
 
                    break;
207
 
                }
208
 
                default:
209
 
                    break;
210
 
                }
211
 
                any = (xAnyClassPtr) ((char *)any + any->length);
212
 
                Any = (XAnyClassPtr) ((char *)Any + Any->length);
213
 
            }
 
228
 
 
229
            ParseClassInfo(&any, &Any, (int)list->num_classes);
214
230
        }
215
231
 
216
232
        clist = sclist;
238
254
 */
239
255
 
240
256
void
241
 
XFreeDeviceList(list)
242
 
    XDeviceInfo *list;
 
257
XFreeDeviceList(XDeviceInfo *list)
243
258
{
244
259
    if (list != NULL) {
245
260
        XFree((char *)list);