← Back to branch summary

~jderose/ubuntu/raring/xserver-xorg-input-synaptics/clickpad

« back to all changes in this revision

Viewing changes to src/properties.c

  • Committer: Package Import Robot
  • Author(s): Cyril Brulebois, Julien Cristau, Cyril Brulebois
  • Date: 2012-05-20 16:50:18 UTC
  • mfrom: (0.4.9)
  • mto: (61.1.1 quantal)
  • mto: This revision was merged to the branch mainline in revision 60.
  • Revision ID: package-import@ubuntu.com-20120520165018-ap60y9jh84nv75vp
Tags: 1.6.1-1
http://bugs.debian.org/672572
[ Julien Cristau ]
* The mtdev build-dep is linux-only (closes: #672572).  Thanks, Pino
  Toscano!

[ Cyril Brulebois ]
* New upstream release, from the 1.6 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/properties.c
53
53
 
54
54
static Atom float_type;
55
55
 
56
 
Atom prop_edges                 = 0;
57
 
Atom prop_finger                = 0;
58
 
Atom prop_tap_time              = 0;
59
 
Atom prop_tap_move              = 0;
60
 
Atom prop_tap_durations         = 0;
61
 
Atom prop_clickpad              = 0;
62
 
Atom prop_tap_fast              = 0;
63
 
Atom prop_middle_timeout        = 0;
64
 
Atom prop_twofinger_pressure    = 0;
65
 
Atom prop_twofinger_width       = 0;
66
 
Atom prop_scrolldist            = 0;
67
 
Atom prop_scrolledge            = 0;
68
 
Atom prop_scrolltwofinger       = 0;
69
 
Atom prop_speed                 = 0;
70
 
Atom prop_edgemotion_pressure   = 0;
71
 
Atom prop_edgemotion_speed      = 0;
72
 
Atom prop_edgemotion_always     = 0;
73
 
Atom prop_buttonscroll          = 0;
74
 
Atom prop_buttonscroll_repeat   = 0;
75
 
Atom prop_buttonscroll_time     = 0;
76
 
Atom prop_off                   = 0;
77
 
Atom prop_lockdrags             = 0;
78
 
Atom prop_lockdrags_time        = 0;
79
 
Atom prop_tapaction             = 0;
80
 
Atom prop_clickaction           = 0;
81
 
Atom prop_circscroll            = 0;
82
 
Atom prop_circscroll_dist       = 0;
83
 
Atom prop_circscroll_trigger    = 0;
84
 
Atom prop_circpad               = 0;
85
 
Atom prop_palm                  = 0;
86
 
Atom prop_palm_dim              = 0;
87
 
Atom prop_coastspeed            = 0;
88
 
Atom prop_pressuremotion        = 0;
 
56
Atom prop_edges = 0;
 
57
Atom prop_finger = 0;
 
58
Atom prop_tap_time = 0;
 
59
Atom prop_tap_move = 0;
 
60
Atom prop_tap_durations = 0;
 
61
Atom prop_clickpad = 0;
 
62
Atom prop_tap_fast = 0;
 
63
Atom prop_middle_timeout = 0;
 
64
Atom prop_twofinger_pressure = 0;
 
65
Atom prop_twofinger_width = 0;
 
66
Atom prop_scrolldist = 0;
 
67
Atom prop_scrolledge = 0;
 
68
Atom prop_scrolltwofinger = 0;
 
69
Atom prop_speed = 0;
 
70
Atom prop_edgemotion_pressure = 0;
 
71
Atom prop_edgemotion_speed = 0;
 
72
Atom prop_edgemotion_always = 0;
 
73
Atom prop_buttonscroll = 0;
 
74
Atom prop_buttonscroll_repeat = 0;
 
75
Atom prop_buttonscroll_time = 0;
 
76
Atom prop_off = 0;
 
77
Atom prop_lockdrags = 0;
 
78
Atom prop_lockdrags_time = 0;
 
79
Atom prop_tapaction = 0;
 
80
Atom prop_clickaction = 0;
 
81
Atom prop_circscroll = 0;
 
82
Atom prop_circscroll_dist = 0;
 
83
Atom prop_circscroll_trigger = 0;
 
84
Atom prop_circpad = 0;
 
85
Atom prop_palm = 0;
 
86
Atom prop_palm_dim = 0;
 
87
Atom prop_coastspeed = 0;
 
88
Atom prop_pressuremotion = 0;
89
89
Atom prop_pressuremotion_factor = 0;
90
 
Atom prop_grab                  = 0;
91
 
Atom prop_gestures              = 0;
92
 
Atom prop_capabilities          = 0;
93
 
Atom prop_resolution            = 0;
94
 
Atom prop_area                  = 0;
95
 
Atom prop_softbutton_areas      = 0;
96
 
Atom prop_noise_cancellation    = 0;
97
 
Atom prop_product_id            = 0;
98
 
Atom prop_device_node           = 0;
 
90
Atom prop_grab = 0;
 
91
Atom prop_gestures = 0;
 
92
Atom prop_capabilities = 0;
 
93
Atom prop_resolution = 0;
 
94
Atom prop_area = 0;
 
95
Atom prop_softbutton_areas = 0;
 
96
Atom prop_noise_cancellation = 0;
 
97
Atom prop_product_id = 0;
 
98
Atom prop_device_node = 0;
99
99
 
100
100
static Atom
101
101
InitTypedAtom(DeviceIntPtr dev, char *name, Atom type, int format, int nvalues,
103
103
{
104
104
    int i;
105
105
    Atom atom;
106
 
    uint8_t val_8[9]; /* we never have more than 9 values in an atom */
 
106
    uint8_t val_8[9];           /* we never have more than 9 values in an atom */
107
107
    uint16_t val_16[9];
108
108
    uint32_t val_32[9];
109
109
    pointer converted;
110
110
 
111
 
 
112
 
    for (i = 0; i < nvalues; i++)
113
 
    {
114
 
        switch(format)
115
 
        {
116
 
            case 8:  val_8[i]  = values[i]; break;
117
 
            case 16: val_16[i] = values[i]; break;
118
 
            case 32: val_32[i] = values[i]; break;
 
111
    for (i = 0; i < nvalues; i++) {
 
112
        switch (format) {
 
113
        case 8:
 
114
            val_8[i] = values[i];
 
115
            break;
 
116
        case 16:
 
117
            val_16[i] = values[i];
 
118
            break;
 
119
        case 32:
 
120
            val_32[i] = values[i];
 
121
            break;
119
122
        }
120
123
    }
121
124
 
122
 
    switch(format)
123
 
    {
124
 
        case 8: converted = val_8; break;
125
 
        case 16: converted = val_16; break;
126
 
        case 32: converted = val_32; break;
 
125
    switch (format) {
 
126
    case 8:
 
127
        converted = val_8;
 
128
        break;
 
129
    case 16:
 
130
        converted = val_16;
 
131
        break;
 
132
    case 32:
 
133
        converted = val_32;
 
134
        break;
127
135
    }
128
136
 
129
137
    atom = MakeAtom(name, strlen(name), TRUE);
166
174
    values[5] = para->softbutton_areas[1][1];
167
175
    values[6] = para->softbutton_areas[1][2];
168
176
    values[7] = para->softbutton_areas[1][3];
169
 
    prop_softbutton_areas = InitAtom(pInfo->dev, SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 8, values);
 
177
    prop_softbutton_areas =
 
178
        InitAtom(pInfo->dev, SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 8, values);
170
179
}
171
180
 
172
181
void
174
183
{
175
184
    SynapticsPrivate *priv = (SynapticsPrivate *) pInfo->private;
176
185
    SynapticsParameters *para = &priv->synpara;
177
 
    int values[9]; /* we never have more than 9 values in an atom */
178
 
    float fvalues[4]; /* never have more than 4 float values */
 
186
    int values[9];              /* we never have more than 9 values in an atom */
 
187
    float fvalues[4];           /* never have more than 4 float values */
179
188
 
180
189
    float_type = XIGetKnownProperty(XATOM_FLOAT);
181
 
    if (!float_type)
182
 
    {
 
190
    if (!float_type) {
183
191
        float_type = MakeAtom(XATOM_FLOAT, strlen(XATOM_FLOAT), TRUE);
184
 
        if (!float_type)
185
 
        {
 
192
        if (!float_type) {
186
193
            xf86IDrvMsg(pInfo, X_ERROR, "Failed to init float atom. "
187
194
                        "Disabling property support.\n");
188
195
            return;
201
208
    values[2] = para->finger_press;
202
209
 
203
210
    prop_finger = InitAtom(pInfo->dev, SYNAPTICS_PROP_FINGER, 32, 3, values);
204
 
    prop_tap_time = InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_TIME, 32, 1, &para->tap_time);
205
 
    prop_tap_move = InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_MOVE, 32, 1, &para->tap_move);
 
211
    prop_tap_time =
 
212
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_TIME, 32, 1, &para->tap_time);
 
213
    prop_tap_move =
 
214
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_MOVE, 32, 1, &para->tap_move);
206
215
 
207
216
    values[0] = para->single_tap_timeout;
208
217
    values[1] = para->tap_time_2;
209
218
    values[2] = para->click_time;
210
219
 
211
 
    prop_tap_durations = InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_DURATIONS, 32, 3, values);
212
 
    prop_clickpad = InitAtom(pInfo->dev, SYNAPTICS_PROP_CLICKPAD, 8, 1,
213
 
                             &para->clickpad);
214
 
    prop_tap_fast = InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_FAST, 8, 1, &para->fast_taps);
215
 
    prop_middle_timeout = InitAtom(pInfo->dev, SYNAPTICS_PROP_MIDDLE_TIMEOUT,
216
 
                                   32, 1, &para->emulate_mid_button_time);
217
 
    prop_twofinger_pressure = InitAtom(pInfo->dev, SYNAPTICS_PROP_TWOFINGER_PRESSURE,
218
 
                                       32, 1, &para->emulate_twofinger_z);
219
 
    prop_twofinger_width = InitAtom(pInfo->dev, SYNAPTICS_PROP_TWOFINGER_WIDTH,
220
 
                                       32, 1, &para->emulate_twofinger_w);
 
220
    prop_tap_durations =
 
221
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_DURATIONS, 32, 3, values);
 
222
    prop_clickpad =
 
223
        InitAtom(pInfo->dev, SYNAPTICS_PROP_CLICKPAD, 8, 1, &para->clickpad);
 
224
    prop_tap_fast =
 
225
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_FAST, 8, 1, &para->fast_taps);
 
226
    prop_middle_timeout =
 
227
        InitAtom(pInfo->dev, SYNAPTICS_PROP_MIDDLE_TIMEOUT, 32, 1,
 
228
                 &para->emulate_mid_button_time);
 
229
    prop_twofinger_pressure =
 
230
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TWOFINGER_PRESSURE, 32, 1,
 
231
                 &para->emulate_twofinger_z);
 
232
    prop_twofinger_width =
 
233
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TWOFINGER_WIDTH, 32, 1,
 
234
                 &para->emulate_twofinger_w);
