2 * Copyright (c) 2007, 2008 Edward Tomasz Napiera�ła <trasz@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * This is piano_keyboard, piano keyboard-like GTK+ widget. It contains
29 * no MIDI-specific code.
31 * For questions and comments, contact Edward Tomasz Napierala <trasz@FreeBSD.org>.
38 #include <cairo/cairo.h>
40 #include <gdk/gdkkeysyms.h>
42 #include "gtk_pianokeyboard.h"
44 #define PIANO_KEYBOARD_DEFAULT_WIDTH 730
45 #define PIANO_KEYBOARD_DEFAULT_HEIGHT 70
54 static guint piano_keyboard_signals[LAST_SIGNAL] = { 0 };
57 draw_keyboard_cue(PianoKeyboard *pk, cairo_t* cr)
59 int w = pk->notes[0].w;
60 int h = pk->notes[0].h;
62 int first_note_in_lower_row = (pk->octave + 5) * 12;
63 int last_note_in_lower_row = (pk->octave + 6) * 12 - 1;
64 int first_note_in_higher_row = (pk->octave + 6) * 12;
65 int last_note_in_higher_row = (pk->octave + 7) * 12 + 4;
67 cairo_set_source_rgb (cr, 1.0f, 0.0f, 0.0f);
68 cairo_move_to (cr, pk->notes[first_note_in_lower_row].x + 3, h - 6);
69 cairo_line_to (cr, pk->notes[last_note_in_lower_row].x + w - 3, h - 6);
72 cairo_set_source_rgb (cr, 0.0f, 0.0f, 1.0f);
73 cairo_move_to (cr, pk->notes[first_note_in_higher_row].x + 3, h - 9);
74 cairo_line_to (cr, pk->notes[last_note_in_higher_row].x + w - 3, h - 9);
79 queue_note_draw (PianoKeyboard* pk, int note)
81 GdkWindow* w = GTK_WIDGET(pk)->window;
86 r.x = pk->notes[note].x;
88 r.width = pk->notes[note].w;
89 r.height = pk->notes[note].h;
91 gdk_window_invalidate_rect (w, &r, TRUE);
96 draw_note(PianoKeyboard *pk, cairo_t* cr, int note)
98 int is_white = pk->notes[note].white;
100 int x = pk->notes[note].x;
101 int w = pk->notes[note].w;
102 int h = pk->notes[note].h;
104 if (pk->notes[note].pressed || pk->notes[note].sustained) {
105 is_white = !is_white;
108 cairo_set_line_width (cr, 1.0);
111 cairo_set_source_rgb (cr, 1.0f, 1.0f, 1.0f);
113 cairo_set_source_rgb (cr, 0.0f, 0.0f, 0.0f);
116 cairo_rectangle (cr, x, 0, w, h);
119 cairo_set_source_rgb(cr, 0.0f, 0.0f, 0.0f); /* black outline */
120 cairo_rectangle (cr, x, 0, w, h);
123 if (pk->enable_keyboard_cue) {
124 draw_keyboard_cue (pk, cr);
127 /* We need to redraw black keys that partially obscure the white one. */
128 if (note < NNOTES - 2 && !pk->notes[note + 1].white) {
129 draw_note(pk, cr, note + 1);
132 if (note > 0 && !pk->notes[note - 1].white) {
133 draw_note(pk, cr, note - 1);
138 press_key(PianoKeyboard *pk, int key)
141 assert(key < NNOTES);
143 pk->maybe_stop_sustained_notes = 0;
145 /* This is for keyboard autorepeat protection. */
146 if (pk->notes[key].pressed)
149 if (pk->sustain_new_notes)
150 pk->notes[key].sustained = 1;
152 pk->notes[key].sustained = 0;
154 pk->notes[key].pressed = 1;
156 g_signal_emit_by_name(GTK_WIDGET(pk), "note-on", key);
157 queue_note_draw(pk, key);
163 release_key(PianoKeyboard *pk, int key)
166 assert(key < NNOTES);
168 pk->maybe_stop_sustained_notes = 0;
170 if (!pk->notes[key].pressed)
173 if (pk->sustain_new_notes)
174 pk->notes[key].sustained = 1;
176 pk->notes[key].pressed = 0;
178 if (pk->notes[key].sustained)
181 g_signal_emit_by_name(GTK_WIDGET(pk), "note-off", key);
182 queue_note_draw(pk, key);
188 rest (PianoKeyboard* pk)
190 g_signal_emit_by_name(GTK_WIDGET(pk), "rest");
194 stop_unsustained_notes(PianoKeyboard *pk)
198 for (i = 0; i < NNOTES; i++) {
199 if (pk->notes[i].pressed && !pk->notes[i].sustained) {
200 pk->notes[i].pressed = 0;
201 g_signal_emit_by_name(GTK_WIDGET(pk), "note-off", i);
202 queue_note_draw(pk, i);
208 stop_sustained_notes(PianoKeyboard *pk)
212 for (i = 0; i < NNOTES; i++) {
213 if (pk->notes[i].sustained) {
214 pk->notes[i].pressed = 0;
215 pk->notes[i].sustained = 0;
216 g_signal_emit_by_name(GTK_WIDGET(pk), "note-off", i);
217 queue_note_draw(pk, i);
223 key_binding(PianoKeyboard *pk, const char *key)
225 gpointer notused, note;
228 assert(pk->key_bindings != NULL);
230 found = g_hash_table_lookup_extended(pk->key_bindings, key, ¬used, ¬e);
235 return (intptr_t)note;
239 bind_key(PianoKeyboard *pk, const char *key, int note)
241 assert(pk->key_bindings != NULL);
243 g_hash_table_insert(pk->key_bindings, (gpointer)key, (gpointer)((intptr_t)note));
247 clear_notes(PianoKeyboard *pk)
249 assert(pk->key_bindings != NULL);
251 g_hash_table_remove_all(pk->key_bindings);
255 bind_keys_qwerty(PianoKeyboard *pk)
259 bind_key(pk, "space", 128);
261 /* Lower keyboard row - "zxcvbnm". */
262 bind_key(pk, "z", 12); /* C0 */
263 bind_key(pk, "s", 13);
264 bind_key(pk, "x", 14);
265 bind_key(pk, "d", 15);
266 bind_key(pk, "c", 16);
267 bind_key(pk, "v", 17);
268 bind_key(pk, "g", 18);
269 bind_key(pk, "b", 19);
270 bind_key(pk, "h", 20);
271 bind_key(pk, "n", 21);
272 bind_key(pk, "j", 22);
273 bind_key(pk, "m", 23);
275 /* Upper keyboard row, first octave - "qwertyu". */
276 bind_key(pk, "q", 24);
277 bind_key(pk, "2", 25);
278 bind_key(pk, "w", 26);
279 bind_key(pk, "3", 27);
280 bind_key(pk, "e", 28);
281 bind_key(pk, "r", 29);
282 bind_key(pk, "5", 30);
283 bind_key(pk, "t", 31);
284 bind_key(pk, "6", 32);
285 bind_key(pk, "y", 33);
286 bind_key(pk, "7", 34);
287 bind_key(pk, "u", 35);
289 /* Upper keyboard row, the rest - "iop". */
290 bind_key(pk, "i", 36);
291 bind_key(pk, "9", 37);
292 bind_key(pk, "o", 38);
293 bind_key(pk, "0", 39);
294 bind_key(pk, "p", 40);
298 bind_keys_qwertz(PianoKeyboard *pk)
300 bind_keys_qwerty(pk);
302 /* The only difference between QWERTY and QWERTZ is that the "y" and "z" are swapped together. */
303 bind_key(pk, "y", 12);
304 bind_key(pk, "z", 33);
308 bind_keys_azerty(PianoKeyboard *pk)
312 bind_key(pk, "space", 128);
314 /* Lower keyboard row - "wxcvbn,". */
315 bind_key(pk, "w", 12); /* C0 */
316 bind_key(pk, "s", 13);
317 bind_key(pk, "x", 14);
318 bind_key(pk, "d", 15);
319 bind_key(pk, "c", 16);
320 bind_key(pk, "v", 17);
321 bind_key(pk, "g", 18);
322 bind_key(pk, "b", 19);
323 bind_key(pk, "h", 20);
324 bind_key(pk, "n", 21);
325 bind_key(pk, "j", 22);
326 bind_key(pk, "comma", 23);
328 /* Upper keyboard row, first octave - "azertyu". */
329 bind_key(pk, "a", 24);
330 bind_key(pk, "eacute", 25);
331 bind_key(pk, "z", 26);
332 bind_key(pk, "quotedbl", 27);
333 bind_key(pk, "e", 28);
334 bind_key(pk, "r", 29);
335 bind_key(pk, "parenleft", 30);
336 bind_key(pk, "t", 31);
337 bind_key(pk, "minus", 32);
338 bind_key(pk, "y", 33);
339 bind_key(pk, "egrave", 34);
340 bind_key(pk, "u", 35);
342 /* Upper keyboard row, the rest - "iop". */
343 bind_key(pk, "i", 36);
344 bind_key(pk, "ccedilla", 37);
345 bind_key(pk, "o", 38);
346 bind_key(pk, "agrave", 39);
347 bind_key(pk, "p", 40);
351 keyboard_event_handler(GtkWidget *mk, GdkEventKey *event, gpointer notused)
357 PianoKeyboard *pk = PIANO_KEYBOARD(mk);
359 /* We're not using event->keyval, because we need keyval with level set to 0.
360 E.g. if user holds Shift and presses '7', we want to get a '7', not '&'. */
361 kk.keycode = event->hardware_keycode;
365 keyval = gdk_keymap_lookup_key(NULL, &kk);
367 key = gdk_keyval_name(gdk_keyval_to_lower(keyval));
370 g_message("gtk_keyval_name() returned NULL; please report this.");
374 note = key_binding(pk, key);
377 /* Key was not bound. Maybe it's one of the keys handled in jack-keyboard.c. */
382 if (event->type == GDK_KEY_RELEASE) {
389 note += pk->octave * 12;
392 assert(note < NNOTES);
394 if (event->type == GDK_KEY_PRESS) {
397 } else if (event->type == GDK_KEY_RELEASE) {
398 release_key(pk, note);
405 get_note_for_xy(PianoKeyboard *pk, int x, int y)
407 int height = GTK_WIDGET(pk)->allocation.height;
410 if (y <= height / 2) {
411 for (note = 0; note < NNOTES - 1; note++) {
412 if (pk->notes[note].white)
415 if (x >= pk->notes[note].x && x <= pk->notes[note].x + pk->notes[note].w)
420 for (note = 0; note < NNOTES - 1; note++) {
421 if (!pk->notes[note].white)
424 if (x >= pk->notes[note].x && x <= pk->notes[note].x + pk->notes[note].w)
432 mouse_button_event_handler(PianoKeyboard *pk, GdkEventButton *event, gpointer notused)
437 int note = get_note_for_xy(pk, x, y);
439 if (event->button != 1)
442 if (event->type == GDK_BUTTON_PRESS) {
443 /* This is possible when you make the window a little wider and then click
449 if (pk->note_being_pressed_using_mouse >= 0)
450 release_key(pk, pk->note_being_pressed_using_mouse);
453 pk->note_being_pressed_using_mouse = note;
455 } else if (event->type == GDK_BUTTON_RELEASE) {
457 release_key(pk, note);
460 if (pk->note_being_pressed_using_mouse >= 0)
461 release_key(pk, pk->note_being_pressed_using_mouse);
464 pk->note_being_pressed_using_mouse = -1;
472 mouse_motion_event_handler(PianoKeyboard *pk, GdkEventMotion *event, gpointer notused)
476 if ((event->state & GDK_BUTTON1_MASK) == 0)
479 note = get_note_for_xy(pk, event->x, event->y);
481 if (note != pk->note_being_pressed_using_mouse && note >= 0) {
483 if (pk->note_being_pressed_using_mouse >= 0)
484 release_key(pk, pk->note_being_pressed_using_mouse);
486 pk->note_being_pressed_using_mouse = note;
493 piano_keyboard_expose(GtkWidget *widget, GdkEventExpose *event)
496 PianoKeyboard *pk = PIANO_KEYBOARD(widget);
497 cairo_t* cr = gdk_cairo_create (GDK_DRAWABLE (GTK_WIDGET(pk)->window));
499 gdk_cairo_region (cr, event->region);
502 for (i = 0; i < NNOTES; i++) {
505 r.x = pk->notes[i].x;
507 r.width = pk->notes[i].w;
508 r.height = pk->notes[i].h;
510 switch (gdk_region_rect_in (event->region, &r)) {
511 case GDK_OVERLAP_RECTANGLE_PART:
512 case GDK_OVERLAP_RECTANGLE_IN:
513 draw_note (pk, cr, i);
526 piano_keyboard_size_request(GtkWidget* widget, GtkRequisition *requisition)
528 requisition->width = PIANO_KEYBOARD_DEFAULT_WIDTH;
529 requisition->height = PIANO_KEYBOARD_DEFAULT_HEIGHT;
533 recompute_dimensions(PianoKeyboard *pk)
535 int number_of_white_keys = (NNOTES - 1) * (7.0 / 12.0);
545 int width = GTK_WIDGET(pk)->allocation.width;
546 int height = GTK_WIDGET(pk)->allocation.height;
548 key_width = width / number_of_white_keys;
549 black_key_width = key_width * 0.8;
550 useful_width = number_of_white_keys * key_width;
551 pk->widget_margin = (width - useful_width) / 2;
553 for (note = 0, white_key = 0; note < NNOTES - 2; note++) {
554 note_in_octave = note % 12;
556 if (note_in_octave == 1 || note_in_octave == 3 || note_in_octave == 6 ||
557 note_in_octave == 8 || note_in_octave == 10) {
559 /* This note is black key. */
560 pk->notes[note].x = pk->widget_margin + white_key * key_width - black_key_width / 2;
561 pk->notes[note].w = black_key_width;
562 pk->notes[note].h = height / 2;
563 pk->notes[note].white = 0;
568 /* This note is white key. */
569 pk->notes[note].x = pk->widget_margin + white_key * key_width;
570 pk->notes[note].w = key_width;
571 pk->notes[note].h = height;
572 pk->notes[note].white = 1;
579 piano_keyboard_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
581 /* XXX: Are these two needed? */
582 g_return_if_fail(widget != NULL);
583 g_return_if_fail(allocation != NULL);
585 widget->allocation = *allocation;
587 recompute_dimensions(PIANO_KEYBOARD(widget));
589 if (GTK_WIDGET_REALIZED(widget)) {
590 gdk_window_move_resize (widget->window, allocation->x, allocation->y, allocation->width, allocation->height);
595 piano_keyboard_class_init(PianoKeyboardClass *klass)
597 GtkWidgetClass *widget_klass;
599 /* Set up signals. */
600 piano_keyboard_signals[NOTE_ON_SIGNAL] = g_signal_new ("note-on",
601 G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
602 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
604 piano_keyboard_signals[NOTE_OFF_SIGNAL] = g_signal_new ("note-off",
605 G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
606 0, NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
608 piano_keyboard_signals[REST_SIGNAL] = g_signal_new ("rest",
609 G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
610 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
612 widget_klass = (GtkWidgetClass*) klass;
614 widget_klass->expose_event = piano_keyboard_expose;
615 widget_klass->size_request = piano_keyboard_size_request;
616 widget_klass->size_allocate = piano_keyboard_size_allocate;
620 piano_keyboard_init(GtkWidget *mk)
622 gtk_widget_add_events(mk, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK);
624 g_signal_connect(G_OBJECT(mk), "button-press-event", G_CALLBACK(mouse_button_event_handler), NULL);
625 g_signal_connect(G_OBJECT(mk), "button-release-event", G_CALLBACK(mouse_button_event_handler), NULL);
626 g_signal_connect(G_OBJECT(mk), "motion-notify-event", G_CALLBACK(mouse_motion_event_handler), NULL);
627 g_signal_connect(G_OBJECT(mk), "key-press-event", G_CALLBACK(keyboard_event_handler), NULL);
628 g_signal_connect(G_OBJECT(mk), "key-release-event", G_CALLBACK(keyboard_event_handler), NULL);
632 piano_keyboard_get_type(void)
634 static GType mk_type = 0;
637 static const GTypeInfo mk_info = {
638 sizeof(PianoKeyboardClass),
639 NULL, /* base_init */
640 NULL, /* base_finalize */
641 (GClassInitFunc) piano_keyboard_class_init,
642 NULL, /* class_finalize */
643 NULL, /* class_data */
644 sizeof (PianoKeyboard),
646 (GInstanceInitFunc) piano_keyboard_init,
650 mk_type = g_type_register_static(GTK_TYPE_DRAWING_AREA, "PianoKeyboard", &mk_info, 0);
657 piano_keyboard_new(void)
659 GtkWidget *widget = gtk_type_new(piano_keyboard_get_type());
661 PianoKeyboard *pk = PIANO_KEYBOARD(widget);
663 pk->maybe_stop_sustained_notes = 0;
664 pk->sustain_new_notes = 0;
665 pk->enable_keyboard_cue = 0;
667 pk->note_being_pressed_using_mouse = -1;
668 memset((void *)pk->notes, 0, sizeof(struct Note) * NNOTES);
669 pk->key_bindings = g_hash_table_new(g_str_hash, g_str_equal);
670 bind_keys_qwerty(pk);
676 piano_keyboard_set_keyboard_cue(PianoKeyboard *pk, int enabled)
678 pk->enable_keyboard_cue = enabled;
682 piano_keyboard_sustain_press(PianoKeyboard *pk)
684 if (!pk->sustain_new_notes) {
685 pk->sustain_new_notes = 1;
686 pk->maybe_stop_sustained_notes = 1;
691 piano_keyboard_sustain_release(PianoKeyboard *pk)
693 if (pk->maybe_stop_sustained_notes)
694 stop_sustained_notes(pk);
696 pk->sustain_new_notes = 0;
700 piano_keyboard_set_note_on(PianoKeyboard *pk, int note)
702 if (pk->notes[note].pressed == 0) {
703 pk->notes[note].pressed = 1;
704 queue_note_draw (pk, note);
709 piano_keyboard_set_note_off(PianoKeyboard *pk, int note)
711 if (pk->notes[note].pressed || pk->notes[note].sustained) {
712 pk->notes[note].pressed = 0;
713 pk->notes[note].sustained = 0;
714 queue_note_draw (pk, note);
719 piano_keyboard_set_octave(PianoKeyboard *pk, int octave)
721 stop_unsustained_notes(pk);
723 gtk_widget_queue_draw(GTK_WIDGET(pk));
727 piano_keyboard_set_keyboard_layout(PianoKeyboard *pk, const char *layout)
731 if (!strcasecmp(layout, "QWERTY")) {
732 bind_keys_qwerty(pk);
734 } else if (!strcasecmp(layout, "QWERTZ")) {
735 bind_keys_qwertz(pk);
737 } else if (!strcasecmp(layout, "AZERTY")) {
738 bind_keys_azerty(pk);
741 /* Unknown layout name. */