![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gtk-mouse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / gtk|
Return to gtk-mouse.c CVS log | Up to [The Machine Emulator] / tme / host / gtk |
1.1 root 1: /* $Id: gtk-mouse.c,v 1.1 2003/07/31 01:41:48 fredette Exp $ */
2:
3: /* host/gtk/gtk-mouse.c - GTK mouse support: */
4:
5: /*
6: * Copyright (c) 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: gtk-mouse.c,v 1.1 2003/07/31 01:41:48 fredette Exp $");
38:
39: /* includes: */
40: #include "gtk-display.h"
41: #include <gdk/gdkkeysyms.h>
42:
43: /* macros: */
44: #define TME_GTK_MOUSE_CURSOR_WIDTH (16)
45: #define TME_GTK_MOUSE_CURSOR_HEIGHT (16)
46:
47: /* types: */
48:
49: /* globals: */
50:
51: /* our invisible cursor: */
52: static const unsigned char _tme_gtk_mouse_cursor_source[(TME_GTK_MOUSE_CURSOR_WIDTH
53: * TME_GTK_MOUSE_CURSOR_HEIGHT
54: / 8)] =
55: {
56: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
57: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
58: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
59: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
60: };
61: static const unsigned char _tme_gtk_mouse_cursor_mask[(TME_GTK_MOUSE_CURSOR_WIDTH
62: * TME_GTK_MOUSE_CURSOR_HEIGHT
63: / 8)] =
64: {
65: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
66: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
67: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
68: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
69: };
70: static GdkColor _tme_gtk_mouse_cursor_color = { 0, 0, 0, 0 };
71:
72: /* if X11 support is present: */
73: #ifndef X_DISPLAY_MISSING
74:
75: /* includes: */
76: #include <gdk/gdkx.h>
77: #include <X11/Xlib.h>
78:
79: #if TME_MOUSE_EVENT_TIME_UNDEF != CurrentTime
80: #error "TME_MOUSE_EVENT_TIME_UNDEF and CurrentTime disagree"
81: #endif
82:
83: /* this warps the pointer to the middle of the GtkImage: */
84: static void
85: _tme_gtk_mouse_warp_pointer(struct tme_gtk_screen *screen)
86: {
87: XWarpPointer(GDK_DISPLAY(),
88: None,
89: GDK_WINDOW_XWINDOW(screen->tme_gtk_screen_gtkimage->window),
90: 0, 0, 0, 0,
91: screen->tme_gtk_screen_mouse_warp_x,
92: screen->tme_gtk_screen_mouse_warp_y);
93: }
94:
95: #endif /* !X_DISPLAY_MISSING */
96:
97: /* this is for debugging only: */
98: #if 0
99: #include <stdio.h>
100: void
101: _tme_gtk_mouse_debug(const struct tme_mouse_event *event)
102: {
103: fprintf(stderr,
104: "buttons = 0x%02x dx=%d dy=%d\n",
105: event->tme_mouse_event_buttons,
106: event->tme_mouse_event_delta_x,
107: event->tme_mouse_event_delta_y);
108: }
109: #else
110: #define _tme_gtk_mouse_debug(e) do { } while (/* CONSTCOND */ 0)
111: #endif
112:
113: /* this is a GTK callback for a mouse event in the framebuffer event box: */
114: static int
115: _tme_gtk_mouse_mouse_event(GtkWidget *widget,
116: GdkEvent *gdk_event_raw,
117: struct tme_gtk_screen *screen)
118: {
119: struct tme_gtk_display *display;
120: struct tme_mouse_event tme_event;
121: guint x;
122: guint y;
123: guint state, button;
124: unsigned int buttons;
125: int was_empty;
126: int new_callouts;
127: int rc;
128:
129: /* start the tme event: */
130: tme_event.tme_mouse_event_delta_units
131: = TME_MOUSE_UNITS_UNKNOWN;
132:
133: /* recover our data structure: */
134: display = screen->tme_gtk_screen_display;
135:
136: /* lock the mutex: */
137: tme_mutex_lock(&display->tme_gtk_display_mutex);
138:
139: /* if this is motion: */
140: if (gdk_event_raw->type == GDK_MOTION_NOTIFY) {
141:
142: /* this event must have happened in the gtkimage: */
143: assert (gdk_event_raw->motion.window
144: == screen->tme_gtk_screen_gtkimage->window);
145:
146: /* set the event time: */
147: tme_event.tme_mouse_event_time
148: = gdk_event_raw->motion.time;
149:
150: /* the buttons haven't changed: */
151: tme_event.tme_mouse_event_buttons =
152: screen->tme_gtk_screen_mouse_buttons_last;
153:
154: /* if the pointer position hasn't changed either, return now.
155: every time we warp the pointer we will get a motion event, and
156: this should ignore those events: */
157: x = gdk_event_raw->motion.x;
158: y = gdk_event_raw->motion.y;
159: if (x == screen->tme_gtk_screen_mouse_warp_x
160: && y == screen->tme_gtk_screen_mouse_warp_y) {
161:
162: /* unlock the mutex: */
163: tme_mutex_unlock(&display->tme_gtk_display_mutex);
164:
165: /* stop propagating this event: */
166: return (TRUE);
167: }
168:
169: /* warp the pointer back to center: */
170: _tme_gtk_mouse_warp_pointer(screen);
171: }
172:
173: /* otherwise, this must be a button press or a release: */
174: else {
175: assert (gdk_event_raw->type == GDK_BUTTON_PRESS
176: || gdk_event_raw->type == GDK_BUTTON_RELEASE);
177:
178: /* this event must have happened in the gtkimage: */
179: assert (gdk_event_raw->button.window
180: == screen->tme_gtk_screen_gtkimage->window);
181:
182: /* set the event time: */
183: tme_event.tme_mouse_event_time
184: = gdk_event_raw->button.time;
185:
186: /* get the pointer position: */
187: x = gdk_event_raw->button.x;
188: y = gdk_event_raw->button.y;
189:
190: /* make the buttons mask: */
191: buttons = 0;
192: button = gdk_event_raw->button.button;
193: state = gdk_event_raw->button.state;
194: #define _TME_GTK_MOUSE_BUTTON(i, gdk, tme) \
195: if ((button == i) \
196: ? (gdk_event_raw->type == GDK_BUTTON_PRESS) \
197: : (state & gdk)) \
198: buttons |= tme
199: _TME_GTK_MOUSE_BUTTON(1, GDK_BUTTON1_MASK, TME_MOUSE_BUTTON_0);
200: _TME_GTK_MOUSE_BUTTON(2, GDK_BUTTON2_MASK, TME_MOUSE_BUTTON_1);
201: _TME_GTK_MOUSE_BUTTON(3, GDK_BUTTON3_MASK, TME_MOUSE_BUTTON_2);
202: _TME_GTK_MOUSE_BUTTON(4, GDK_BUTTON4_MASK, TME_MOUSE_BUTTON_3);
203: _TME_GTK_MOUSE_BUTTON(5, GDK_BUTTON5_MASK, TME_MOUSE_BUTTON_4);
204: #undef _TME_GTK_MOUSE_BUTTON
205: tme_event.tme_mouse_event_buttons = buttons;
206: screen->tme_gtk_screen_mouse_buttons_last = buttons;
207: }
208:
209: /* make the deltas: */
210: tme_event.tme_mouse_event_delta_x =
211: (((int) x)
212: - ((int) screen->tme_gtk_screen_mouse_warp_x));
213: tme_event.tme_mouse_event_delta_y =
214: (((int) y)
215: - ((int) screen->tme_gtk_screen_mouse_warp_y));
216:
217: /* assume that we won't need any new callouts: */
218: new_callouts = 0;
219:
220: /* remember if the mouse buffer was empty: */
221: was_empty
222: = tme_mouse_buffer_is_empty(display->tme_gtk_display_mouse_buffer);
223:
224: /* add this tme event to the mouse buffer: */
225: _tme_gtk_mouse_debug(&tme_event);
226: rc = tme_mouse_buffer_copyin(display->tme_gtk_display_mouse_buffer,
227: &tme_event);
228: assert (rc == TME_OK);
229:
230: /* if the mouse buffer was empty and now it isn't,
231: call out the mouse controls: */
232: if (was_empty
233: && !tme_mouse_buffer_is_empty(display->tme_gtk_display_mouse_buffer)) {
234: new_callouts |= TME_GTK_DISPLAY_CALLOUT_MOUSE_CTRL;
235: }
236:
237: /* run any callouts: */
238: _tme_gtk_display_callout(display, new_callouts);
239:
240: /* unlock the mutex: */
241: tme_mutex_unlock(&display->tme_gtk_display_mutex);
242:
243: /* stop propagating this event: */
244: return (TRUE);
245: }
246:
247: /* this is a GTK callback for an event in the event box containing the
248: mouse label: */
249: static int
250: _tme_gtk_mouse_ebox_event(GtkWidget *widget,
251: GdkEvent *gdk_event_raw,
252: struct tme_gtk_screen *screen)
253: {
254: struct tme_gtk_display *display;
255: int rc;
256: gint junk;
257: char *status;
258:
259: /* if this is an enter notify event, grab the focus and continue
260: propagating the event: */
261: if (gdk_event_raw->type == GDK_ENTER_NOTIFY) {
262: gtk_widget_grab_focus(widget);
263: return (FALSE);
264: }
265:
266: /* if this is not a key press event, continue propagating it now: */
267: if (gdk_event_raw->type != GDK_KEY_PRESS) {
268: return (FALSE);
269: }
270:
271: /* recover our data structure: */
272: display = screen->tme_gtk_screen_display;
273:
274: /* lock the mutex: */
275: tme_mutex_lock(&display->tme_gtk_display_mutex);
276:
277: /* the mouse must not be on already: */
278: assert (screen->tme_gtk_screen_mouse_keyval
279: == GDK_VoidSymbol);
280:
281: /* this keyval must not be GDK_VoidSymbol: */
282: assert (gdk_event_raw->key.keyval
283: != GDK_VoidSymbol);
284:
285: /* set the text on the mouse label: */
286: gtk_label_set_text(GTK_LABEL(screen->tme_gtk_screen_mouse_label),
287: _("Mouse is on"));
288:
289: /* push the mouse status onto the statusbar: */
290: status = NULL;
291: tme_output_append(&status,
292: _("Press the %s key to turn the mouse off"),
293: gdk_keyval_name(gdk_event_raw->key.keyval));
294: gtk_statusbar_push(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
295: screen->tme_gtk_screen_mouse_statusbar_cid,
296: status);
297: tme_free(status);
298:
299: /* if the original events mask on the framebuffer event box have
300: never been saved, save them now, and add the mouse events: */
301: if (screen->tme_gtk_screen_mouse_events_old == 0) {
302: screen->tme_gtk_screen_mouse_events_old
303: = gdk_window_get_events(screen->tme_gtk_screen_event_box->window);
304: gtk_widget_add_events(screen->tme_gtk_screen_event_box,
305: GDK_POINTER_MOTION_MASK
306: | GDK_BUTTON_PRESS_MASK
307: | GDK_BUTTON_RELEASE_MASK);
308: }
309:
310: /* get the current width and height of the framebuffer gtkimage, and
311: halve them to get the warp center: */
312: gdk_window_get_geometry(screen->tme_gtk_screen_gtkimage->window,
313: &junk,
314: &junk,
315: &screen->tme_gtk_screen_mouse_warp_x,
316: &screen->tme_gtk_screen_mouse_warp_y,
317: &junk);
318: screen->tme_gtk_screen_mouse_warp_x >>= 1;
319: screen->tme_gtk_screen_mouse_warp_y >>= 1;
320:
321: /* warp the pointer to center: */
322: _tme_gtk_mouse_warp_pointer(screen);
323:
324: /* grab the pointer: */
325: rc
326: = gdk_pointer_grab(screen->tme_gtk_screen_gtkimage->window,
327: TRUE,
328: GDK_POINTER_MOTION_MASK
329: | GDK_BUTTON_PRESS_MASK
330: | GDK_BUTTON_RELEASE_MASK,
331: screen->tme_gtk_screen_gtkimage->window,
332: display->tme_gtk_display_mouse_cursor,
333: gdk_event_raw->key.time);
334: assert (rc == 0);
335:
336: /* we are now in mouse mode: */
337: screen->tme_gtk_screen_mouse_keyval
338: = gdk_event_raw->key.keyval;
339:
340: /* unlock the mutex: */
341: tme_mutex_unlock(&display->tme_gtk_display_mutex);
342:
343: /* stop propagating this event: */
344: return (TRUE);
345: }
346:
347: /* this turns mouse mode off. it is called with the mutex locked: */
348: void
349: _tme_gtk_mouse_mode_off(struct tme_gtk_screen *screen,
350: guint32 time)
351: {
352: /* the mouse must be on: */
353: assert (screen->tme_gtk_screen_mouse_keyval
354: != GDK_VoidSymbol);
355:
356: /* ungrab the pointer: */
357: gdk_pointer_ungrab(time);
358:
359: /* restore the old events mask on the event box: */
360: gdk_window_set_events(screen->tme_gtk_screen_event_box->window,
361: screen->tme_gtk_screen_mouse_events_old);
362:
363: /* pop our message off of the statusbar: */
364: gtk_statusbar_pop(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
365: screen->tme_gtk_screen_mouse_statusbar_cid);
366:
367: /* restore the text on the mouse label: */
368: gtk_label_set_text(GTK_LABEL(screen->tme_gtk_screen_mouse_label),
369: _("Mouse is off"));
370:
371: /* the mouse is now off: */
372: screen->tme_gtk_screen_mouse_keyval = GDK_VoidSymbol;
373: }
374:
375: /* this is called when the mouse controls change: */
376: static int
377: _tme_gtk_mouse_ctrl(struct tme_mouse_connection *conn_mouse,
378: unsigned int ctrl)
379: {
380: struct tme_gtk_display *display;
381:
382: /* recover our data structure: */
383: display = conn_mouse
384: ->tme_mouse_connection.tme_connection_element->tme_element_private;
385:
386: /* XXX TBD */
387: abort();
388:
389: return (TME_OK);
390: }
391:
392: /* this is called to read the mouse: */
393: static int
394: _tme_gtk_mouse_read(struct tme_mouse_connection *conn_mouse,
395: struct tme_mouse_event *event,
396: unsigned int count)
397: {
398: struct tme_gtk_display *display;
399: int rc;
400:
401: /* recover our data structure: */
402: display = conn_mouse
403: ->tme_mouse_connection.tme_connection_element->tme_element_private;
404:
405: /* lock the mutex: */
406: tme_mutex_lock(&display->tme_gtk_display_mutex);
407:
408: /* copy an event out of the mouse buffer: */
409: rc = tme_mouse_buffer_copyout(display->tme_gtk_display_mouse_buffer,
410: event,
411: count);
412:
413: /* unlock the mutex: */
414: tme_mutex_unlock(&display->tme_gtk_display_mutex);
415:
416: return (rc);
417: }
418:
419: /* this breaks a mouse connection: */
420: static int
421: _tme_gtk_mouse_connection_break(struct tme_connection *conn,
422: unsigned int state)
423: {
424: abort();
425: }
426:
427: /* this makes a new mouse connection: */
428: static int
429: _tme_gtk_mouse_connection_make(struct tme_connection *conn,
430: unsigned int state)
431: {
432: struct tme_gtk_display *display;
433:
434: /* recover our data structure: */
435: display = conn->tme_connection_element->tme_element_private;
436:
437: /* both sides must be mouse connections: */
438: assert(conn->tme_connection_type
439: == TME_CONNECTION_MOUSE);
440: assert(conn->tme_connection_other->tme_connection_type
441: == TME_CONNECTION_MOUSE);
442:
443: /* we are always set up to answer calls across the connection, so we
444: only have to do work when the connection has gone full, namely
445: taking the other side of the connection: */
446: if (state == TME_CONNECTION_FULL) {
447:
448: /* save our connection: */
449: tme_mutex_lock(&display->tme_gtk_display_mutex);
450: display->tme_gtk_display_mouse_connection
451: = (struct tme_mouse_connection *) conn->tme_connection_other;
452: tme_mutex_unlock(&display->tme_gtk_display_mutex);
453: }
454:
455: return (TME_OK);
456: }
457:
458: /* this scores a mouse connection: */
459: static int
460: _tme_gtk_mouse_connection_score(struct tme_connection *conn,
461: unsigned int *_score)
462: {
463: struct tme_mouse_connection *conn_mouse;
464:
465: /* both sides must be mouse connections: */
466: assert(conn->tme_connection_type == TME_CONNECTION_MOUSE);
467: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_MOUSE);
468:
469: /* the other side cannot be a real mouse: */
470: conn_mouse
471: = (struct tme_mouse_connection *) conn->tme_connection_other;
472: *_score = (conn_mouse->tme_mouse_connection_read == NULL);
473: return (TME_OK);
474: }
475:
476: /* this makes a new connection side for a GTK mouse: */
477: int
478: _tme_gtk_mouse_connections_new(struct tme_gtk_display *display,
479: struct tme_connection **_conns)
480: {
481: struct tme_mouse_connection *conn_mouse;
482: struct tme_connection *conn;
483:
484: /* if we don't have a mouse connection yet: */
485: if (display->tme_gtk_display_mouse_connection == NULL) {
486:
487: /* create our side of a mouse connection: */
488: conn_mouse = tme_new0(struct tme_mouse_connection, 1);
489: conn = &conn_mouse->tme_mouse_connection;
490:
491: /* fill in the generic connection: */
492: conn->tme_connection_next = *_conns;
493: conn->tme_connection_type = TME_CONNECTION_MOUSE;
494: conn->tme_connection_score = _tme_gtk_mouse_connection_score;
495: conn->tme_connection_make = _tme_gtk_mouse_connection_make;
496: conn->tme_connection_break = _tme_gtk_mouse_connection_break;
497:
498: /* fill in the mouse connection: */
499: conn_mouse->tme_mouse_connection_ctrl = _tme_gtk_mouse_ctrl;
500: conn_mouse->tme_mouse_connection_read = _tme_gtk_mouse_read;
501:
502: /* return the connection side possibility: */
503: *_conns = conn;
504: }
505:
506: /* done: */
507: return (TME_OK);
508: }
509:
510: /* this attaches the GTK mouse to a new screen: */
511: void
512: _tme_gtk_mouse_attach(struct tme_gtk_screen *screen)
513: {
514: struct tme_gtk_display *display;
515: GtkWidget *hbox0;
516: GtkWidget *ebox;
517:
518: /* get the display: */
519: display = screen->tme_gtk_screen_display;
520:
521: /* create the horizontal packing box for the mouse controls: */
522: hbox0 = gtk_hbox_new(FALSE, 0);
523:
524: /* pack the horizontal packing box into the outer vertical packing box: */
525: gtk_box_pack_start(GTK_BOX(screen->tme_gtk_screen_vbox0),
526: hbox0,
527: FALSE, FALSE, 0);
528:
529: /* show the horizontal packing box: */
530: gtk_widget_show(hbox0);
531:
532: /* create the event box for the mouse on label: */
533: ebox = gtk_event_box_new();
534:
535: /* pack the event box into the horizontal packing box: */
536: gtk_box_pack_start(GTK_BOX(hbox0),
537: ebox,
538: FALSE, FALSE, 0);
539:
540: /* set the tip on the event box, which will eventually contain the mouse on label: */
541: gtk_tooltips_set_tip(GTK_TOOLTIPS(display->tme_gtk_display_tooltips),
542: ebox,
543: "Press a key here to turn the mouse on. The same key " \
544: "will turn the mouse off.",
545: NULL);
546:
547: /* make sure the event box gets key_press events: */
548: gtk_widget_add_events(ebox,
549: GDK_KEY_PRESS_MASK);
550:
551: /* set a signal handler for the event box events: */
552: gtk_signal_connect(GTK_OBJECT(ebox),
553: "event",
554: GTK_SIGNAL_FUNC(_tme_gtk_mouse_ebox_event),
555: screen);
556:
557: /* the event box can focus: */
558: GTK_WIDGET_SET_FLAGS(ebox, GTK_CAN_FOCUS);
559:
560: /* show the event box: */
561: gtk_widget_show(ebox);
562:
563: /* create the mouse on label: */
564: screen->tme_gtk_screen_mouse_label
565: = gtk_label_new(_("Mouse is off"));
566:
567: /* add the mouse on label to the event box: */
568: gtk_container_add(GTK_CONTAINER(ebox),
569: screen->tme_gtk_screen_mouse_label);
570:
571: /* show the mouse on label: */
572: gtk_widget_show(screen->tme_gtk_screen_mouse_label);
573:
574: /* create the mouse statusbar: */
575: screen->tme_gtk_screen_mouse_statusbar
576: = gtk_statusbar_new();
577:
578: /* pack the mouse statusbar into the horizontal packing box: */
579: gtk_box_pack_start(GTK_BOX(hbox0),
580: screen->tme_gtk_screen_mouse_statusbar,
581: TRUE, TRUE, 10);
582:
583: /* show the mouse statusbar: */
584: gtk_widget_show(screen->tme_gtk_screen_mouse_statusbar);
585:
586: /* push an initial message onto the statusbar: */
587: screen->tme_gtk_screen_mouse_statusbar_cid
588: = gtk_statusbar_get_context_id(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
589: "mouse context");
590: gtk_statusbar_push(GTK_STATUSBAR(screen->tme_gtk_screen_mouse_statusbar),
591: screen->tme_gtk_screen_mouse_statusbar_cid,
592: _("The Machine Emulator"));
593:
594: /* although the event mask doesn't include these events yet,
595: set a signal handler for the mouse events: */
596: gtk_signal_connect(GTK_OBJECT(screen->tme_gtk_screen_event_box),
597: "motion_notify_event",
598: GTK_SIGNAL_FUNC(_tme_gtk_mouse_mouse_event),
599: screen);
600: gtk_signal_connect(GTK_OBJECT(screen->tme_gtk_screen_event_box),
601: "button_press_event",
602: GTK_SIGNAL_FUNC(_tme_gtk_mouse_mouse_event),
603: screen);
604: gtk_signal_connect(GTK_OBJECT(screen->tme_gtk_screen_event_box),
605: "button_release_event",
606: GTK_SIGNAL_FUNC(_tme_gtk_mouse_mouse_event),
607: screen);
608:
609: /* mouse mode is off: */
610: screen->tme_gtk_screen_mouse_keyval = GDK_VoidSymbol;
611: }
612:
613: /* this initializes mouse part of the display: */
614: void
615: _tme_gtk_mouse_new(struct tme_gtk_display *display)
616: {
617: GdkPixmap *source, *mask;
618:
619: /* we have no mouse connection: */
620: display->tme_gtk_display_mouse_connection = NULL;
621:
622: /* allocate the mouse buffer: */
623: display->tme_gtk_display_mouse_buffer
624: = tme_mouse_buffer_new(1024);
625:
626: /* create the mouse cursor: */
627: source
628: = gdk_bitmap_create_from_data(NULL,
629: _tme_gtk_mouse_cursor_source,
630: TME_GTK_MOUSE_CURSOR_WIDTH,
631: TME_GTK_MOUSE_CURSOR_HEIGHT);
632: mask
633: = gdk_bitmap_create_from_data (NULL,
634: _tme_gtk_mouse_cursor_mask,
635: TME_GTK_MOUSE_CURSOR_WIDTH,
636: TME_GTK_MOUSE_CURSOR_HEIGHT);
637: display->tme_gtk_display_mouse_cursor
638: = gdk_cursor_new_from_pixmap(source,
639: mask,
640: &_tme_gtk_mouse_cursor_color,
641: &_tme_gtk_mouse_cursor_color,
642: 0,
643: 0);
644: gdk_pixmap_unref(source);
645: gdk_pixmap_unref(mask);
646: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.