221
235
 
222
236
    values[0] = para->scroll_dist_vert;
223
237
    values[1] = para->scroll_dist_horiz;
224
 
    prop_scrolldist = InitAtom(pInfo->dev, SYNAPTICS_PROP_SCROLL_DISTANCE, 32, 2, values);
 
238
    prop_scrolldist =
 
239
        InitAtom(pInfo->dev, SYNAPTICS_PROP_SCROLL_DISTANCE, 32, 2, values);
225
240
 
226
241
    values[0] = para->scroll_edge_vert;
227
242
    values[1] = para->scroll_edge_horiz;
228
243
    values[2] = para->scroll_edge_corner;
229
 
    prop_scrolledge = InitAtom(pInfo->dev, SYNAPTICS_PROP_SCROLL_EDGE,8, 3, values);
 
244
    prop_scrolledge =
 
245
        InitAtom(pInfo->dev, SYNAPTICS_PROP_SCROLL_EDGE, 8, 3, values);
230
246
    values[0] = para->scroll_twofinger_vert;
231
247
    values[1] = para->scroll_twofinger_horiz;
232
 
    prop_scrolltwofinger = InitAtom(pInfo->dev, SYNAPTICS_PROP_SCROLL_TWOFINGER,8, 2, values);
 
248
    prop_scrolltwofinger =
 
