libs/gtkmm2ext/motionfeedback.cc

   1 /*
   2     Copyright (C) 1998-99 Paul Barton-Davis
   3     This program is free software; you can redistribute it and/or modify
   4     it under the terms of the GNU General Public License as published by
   5     the Free Software Foundation; either version 2 of the License, or
   6     (at your option) any later version.
   7
   8     This program is distributed in the hope that it will be useful,
   9     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11     GNU General Public License for more details.
  12
  13     You should have received a copy of the GNU General Public License
  14     along with this program; if not, write to the Free Software
  15     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16
  17     $Id: motionfeedback.cc,v 1.5 2004/03/01 03:44:19 pauld Exp $
  18 */
  19
  20 #include <iostream>
  21 #include <cmath>
  22 #include <unistd.h>
  23 #include <stdio.h> /* for snprintf, grrr */
  24
  25 #include <gdk/gdkkeysyms.h>
  26 #include <gtkmm.h>
  27
  28 #include "gtkmm2ext/motionfeedback.h"
  29 #include "gtkmm2ext/keyboard.h"
  30 #include "gtkmm2ext/prolooks-helpers.h"
  31
  32 using namespace Gtk;
  33 using namespace Gtkmm2ext;
  34 using namespace sigc;
  35
  36 MotionFeedback::MotionFeedback (Glib::RefPtr<Gdk::Pixbuf> pix,
  37                                 Type t,
  38                                 const char *widget_name,
  39                                 Adjustment *adj,
  40                                 bool with_numeric_display,
  41                                 int subw,
  42                                 int subh)
  43         : type (t)
  44         , value_packer (0)
  45         , value (0)
  46         , pixbuf (pix)
  47         , subwidth (subw)
  48         , subheight (subh)
  49 {
  50         char value_name[1024];
  51
  52         if (adj == NULL) {
  53             i_own_my_adjustment = true;
  54             set_adjustment (new Adjustment (0, 0, 10000, 1, 10, 0));
  55         } else {
  56             i_own_my_adjustment = false;
  57             set_adjustment (adj);
  58         }
  59
  60         default_value = adjustment->get_value();
  61
  62         HBox* hpacker = manage (new HBox);
  63         hpacker->pack_start (pixwin, true, false);
  64         hpacker->show ();
  65         pack_start (*hpacker, false, false);
  66         pixwin.show ();
  67
  68         if (with_numeric_display) {
  69
  70                 value_packer = new HBox;
  71                 value = new SpinButton (*adjustment);
  72                 value_packer->pack_start (*value, false, false);
  73
  74                 if (step_inc < 1) {
  75                         value->set_digits (abs ((int) ceil (log10 (step_inc))));
  76                 }
  77
  78                 pack_start (*value_packer, false, false);
  79
  80                 if (widget_name) {
  81                         snprintf (value_name, sizeof(value_name), "%sValue", widget_name);
  82                         value->set_name (value_name);
  83                 }
  84
  85                 value->show ();
  86         }
  87
  88         adjustment->signal_value_changed().connect (mem_fun (*this, &MotionFeedback::adjustment_changed));
  89
  90         pixwin.set_events (Gdk::BUTTON_PRESS_MASK|
  91                            Gdk::BUTTON_RELEASE_MASK|
  92                            Gdk::POINTER_MOTION_MASK|
  93                            Gdk::ENTER_NOTIFY_MASK|
  94                            Gdk::LEAVE_NOTIFY_MASK|
  95                            Gdk::SCROLL_MASK|
  96                            Gdk::KEY_PRESS_MASK|
  97                            Gdk::KEY_RELEASE_MASK);
  98
  99         pixwin.set_flags (CAN_FOCUS);
 100
 101         /* Proxy all important events on the pixwin to ourselves */
 102
 103         pixwin.signal_button_press_event().connect(mem_fun (*this,&MotionFeedback::pixwin_button_press_event));
 104         pixwin.signal_button_release_event().connect(mem_fun (*this,&MotionFeedback::pixwin_button_release_event));
 105         pixwin.signal_motion_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_motion_notify_event));
 106         pixwin.signal_enter_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_enter_notify_event));
 107         pixwin.signal_leave_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_leave_notify_event));
 108         pixwin.signal_key_press_event().connect(mem_fun (*this,&MotionFeedback::pixwin_key_press_event));
 109         pixwin.signal_scroll_event().connect(mem_fun (*this,&MotionFeedback::pixwin_scroll_event));
 110         pixwin.signal_expose_event().connect(mem_fun (*this,&MotionFeedback::pixwin_expose_event), true);
 111         pixwin.signal_size_request().connect(mem_fun (*this,&MotionFeedback::pixwin_size_request));
 112         pixwin.signal_realize().connect(mem_fun (*this,&MotionFeedback::pixwin_realized));
 113 }
 114
 115 MotionFeedback::~MotionFeedback()
 116
 117 {
 118         if (i_own_my_adjustment) {
 119                 delete adjustment;
 120         }
 121
 122         delete value;
 123         delete value_packer;
 124 }
 125
 126 void
 127 MotionFeedback::set_adjustment (Adjustment *adj)
 128 {
 129         adjustment = adj;
 130
 131         if (value) {
 132                 value->set_adjustment (*adj);
 133         }
 134
 135         _lower = adj->get_lower();
 136         _upper = adj->get_upper();
 137         _range = _upper - _lower;
 138         step_inc = adj->get_step_increment();
 139         page_inc = adj->get_page_increment();
 140 }
 141
 142 bool
 143 MotionFeedback::pixwin_button_press_event (GdkEventButton *ev)
 144 {
 145         if (binding_proxy.button_press_handler (ev)) {
 146                 return true;
 147         }
 148
 149         switch (ev->button) {
 150         case 2:
 151                 return FALSE;  /* XXX why ? */
 152
 153         case 1:
 154                 grab_is_fine = false;
 155                 break;
 156         case 3:
 157                 grab_is_fine = true;
 158                 break;
 159         }
 160
 161         gtk_grab_add(GTK_WIDGET(pixwin.gobj()));
 162         grabbed_y = ev->y_root;
 163         grabbed_x = ev->x_root;
 164
 165         /* XXX should we return TRUE ? */
 166
 167         return FALSE;
 168 }
 169
 170 bool
 171 MotionFeedback::pixwin_button_release_event (GdkEventButton *ev)
 172 {
 173         switch (ev->button) {
 174         case 1:
 175                 if (pixwin.has_grab()) {
 176                         if (!grab_is_fine) {
 177                                 gtk_grab_remove
 178                                         (GTK_WIDGET(pixwin.gobj()));
 179                         }
 180                 }
 181                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 182                         /* shift click back to the default */
 183                         adjustment->set_value (default_value);
 184                         return true;
 185                 }
 186                 break;
 187
 188         case 3:
 189                 if (pixwin.has_grab()) {
 190                         if (grab_is_fine) {
 191                                 gtk_grab_remove
 192                                         (GTK_WIDGET(pixwin.gobj()));
 193                         }
 194                 }
 195                 break;
 196         }
 197
 198         return VBox::on_button_release_event (ev);
 199 }
 200
 201 bool
 202 MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev)
 203 {
 204         gfloat multiplier;
 205         gfloat x_delta;
 206         gfloat y_delta;
 207
 208         if (!pixwin.has_grab()) {
 209                 return VBox::on_motion_notify_event (ev);
 210         }
 211
 212         multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100 : 1) *
 213                 ((ev->state & Keyboard::SecondaryModifier) ? 10 : 1) *
 214                 ((ev->state & Keyboard::PrimaryModifier) ? 2 : 1);
 215
 216
 217         if (ev->state & Gdk::BUTTON1_MASK) {
 218
 219                 y_delta = grabbed_y - ev->y_root;
 220                 grabbed_y = ev->y_root;
 221
 222                 x_delta = ev->x_root - grabbed_x;
 223
 224                 if (y_delta == 0) return TRUE;
 225
 226                 y_delta *= 1 + (x_delta/100);
 227                 y_delta *= multiplier;
 228                 y_delta /= 10;
 229
 230                 adjustment->set_value (adjustment->get_value() +
 231                                        ((grab_is_fine ? step_inc : page_inc) * y_delta));
 232
 233         } else if (ev->state & Gdk::BUTTON3_MASK) {
 234
 235                 double range = adjustment->get_upper() - adjustment->get_lower();
 236                 double x = ev->x - subwidth/2;
 237                 double y = - ev->y + subwidth/2;
 238                 double angle = std::atan2 (y, x) / M_PI;
 239
 240                 if (angle < -0.5) {
 241                         angle += 2.0;
 242                 }
 243
 244                 angle = -(2.0/3.0) * (angle - 1.25);
 245                 angle *= range;
 246                 angle *= multiplier;
 247                 angle += adjustment->get_lower();
 248
 249                 adjustment->set_value (angle);
 250         }
 251
 252
 253         return true;
 254 }
 255
 256 bool
 257 MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing *ev)
 258 {
 259         pixwin.grab_focus();
 260         return false;
 261 }
 262
 263 bool
 264 MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing *ev)
 265 {
 266         pixwin.unset_flags (HAS_FOCUS);
 267         return false;
 268 }
 269
 270 bool
 271 MotionFeedback::pixwin_key_press_event (GdkEventKey *ev)
 272 {
 273         bool retval = false;
 274         gfloat curval;
 275         gfloat multiplier;
 276
 277         multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100 : 1) *
 278                 ((ev->state & Keyboard::SecondaryModifier) ? 10 : 1) *
 279                 ((ev->state & Keyboard::PrimaryModifier) ? 2 : 1);
 280
 281         switch (ev->keyval) {
 282         case GDK_Page_Up:
 283                 retval = true;
 284                 curval = adjustment->get_value();
 285                 adjustment->set_value (curval + (multiplier * page_inc));
 286                 break;
 287
 288         case GDK_Page_Down:
 289                 retval = true;
 290                 curval = adjustment->get_value();
 291                 adjustment->set_value (curval - (multiplier * page_inc));
 292                 break;
 293
 294         case GDK_Up:
 295                 retval = true;
 296                 curval = adjustment->get_value();
 297                 adjustment->set_value (curval + (multiplier * step_inc));
 298                 break;
 299
 300         case GDK_Down:
 301                 retval = true;
 302                 curval = adjustment->get_value();
 303                 adjustment->set_value (curval - (multiplier * step_inc));
 304                 break;
 305
 306         case GDK_Home:
 307                 retval = true;
 308                 adjustment->set_value (_lower);
 309                 break;
 310
 311         case GDK_End:
 312                 retval = true;
 313                 adjustment->set_value (_upper);
 314                 break;
 315         }
 316
 317         return retval;
 318 }
 319
 320 void
 321 MotionFeedback::adjustment_changed ()
 322 {
 323         pixwin.queue_draw ();
 324 }
 325
 326 void
 327 MotionFeedback::core_draw (cairo_t* cr, int phase, double radius, double x, double y)
 328 {
 329         double width;
 330         double height;
 331         double xc;
 332         double yc;
 333         double start_angle;
 334         double end_angle;
 335         double value_angle;
 336         double value;
 337         double value_x;
 338         double value_y;
 339         double start_angle_x;
 340         double start_angle_y;
 341         double end_angle_x;
 342         double end_angle_y;
 343         double progress_width;
 344         double progress_radius;
 345         double progress_radius_inner;
 346         double progress_radius_outer;
 347         double knob_disc_radius;
 348         cairo_pattern_t* pattern;
 349         double progress_rim_width;
 350         cairo_pattern_t* progress_shine;
 351         double degrees;
 352         cairo_pattern_t* knob_ripples;
 353
 354         g_return_if_fail (cr != NULL);
 355
 356         cairo_set_source_rgba (cr, 0.75, 0.75, 0.75, (double) 1.0);
 357         cairo_rectangle (cr, (double) 0, (double) 0, subwidth, subheight);
 358         cairo_fill (cr);
 359
 360         width = 105.0;
 361         height = 105.0;
 362         xc = width / 2.0;
 363         yc = height / 2.0;
 364         start_angle = 0.0;
 365         end_angle = 0.0;
 366         value_angle = 0.0;
 367         value = (phase * 1.0) / (65 - 1);
 368
 369         start_angle = ((180 - 65) * G_PI) / 180;
 370         end_angle = ((360 + 65) * G_PI) / 180;
 371
 372         value_angle = start_angle + (value * (end_angle - start_angle));
 373         value_x = cos (value_angle);
 374         value_y = sin (value_angle);
 375         start_angle_x = cos (start_angle);
 376         start_angle_y = sin (start_angle);
 377         end_angle_x = cos (end_angle);
 378         end_angle_y = sin (end_angle);
 379         cairo_save (cr);
 380         //cairo_translate (cr, x, (double) 0);
 381         cairo_scale (cr, (2.0 * radius) / width, (2.0 * radius) / height);
 382         //cairo_translate (cr, -xc, (double) 0);
 383
 384         pattern = prolooks_create_gradient_str ((double) 32, (double) 16, (double) 75, (double) 16, "#d4c8b9", "#ae977b", 1.0, 1.0);
 385         cairo_set_source (cr, pattern);
 386         cairo_pattern_destroy (pattern);
 387         cairo_set_line_width (cr, 2.0);
 388         cairo_arc (cr, xc, yc, 31.5, 0.0, 2 * G_PI);
 389         cairo_stroke (cr);
 390
 391         progress_width = 10.0;
 392         progress_radius = 40.0;
 393         progress_radius_inner = progress_radius - (progress_width / 2.0);
 394         progress_radius_outer = progress_radius + (progress_width / 2.0);
 395         knob_disc_radius = progress_radius_inner - 5.0;
 396
 397         pattern = prolooks_create_gradient_str ((double) 20, (double) 20, (double) 89, (double) 87, "#2f2f4c", "#090a0d", 1.0, 1.0);
 398         cairo_set_source (cr, pattern);
 399         cairo_pattern_destroy (pattern);
 400         cairo_set_line_width (cr, progress_width);
 401         cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
 402         cairo_stroke (cr);
 403
 404         pattern = prolooks_create_gradient ((double) 20, (double) 20, (double) 89, (double) 87, &lamp_bright, &lamp_dark, 1.0, 1.0);
 405         cairo_set_source (cr, pattern);
 406         cairo_pattern_destroy (pattern);
 407         cairo_set_line_width (cr, progress_width);
 408         cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle);
 409         cairo_stroke (cr);
 410
 411         cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 412         progress_rim_width = 2.0;
 413         cairo_set_line_width (cr, progress_rim_width);
 414         pattern = prolooks_create_gradient_str ((double) 18, (double) 79, (double) 35, (double) 79, "#dfd5c9", "#dfd5c9", 1.0, 0.0);
 415         cairo_set_source (cr, pattern);
 416         cairo_pattern_destroy (pattern);
 417         cairo_move_to (cr, xc + (progress_radius_outer * start_angle_x), yc + (progress_radius_outer * start_angle_y));
 418         cairo_line_to (cr, xc + (progress_radius_inner * start_angle_x), yc + (progress_radius_inner * start_angle_y));
 419         cairo_stroke (cr);
 420
 421         prolooks_set_source_color_string (cr, "#000000", 1.0);
 422         cairo_move_to (cr, xc + (progress_radius_outer * end_angle_x), yc + (progress_radius_outer * end_angle_y));
 423         cairo_line_to (cr, xc + (progress_radius_inner * end_angle_x), yc + (progress_radius_inner * end_angle_y));
 424         cairo_stroke (cr);
 425
 426         // pattern = prolooks_create_gradient_str ((double) 95, (double) 6, (double) 5, (double) 44, "#dfd5c9", "#b0a090", 1.0, 1.0);
 427         pattern = prolooks_create_gradient_str ((double) 95, (double) 6, (double) 5, (double) 44, "#000000", "#000000", 1.0, 1.0);
 428         cairo_set_source (cr, pattern);
 429         cairo_pattern_destroy (pattern);
 430         cairo_arc (cr, xc, yc, progress_radius_outer, start_angle, end_angle);
 431         cairo_stroke (cr);
 432
 433         cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
 434         pattern = prolooks_create_gradient ((double) 20, (double) 20, (double) 89, (double) 87, &lamp_bright, &lamp_dark, 0.25, 0.25);
 435         cairo_set_source (cr, pattern);
 436         cairo_pattern_destroy (pattern);
 437         cairo_set_line_width (cr, progress_width);
 438         cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle + (G_PI / 180.0));
 439         cairo_stroke (cr);
 440
 441         progress_shine = prolooks_create_gradient_str ((double) 89, (double) 73, (double) 34, (double) 16, "#ffffff", "#ffffff", 0.3, 0.04);
 442         cairo_pattern_add_color_stop_rgba (progress_shine, 0.5, 1.0, 1.0, 1.0, 0.0);
 443         if (subwidth > 50) {
 444                 cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.3);
 445         } else {
 446                 cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.2);
 447         }
 448         cairo_set_source (cr, progress_shine);
 449         cairo_set_line_width (cr, progress_width);
 450         cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
 451         cairo_stroke (cr);
 452         cairo_pattern_destroy (progress_shine);
 453
 454         cairo_set_line_width (cr, 1.0);
 455         cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 456         cairo_arc (cr, xc, yc, progress_radius_inner, (double) 0, 2 * G_PI);
 457         pattern = prolooks_create_gradient_str ((double) 35, (double) 31, (double) 75, (double) 72, "#68625c", "#44494b", 1.0, 1.0);
 458         cairo_set_source (cr, pattern);
 459         cairo_pattern_destroy (pattern);
 460         cairo_fill (cr);
 461         cairo_set_source_rgb (cr, (double) 0, (double) 0, (double) 0);
 462         cairo_arc (cr, xc, yc, progress_radius_inner, (double) 0, 2 * G_PI);
 463         cairo_stroke (cr);
 464
 465         pattern = prolooks_create_gradient_str ((double) 42, (double) 34, (double) 68, (double) 70, "#e7ecef", "#9cafb8", 1.0, 1.0);
 466         cairo_set_source (cr, pattern);
 467         cairo_pattern_destroy (pattern);
 468         cairo_arc (cr, xc, yc, knob_disc_radius, (double) 0, 2 * G_PI);
 469         cairo_fill (cr);
 470
 471         cairo_set_line_width (cr, 2.0);
 472         degrees = G_PI / 180.0;
 473         pattern = prolooks_create_gradient_str ((double) 38, (double) 34, (double) 70, (double) 68, "#ffffff", "#caddf2", 0.2, 0.2);
 474         cairo_set_source (cr, pattern);
 475         cairo_pattern_destroy (pattern);
 476         cairo_move_to (cr, xc, yc);
 477         cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-154) * degrees, (-120) * degrees);
 478         cairo_move_to (cr, xc, yc);
 479         cairo_arc (cr, xc, yc, knob_disc_radius - 1, (G_PI / 2.0) - (60 * degrees), (G_PI / 2.0) - (29 * degrees));
 480         cairo_fill (cr);
 481
 482         pattern = prolooks_create_gradient_str ((double) 50, (double) 40, (double) 62, (double) 60, "#a1adb6", "#47535c", 0.07, 0.15);
 483         cairo_set_source (cr, pattern);
 484         cairo_pattern_destroy (pattern);
 485         cairo_move_to (cr, xc, yc);
 486         cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-67) * degrees, (-27) * degrees);
 487         cairo_move_to (cr, xc, yc);
 488         cairo_arc (cr, xc, yc, knob_disc_radius - 1, G_PI - (67 * degrees), G_PI - (27 * degrees));
 489         cairo_fill (cr);
 490
 491         knob_ripples = cairo_pattern_create_radial (xc, yc, (double) 0, xc, yc, (double) 4);
 492         prolooks_add_color_stop_str (knob_ripples, 0.0, "#e7ecef", 0.05);
 493         prolooks_add_color_stop_str (knob_ripples, 0.5, "#58717d", 0.05);
 494         prolooks_add_color_stop_str (knob_ripples, 0.75, "#d1d9de", 0.05);
 495         prolooks_add_color_stop_str (knob_ripples, 1.0, "#5d7682", 0.05);
 496         cairo_pattern_set_extend (knob_ripples, CAIRO_EXTEND_REPEAT);
 497         cairo_set_line_width (cr, 0.0);
 498         cairo_set_source (cr, knob_ripples);
 499         cairo_arc (cr, xc, yc, knob_disc_radius, (double) 0, 2 * G_PI);
 500         cairo_fill (cr);
 501
 502         cairo_save (cr);
 503         cairo_translate (cr, xc + (knob_disc_radius * value_x), yc + (knob_disc_radius * value_y));
 504         cairo_rotate (cr, value_angle - G_PI);
 505         cairo_set_source (cr, pattern = prolooks_create_gradient_str ((double) 16, (double) (-2), (double) 9, (double) 13, "#e7ecef", "#9cafb8", 0.8, 0.8));
 506         cairo_pattern_destroy (pattern);
 507         cairo_move_to (cr, (double) 0, (double) 4);
 508         cairo_line_to (cr, (double) 17, (double) 4);
 509         cairo_curve_to (cr, (double) 19, (double) 4, (double) 21, (double) 2, (double) 21, (double) 0);
 510         cairo_curve_to (cr, (double) 21, (double) (-2), (double) 19, (double) (-4), (double) 17, (double) (-4));
 511         cairo_line_to (cr, (double) 0, (double) (-4));
 512         cairo_close_path (cr);
 513         cairo_fill (cr);
 514
 515         pattern = prolooks_create_gradient_str ((double) 9, (double) (-2), (double) 9, (double) 2, "#68625c", "#44494b", 1.0, 1.0);
 516         cairo_set_source (cr, pattern);
 517         cairo_pattern_destroy (pattern);
 518         cairo_move_to (cr, (double) 0, (double) 2);
 519         cairo_line_to (cr, (double) 16, (double) 2);
 520         cairo_curve_to (cr, (double) 17, (double) 2, (double) 18, (double) 1, (double) 18, (double) 0);
 521         cairo_curve_to (cr, (double) 18, (double) (-1), (double) 17, (double) (-2), (double) 16, (double) (-2));
 522         cairo_line_to (cr, (double) 0, (double) (-2));
 523         cairo_close_path (cr);
 524         cairo_fill (cr);
 525
 526         cairo_restore (cr);
 527         cairo_set_line_width (cr, 2.0);
 528         pattern = prolooks_create_gradient_str ((double) 38, (double) 32, (double) 70, (double) 67, "#3d3d3d", "#000000", 1.0, 1.0);
 529         cairo_set_source (cr, pattern);
 530         cairo_pattern_destroy (pattern);
 531         cairo_arc (cr, xc, yc, knob_disc_radius, (double) 0, 2 * G_PI);
 532         cairo_stroke (cr);
 533         cairo_restore (cr);
 534
 535         cairo_pattern_destroy (knob_ripples);
 536 }
 537
 538 bool
 539 MotionFeedback::pixwin_expose_event (GdkEventExpose* ev)
 540 {
 541         GdkWindow *window = pixwin.get_window()->gobj();
 542         GtkAdjustment* adj = adjustment->gobj();
 543
 544         int phase = (int)((adj->value - adj->lower) * 64 /
 545                           (adj->upper - adj->lower));
 546
 547         // skip middle phase except for true middle value
 548
 549         if (type == Rotary && phase == 32) {
 550                 double pt = (adj->value - adj->lower) * 2.0 /
 551                         (adj->upper - adj->lower) - 1.0;
 552                 if (pt < 0)
 553                         phase = 31;
 554                 if (pt > 0)
 555                         phase = 33;
 556         }
 557
 558         // endless knob: skip 90deg highlights unless the value is really a multiple of 90deg
 559
 560         if (type == Endless && !(phase % 16)) {
 561                 if (phase == 64) {
 562                         phase = 0;
 563                 }
 564
 565                 double nom = adj->lower + phase * (adj->upper - adj->lower) / 64.0;
 566                 double diff = (adj->value - nom) / (adj->upper - adj->lower);
 567
 568                 if (diff > 0.0001)
 569                         phase = (phase + 1) % 64;
 570                 if (diff < -0.0001)
 571                         phase = (phase + 63) % 64;
 572         }
 573
 574         if (pixbuf) {
 575                 std::cerr << "Render from pixbuf\n";
 576                 GtkWidget* widget = GTK_WIDGET(pixwin.gobj());
 577                 gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0],
 578                                  pixbuf->gobj(),
 579                                  phase * subwidth, type * subheight,
 580                                  0, 0, subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0);
 581         } else {
 582                 std::cerr << "Render with cairo\n";
 583                 cairo_t* cr = gdk_cairo_create (GDK_DRAWABLE (window));
 584
 585                 gdk_cairo_rectangle (cr, &ev->area);
 586                 cairo_clip (cr);
 587
 588                 core_draw (cr, phase, subheight/2, subwidth/2, subheight/2);
 589                 cairo_destroy (cr);
 590         }
 591
 592         return true;
 593 }
 594
 595 bool
 596 MotionFeedback::pixwin_scroll_event (GdkEventScroll* ev)
 597 {
 598         double scale;
 599
 600         if ((ev->state & (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier)) == (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier)) {
 601                 scale = 0.01;
 602         } else if (ev->state & Keyboard::PrimaryModifier) {
 603                 scale = 0.1;
 604         } else {
 605                 scale = 1.0;
 606         }
 607
 608         switch (ev->direction) {
 609         case GDK_SCROLL_UP:
 610         case GDK_SCROLL_RIGHT:
 611                 adjustment->set_value (adjustment->get_value() + (scale * adjustment->get_step_increment()));
 612                 break;
 613
 614         case GDK_SCROLL_DOWN:
 615         case GDK_SCROLL_LEFT:
 616                 adjustment->set_value (adjustment->get_value() - (scale * adjustment->get_step_increment()));
 617                 break;
 618         }
 619
 620         return true;
 621 }
 622
 623 void
 624 MotionFeedback::pixwin_size_request (GtkRequisition* req)
 625 {
 626         req->width = subwidth;
 627         req->height = subheight;
 628 }
 629
 630 void
 631 MotionFeedback::pixwin_realized ()
 632 {
 633         set_lamp_color (Gdk::Color ("#b9feff"));
 634 }
 635
 636 void
 637 MotionFeedback::set_lamp_color (const Gdk::Color& c)
 638 {
 639         GdkColor col2 = {0,0,0,0};
 640         GdkColor col3 = {0,0,0,0};
 641
 642         _lamp_color = c;
 643         lamp_hsv = prolooks_hsv_new_for_gdk_color (_lamp_color.gobj());
 644         lamp_bright = (prolooks_hsv_to_gdk_color (lamp_hsv, &col2), col2);
 645         prolooks_hsv_set_saturation (lamp_hsv, 0.66);
 646         prolooks_hsv_set_value (lamp_hsv, 0.67);
 647         lamp_dark = (prolooks_hsv_to_gdk_color (lamp_hsv, &col3), col3);
 648 }
 649
 650 void
 651 MotionFeedback::render_file (const std::string& path, int w, int h)
 652 {
 653         GdkPixmap* pixmap = gdk_pixmap_new (0, w, h, 24);
 654         GdkPixbuf* pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, 1, 8, w * 65, h);
 655         GError* err = 0;
 656         GdkRectangle r;
 657
 658         r.x = 0;
 659         r.y = 0;
 660         r.width = w;
 661         r.height = h;
 662
 663         set_lamp_color (Gdk::Color ("#b9feff"));
 664
 665         for (int i = 0; i < 65; ++i) {
 666                 cairo_t* cr = gdk_cairo_create (GDK_DRAWABLE (pixmap));
 667                 gdk_cairo_rectangle (cr, &r);
 668                 cairo_clip (cr);
 669                 core_draw (cr, i, h/2, w/2, h/2);
 670                 gdk_pixbuf_get_from_drawable (pixbuf, pixmap, gdk_colormap_get_system(), 0, 0, w*i, 0, w, h);
 671                 cairo_destroy (cr);
 672         }
 673
 674         if (gdk_pixbuf_save (pixbuf, path.c_str(), "png", &err, 0)) {
 675                 if (err) {
 676                         std::cerr << "could not save image set to " << path << ": " << err->message << std::endl;
 677                 }
 678         }
 679
 680         g_object_unref (G_OBJECT (pixbuf));
 681         g_object_unref (G_OBJECT (pixmap));
 682 }