1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/*
* Copyright © 2016 Red Hat, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of the copyright holders not be used in
* advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. The copyright holders make
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "config.h"
#include <assert.h>
#include <limits.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "evdev-tablet-pad.h"
struct pad_led_group {
struct libinput_tablet_pad_mode_group base;
};
static void
pad_led_group_destroy(struct libinput_tablet_pad_mode_group *g)
{
struct pad_led_group *group = (struct pad_led_group *)g;
free(group);
}
static struct pad_led_group *
pad_group_new_basic(struct pad_dispatch *pad,
unsigned int group_index,
int nleds)
{
struct pad_led_group *group;
group = zalloc(sizeof *group);
if (!group)
return NULL;
group->base.device = &pad->device->base;
group->base.refcount = 1;
group->base.index = group_index;
group->base.current_mode = 0;
group->base.num_modes = nleds;
group->base.destroy = pad_led_group_destroy;
return group;
}
static inline struct libinput_tablet_pad_mode_group *
pad_get_mode_group(struct pad_dispatch *pad, unsigned int index)
{
struct libinput_tablet_pad_mode_group *group;
list_for_each(group, &pad->modes.mode_group_list, link) {
if (group->index == index)
return group;
}
return NULL;
}
static int
pad_init_fallback_group(struct pad_dispatch *pad)
{
struct pad_led_group *group;
group = pad_group_new_basic(pad, 0, 1);
if (!group)
return 1;
/* If we only have one group, all buttons/strips/rings are part of
* that group. We rely on the other layers to filter out invalid
* indices */
group->base.button_mask = -1;
group->base.strip_mask = -1;
group->base.ring_mask = -1;
group->base.toggle_button_mask = 0;
list_insert(&pad->modes.mode_group_list, &group->base.link);
return 0;
}
int
pad_init_leds(struct pad_dispatch *pad,
struct evdev_device *device)
{
int rc = 1;
list_init(&pad->modes.mode_group_list);
if (pad->nbuttons > 32) {
log_bug_libinput(device->base.seat->libinput,
"Too many pad buttons for modes %d\n",
pad->nbuttons);
return rc;
}
/* Eventually we slot the libwacom-based led detection in here. That
* requires getting the kernel ready first. For now we just init the
* fallback single-mode group.
*/
rc = pad_init_fallback_group(pad);
return rc;
}
void
pad_destroy_leds(struct pad_dispatch *pad)
{
struct libinput_tablet_pad_mode_group *group, *tmpgrp;
list_for_each_safe(group, tmpgrp, &pad->modes.mode_group_list, link)
libinput_tablet_pad_mode_group_unref(group);
}
void
pad_button_update_mode(struct libinput_tablet_pad_mode_group *g,
unsigned int button_index,
enum libinput_button_state state)
{
struct pad_led_group *group = (struct pad_led_group*)g;
if (state != LIBINPUT_BUTTON_STATE_PRESSED)
return;
if (!libinput_tablet_pad_mode_group_button_is_toggle(g, button_index))
return;
log_bug_libinput(group->base.device->seat->libinput,
"Button %d should not be a toggle button",
button_index);
}
int
evdev_device_tablet_pad_get_num_mode_groups(struct evdev_device *device)
{
struct pad_dispatch *pad = (struct pad_dispatch*)device->dispatch;
struct libinput_tablet_pad_mode_group *group;
int num_groups = 0;
if (!(device->seat_caps & EVDEV_DEVICE_TABLET_PAD))
return -1;
list_for_each(group, &pad->modes.mode_group_list, link)
num_groups++;
return num_groups;
}
struct libinput_tablet_pad_mode_group *
evdev_device_tablet_pad_get_mode_group(struct evdev_device *device,
unsigned int index)
{
struct pad_dispatch *pad = (struct pad_dispatch*)device->dispatch;
if (!(device->seat_caps & EVDEV_DEVICE_TABLET_PAD))
return NULL;
return pad_get_mode_group(pad, index);
}
|