249
        InitAtom(pInfo->dev, SYNAPTICS_PROP_SCROLL_TWOFINGER, 8, 2, values);
233
250
 
234
251
    fvalues[0] = para->min_speed;
235
252
    fvalues[1] = para->max_speed;
239
256
 
240
257
    values[0] = para->edge_motion_min_z;
241
258
    values[1] = para->edge_motion_max_z;
242
 
    prop_edgemotion_pressure = InitAtom(pInfo->dev, SYNAPTICS_PROP_EDGEMOTION_PRESSURE, 32, 2, values);
 
259
    prop_edgemotion_pressure =
 
260
        InitAtom(pInfo->dev, SYNAPTICS_PROP_EDGEMOTION_PRESSURE, 32, 2, values);
243
261
 
244
262
    values[0] = para->edge_motion_min_speed;
245
263
    values[1] = para->edge_motion_max_speed;
246
 
    prop_edgemotion_speed = InitAtom(pInfo->dev, SYNAPTICS_PROP_EDGEMOTION_SPEED, 32, 2, values);
247
 
    prop_edgemotion_always = InitAtom(pInfo->dev, SYNAPTICS_PROP_EDGEMOTION, 8, 1, &para->edge_motion_use_always);
 
264
    prop_edgemotion_speed =
 
265
        InitAtom(pInfo->dev, SYNAPTICS_PROP_EDGEMOTION_SPEED, 32, 2, values);
 
266
    prop_edgemotion_always =
 
267
        InitAtom(pInfo->dev, SYNAPTICS_PROP_EDGEMOTION, 8, 1,
 
268
                 &para->edge_motion_use_always);
248
269
 
249
 
    if (priv->has_scrollbuttons)
250
 
    {
 
270
    if (priv->has_scrollbuttons) {
251
271
        values[0] = para->updown_button_scrolling;
252
272
        values[1] = para->leftright_button_scrolling;
253
 
        prop_buttonscroll = InitAtom(pInfo->dev, SYNAPTICS_PROP_BUTTONSCROLLING, 8, 2, values);
 
273
        prop_buttonscroll =
 
274
            InitAtom(pInfo->dev, SYNAPTICS_PROP_BUTTONSCROLLING, 8, 2, values);
254
275
 
255
276
        values[0] = para->updown_button_repeat;
256
277
        values[1] = para->leftright_button_repeat;
257
 
        prop_buttonscroll_repeat = InitAtom(pInfo->dev, SYNAPTICS_PROP_BUTTONSCROLLING_REPEAT, 8, 2, values);
258
 
        prop_buttonscroll_time = InitAtom(pInfo->dev, SYNAPTICS_PROP_BUTTONSCROLLING_TIME, 32, 1, &para->scroll_button_repeat);
 
278
        prop_buttonscroll_repeat =
 
279
            InitAtom(pInfo->dev, SYNAPTICS_PROP_BUTTONSCROLLING_REPEAT, 8, 2,
 
280
                     values);
 
281
        prop_buttonscroll_time =
 
282
            InitAtom(pInfo->dev, SYNAPTICS_PROP_BUTTONSCROLLING_TIME, 32, 1,
 
283
                     &para->scroll_button_repeat);
259
284
    }
260
285
 
261
 
    prop_off = InitAtom(pInfo->dev, SYNAPTICS_PROP_OFF, 8, 1, &para->touchpad_off);
262
 
    prop_lockdrags = InitAtom(pInfo->dev, SYNAPTICS_PROP_LOCKED_DRAGS, 8, 1, &para->locked_drags);
263
 
    prop_lockdrags_time = InitAtom(pInfo->dev, SYNAPTICS_PROP_LOCKED_DRAGS_TIMEOUT, 32, 1, &para->locked_drag_time);
 
286
    prop_off =
 
287
        InitAtom(pInfo->dev, SYNAPTICS_PROP_OFF, 8, 1, &para->touchpad_off);
 
288
    prop_lockdrags =
 
289
        InitAtom(pInfo->dev, SYNAPTICS_PROP_LOCKED_DRAGS, 8, 1,
 
290
                 &para->locked_drags);
 
291
    prop_lockdrags_time =
 
292
        InitAtom(pInfo->dev, SYNAPTICS_PROP_LOCKED_DRAGS_TIMEOUT, 32, 1,
 
293
                 &para->locked_drag_time);
264
294
 
265
295
    memcpy(values, para->tap_action, MAX_TAP * sizeof(int));
266
 
    prop_tapaction = InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_ACTION, 8, MAX_TAP, values);
 
296
    prop_tapaction =
 
297
        InitAtom(pInfo->dev, SYNAPTICS_PROP_TAP_ACTION, 8, MAX_TAP, values);
267
298
 
268
299
    memcpy(values, para->click_action, MAX_CLICK * sizeof(int));
269
 
    prop_clickaction = InitAtom(pInfo->dev, SYNAPTICS_PROP_CLICK_ACTION, 8, MAX_CLICK, values);
 
300
    prop_clickaction =
 
301
        InitAtom(pInfo->dev, SYNAPTICS_PROP_CLICK_ACTION, 8, MAX_CLICK, values);
270
302
 
271
 
    prop_circscroll = InitAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_SCROLLING, 8, 1, &para->circular_scrolling);
 
303
    prop_circscroll =
 
304
        InitAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_SCROLLING, 8, 1,
 
305
                 &para->circular_scrolling);
272
306
 
273
307
    fvalues[0] = para->scroll_dist_circ;
274
 
    prop_circscroll_dist = InitFloatAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_SCROLLING_DIST, 1, fvalues);
 
308
    prop_circscroll_dist =
 
309
        InitFloatAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_SCROLLING_DIST, 1,
 
310
                      fvalues);
275
311
 
