Statistics
| Branch: | Revision:

root / input.c @ 7e581fb3

History | View | Annotate | Download (7.8 kB)

1
/*
2
 * QEMU System Emulator
3
 *
4
 * Copyright (c) 2003-2008 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24

    
25
#include "sysemu.h"
26
#include "net.h"
27
#include "monitor.h"
28
#include "console.h"
29
#include "qjson.h"
30

    
31
static QEMUPutKBDEvent *qemu_put_kbd_event;
32
static void *qemu_put_kbd_event_opaque;
33
static QTAILQ_HEAD(, QEMUPutLEDEntry) led_handlers = QTAILQ_HEAD_INITIALIZER(led_handlers);
34
static QTAILQ_HEAD(, QEMUPutMouseEntry) mouse_handlers =
35
    QTAILQ_HEAD_INITIALIZER(mouse_handlers);
36
static NotifierList mouse_mode_notifiers = 
37
    NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
38

    
39
void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
40
{
41
    qemu_put_kbd_event_opaque = opaque;
42
    qemu_put_kbd_event = func;
43
}
44

    
45
static void check_mode_change(void)
46
{
47
    static int current_is_absolute, current_has_absolute;
48
    int is_absolute;
49
    int has_absolute;
50

    
51
    is_absolute = kbd_mouse_is_absolute();
52
    has_absolute = kbd_mouse_has_absolute();
53

    
54
    if (is_absolute != current_is_absolute ||
55
        has_absolute != current_has_absolute) {
56
        notifier_list_notify(&mouse_mode_notifiers);
57
    }
58

    
59
    current_is_absolute = is_absolute;
60
    current_has_absolute = has_absolute;
61
}
62

    
63
QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
64
                                                void *opaque, int absolute,
65
                                                const char *name)
66
{
67
    QEMUPutMouseEntry *s;
68
    static int mouse_index = 0;
69

    
70
    s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
71

    
72
    s->qemu_put_mouse_event = func;
73
    s->qemu_put_mouse_event_opaque = opaque;
74
    s->qemu_put_mouse_event_absolute = absolute;
75
    s->qemu_put_mouse_event_name = qemu_strdup(name);
76
    s->index = mouse_index++;
77

    
78
    QTAILQ_INSERT_TAIL(&mouse_handlers, s, node);
79

    
80
    check_mode_change();
81

    
82
    return s;
83
}
84

    
85
void qemu_activate_mouse_event_handler(QEMUPutMouseEntry *entry)
86
{
87
    QTAILQ_REMOVE(&mouse_handlers, entry, node);
88
    QTAILQ_INSERT_HEAD(&mouse_handlers, entry, node);
89

    
90
    check_mode_change();
91
}
92

    
93
void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
94
{
95
    QTAILQ_REMOVE(&mouse_handlers, entry, node);
96

    
97
    qemu_free(entry->qemu_put_mouse_event_name);
98
    qemu_free(entry);
99

    
100
    check_mode_change();
101
}
102

    
103
QEMUPutLEDEntry *qemu_add_led_event_handler(QEMUPutLEDEvent *func,
104
                                            void *opaque)
105
{
106
    QEMUPutLEDEntry *s;
107

    
108
    s = qemu_mallocz(sizeof(QEMUPutLEDEntry));
109

    
110
    s->put_led = func;
111
    s->opaque = opaque;
112
    QTAILQ_INSERT_TAIL(&led_handlers, s, next);
113
    return s;
114
}
115

    
116
void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry)
117
{
118
    if (entry == NULL)
119
        return;
120
    QTAILQ_REMOVE(&led_handlers, entry, next);
121
    qemu_free(entry);
122
}
123

    
124
void kbd_put_keycode(int keycode)
125
{
126
    if (qemu_put_kbd_event) {
127
        qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
128
    }
129
}
130

    
131
void kbd_put_ledstate(int ledstate)
132
{
133
    QEMUPutLEDEntry *cursor;
134

    
135
    QTAILQ_FOREACH(cursor, &led_handlers, next) {
136
        cursor->put_led(cursor->opaque, ledstate);
137
    }
138
}
139

    
140
void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
141
{
142
    QEMUPutMouseEntry *entry;
143
    QEMUPutMouseEvent *mouse_event;
144
    void *mouse_event_opaque;
145
    int width;
146

    
147
    if (QTAILQ_EMPTY(&mouse_handlers)) {
148
        return;
149
    }
150

    
151
    entry = QTAILQ_FIRST(&mouse_handlers);
152

    
153
    mouse_event = entry->qemu_put_mouse_event;
154
    mouse_event_opaque = entry->qemu_put_mouse_event_opaque;
155

    
156
    if (mouse_event) {
157
        if (graphic_rotate) {
158
            if (entry->qemu_put_mouse_event_absolute)
159
                width = 0x7fff;
160
            else
161
                width = graphic_width - 1;
162
            mouse_event(mouse_event_opaque,
163
                        width - dy, dx, dz, buttons_state);
164
        } else
165
            mouse_event(mouse_event_opaque,
166
                        dx, dy, dz, buttons_state);
167
    }
168
}
169

    
170
int kbd_mouse_is_absolute(void)
171
{
172
    if (QTAILQ_EMPTY(&mouse_handlers)) {
173
        return 0;
174
    }
175

    
176
    return QTAILQ_FIRST(&mouse_handlers)->qemu_put_mouse_event_absolute;
177
}
178

    
179
int kbd_mouse_has_absolute(void)
180
{
181
    QEMUPutMouseEntry *entry;
182

    
183
    QTAILQ_FOREACH(entry, &mouse_handlers, node) {
184
        if (entry->qemu_put_mouse_event_absolute) {
185
            return 1;
186
        }
187
    }
188

    
189
    return 0;
190
}
191

    
192
static void info_mice_iter(QObject *data, void *opaque)
193
{
194
    QDict *mouse;
195
    Monitor *mon = opaque;
196

    
197
    mouse = qobject_to_qdict(data);
198
    monitor_printf(mon, "%c Mouse #%" PRId64 ": %s\n",
199
                  (qdict_get_bool(mouse, "current") ? '*' : ' '),
200
                  qdict_get_int(mouse, "index"), qdict_get_str(mouse, "name"));
201
}
202

    
203
void do_info_mice_print(Monitor *mon, const QObject *data)
204
{
205
    QList *mice_list;
206

    
207
    mice_list = qobject_to_qlist(data);
208
    if (qlist_empty(mice_list)) {
209
        monitor_printf(mon, "No mouse devices connected\n");
210
        return;
211
    }
212

    
213
    qlist_iter(mice_list, info_mice_iter, mon);
214
}
215

    
216
/**
217
 * do_info_mice(): Show VM mice information
218
 *
219
 * Each mouse is represented by a QDict, the returned QObject is a QList of
220
 * all mice.
221
 *
222
 * The mouse QDict contains the following:
223
 *
224
 * - "name": mouse's name
225
 * - "index": mouse's index
226
 * - "current": true if this mouse is receiving events, false otherwise
227
 *
228
 * Example:
229
 *
230
 * [ { "name": "QEMU Microsoft Mouse", "index": 0, "current": false },
231
 *   { "name": "QEMU PS/2 Mouse", "index": 1, "current": true } ]
232
 */
