X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fgtkmm2ext%2Fmotionfeedback.cc;h=2637ae7a2e53991de50c8f6917fe0fae2aed1914;hb=51ad790745400eeb38547fa4de842202fec934b8;hp=7a10b3f614c9e8d505201a4d9f9fc0795d89e795;hpb=ada93428b45e9adfe5ffc799b1f3017ab5ea0a35;p=ardour.git diff --git a/libs/gtkmm2ext/motionfeedback.cc b/libs/gtkmm2ext/motionfeedback.cc index 7a10b3f614..2637ae7a2e 100644 --- a/libs/gtkmm2ext/motionfeedback.cc +++ b/libs/gtkmm2ext/motionfeedback.cc @@ -19,6 +19,8 @@ #include #include +#include +#include #include #include /* for snprintf, grrr */ @@ -27,6 +29,7 @@ #include "gtkmm2ext/motionfeedback.h" #include "gtkmm2ext/keyboard.h" +#include "gtkmm2ext/prolooks-helpers.h" using namespace Gtk; using namespace Gtkmm2ext; @@ -36,7 +39,9 @@ MotionFeedback::MotionFeedback (Glib::RefPtr pix, Type t, const char *widget_name, Adjustment *adj, - bool with_numeric_display, int subw, int subh) + bool with_numeric_display, + int subw, + int subh) : type (t) , value_packer (0) , value (0) @@ -54,7 +59,12 @@ MotionFeedback::MotionFeedback (Glib::RefPtr pix, set_adjustment (adj); } - pack_start (pixwin, false, false); + default_value = adjustment->get_value(); + + HBox* hpacker = manage (new HBox); + hpacker->pack_start (pixwin, true, false); + hpacker->show (); + pack_start (*hpacker, false, false); pixwin.show (); if (with_numeric_display) { @@ -101,6 +111,7 @@ MotionFeedback::MotionFeedback (Glib::RefPtr pix, pixwin.signal_scroll_event().connect(mem_fun (*this,&MotionFeedback::pixwin_scroll_event)); pixwin.signal_expose_event().connect(mem_fun (*this,&MotionFeedback::pixwin_expose_event), true); pixwin.signal_size_request().connect(mem_fun (*this,&MotionFeedback::pixwin_size_request)); + pixwin.signal_realize().connect(mem_fun (*this,&MotionFeedback::pixwin_realized)); } MotionFeedback::~MotionFeedback() @@ -133,6 +144,10 @@ MotionFeedback::set_adjustment (Adjustment *adj) bool MotionFeedback::pixwin_button_press_event (GdkEventButton *ev) { + if (binding_proxy.button_press_handler (ev)) { + return true; + } + switch (ev->button) { case 2: return FALSE; /* XXX why ? */ @@ -165,6 +180,11 @@ MotionFeedback::pixwin_button_release_event (GdkEventButton *ev) (GTK_WIDGET(pixwin.gobj())); } } + if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) { + /* shift click back to the default */ + adjustment->set_value (default_value); + return true; + } break; case 3: @@ -187,7 +207,7 @@ MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev) gfloat x_delta; gfloat y_delta; - if(!pixwin.has_grab()) { + if (!pixwin.has_grab()) { return VBox::on_motion_notify_event (ev); } @@ -195,19 +215,42 @@ MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev) ((ev->state & Keyboard::SecondaryModifier) ? 10 : 1) * ((ev->state & Keyboard::PrimaryModifier) ? 2 : 1); - y_delta = grabbed_y - ev->y_root; - grabbed_y = ev->y_root; - - x_delta = ev->x_root - grabbed_x; - - if (y_delta == 0) return TRUE; - y_delta *= 1 + (x_delta/100); - y_delta *= multiplier; - y_delta /= 10; + if (ev->state & Gdk::BUTTON1_MASK) { + + y_delta = grabbed_y - ev->y_root; + grabbed_y = ev->y_root; + + x_delta = ev->x_root - grabbed_x; + + if (y_delta == 0) return TRUE; + + y_delta *= 1 + (x_delta/100); + y_delta *= multiplier; + y_delta /= 10; + + adjustment->set_value (adjustment->get_value() + + ((grab_is_fine ? step_inc : page_inc) * y_delta)); + + } else if (ev->state & Gdk::BUTTON3_MASK) { + + double range = adjustment->get_upper() - adjustment->get_lower(); + double x = ev->x - subwidth/2; + double y = - ev->y + subwidth/2; + double angle = std::atan2 (y, x) / M_PI; + + if (angle < -0.5) { + angle += 2.0; + } + + angle = -(2.0/3.0) * (angle - 1.25); + angle *= range; + angle *= multiplier; + angle += adjustment->get_lower(); + + adjustment->set_value (angle); + } - adjustment->set_value (adjustment->get_value() + - ((grab_is_fine ? step_inc : page_inc) * y_delta)); return true; } @@ -282,10 +325,225 @@ MotionFeedback::adjustment_changed () pixwin.queue_draw (); } +void +MotionFeedback::core_draw (cairo_t* cr, int phase, double size, double progress_width, double xorigin, double yorigin, + const GdkColor* bright, const GdkColor* dark) +{ + double xc; + double yc; + double start_angle; + double end_angle; + double value_angle; + double value; + double value_x; + double value_y; + double start_angle_x; + double start_angle_y; + double end_angle_x; + double end_angle_y; + double progress_radius; + double progress_radius_inner; + double progress_radius_outer; + double knob_disc_radius; + cairo_pattern_t* pattern; + double progress_rim_width; + cairo_pattern_t* progress_shine; + double degrees; + cairo_pattern_t* knob_ripples; + double pxs; + double pys; + + g_return_if_fail (cr != NULL); + + progress_radius = 40.0; + progress_radius_inner = progress_radius - (progress_width / 2.0); + progress_radius_outer = progress_radius + (progress_width / 2.0); + knob_disc_radius = progress_radius_inner - 5.0; + + const double pad = 2.0; /* line width for boundary of progress ring */ + const double actual_width = ((2.0 * pad) + (2.0 * progress_radius_outer)); + const double scale_factor = size / actual_width; + + /* knob center is at middle of the area bounded by (xorigin,yorigin) and (xorigin+size, yorigin+size) + but the coordinates will be scaled by the scale factor when cairo uses them so first + adjust them by the reciprocal of the scale factor. + */ + + xc = (xorigin + (size / 2.0)) * (1.0/scale_factor); + yc = (yorigin + (size / 2.0)) * (1.0/scale_factor); + + pxs = xorigin * (1.0/scale_factor); + pys = yorigin * (1.0/scale_factor); + + start_angle = 0.0; + end_angle = 0.0; + value_angle = 0.0; + value = (phase * 1.0) / (65 - 1); + + start_angle = ((180 - 65) * G_PI) / 180; + end_angle = ((360 + 65) * G_PI) / 180; + + value_angle = start_angle + (value * (end_angle - start_angle)); + value_x = cos (value_angle); + value_y = sin (value_angle); + start_angle_x = cos (start_angle); + start_angle_y = sin (start_angle); + end_angle_x = cos (end_angle); + end_angle_y = sin (end_angle); + + cairo_scale (cr, scale_factor, scale_factor); + + pattern = prolooks_create_gradient_str (pxs + 32.0, pys + 16.0, pxs + 75.0, pys + 16.0, "#d4c8b9", "#ae977b", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_set_line_width (cr, 2.0); + cairo_arc (cr, xc, yc, 31.5, 0.0, 2 * G_PI); + cairo_stroke (cr); + + pattern = prolooks_create_gradient_str (pxs + 20.0, pys + 20.0, pxs + 89.0, pys + 87.0, "#2f2f4c", "#090a0d", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_set_line_width (cr, progress_width); + cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle); + cairo_stroke (cr); + + pattern = prolooks_create_gradient (pxs + 20.0, pys + 20.0, pxs + 89.0, pys + 87.0, bright, dark, 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_set_line_width (cr, progress_width); + cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle); + cairo_stroke (cr); + + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + progress_rim_width = 2.0; + cairo_set_line_width (cr, progress_rim_width); + pattern = prolooks_create_gradient_str (pxs + 18.0, pys + 79.0, pxs + 35.0, pys + 79.0, "#dfd5c9", "#dfd5c9", 1.0, 0.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_move_to (cr, xc + (progress_radius_outer * start_angle_x), yc + (progress_radius_outer * start_angle_y)); + cairo_line_to (cr, xc + (progress_radius_inner * start_angle_x), yc + (progress_radius_inner * start_angle_y)); + cairo_stroke (cr); + + prolooks_set_source_color_string (cr, "#000000", 1.0); + cairo_move_to (cr, xc + (progress_radius_outer * end_angle_x), yc + (progress_radius_outer * end_angle_y)); + cairo_line_to (cr, xc + (progress_radius_inner * end_angle_x), yc + (progress_radius_inner * end_angle_y)); + cairo_stroke (cr); + + // pattern = prolooks_create_gradient_str (95.0, 6.0, 5.0, 44.0, "#dfd5c9", "#b0a090", 1.0, 1.0); + pattern = prolooks_create_gradient_str (pxs + 95.0, pys + 6.0, pxs + 5.0, pys + 44.0, "#000000", "#000000", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_arc (cr, xc, yc, progress_radius_outer, start_angle, end_angle); + cairo_stroke (cr); + + cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT); + pattern = prolooks_create_gradient (pxs + 20.0, pys + 20.0, pxs + 89.0, pys + 87.0, bright, dark, 0.25, 0.25); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_set_line_width (cr, progress_width); + cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle + (G_PI / 180.0)); + cairo_stroke (cr); + + progress_shine = prolooks_create_gradient_str (pxs + 89.0, pys + 73.0, pxs + 34.0, pys + 16.0, "#ffffff", "#ffffff", 0.3, 0.04); + cairo_pattern_add_color_stop_rgba (progress_shine, 0.5, 1.0, 1.0, 1.0, 0.0); + if (size > 50) { + cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.3); + } else { + cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.2); + } + cairo_set_source (cr, progress_shine); + cairo_set_line_width (cr, progress_width); + cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle); + cairo_stroke (cr); + cairo_pattern_destroy (progress_shine); + + cairo_set_line_width (cr, 1.0); + cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); + cairo_arc (cr, xc, yc, progress_radius_inner, 0.0, 2 * G_PI); + pattern = prolooks_create_gradient_str (pxs + 35.0, pys + 31.0, pxs + 75.0, pys + 72.0, "#68625c", "#44494b", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_fill (cr); + cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); + cairo_arc (cr, xc, yc, progress_radius_inner, 0.0, 2 * G_PI); + cairo_stroke (cr); + + pattern = prolooks_create_gradient_str (pxs + 42.0, pys + 34.0, pxs + 68.0, pys + 70.0, "#e7ecef", "#9cafb8", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_arc (cr, xc, yc, knob_disc_radius, 0.0, 2 * G_PI); + cairo_fill (cr); + + cairo_set_line_width (cr, 2.0); + degrees = G_PI / 180.0; + pattern = prolooks_create_gradient_str (pxs + 38.0, pys + 34.0, pxs + 70.0, pys + 68.0, "#ffffff", "#caddf2", 0.2, 0.2); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_move_to (cr, xc, yc); + cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-154) * degrees, (-120) * degrees); + cairo_move_to (cr, xc, yc); + cairo_arc (cr, xc, yc, knob_disc_radius - 1, (G_PI / 2.0) - (60 * degrees), (G_PI / 2.0) - (29 * degrees)); + cairo_fill (cr); + + pattern = prolooks_create_gradient_str (pxs + 50.0, pys + 40.0, pxs + 62.0, pys + 60.0, "#a1adb6", "#47535c", 0.07, 0.15); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_move_to (cr, xc, yc); + cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-67) * degrees, (-27) * degrees); + cairo_move_to (cr, xc, yc); + cairo_arc (cr, xc, yc, knob_disc_radius - 1, G_PI - (67 * degrees), G_PI - (27 * degrees)); + cairo_fill (cr); + + knob_ripples = cairo_pattern_create_radial (xc, yc, 0.0, xc, yc, 4.0); + prolooks_add_color_stop_str (knob_ripples, 0.0, "#e7ecef", 0.05); + prolooks_add_color_stop_str (knob_ripples, 0.5, "#58717d", 0.05); + prolooks_add_color_stop_str (knob_ripples, 0.75, "#d1d9de", 0.05); + prolooks_add_color_stop_str (knob_ripples, 1.0, "#5d7682", 0.05); + cairo_pattern_set_extend (knob_ripples, CAIRO_EXTEND_REPEAT); + cairo_set_line_width (cr, 0.0); + cairo_set_source (cr, knob_ripples); + cairo_arc (cr, xc, yc, knob_disc_radius, 0.0, 2 * G_PI); + cairo_fill (cr); + + cairo_save (cr); + cairo_translate (cr, xc + (knob_disc_radius * value_x), yc + (knob_disc_radius * value_y)); + cairo_rotate (cr, value_angle - G_PI); + pattern = prolooks_create_gradient_str (pxs + 16.0, pys + -2.0, pxs + 9.0, pys + 13.0, "#e7ecef", "#9cafb8", 0.8, 0.8); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_move_to (cr, 0.0, 4.0); + cairo_line_to (cr, 17.0, 4.0); + cairo_curve_to (cr, 19.0, 4.0, 21.0, 2.0, 21.0, 0.0); + cairo_curve_to (cr, 21.0, -2.0, 19.0, -4.0, 17.0, -4.0); + cairo_line_to (cr, 0.0, -4.0); + cairo_close_path (cr); + cairo_fill (cr); + + pattern = prolooks_create_gradient_str (pxs + 9.0, pys + -2.0, pxs + 9.0, pys + 2.0, "#68625c", "#44494b", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_move_to (cr, 0.0, 2.0); + cairo_line_to (cr, 16.0, 2.0); + cairo_curve_to (cr, 17.0, 2.0, 18.0, 1.0, 18.0, 0.0); + cairo_curve_to (cr, 18.0, -1.0, 17.0, -2.0, 16.0, -2.0); + cairo_line_to (cr, 0.0, -2.0); + cairo_close_path (cr); + cairo_fill (cr); + + cairo_restore (cr); + cairo_set_line_width (cr, 2.0); + pattern = prolooks_create_gradient_str (pxs + 38.0, pys + 32.0, pxs + 70.0, pys + 67.0, "#3d3d3d", "#000000", 1.0, 1.0); + cairo_set_source (cr, pattern); + cairo_pattern_destroy (pattern); + cairo_arc (cr, xc, yc, knob_disc_radius, 0.0, 2 * G_PI); + cairo_stroke (cr); + + cairo_pattern_destroy (knob_ripples); +} + bool MotionFeedback::pixwin_expose_event (GdkEventExpose* ev) { - GtkWidget* widget = GTK_WIDGET(pixwin.gobj()); GdkWindow *window = pixwin.get_window()->gobj(); GtkAdjustment* adj = adjustment->gobj(); @@ -319,11 +577,14 @@ MotionFeedback::pixwin_expose_event (GdkEventExpose* ev) phase = (phase + 63) % 64; } - gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0], - pixbuf->gobj(), - phase * subwidth, type * subheight, - 0, 0, subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0); - + phase = std::min (phase, 63); + + GtkWidget* widget = GTK_WIDGET(pixwin.gobj()); + gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0], + pixbuf->gobj(), + phase * subwidth, type * subheight, + 0, 0, subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0); + return true; } @@ -361,3 +622,85 @@ MotionFeedback::pixwin_size_request (GtkRequisition* req) req->width = subwidth; req->height = subheight; } + +void +MotionFeedback::pixwin_realized () +{ + set_lamp_color (Gdk::Color ("#b9feff")); +} + +void +MotionFeedback::set_lamp_color (const Gdk::Color& c) +{ + GdkColor col2 = {0,0,0,0}; + GdkColor col3 = {0,0,0,0}; + + _lamp_color = c; + lamp_hsv = prolooks_hsv_new_for_gdk_color (_lamp_color.gobj()); + lamp_bright = (prolooks_hsv_to_gdk_color (lamp_hsv, &col2), col2); + prolooks_hsv_set_saturation (lamp_hsv, 0.66); + prolooks_hsv_set_value (lamp_hsv, 0.67); + lamp_dark = (prolooks_hsv_to_gdk_color (lamp_hsv, &col3), col3); +} + +Glib::RefPtr +MotionFeedback::render_pixbuf (int size) +{ + Glib::RefPtr pixbuf; + char path[32]; + int fd; + + snprintf (path, sizeof (path), "/tmp/mfimg%dXXXXXX", size); + + if ((fd = mkstemp (path)) < 0) { + return pixbuf; + } + + GdkColor col2 = {0,0,0,0}; + GdkColor col3 = {0,0,0,0}; + Gdk::Color base ("#b9feff"); + GdkColor dark; + GdkColor bright; + ProlooksHSV* hsv; + + hsv = prolooks_hsv_new_for_gdk_color (base.gobj()); + bright = (prolooks_hsv_to_gdk_color (hsv, &col2), col2); + prolooks_hsv_set_saturation (hsv, 0.66); + prolooks_hsv_set_value (hsv, 0.67); + dark = (prolooks_hsv_to_gdk_color (hsv, &col3), col3); + + cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, size * 64, size); + cairo_t* cr = cairo_create (surface); + + for (int i = 0; i < 64; ++i) { + cairo_save (cr); + core_draw (cr, i, size, 20, size*i, 0, &bright, &dark); + cairo_restore (cr); + } + + if (cairo_surface_write_to_png (surface, path) != CAIRO_STATUS_SUCCESS) { + std::cerr << "could not save image set to " << path << std::endl; + return pixbuf; + } + + close (fd); + + cairo_destroy (cr); + cairo_surface_destroy (surface); + + try { + pixbuf = Gdk::Pixbuf::create_from_file (path); + } catch (const Gdk::PixbufError &e) { + std::cerr << "Caught PixbufError: " << e.what() << std::endl; + unlink (path); + throw; + } catch (...) { + unlink (path); + g_message("Caught ... "); + throw; + } + + unlink (path); + + return pixbuf; +}