276
 
    prop_circscroll_trigger = InitAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_SCROLLING_TRIGGER, 8, 1, &para->circular_trigger);
277
 
    prop_circpad = InitAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_PAD, 8, 1, &para->circular_pad);
278
 
    prop_palm = InitAtom(pInfo->dev, SYNAPTICS_PROP_PALM_DETECT, 8, 1, &para->palm_detect);
 
312
    prop_circscroll_trigger =
 
313
        InitAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_SCROLLING_TRIGGER, 8, 1,
 
314
                 &para->circular_trigger);
 
315
    prop_circpad =
 
316
        InitAtom(pInfo->dev, SYNAPTICS_PROP_CIRCULAR_PAD, 8, 1,
 
317
                 &para->circular_pad);
 
318
    prop_palm =
 
319
        InitAtom(pInfo->dev, SYNAPTICS_PROP_PALM_DETECT, 8, 1,
 
320
                 &para->palm_detect);
279
321
 
280
322
    values[0] = para->palm_min_width;
281
323
    values[1] = para->palm_min_z;
282
324
 
283
 
    prop_palm_dim = InitAtom(pInfo->dev, SYNAPTICS_PROP_PALM_DIMENSIONS, 32, 2, values);
 
325
    prop_palm_dim =
 
326
        InitAtom(pInfo->dev, SYNAPTICS_PROP_PALM_DIMENSIONS, 32, 2, values);
284
327
 
285
328
    fvalues[0] = para->coasting_speed;
286
329
    fvalues[1] = para->coasting_friction;
287
 
    prop_coastspeed = InitFloatAtom(pInfo->dev, SYNAPTICS_PROP_COASTING_SPEED, 2, fvalues);
 
330
    prop_coastspeed =
 
331
        InitFloatAtom(pInfo->dev, SYNAPTICS_PROP_COASTING_SPEED, 2, fvalues);
288
332
 
289
333
    values[0] = para->press_motion_min_z;
290
334
    values[1] = para->press_motion_max_z;
291
 
    prop_pressuremotion = InitTypedAtom(pInfo->dev, SYNAPTICS_PROP_PRESSURE_MOTION, XA_CARDINAL, 32, 2, values);
 
335
    prop_pressuremotion =
 
336
        InitTypedAtom(pInfo->dev, SYNAPTICS_PROP_PRESSURE_MOTION, XA_CARDINAL,
 
337
                      32, 2, values);
292
338
 
293
339
    fvalues[0] = para->press_motion_min_factor;
294
340
    fvalues[1] = para->press_motion_max_factor;
295
341
 
296
 
    prop_pressuremotion_factor = InitFloatAtom(pInfo->dev, SYNAPTICS_PROP_PRESSURE_MOTION_FACTOR, 2, fvalues);
 
342
    prop_pressuremotion_factor =
 
343
        InitFloatAtom(pInfo->dev, SYNAPTICS_PROP_PRESSURE_MOTION_FACTOR, 2,
 
344
                      fvalues);
297
345
 
298
 
    prop_grab = InitAtom(pInfo->dev, SYNAPTICS_PROP_GRAB, 8, 1, &para->grab_event_device);
 
346
    prop_grab =
 
347
        InitAtom(pInfo->dev, SYNAPTICS_PROP_GRAB, 8, 1,
 
348
                 &para->grab_event_device);
299
349
 
300
350
    values[0] = para->tap_and_drag_gesture;
301
351
    prop_gestures = InitAtom(pInfo->dev, SYNAPTICS_PROP_GESTURES, 8, 1, values);
307
357
    values[4] = priv->has_triple;
308
358
    values[5] = priv->has_pressure;
309
359
    values[6] = priv->has_width;
310
 
    prop_capabilities = InitAtom(pInfo->dev, SYNAPTICS_PROP_CAPABILITIES, 8, 7, values);
 
360
    prop_capabilities =
 
361
        InitAtom(pInfo->dev, SYNAPTICS_PROP_CAPABILITIES, 8, 7, values);
311
362
 
312
363
    values[0] = para->resolution_vert;
313
364
    values[1] = para->resolution_horiz;
314
 
    prop_resolution = InitAtom(pInfo->dev, SYNAPTICS_PROP_RESOLUTION, 32, 2, values);
 
365
    prop_resolution =
 
366
        InitAtom(pInfo->dev, SYNAPTICS_PROP_RESOLUTION, 32, 2, values);
315
367
 
316
368
    values[0] = para->area_left_edge;
317
369
    values[1] = para->area_right_edge;
325
377
    values[0] = para->hyst_x;
326
378
    values[1] = para->hyst_y;
327
379
    prop_noise_cancellation = InitAtom(pInfo->dev,
328
 
            SYNAPTICS_PROP_NOISE_CANCELLATION, 32, 2, values);
 
380
                                       SYNAPTICS_PROP_NOISE_CANCELLATION, 32, 2,
 
381
                                       values);
329
382
 
330
383
    /* only init product_id property if we actually know them */
331
 
    if (priv->id_vendor || priv->id_product)