233
void do_info_mice(Monitor *mon, QObject **ret_data)
234
{
235
    QEMUPutMouseEntry *cursor;
236
    QList *mice_list;
237
    int current;
238

    
239
    mice_list = qlist_new();
240

    
241
    if (QTAILQ_EMPTY(&mouse_handlers)) {
242
        goto out;
243
    }
244

    
245
    current = QTAILQ_FIRST(&mouse_handlers)->index;
246

    
247
    QTAILQ_FOREACH(cursor, &mouse_handlers, node) {
248
        QObject *obj;
249
        obj = qobject_from_jsonf("{ 'name': %s, 'index': %d, 'current': %i }",
250
                                 cursor->qemu_put_mouse_event_name,
251
                                 cursor->index,
252
                                 cursor->index == current);
253
        qlist_append_obj(mice_list, obj);
254
    }
255

    
256
out:
257
    *ret_data = QOBJECT(mice_list);
258
}
259

    
260
void do_mouse_set(Monitor *mon, const QDict *qdict)
261
{
262
    QEMUPutMouseEntry *cursor;
263
    int index = qdict_get_int(qdict, "index");
264
    int found = 0;
265

    
266
    if (QTAILQ_EMPTY(&mouse_handlers)) {
267
        monitor_printf(mon, "No mouse devices connected\n");
268
        return;
269
    }
270

    
271
    QTAILQ_FOREACH(cursor, &mouse_handlers, node) {
272
        if (cursor->index == index) {
273
            found = 1;
274
            qemu_activate_mouse_event_handler(cursor);
275
            break;
276
        }
277
    }
278

    
279
    if (!found) {
280
        monitor_printf(mon, "Mouse at given index not found\n");
281
    }
282

    
283
    check_mode_change();
284
}
285

    
286
void qemu_add_mouse_mode_change_notifier(Notifier *notify)
287
{
288
    notifier_list_add(&mouse_mode_notifiers, notify);
289
}
290

    
291
void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
292
{
293
    notifier_list_remove(&mouse_mode_notifiers, notify);
294
}