]> diplodocus.org Git - xorg-xinput/blob - src/property.c
projects / xorg-xinput / blob
? search:


e8ce611e8c24e31513164c7c9c77436cd97add79
[xorg-xinput] / src / property.c
1 /*
2 * Copyright 2007 Peter Hutterer
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation.
9 *
10 * The above copyright notice and this permission notice shall be included
11 * in all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
15 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR
17 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
18 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
19 * OTHER DEALINGS IN THE SOFTWARE.
20 *
21 * Except as contained in this notice, the name of the author shall
22 * not be used in advertising or otherwise to promote the sale, use or
23 * other dealings in this Software without prior written authorization
24 * from the author.
25 *
26 */
27
28 #include <ctype.h>
29 #include <string.h>
30 #include <stdlib.h>
31 #include <stdint.h>
32 #include <X11/Xatom.h>
33 #include <X11/extensions/XIproto.h>
34
35 #include "xinput.h"
36
37 static Atom parse_atom(Display *dpy, char *name) {
38 Bool is_atom = True;
39 int i;
40
41 for (i = 0; name[i] != '\0'; i++) {
42 if (!isdigit(name[i])) {
43 is_atom = False;
44 break;
45 }
46 }
47
48 if (is_atom)
49 return atoi(name);
50 else
51 return XInternAtom(dpy, name, False);
52 }
53
54 static void
55 print_property(Display *dpy, XDevice* dev, Atom property)
56 {
57 Atom act_type;
58 char *name;
59 int act_format;
60 unsigned long nitems, bytes_after;
61 unsigned char *data, *ptr;
62 int j, done = False, size;
63
64 name = XGetAtomName(dpy, property);
65 printf("\t%s (%ld):\t", name, property);
66
67 if (XGetDeviceProperty(dpy, dev, property, 0, 1000, False,
68 AnyPropertyType, &act_type, &act_format,
69 &nitems, &bytes_after, &data) == Success)
70 {
71 Atom float_atom = XInternAtom(dpy, "FLOAT", True);
72
73 ptr = data;
74
75 if (nitems == 0)
76 printf("<no items>");
77
78 switch(act_format)
79 {
80 case 8: size = sizeof(char); break;
81 case 16: size = sizeof(short); break;
82 case 32: size = sizeof(long); break;
83 }
84
85 for (j = 0; j < nitems; j++)
86 {
87 switch(act_type)
88 {
89 case XA_INTEGER:
90 switch(act_format)
91 {
92 case 8:
93 printf("%d", *((char*)ptr));
94 break;
95 case 16:
96 printf("%d", *((short*)ptr));
97 break;
98 case 32:
99 printf("%ld", *((long*)ptr));
100 break;
101 }
102 break;
103 case XA_STRING:
104 if (act_format != 8)
105 {
106 printf("Unknown string format.\n");
107 done = True;
108 break;
109 }
110 printf("\"%s\"", ptr);
111 j += strlen((char*)ptr); /* The loop's j++ jumps over the
112 terminating 0 */
113 ptr += strlen((char*)ptr); /* ptr += size below jumps over
114 the terminating 0 */
115 break;
116 case XA_ATOM:
117 {
118 Atom a = *(Atom*)ptr;
119 printf("\"%s\" (%d)",
120 (a) ? XGetAtomName(dpy, a) : "None",
121 (int)a);
122 break;
123 }
124 default:
125 if (float_atom != None && act_type == float_atom)
126 {
127 printf("%f", *((float*)ptr));
128 break;
129 }
130
131 printf("\t... of unknown type %s\n",
132 XGetAtomName(dpy, act_type));
133 done = True;
134 break;
135 }
136
137 ptr += size;
138
139 if (done == True)
140 break;
141 if (j < nitems - 1)
142 printf(", ");
143 }
144 printf("\n");
145 XFree(data);
146 } else
147 printf("\tFetch failure\n");
148
149 }
150
151 static int
152 list_props_xi1(Display *dpy, int argc, char** argv, char* name, char *desc)
153 {
154 XDeviceInfo *info;
155 XDevice *dev;
156 int i;
157 int nprops;
158 Atom *props;
159
160 if (argc == 0)
161 {
162 fprintf(stderr, "Usage: xinput %s %s\n", name, desc);
163 return EXIT_FAILURE;
164 }
165
166 for (i = 0; i < argc; i++)
167 {
168 info = find_device_info(dpy, argv[i], False);
169 if (!info)
170 {
171 fprintf(stderr, "unable to find device %s\n", argv[i]);
172 continue;
173 }
174
175 dev = XOpenDevice(dpy, info->id);
176 if (!dev)
177 {
178 fprintf(stderr, "unable to open device '%s'\n", info->name);
179 continue;
180 }
181
182 props = XListDeviceProperties(dpy, dev, &nprops);
183 if (!nprops)
184 {
185 printf("Device '%s' does not report any properties.\n", info->name);
186 continue;
187 }
188
189 printf("Device '%s':\n", info->name);
190 while(nprops--)
191 {
192 print_property(dpy, dev, props[nprops]);
193 }
194
195 XFree(props);
196 XCloseDevice(dpy, dev);
197 }
198 return EXIT_SUCCESS;
199 }
200
201 int
202 set_int_prop(Display *dpy, int argc, char** argv, char* n, char *desc)
203 {
204 XDeviceInfo *info;
205 XDevice *dev;
206 Atom prop;
207 char *name;
208 int i;
209 char *data;
210 int format, nelements = 0;
211
212 if (argc < 3)
213 {
214 fprintf(stderr, "Usage: xinput %s %s\n", n, desc);
215 return EXIT_FAILURE;
216 }
217
218 info = find_device_info(dpy, argv[0], False);
219 if (!info)
220 {
221 fprintf(stderr, "unable to find device %s\n", argv[0]);
222 return EXIT_FAILURE;
223 }
224
225 dev = XOpenDevice(dpy, info->id);
226 if (!dev)
227 {
228 fprintf(stderr, "unable to open device %s\n", argv[0]);
229 return EXIT_FAILURE;
230 }
231
232 name = argv[1];
233
234 prop = parse_atom(dpy, name);
235
236 nelements = argc - 3;
237 format = atoi(argv[2]);
238 if (format != 8 && format != 16 && format != 32)
239 {
240 fprintf(stderr, "Invalid format %d\n", format);
241 return EXIT_FAILURE;
242 }
243
244 data = calloc(nelements, sizeof(long));
245 for (i = 0; i < nelements; i++)
246 {
247 switch(format)
248 {
249 case 8:
250 *(((char*)data) + i) = atoi(argv[3 + i]);
251 break;
252 case 16:
253 *(((short*)data) + i) = atoi(argv[3 + i]);
254 break;
255 case 32:
256 *(((long*)data) + i) = atoi(argv[3 + i]);
257 break;
258 }
259 }
260
261 XChangeDeviceProperty(dpy, dev, prop, XA_INTEGER, format, PropModeReplace,
262 (unsigned char*)data, nelements);
263
264 free(data);
265 XCloseDevice(dpy, dev);
266 return EXIT_SUCCESS;
267 }
268
269 int
270 set_float_prop(Display *dpy, int argc, char** argv, char* n, char *desc)
271 {
272 XDeviceInfo *info;
273 XDevice *dev;
274 Atom prop, float_atom;
275 char *name;
276 int i;
277 long *data;
278 int nelements = 0;
279 char* endptr;
280
281 if (argc < 2)
282 {
283 fprintf(stderr, "Usage: xinput %s %s\n", n, desc);
284 return EXIT_FAILURE;
285 }
286
287 info = find_device_info(dpy, argv[0], False);
288 if (!info)
289 {
290 fprintf(stderr, "unable to find device %s\n", argv[0]);
291 return EXIT_FAILURE;
292 }
293
294 dev = XOpenDevice(dpy, info->id);
295 if (!dev)
296 {
297 fprintf(stderr, "unable to open device %s\n", argv[0]);
298 return EXIT_FAILURE;
299 }
300
301 name = argv[1];
302
303 prop = parse_atom(dpy, name);
304
305 nelements = argc - 2;
306
307 float_atom = XInternAtom(dpy, "FLOAT", False);
308
309 if (float_atom == (Atom)0)
310 {
311 fprintf(stderr, "no FLOAT atom present in server\n");
312 return EXIT_FAILURE;
313 }
314
315 if (sizeof(float) != 4)
316 {
317 fprintf(stderr, "sane FP required\n");
318 return EXIT_FAILURE;
319 }
320
321 data = calloc(nelements, sizeof(long));
322 for (i = 0; i < nelements; i++)
323 {
324 *((float*)(data + i)) = strtod(argv[2 + i], &endptr);
325 if(endptr == argv[2 + i]){
326 fprintf(stderr, "argument %s could not be parsed\n", argv[2 + i]);
327 return EXIT_FAILURE;
328 }
329 }
330
331 XChangeDeviceProperty(dpy, dev, prop, float_atom, 32, PropModeReplace,
332 (unsigned char*)data, nelements);
333
334 free(data);
335 XCloseDevice(dpy, dev);
336 return EXIT_SUCCESS;
337 }
338
339
340 int watch_props(Display *dpy, int argc, char** argv, char* n, char *desc)
341 {
342 XDevice *dev;
343 XDeviceInfo *info;
344 XEvent ev;
345 XDevicePropertyNotifyEvent *dpev;
346 char *name;
347 int type_prop;
348 XEventClass cls_prop;
349
350 if (list_props(dpy, argc, argv, n, desc) != EXIT_SUCCESS)
351 return EXIT_FAILURE;
352
353 info = find_device_info(dpy, argv[0], False);
354 if (!info)
355 {
356 fprintf(stderr, "unable to find device %s\n", argv[0]);
357 return EXIT_FAILURE;
358 }
359
360 dev = XOpenDevice(dpy, info->id);
361 if (!dev)
362 {
363 fprintf(stderr, "unable to open device '%s'\n", info->name);
364 return EXIT_FAILURE;
365 }
366
367 DevicePropertyNotify(dev, type_prop, cls_prop);
368 XSelectExtensionEvent(dpy, DefaultRootWindow(dpy), &cls_prop, 1);
369
370 while(1)
371 {
372 XNextEvent(dpy, &ev);
373
374 dpev = (XDevicePropertyNotifyEvent*)&ev;
375 if (dpev->type != type_prop)
376 continue;
377
378 name = XGetAtomName(dpy, dpev->atom);
379 printf("Property '%s' changed.\n", name);
380 print_property(dpy, dev, dpev->atom);
381 }
382
383 XCloseDevice(dpy, dev);
384 }
385
386 static int
387 delete_prop_xi1(Display *dpy, int argc, char** argv, char* n, char *desc)
388 {
389 XDevice *dev;
390 XDeviceInfo *info;
391 char *name;
392 Atom prop;
393
394 info = find_device_info(dpy, argv[0], False);
395 if (!info)
396 {
397 fprintf(stderr, "unable to find device %s\n", argv[0]);
398 return EXIT_FAILURE;
399 }
400
401 dev = XOpenDevice(dpy, info->id);
402 if (!dev)
403 {
404 fprintf(stderr, "unable to open device '%s'\n", info->name);
405 return EXIT_FAILURE;
406 }
407
408 name = argv[1];
409
410 prop = parse_atom(dpy, name);
411
412 XDeleteDeviceProperty(dpy, dev, prop);
413
414 XCloseDevice(dpy, dev);
415 return EXIT_SUCCESS;
416 }
417
418 int
419 set_atom_prop(Display *dpy, int argc, char** argv, char* n, char *desc)
420 {
421 XDeviceInfo *info;
422 XDevice *dev;
423 Atom prop;
424 char *name;
425 int i, j;
426 Bool is_atom;
427 Atom *data;
428 int nelements = 0;
429
430 if (argc < 3)
431 {
432 fprintf(stderr, "Usage: xinput %s %s\n", n, desc);
433 return EXIT_FAILURE;
434 }
435
436 info = find_device_info(dpy, argv[0], False);
437 if (!info)
438 {
439 fprintf(stderr, "unable to find device %s\n", argv[0]);
440 return EXIT_FAILURE;
441 }
442
443 dev = XOpenDevice(dpy, info->id);
444 if (!dev)
445 {
446 fprintf(stderr, "unable to open device %s\n", argv[0]);
447 return EXIT_FAILURE;
448 }
449
450 name = argv[1];
451
452 prop = parse_atom(dpy, name);
453
454 nelements = argc - 2;
455 data = calloc(nelements, sizeof(Atom));
456 for (i = 0; i < nelements; i++)
457 {
458 is_atom = True;
459 name = argv[2 + i];
460 for(j = 0; j < strlen(name); j++) {
461 if (!isdigit(name[j])) {
462 is_atom = False;
463 break;
464 }
465 }
466
467 if (!is_atom)
468 data[i] = XInternAtom(dpy, name, False);
469 else
470 {
471 data[i] = atoi(name);
472 XFree(XGetAtomName(dpy, data[i]));
473 }
474 }
475
476 XChangeDeviceProperty(dpy, dev, prop, XA_ATOM, 32, PropModeReplace,
477 (unsigned char*)data, nelements);
478
479 free(data);
480 XCloseDevice(dpy, dev);
481 return EXIT_SUCCESS;
482 }
483
484 static int
485 set_prop_xi1(Display *dpy, int argc, char **argv, char *n, char *desc)
486 {
487 XDeviceInfo *info;
488 XDevice *dev;
489 Atom prop;
490 Atom type;
491 char *name;
492 int i;
493 Atom float_atom;
494 int format, nelements = 0;
495 unsigned long act_nitems, bytes_after;
496 char *endptr;
497 union {
498 unsigned char *c;
499 short *s;
500 long *l;
501 Atom *a;
502 } data;
503
504 if (argc < 3)
505 {
506 fprintf(stderr, "Usage: xinput %s %s\n", n, desc);
507 return EXIT_FAILURE;
508 }
509
510 info = find_device_info(dpy, argv[0], False);
511 if (!info)
512 {
513 fprintf(stderr, "unable to find device %s\n", argv[0]);
514 return EXIT_FAILURE;
515 }
516
517 dev = XOpenDevice(dpy, info->id);
518 if (!dev)
519 {
520 fprintf(stderr, "unable to open device %s\n", argv[0]);
521 return EXIT_FAILURE;
522 }
523
524 name = argv[1];
525
526 prop = parse_atom(dpy, name);
527
528 if (prop == None) {
529 fprintf(stderr, "invalid property %s\n", name);
530 return EXIT_FAILURE;
531 }
532
533 float_atom = XInternAtom(dpy, "FLOAT", False);
534
535 nelements = argc - 2;
536 if (XGetDeviceProperty(dpy, dev, prop, 0, 0, False, AnyPropertyType,
537 &type, &format, &act_nitems, &bytes_after, &data.c)
538 != Success) {
539 fprintf(stderr, "failed to get property type and format for %s\n", name);
540 return EXIT_FAILURE;
541 }
542
543 XFree(data.c);
544
545 if (type == None) {
546 fprintf(stderr, "property %s doesn't exist\n", name);
547 return EXIT_FAILURE;
548 }
549
550 data.c = calloc(nelements, sizeof(long));
551
552 for (i = 0; i < nelements; i++)
553 {
554 if (type == XA_INTEGER) {
555 switch (format)
556 {
557 case 8:
558 data.c[i] = atoi(argv[2 + i]);
559 break;
560 case 16:
561 data.s[i] = atoi(argv[2 + i]);
562 break;
563 case 32:
564 data.l[i] = atoi(argv[2 + i]);
565 break;
566 default:
567 fprintf(stderr, "unexpected size for property %s", name);
568 return EXIT_FAILURE;
569 }
570 } else if (type == float_atom) {
571 if (format != 32) {
572 fprintf(stderr, "unexpected format %d for property %s\n",
573 format, name);
574 return EXIT_FAILURE;
575 }
576 *(float *)(data.l + i) = strtod(argv[2 + i], &endptr);
577 if (endptr == argv[2 + i]) {
578 fprintf(stderr, "argument %s could not be parsed\n", argv[2 + i]);
579 return EXIT_FAILURE;
580 }
581 } else if (type == XA_ATOM) {
582 if (format != 32) {
583 fprintf(stderr, "unexpected format %d for property %s\n",
584 format, name);
585 return EXIT_FAILURE;
586 }
587 data.a[i] = parse_atom(dpy, argv[2 + i]);
588 } else {
589 fprintf(stderr, "unexpected type for property %s\n", name);
590 return EXIT_FAILURE;
591 }
592 }
593
594 XChangeDeviceProperty(dpy, dev, prop, type, format, PropModeReplace,
595 data.c, nelements);
596 free(data.c);
597 XCloseDevice(dpy, dev);
598 return EXIT_SUCCESS;
599 }
600
601 #if HAVE_XI2
602 static void
603 print_property_xi2(Display *dpy, int deviceid, Atom property)
604 {
605 Atom act_type;
606 char *name;
607 int act_format;
608 unsigned long nitems, bytes_after;
609 unsigned char *data, *ptr;
610 int j, done = False;
611
612 name = XGetAtomName(dpy, property);
613 printf("\t%s (%ld):\t", name, property);
614
615 if (XIGetProperty(dpy, deviceid, property, 0, 1000, False,
616 AnyPropertyType, &act_type, &act_format,
617 &nitems, &bytes_after, &data) == Success)
618 {
619 Atom float_atom = XInternAtom(dpy, "FLOAT", True);
620
621 ptr = data;
622
623 for (j = 0; j < nitems; j++)
624 {
625 switch(act_type)
626 {
627 case XA_INTEGER:
628 switch(act_format)
629 {
630 case 8:
631 printf("%d", *((int8_t*)ptr));
632 break;
633 case 16:
634 printf("%d", *((int16_t*)ptr));
635 break;
636 case 32:
637 printf("%d", *((int32_t*)ptr));
638 break;
639 }
640 break;
641 case XA_STRING:
642 if (act_format != 8)
643 {
644 printf("Unknown string format.\n");
645 done = True;
646 break;
647 }
648 printf("\"%s\"", ptr);
649 j += strlen((char*)ptr); /* The loop's j++ jumps over the
650 terminating 0 */
651 ptr += strlen((char*)ptr); /* ptr += size below jumps over
652 the terminating 0 */
653 break;
654 case XA_ATOM:
655 {
656 Atom a = *(Atom*)ptr;
657 printf("\"%s\" (%d)",
658 (a) ? XGetAtomName(dpy, a) : "None",
659 (int)a);
660 break;
661 }
662 break;
663 default:
664 if (float_atom != None && act_type == float_atom)
665 {
666 printf("%f", *((float*)ptr));
667 break;
668 }
669
670 printf("\t... of unknown type %s\n",
671 XGetAtomName(dpy, act_type));
672 done = True;
673 break;
674 }
675
676 ptr += act_format/8;
677
678 if (done == True)
679 break;
680 if (j < nitems - 1)
681 printf(", ");
682 }
683 printf("\n");
684 XFree(data);
685 } else
686 printf("\tFetch failure\n");
687
688 }
689
690 static int
691 list_props_xi2(Display *dpy, int argc, char** argv, char* name, char *desc)
692 {
693 XIDeviceInfo *info;
694 int i;
695 int nprops;
696 Atom *props;
697
698 if (argc == 0)
699 {
700 fprintf(stderr, "Usage: xinput %s %s\n", name, desc);
701 return EXIT_FAILURE;
702 }
703
704 for (i = 0; i < argc; i++)
705 {
706 info = xi2_find_device_info(dpy, argv[i]);
707 if (!info)
708 {
709 fprintf(stderr, "unable to find device %s\n", argv[i]);
710 continue;
711 }
712
713 props = XIListProperties(dpy, info->deviceid, &nprops);
714 if (!nprops)
715 {
716 printf("Device '%s' does not report any properties.\n", info->name);
717 continue;
718 }
719
720 printf("Device '%s':\n", info->name);
721 while(nprops--)
722 {
723 print_property_xi2(dpy, info->deviceid, props[nprops]);
724 }
725
726 XFree(props);
727 }
728 return EXIT_SUCCESS;
729 }
730
731 static int
732 delete_prop_xi2(Display *dpy, int argc, char** argv, char* n, char *desc)
733 {
734 XIDeviceInfo *info;
735 char *name;
736 Atom prop;
737
738 info = xi2_find_device_info(dpy, argv[0]);
739 if (!info)
740 {
741 fprintf(stderr, "unable to find device %s\n", argv[0]);
742 return EXIT_FAILURE;
743 }
744
745 name = argv[1];
746
747 prop = parse_atom(dpy, name);
748
749 XIDeleteProperty(dpy, info->deviceid, prop);
750
751 return EXIT_SUCCESS;
752 }
753
754 static int
755 set_prop_xi2(Display *dpy, int argc, char **argv, char *n, char *desc)
756 {
757 XIDeviceInfo *info;
758 Atom prop;
759 Atom type;
760 char *name;
761 int i;
762 Atom float_atom;
763 int format, nelements = 0;
764 unsigned long act_nitems, bytes_after;
765 char *endptr;
766 union {
767 unsigned char *c;
768 int16_t *s;
769 int32_t *l;
770 } data;
771
772 if (argc < 3)
773 {
774 fprintf(stderr, "Usage: xinput %s %s\n", n, desc);
775 return EXIT_FAILURE;
776 }
777
778 info = xi2_find_device_info(dpy, argv[0]);
779 if (!info)
780 {
781 fprintf(stderr, "unable to find device %s\n", argv[0]);
782 return EXIT_FAILURE;
783 }
784
785 name = argv[1];
786
787 prop = parse_atom(dpy, name);
788
789 if (prop == None) {
790 fprintf(stderr, "invalid property %s\n", name);
791 return EXIT_FAILURE;
792 }
793
794 float_atom = XInternAtom(dpy, "FLOAT", False);
795
796 nelements = argc - 2;
797 if (XIGetProperty(dpy, info->deviceid, prop, 0, 0, False, AnyPropertyType,
798 &type, &format, &act_nitems, &bytes_after, &data.c)
799 != Success) {
800 fprintf(stderr, "failed to get property type and format for %s\n", name);
801 return EXIT_FAILURE;
802 }
803
804 XFree(data.c);
805
806 if (type == None) {
807 fprintf(stderr, "property %s doesn't exist\n", name);
808 return EXIT_FAILURE;
809 }
810
811 data.c = calloc(nelements, sizeof(int32_t));
812
813 for (i = 0; i < nelements; i++)
814 {
815 if (type == XA_INTEGER) {
816 switch (format)
817 {
818 case 8:
819 data.c[i] = atoi(argv[2 + i]);
820 break;
821 case 16:
822 data.s[i] = atoi(argv[2 + i]);
823 break;
824 case 32:
825 data.l[i] = atoi(argv[2 + i]);
826 break;
827 default:
828 fprintf(stderr, "unexpected size for property %s", name);
829 return EXIT_FAILURE;
830 }
831 } else if (type == float_atom) {
832 if (format != 32) {
833 fprintf(stderr, "unexpected format %d for property %s\n",
834 format, name);
835 return EXIT_FAILURE;
836 }
837 *(float *)(data.l + i) = strtod(argv[2 + i], &endptr);
838 if (endptr == argv[2 + i]) {
839 fprintf(stderr, "argument %s could not be parsed\n", argv[2 + i]);
840 return EXIT_FAILURE;
841 }
842 } else if (type == XA_ATOM) {
843 if (format != 32) {
844 fprintf(stderr, "unexpected format %d for property %s\n",
845 format, name);
846 return EXIT_FAILURE;
847 }
848 data.l[i] = parse_atom(dpy, argv[2 + i]);
849 } else {
850 fprintf(stderr, "unexpected type for property %s\n", name);
851 return EXIT_FAILURE;
852 }
853 }
854
855 XIChangeProperty(dpy, info->deviceid, prop, type, format, PropModeReplace,
856 data.c, nelements);
857 free(data.c);
858 return EXIT_SUCCESS;
859 }
860 #endif
861
862 int list_props(Display *display, int argc, char *argv[], char *name,
863 char *desc)
864 {
865 #ifdef HAVE_XI2
866 if (xinput_version(display) == XI_2_Major)
867 return list_props_xi2(display, argc, argv, name, desc);
868 #endif
869 return list_props_xi1(display, argc, argv, name, desc);
870
871 }
872
873 int delete_prop(Display *display, int argc, char *argv[], char *name,
874 char *desc)
875 {
876 #ifdef HAVE_XI2
877 if (xinput_version(display) == XI_2_Major)
878 return delete_prop_xi2(display, argc, argv, name, desc);
879 #endif
880 return delete_prop_xi1(display, argc, argv, name, desc);
881
882 }
883
884 int set_prop(Display *display, int argc, char *argv[], char *name,
885 char *desc)
886 {
887 #ifdef HAVE_XI2
888 if (xinput_version(display) == XI_2_Major)
889 return set_prop_xi2(display, argc, argv, name, desc);
890 #endif
891 return set_prop_xi1(display, argc, argv, name, desc);
892 }
Fork of https://gitlab.freedesktop.org/xorg/app/xinput