332
 
    {
 
384
    if (priv->id_vendor || priv->id_product) {
333
385
        values[0] = priv->id_vendor;
334
386
        values[1] = priv->id_product;
335
 
        prop_product_id = InitAtom(pInfo->dev, XI_PROP_PRODUCT_ID, 32, 2, values);
 
387
        prop_product_id =
 
388
            InitAtom(pInfo->dev, XI_PROP_PRODUCT_ID, 32, 2, values);
336
389
    }
337
390
 
338
 
    if (priv->device)
339
 
    {
340
 
        prop_device_node = MakeAtom(XI_PROP_DEVICE_NODE, strlen(XI_PROP_DEVICE_NODE), TRUE);
 
391
    if (priv->device) {
 
392
        prop_device_node =
 
393
            MakeAtom(XI_PROP_DEVICE_NODE, strlen(XI_PROP_DEVICE_NODE), TRUE);
341
394
        XIChangeDeviceProperty(pInfo->dev, prop_device_node, XA_STRING, 8,
342
395
                               PropModeReplace, strlen(priv->device),
343
396
                               (pointer) priv->device, FALSE);
357
410
 
358
411
    /* If checkonly is set, no parameters may be changed. So just let the code
359
412
     * change temporary variables and forget about it. */
360
 
    if (checkonly)
361
 
    {
 
413
    if (checkonly) {
362
414
        tmp = *para;
363
415
        para = &tmp;
364
416
    }
365
417
 
366
 
    if (property == prop_edges)
367
 
    {
 
418
    if (property == prop_edges) {
368
419
        INT32 *edges;
 
420
 
369
421
        if (prop->size != 4 || prop->format != 32 || prop->type != XA_INTEGER)
370
422
            return BadMatch;
371
423
 
372
 
        edges = (INT32*)prop->data;
 
424
        edges = (INT32 *) prop->data;
373
425
        if (edges[0] > edges[1] || edges[2] > edges[3])
374
426
            return BadValue;
375
427
 
376
 
        para->left_edge   = edges[0];
377
 
        para->right_edge  = edges[1];
378
 
        para->top_edge    = edges[2];
 
428
        para->left_edge = edges[0];
 
429
        para->right_edge = edges[1];
 
430
        para->top_edge = edges[2];
379
431
        para->bottom_edge = edges[3];
380
432
 
381
 
    } else if (property == prop_finger)
382
 
    {
 
433
    }
 
434
    else if (property == prop_finger) {
383
435
        INT32 *finger;
 
436
 
384
437
        if (prop->size != 3 || prop->format != 32 || prop->type != XA_INTEGER)
385
438
            return BadMatch;
386
439
 
387
 
        finger = (INT32*)prop->data;
 
440
        finger = (INT32 *) prop->data;
388
441
        if (finger[0] > finger[1])
389
442
            return BadValue;
390
443
 
391
 
        para->finger_low   = finger[0];
392
 
        para->finger_high  = finger[1];
 
444
        para->finger_low = finger[0];
 
445
        para->finger_high = finger[1];
393
446
        para->finger_press = finger[2];
394
447
 
395
 
    } else if (property == prop_tap_time)
396
 
    {
397
 
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
398
 
            return BadMatch;
399
 
 
400
 
        para->tap_time = *(INT32*)prop->data;
401
 
 
402
 
    } else if (property == prop_tap_move)
403
 
    {
404
 
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
405
 
            return BadMatch;
406
 
 
407
 
        para->tap_move = *(INT32*)prop->data;
408
 
    } else if (property == prop_tap_durations)
409
 
    {
 
448
    }
 
449
    else if (property == prop_tap_time) {
 
450
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
 
451
            return BadMatch;
 
452
 
 
453
        para->tap_time = *(INT32 *) prop->data;
 
454
 
 
455
    }
 
456
    else if (property == prop_tap_move) {
 
457
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
 
458
            return BadMatch;
 
459
 
 
460
        para->tap_move = *(INT32 *) prop->data;
 
461
    }
 
462
    else if (property == prop_tap_durations) {
410
463
        INT32 *timeouts;
411
464
 
412
465
        if (prop->size != 3 || prop->format != 32 || prop->type != XA_INTEGER)
413
466
            return BadMatch;
414
467
 
415
 
        timeouts = (INT32*)prop->data;
 
468
        timeouts = (INT32 *) prop->data;
416
469
 
417
470
        para->single_tap_timeout = timeouts[0];
418
 
        para->tap_time_2         = timeouts[1];
419
 
        para->click_time         = timeouts[2];
420
 
    } else if (property == prop_clickpad) {
 
471
        para->tap_time_2 = timeouts[1];
 
472
        para->click_time = timeouts[2];
 
473
    }
 
474
    else if (property == prop_clickpad) {
421
475
        BOOL value;
422
476
 
423
477
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
424
478
            return BadMatch;
425
479
 
426
 
        value = *(BOOL*)prop->data;
 
480
        value = *(BOOL *) prop->data;
427
481
        if (!para->clickpad && value && !prop_softbutton_areas)
428
482
            InitSoftButtonProperty(pInfo);
429
 
        else if (para->clickpad && !value && prop_softbutton_areas)
430
 
        {
 
483
        else if (para->clickpad && !value && prop_softbutton_areas) {
431
484
            XIDeleteDeviceProperty(dev, prop_softbutton_areas, FALSE);
432
485
            prop_softbutton_areas = 0;
433
486
        }
434
487
 
435
 
        para->clickpad = *(BOOL*)prop->data;
436
 
    } else if (property == prop_tap_fast)
437
 
    {
 
488
        para->clickpad = *(BOOL *) prop->data;
 
489
    }
 
490
    else if (property == prop_tap_fast) {
438
491
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
439
492
            return BadMatch;
440
493
 
441
 
        para->fast_taps = *(BOOL*)prop->data;
442
 
 
443
 
    } else if (property == prop_middle_timeout)
444
 
    {
445
 
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
446
 
            return BadMatch;
447
 
 
448
 
        para->emulate_mid_button_time = *(INT32*)prop->data;
449
 
    } else if (property == prop_twofinger_pressure)
450
 
    {
451
 
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
452
 
            return BadMatch;
453
 
 
454
 
        para->emulate_twofinger_z = *(INT32*)prop->data;
455
 
    } else if (property == prop_twofinger_width)
456
 
    {
457
 
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
458
 
            return BadMatch;
459
 
 
460
 
        para->emulate_twofinger_w = *(INT32*)prop->data;
461
 
    } else if (property == prop_scrolldist)
462
 
    {
 
494
        para->fast_taps = *(BOOL *) prop->data;
 
495
 
 
496
    }
 
497
    else if (property == prop_middle_timeout) {
 
498
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
 
499
            return BadMatch;
 
500
 
 
501
        para->emulate_mid_button_time = *(INT32 *) prop->data;
 
502
    }
 
503
    else if (property == prop_twofinger_pressure) {
 
504
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
 
505
            return BadMatch;
 
506
 
 
507
        para->emulate_twofinger_z = *(INT32 *) prop->data;
 
508
    }
 
509
    else if (property == prop_twofinger_width) {
 
510
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
 
511
            return BadMatch;
 
512
 
 
513
        para->emulate_twofinger_w = *(INT32 *) prop->data;
 
514
    }
 
515
    else if (property == prop_scrolldist) {
463
516
        INT32 *dist;
 
517
 
464
518
        if (prop->size != 2 || prop->format != 32 || prop->type != XA_INTEGER)
465
519
            return BadMatch;
466
520
 
467
 
        dist = (INT32*)prop->data;
468
 
        if (para->scroll_dist_vert != dist[0])
469
 
        {
 
521
        dist = (INT32 *) prop->data;
 
522
        if (para->scroll_dist_vert != dist[0]) {
470
523
            para->scroll_dist_vert = dist[0];
471
524
#ifdef HAVE_SMOOTH_SCROLL
472
525
            SetScrollValuator(dev, priv->scroll_axis_vert, SCROLL_TYPE_VERTICAL,
473
526
                              para->scroll_dist_vert, 0);
474
527
#endif
475
528
        }
476
 
        if (para->scroll_dist_horiz != dist[1])
477
 
        {
 
529
        if (para->scroll_dist_horiz != dist[1]) {
478
530
            para->scroll_dist_horiz = dist[1];
479
531
#ifdef HAVE_SMOOTH_SCROLL
480
 
            SetScrollValuator(dev, priv->scroll_axis_horiz, SCROLL_TYPE_HORIZONTAL,
481
 
                              para->scroll_dist_horiz, 0);
 
532
            SetScrollValuator(dev, priv->scroll_axis_horiz,
 
533
                              SCROLL_TYPE_HORIZONTAL, para->scroll_dist_horiz,
 
534
                              0);
482
535
#endif
483
536
        }
484
 
    } else if (property == prop_scrolledge)
485
 
    {
 
537
    }
 
538
    else if (property == prop_scrolledge) {
486
539
        CARD8 *edge;
 
540
 
487
541
        if (prop->size != 3 || prop->format != 8 || prop->type != XA_INTEGER)
488
542
            return BadMatch;
489
543
 
490
 
        edge = (BOOL*)prop->data;
491
 
        para->scroll_edge_vert   = edge[0];
492
 
        para->scroll_edge_horiz  = edge[1];
 
544
        edge = (BOOL *) prop->data;
 
545
        para->scroll_edge_vert = edge[0];
 
546
        para->scroll_edge_horiz = edge[1];
493
547
        para->scroll_edge_corner = edge[2];
494
 
    } else if (property == prop_scrolltwofinger)
495
 
    {
 
548
    }
 
549
    else if (property == prop_scrolltwofinger) {
496
550
        CARD8 *twofinger;
497
551
 
498
552
        if (prop->size != 2 || prop->format != 8 || prop->type != XA_INTEGER)
499
553
            return BadMatch;
500
554
 
501
 
        twofinger = (BOOL*)prop->data;
502
 
        para->scroll_twofinger_vert  = twofinger[0];
 
555
        twofinger = (BOOL *) prop->data;
 
556
        para->scroll_twofinger_vert = twofinger[0];
503
557
        para->scroll_twofinger_horiz = twofinger[1];
504
 
    } else if (property == prop_speed)
505
 
    {
 
558
    }
 
559
    else if (property == prop_speed) {
506
560
        float *speed;
507
561
 
508
562
        if (prop->size != 4 || prop->format != 32 || prop->type != float_type)
509
563
            return BadMatch;
510
564
 
511
 
        speed = (float*)prop->data;
 
565
        speed = (float *) prop->data;
512
566
        para->min_speed = speed[0];
513
567
        para->max_speed = speed[1];
514
568
        para->accl = speed[2];
515
569
        para->trackstick_speed = speed[3];
516
570
 
517
 
    } else if (property == prop_edgemotion_pressure)
518
 
    {
 
571
    }
 
572
    else if (property == prop_edgemotion_pressure) {
519
573
        CARD32 *pressure;
520
574
 
521
575
        if (prop->size != 2 || prop->format != 32 || prop->type != XA_INTEGER)
522
576
            return BadMatch;
523
577
 
524
 
        pressure = (CARD32*)prop->data;
 
578
        pressure = (CARD32 *) prop->data;
525
579
        if (pressure[0] > pressure[1])
526
580
            return BadValue;
527
581
 
528
582
        para->edge_motion_min_z = pressure[0];
529
583
        para->edge_motion_max_z = pressure[1];
530
584
 
531
 
    } else if (property == prop_edgemotion_speed)
532
 
    {
 
585
    }
 
586
    else if (property == prop_edgemotion_speed) {
533
587
        CARD32 *speed;
534
588
 
535
589
        if (prop->size != 2 || prop->format != 32 || prop->type != XA_INTEGER)
536
590
            return BadMatch;
537
591
 
538
 
        speed = (CARD32*)prop->data;
 
592
        speed = (CARD32 *) prop->data;
539
593
        if (speed[0] > speed[1])
540
594
            return BadValue;
541
595
 
542
596
        para->edge_motion_min_speed = speed[0];
543
597
        para->edge_motion_max_speed = speed[1];
544
598
 
545
 
    } else if (property == prop_edgemotion_always)
546
 
    {
 
599
    }
 
600
    else if (property == prop_edgemotion_always) {
547
601
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
548
602
            return BadMatch;
549
603
 
550
 
        para->edge_motion_use_always = *(BOOL*)prop->data;
 
604
        para->edge_motion_use_always = *(BOOL *) prop->data;
551
605
 
552
 
    } else if (property == prop_buttonscroll)
553
 
    {
 
606
    }
 
607
    else if (property == prop_buttonscroll) {
554
608
        BOOL *scroll;
555
609
 
556
610
        if (!priv->has_scrollbuttons)
559
613
        if (prop->size != 2 || prop->format != 8 || prop->type != XA_INTEGER)
560
614
            return BadMatch;
561
615
 
562
 
        scroll = (BOOL*)prop->data;
563
 
        para->updown_button_scrolling    = scroll[0];
 
616
        scroll = (BOOL *) prop->data;
 
617
        para->updown_button_scrolling = scroll[0];
564
618
        para->leftright_button_scrolling = scroll[1];
565
619
 
566
 
    } else if (property == prop_buttonscroll_repeat)
567
 
    {
 
620
    }
 
621
    else if (property == prop_buttonscroll_repeat) {
568
622
        BOOL *repeat;
569
623
 
570
624
        if (!priv->has_scrollbuttons)
573
627
        if (prop->size != 2 || prop->format != 8 || prop->type != XA_INTEGER)
574
628
            return BadMatch;
575
629
 
576
 
        repeat = (BOOL*)prop->data;
577
 
        para->updown_button_repeat    = repeat[0];
 
630
        repeat = (BOOL *) prop->data;
 
631
        para->updown_button_repeat = repeat[0];
578
632
        para->leftright_button_repeat = repeat[1];
579
 
    } else if (property == prop_buttonscroll_time)
580
 
    {
 
633
    }
 
634
    else if (property == prop_buttonscroll_time) {
581
635
        if (!priv->has_scrollbuttons)
582
636
            return BadMatch;
583
637
 
584
638
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
585
639
            return BadMatch;
586
640
 
587
 
        para->scroll_button_repeat = *(INT32*)prop->data;
 
641
        para->scroll_button_repeat = *(INT32 *) prop->data;
588
642
 
589
 
    } else if (property == prop_off)
590
 
    {
 
643
    }
 
644
    else if (property == prop_off) {
591
645
        CARD8 off;
 
646
 
592
647
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
593
648
            return BadMatch;
594
649
 
595
 
        off = *(CARD8*)prop->data;
 
650
        off = *(CARD8 *) prop->data;
596
651
 
597
652
        if (off > 2)
598
653
            return BadValue;
599
654
 
600
655
        para->touchpad_off = off;
601
 
    } else if (property == prop_gestures)
602
 
    {
 
656
    }
 
657
    else if (property == prop_gestures) {
603
658
        BOOL *gestures;
604
659
 
605
660
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
606
661
            return BadMatch;
607
662
 
608
 
        gestures = (BOOL*)prop->data;
 
663
        gestures = (BOOL *) prop->data;
609
664
        para->tap_and_drag_gesture = gestures[0];
610
 
    } else if (property == prop_lockdrags)
611
 
    {
 
665
    }
 
666
    else if (property == prop_lockdrags) {
612
667
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
613
668
            return BadMatch;
614
669
 
615
 
        para->locked_drags = *(BOOL*)prop->data;
616
 
    } else if (property == prop_lockdrags_time)
617
 
    {
 
670
        para->locked_drags = *(BOOL *) prop->data;
 
671
    }
 
672
    else if (property == prop_lockdrags_time) {
618
673
        if (prop->size != 1 || prop->format != 32 || prop->type != XA_INTEGER)
619
674
            return BadMatch;
620
675
 
621
 
        para->locked_drag_time = *(INT32*)prop->data;
622
 
    } else if (property == prop_tapaction)
623
 
    {
 
676
        para->locked_drag_time = *(INT32 *) prop->data;
 
677
    }
 
678
    else if (property == prop_tapaction) {
624
679
        int i;
625
680
        CARD8 *action;
626
681
 
627
 
        if (prop->size > MAX_TAP || prop->format != 8 || prop->type != XA_INTEGER)
 
682
        if (prop->size > MAX_TAP || prop->format != 8 ||
 
683
            prop->type != XA_INTEGER)
628
684
            return BadMatch;
629
685
 
630
 
        action = (CARD8*)prop->data;
 
686
        action = (CARD8 *) prop->data;
631
687
 
632
688
        for (i = 0; i < MAX_TAP; i++)
633
689
            para->tap_action[i] = action[i];
634
 
    } else if (property == prop_clickaction)
635
 
    {
 
690
    }
 
691
    else if (property == prop_clickaction) {
636
692
        int i;
637
693
        CARD8 *action;
638
694
 
639
 
        if (prop->size > MAX_CLICK || prop->format != 8 || prop->type != XA_INTEGER)
 
695
        if (prop->size > MAX_CLICK || prop->format != 8 ||
 
696
            prop->type != XA_INTEGER)
640
697
            return BadMatch;
641
698
 
642
 
        action = (CARD8*)prop->data;
 
699
        action = (CARD8 *) prop->data;
643
700
 
644
701
        for (i = 0; i < MAX_CLICK; i++)
645
702
            para->click_action[i] = action[i];
646
 
    } else if (property == prop_circscroll)
647
 
    {
 
703
    }
 
704
    else if (property == prop_circscroll) {
648
705
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
649
706
            return BadMatch;
650
707
 
651
 
        para->circular_scrolling = *(BOOL*)prop->data;
 
708
        para->circular_scrolling = *(BOOL *) prop->data;
652
709
 
653
 
    } else if (property == prop_circscroll_dist)
654
 
    {
 
710
    }
 
711
    else if (property == prop_circscroll_dist) {
655
712
        float circdist;
656
713
 
657
714
        if (prop->size != 1 || prop->format != 32 || prop->type != float_type)
658
715
            return BadMatch;
659
716
 
660
 
        circdist = *(float*)prop->data;
 
717
        circdist = *(float *) prop->data;
661
718
        para->scroll_dist_circ = circdist;
662
 
    } else if (property == prop_circscroll_trigger)
663
 
    {
 
719
    }
 
720
    else if (property == prop_circscroll_trigger) {
664
721
        int trigger;
 
722
 
665
723
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
666
724
            return BadMatch;
667
725
 
668
 
        trigger = *(CARD8*)prop->data;
 
726
        trigger = *(CARD8 *) prop->data;
669
727
        if (trigger > 8)
670
728
            return BadValue;
671
729
 
672
730
        para->circular_trigger = trigger;
673
731
 
674
 
    } else if (property == prop_circpad)
675
 
    {
676
 
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
677
 
            return BadMatch;
678
 
 
679
 
        para->circular_pad = *(BOOL*)prop->data;
680
 
    } else if (property == prop_palm)
681
 
    {
682
 
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
683
 
            return BadMatch;
684
 
 
685
 
        para->palm_detect = *(BOOL*)prop->data;
686
 
    } else if (property == prop_palm_dim)
687
 
    {
 
732
    }
 
733
    else if (property == prop_circpad) {
 
734
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
 
735
            return BadMatch;
 
736
 
 
737
        para->circular_pad = *(BOOL *) prop->data;
 
738
    }
 
739
    else if (property == prop_palm) {
 
740
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
 
741
            return BadMatch;
 
742
 
 
743
        para->palm_detect = *(BOOL *) prop->data;
 
744
    }
 
745
    else if (property == prop_palm_dim) {
688
746
        INT32 *dim;
689
747
 
690
748
        if (prop->size != 2 || prop->format != 32 || prop->type != XA_INTEGER)
691
749
            return BadMatch;
692
750
 
693
 
        dim = (INT32*)prop->data;
 
751
        dim = (INT32 *) prop->data;
694
752
 
695
753
        para->palm_min_width = dim[0];
696
 
        para->palm_min_z     = dim[1];
697
 
    } else if (property == prop_coastspeed)
698
 
    {
 
754
        para->palm_min_z = dim[1];
 
755
    }
 
756
    else if (property == prop_coastspeed) {
699
757
        float *coast_speeds;
700
758
 
701
759
        if (prop->size != 2 || prop->format != 32 || prop->type != float_type)
702
760
            return BadMatch;
703
761
 
704
 
        coast_speeds = (float*)prop->data;
 
762
        coast_speeds = (float *) prop->data;
705
763
        para->coasting_speed = coast_speeds[0];
706
764
        para->coasting_friction = coast_speeds[1];
707
 
    } else if (property == prop_pressuremotion)
708
 
    {
 
765
    }
 
766
    else if (property == prop_pressuremotion) {
709
767
        CARD32 *press;
 
768
 
710
769
        if (prop->size != 2 || prop->format != 32 || prop->type != XA_CARDINAL)
711
770
            return BadMatch;
712
771
 
713
 
        press = (CARD32*)prop->data;
 
772
        press = (CARD32 *) prop->data;
714
773
        if (press[0] > press[1])
715
774
            return BadValue;
716
775
 
717
776
        para->press_motion_min_z = press[0];
718
777
        para->press_motion_max_z = press[1];
719
 
    } else if (property == prop_grab)
720
 
    {
 
778
    }
 
779
    else if (property == prop_grab) {
721
780
        if (prop->size != 1 || prop->format != 8 || prop->type != XA_INTEGER)
722
781
            return BadMatch;
723
782
 
724
 
        para->grab_event_device = *(BOOL*)prop->data;
725
 
    } else if (property == prop_capabilities)
726
 
    {
727
 
        /* read-only */
728
 
        return BadValue;
729
 
    } else if (property == prop_resolution)
730
 
    {
731
 
        /* read-only */
732
 
        return BadValue;
733
 
    } else if (property == prop_area)
734
 
    {
 
783
        para->grab_event_device = *(BOOL *) prop->data;
 
784
    }
 
785
    else if (property == prop_capabilities) {
 
786
        /* read-only */
 
787
        return BadValue;
 
788
    }
 
789
    else if (property == prop_resolution) {
 
790
        /* read-only */
 
791
        return BadValue;
 
792
    }
 
793
    else if (property == prop_area) {
735
794
        INT32 *area;
 
795
 
736
796
        if (prop->size != 4 || prop->format != 32 || prop->type != XA_INTEGER)
737
797
            return BadMatch;
738
798
 
739
 
        area = (INT32*)prop->data;
740
 
        if ((((area[0] != 0) && (area[1] != 0)) && (area[0] > area[1]) ) || (((area[2] != 0) && (area[3] != 0)) && (area[2] > area[3])))
 
799
        area = (INT32 *) prop->data;
 
800
        if ((((area[0] != 0) && (area[1] != 0)) && (area[0] > area[1])) ||
 
801
            (((area[2] != 0) && (area[3] != 0)) && (area[2] > area[3])))
741
802
            return BadValue;
742
803
 
743
 
        para->area_left_edge   = area[0];
744
 
        para->area_right_edge  = area[1];
745
 
        para->area_top_edge    = area[2];
 
804
        para->area_left_edge = area[0];
 
805
        para->area_right_edge = area[1];
 
806
        para->area_top_edge = area[2];
746
807
        para->area_bottom_edge = area[3];
747
 
    } else if (property == prop_softbutton_areas)
748
 
    {
 
808
    }
 
809
    else if (property == prop_softbutton_areas) {
749
810
        int *areas;
750
811
 
751
812
        if (prop->size != 8 || prop->format != 32 || prop->type != XA_INTEGER)
752
813
            return BadMatch;
753
814
 
754
 
        areas = (int*)prop->data;
 
815
        areas = (int *) prop->data;
755
816
        if (!SynapticsIsSoftButtonAreasValid(areas))
756
817
            return BadValue;
757
818
 
758
819
        memcpy(para->softbutton_areas[0], areas, 4 * sizeof(int));
759
820
        memcpy(para->softbutton_areas[1], areas + 4, 4 * sizeof(int));
760
 
    } else if (property == prop_noise_cancellation) {
 
821
    }
 
822
    else if (property == prop_noise_cancellation) {
761
823
        INT32 *hyst;
 
824
 
762
825
        if (prop->size != 2 || prop->format != 32 || prop->type != XA_INTEGER)
763
826
            return BadMatch;
764
827
 
765
 
        hyst = (INT32*)prop->data;
 
828
        hyst = (INT32 *) prop->data;
766
829
        if (hyst[0] < 0 || hyst[1] < 0)
767
830
            return BadValue;
768
831
        para->hyst_x = hyst[0];
769
832
        para->hyst_y = hyst[1];
770
 
    } else if (property == prop_product_id || property == prop_device_node)
771
 
        return BadValue; /* read-only */
 
833
    }
 
834
    else if (property == prop_product_id || property == prop_device_node)
 
835
        return BadValue;        /* read-only */
772
836
 
773
837
    return Success;
774
838
}
775