libs/gtkmm2ext/motionfeedback.cc

   1 /*
   2     Copyright (C) 2010-2011 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id: motionfeedback.cc,v 1.5 2004/03/01 03:44:19 pauld Exp $
  19 */
  20
  21 #include <iostream>
  22 #include <cmath>
  23 #include <cstdlib>
  24 #include <algorithm>
  25 #include <unistd.h>
  26 #include <stdio.h> /* for snprintf, grrr */
  27
  28 #include "pbd/gstdio_compat.h"
  29
  30 #include <gdk/gdkkeysyms.h>
  31 #include <gtkmm.h>
  32
  33 #include "pbd/controllable.h"
  34 #include "pbd/compose.h"
  35 #include "pbd/error.h"
  36
  37 #include "gtkmm2ext/motionfeedback.h"
  38 #include "gtkmm2ext/keyboard.h"
  39 #include "gtkmm2ext/prolooks-helpers.h"
  40 #include "gtkmm2ext/gui_thread.h"
  41
  42 #include "i18n.h"
  43
  44 using namespace Gtk;
  45 using namespace Gtkmm2ext;
  46 using namespace sigc;
  47
  48 using PBD::error;
  49 using PBD::Controllable;
  50
  51 Gdk::Color* MotionFeedback::base_color;
  52
  53 MotionFeedback::MotionFeedback (Glib::RefPtr<Gdk::Pixbuf> pix,
  54                                 Type t,
  55                                 boost::shared_ptr<PBD::Controllable> c,
  56                                 double default_val,
  57                                 double step_increment,
  58                                 double page_increment,
  59                                 const char *widget_name,
  60                                 bool with_numeric_display,
  61                                 int subw,
  62                                 int subh)
  63         : _controllable (c)
  64         , value (0)
  65         , default_value (default_val)
  66         , step_inc (step_increment)
  67         , page_inc (page_increment)
  68         , type (t)
  69         , value_packer (0)
  70         , pixbuf (pix)
  71         , subwidth (subw)
  72         , subheight (subh)
  73 {
  74         if (!base_color) {
  75                 base_color = new Gdk::Color ("#1a5274");
  76         }
  77
  78         char value_name[1024];
  79
  80         print_func = default_printer;
  81         print_arg = 0;
  82
  83
  84         HBox* hpacker = manage (new HBox);
  85         hpacker->pack_start (pixwin, true, true);
  86         hpacker->show ();
  87         pack_start (*hpacker, false, false);
  88         pixwin.show ();
  89
  90         if (with_numeric_display) {
  91
  92                 value_packer = new EventBox;
  93                 value_packer->set_name ("MotionControllerValue");
  94                 value_packer->show ();
  95                 value_packer->set_border_width (6);
  96
  97                 value = new Label;
  98                 value->set_justify (Gtk::JUSTIFY_RIGHT);
  99                 value->show ();
 100
 101                 value_packer->add (*value);
 102
 103                 hpacker = manage (new HBox);
 104                 hpacker->pack_start (*value_packer, true, false);
 105                 hpacker->show ();
 106                 hpacker->set_border_width (6);
 107
 108                 pack_start (*hpacker, false, false);
 109
 110                 if (widget_name) {
 111                         snprintf (value_name, sizeof(value_name), "%sValue", widget_name);
 112                         value->set_name (value_name);
 113                 }
 114
 115                 if (_controllable) {
 116                         char buf[32];
 117                         print_func (buf, _controllable, print_arg);
 118                         value->set_text (buf);
 119                 }
 120         }
 121
 122         pixwin.set_events (Gdk::BUTTON_PRESS_MASK|
 123                            Gdk::BUTTON_RELEASE_MASK|
 124                            Gdk::POINTER_MOTION_MASK|
 125                            Gdk::ENTER_NOTIFY_MASK|
 126                            Gdk::LEAVE_NOTIFY_MASK|
 127                            Gdk::SCROLL_MASK|
 128                            Gdk::KEY_PRESS_MASK|
 129                            Gdk::KEY_RELEASE_MASK);
 130
 131         pixwin.set_flags (CAN_FOCUS);
 132
 133         /* Proxy all important events on the pixwin to ourselves */
 134
 135         pixwin.signal_button_press_event().connect(mem_fun (*this,&MotionFeedback::pixwin_button_press_event));
 136         pixwin.signal_button_release_event().connect(mem_fun (*this,&MotionFeedback::pixwin_button_release_event));
 137         pixwin.signal_motion_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_motion_notify_event));
 138         pixwin.signal_enter_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_enter_notify_event));
 139         pixwin.signal_leave_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_leave_notify_event));
 140         pixwin.signal_key_press_event().connect(mem_fun (*this,&MotionFeedback::pixwin_key_press_event));
 141         pixwin.signal_scroll_event().connect(mem_fun (*this,&MotionFeedback::pixwin_scroll_event));
 142         pixwin.signal_expose_event().connect(mem_fun (*this,&MotionFeedback::pixwin_expose_event), true);
 143         pixwin.signal_size_request().connect(mem_fun (*this,&MotionFeedback::pixwin_size_request));
 144 }
 145
 146 MotionFeedback::~MotionFeedback()
 147 {
 148         delete value;
 149         delete value_packer;
 150 }
 151
 152 bool
 153 MotionFeedback::pixwin_button_press_event (GdkEventButton *ev)
 154 {
 155         if (binding_proxy.button_press_handler (ev)) {
 156                 return true;
 157         }
 158
 159         switch (ev->button) {
 160         case 1:
 161                 grab_is_fine = false;
 162                 break;
 163         case 2:
 164                 grab_is_fine = true;
 165                 break;
 166         case 3:
 167                 return false;
 168         }
 169
 170         gtk_grab_add(GTK_WIDGET(pixwin.gobj()));
 171
 172         grabbed_y = ev->y_root;
 173         grabbed_x = ev->x_root;
 174
 175         return false;
 176 }
 177
 178 bool
 179 MotionFeedback::pixwin_button_release_event (GdkEventButton *ev)
 180 {
 181         if (!_controllable) {
 182                 return false;
 183         }
 184
 185         switch (ev->button) {
 186         case 1:
 187                 if (pixwin.has_grab()) {
 188                         if (!grab_is_fine) {
 189                                 gtk_grab_remove
 190                                         (GTK_WIDGET(pixwin.gobj()));
 191                         }
 192                 }
 193                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 194                         /* shift click back to the default */
 195                         _controllable->set_value (default_value, Controllable::NoGroup);
 196                         return true;
 197                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 198                         /* ctrl click back to the minimum value */
 199                         _controllable->set_value (_controllable->lower (), Controllable::NoGroup);
 200                 }
 201                 break;
 202
 203         case 3:
 204                 if (pixwin.has_grab()) {
 205                         if (grab_is_fine) {
 206                                 gtk_grab_remove
 207                                         (GTK_WIDGET(pixwin.gobj()));
 208                         }
 209                 }
 210                 break;
 211         }
 212
 213         return VBox::on_button_release_event (ev);
 214 }
 215
 216 bool
 217 MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev)
 218 {
 219         if (!_controllable) {
 220                 return false;
 221         }
 222
 223         gfloat multiplier;
 224         gfloat x_delta;
 225         gfloat y_delta;
 226
 227         if (!pixwin.has_grab()) {
 228                 return VBox::on_motion_notify_event (ev);
 229         }
 230
 231         multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100 : 1) *
 232                 ((ev->state & Keyboard::PrimaryModifier) ? 10 : 1) *
 233                 ((ev->state & Keyboard::SecondaryModifier) ? 0.1 : 1);
 234
 235         if (ev->state & Gdk::BUTTON1_MASK) {
 236
 237                 /* vertical control */
 238
 239                 y_delta = grabbed_y - ev->y_root;
 240                 grabbed_y = ev->y_root;
 241
 242                 x_delta = ev->x_root - grabbed_x;
 243
 244                 if (y_delta == 0) return TRUE;
 245
 246                 y_delta *= 1 + (x_delta/100);
 247                 y_delta *= multiplier;
 248                 y_delta /= 10;
 249
 250                 _controllable->set_value (adjust ((grab_is_fine ? step_inc : page_inc) * y_delta), Controllable::NoGroup);
 251
 252         } else if (ev->state & Gdk::BUTTON2_MASK) {
 253
 254                 /* rotary control */
 255
 256                 double x = ev->x - subwidth/2;
 257                 double y = - ev->y + subwidth/2;
 258                 double angle = std::atan2 (y, x) / M_PI;
 259
 260                 if (angle < -0.5) {
 261                         angle += 2.0;
 262                 }
 263
 264                 angle = -(2.0/3.0) * (angle - 1.25);
 265                 angle *= multiplier;
 266
 267                 _controllable->set_value (to_control_value (angle), Controllable::NoGroup);
 268         }
 269
 270
 271         return true;
 272 }
 273
 274 bool
 275 MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing*)
 276 {
 277         pixwin.grab_focus();
 278         return false;
 279 }
 280
 281 bool
 282 MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing*)
 283 {
 284         pixwin.unset_flags (HAS_FOCUS);
 285         return false;
 286 }
 287
 288 bool
 289 MotionFeedback::pixwin_key_press_event (GdkEventKey *ev)
 290 {
 291         if (!_controllable) {
 292                 return false;
 293         }
 294
 295         bool retval = false;
 296         double multiplier;
 297
 298         multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100.0 : 1.0) *
 299                 ((ev->state & Keyboard::SecondaryModifier) ? 10.0 : 1.0) *
 300                 ((ev->state & Keyboard::PrimaryModifier) ? 2.0 : 1.0);
 301
 302         switch (ev->keyval) {
 303         case GDK_Page_Up:
 304                 retval = true;
 305                 _controllable->set_value (adjust (multiplier * page_inc), Controllable::NoGroup);
 306                 break;
 307
 308         case GDK_Page_Down:
 309                 retval = true;
 310                 _controllable->set_value (adjust (-multiplier * page_inc), Controllable::NoGroup);
 311                 break;
 312
 313         case GDK_Up:
 314                 retval = true;
 315                 _controllable->set_value (adjust (multiplier * step_inc), Controllable::NoGroup);
 316                 break;
 317
 318         case GDK_Down:
 319                 retval = true;
 320                 _controllable->set_value (adjust (-multiplier * step_inc), Controllable::NoGroup);
 321                 break;
 322
 323         case GDK_Home:
 324                 retval = true;
 325                 _controllable->set_value (_controllable->lower(), Controllable::NoGroup);
 326                 break;
 327
 328         case GDK_End:
 329                 retval = true;
 330                 _controllable->set_value (_controllable->upper(), Controllable::NoGroup);
 331                 break;
 332         }
 333
 334         return retval;
 335 }
 336
 337 bool
 338 MotionFeedback::pixwin_expose_event (GdkEventExpose*)
 339 {
 340         if (!_controllable) {
 341                 return true;
 342         }
 343
 344         GdkWindow *window = pixwin.get_window()->gobj();
 345         double display_val = to_display_value (_controllable->get_value());
 346         int32_t phase = lrint (display_val * 64.0);
 347
 348         // skip middle phase except for true middle value
 349
 350         if (type == Rotary && phase == 32) {
 351                 double pt = (display_val * 2.0) - 1.0;
 352                 if (pt < 0)
 353                         phase = 31;
 354                 if (pt > 0)
 355                         phase = 33;
 356         }
 357
 358         // endless knob: skip 90deg highlights unless the value is really a multiple of 90deg
 359
 360         if (type == Endless && !(phase % 16)) {
 361                 if (phase == 64) {
 362                         phase = 0;
 363                 }
 364
 365                 double nom = phase / 64.0;
 366                 double diff = display_val - nom;
 367
 368                 if (diff > 0.0001)
 369                         phase = (phase + 1) % 64;
 370                 if (diff < -0.0001)
 371                         phase = (phase + 63) % 64;
 372         }
 373
 374         phase = std::min (phase, (int32_t) 63);
 375
 376         GtkWidget* widget = GTK_WIDGET(pixwin.gobj());
 377         gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0],
 378                          pixbuf->gobj(),
 379                          phase * subwidth, type * subheight,
 380                          /* center image in allocated area */
 381                          (get_width() - subwidth)/2,
 382                          0,
 383                          subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0);
 384
 385         return true;
 386 }
 387
 388 bool
 389 MotionFeedback::pixwin_scroll_event (GdkEventScroll* ev)
 390 {
 391         double scale;
 392
 393         if (!_controllable) {
 394                 return false;
 395         }
 396
 397         if (ev->state & Keyboard::GainFineScaleModifier) {
 398                 if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 399                         scale = 0.01;
 400                 } else {
 401                         scale = 0.10;
 402                 }
 403         } else {
 404                 scale = 0.20;
 405         }
 406
 407         switch (ev->direction) {
 408         case GDK_SCROLL_UP:
 409         case GDK_SCROLL_RIGHT:
 410                 _controllable->set_value (adjust (scale * page_inc), Controllable::NoGroup);
 411                 break;
 412
 413         case GDK_SCROLL_DOWN:
 414         case GDK_SCROLL_LEFT:
 415                 _controllable->set_value (adjust (-scale * page_inc), Controllable::NoGroup);
 416                 break;
 417         }
 418
 419         return true;
 420 }
 421
 422 void
 423 MotionFeedback::pixwin_size_request (GtkRequisition* req)
 424 {
 425         req->width = subwidth;
 426         req->height = subheight;
 427 }
 428
 429
 430 void
 431 MotionFeedback::controllable_value_changed ()
 432 {
 433         if (value) {
 434                 char buf[32];
 435                 print_func (buf, _controllable, print_arg);
 436                 value->set_text (buf);
 437         }
 438
 439         pixwin.queue_draw ();
 440 }
 441
 442 void
 443 MotionFeedback::set_controllable (boost::shared_ptr<PBD::Controllable> c)
 444 {
 445         _controllable = c;
 446         binding_proxy.set_controllable (c);
 447         controller_connection.disconnect ();
 448
 449         if (c) {
 450                 c->Changed.connect (controller_connection, MISSING_INVALIDATOR, boost::bind (&MotionFeedback::controllable_value_changed, this), gui_context());
 451
 452                 char buf[32];
 453                 print_func (buf, _controllable, print_arg);
 454                 value->set_text (buf);
 455         }
 456
 457         pixwin.queue_draw ();
 458 }
 459
 460 boost::shared_ptr<PBD::Controllable>
 461 MotionFeedback::controllable () const
 462 {
 463         return _controllable;
 464 }
 465
 466 void
 467 MotionFeedback::default_printer (char buf[32], const boost::shared_ptr<PBD::Controllable>& c, void *)
 468 {
 469         if (c) {
 470                 sprintf (buf, "%.2f", c->get_value());
 471         } else {
 472                 buf[0] = '\0';
 473         }
 474 }
 475
 476 Glib::RefPtr<Gdk::Pixbuf>
 477 MotionFeedback::render_pixbuf (int size)
 478 {
 479         Glib::RefPtr<Gdk::Pixbuf> pixbuf;
 480         char *path;
 481         int fd;
 482         GError *gerror = NULL;
 483
 484         fd = g_file_open_tmp ("mfimgXXXXXX", &path, &gerror);
 485
 486         if (gerror) {
 487                 error << string_compose (_("motionfeedback: failed to open a temporary file for writing: %1"), gerror->message) << endmsg;
 488                 g_error_free (gerror);
 489                 return pixbuf;
 490         } else {
 491                 ::close (fd);
 492         }
 493
 494
 495         GdkColor col2 = {0,0,0,0};
 496         GdkColor col3 = {0,0,0,0};
 497         GdkColor dark;
 498         GdkColor bright;
 499         ProlooksHSV* hsv;
 500
 501         hsv = prolooks_hsv_new_for_gdk_color (base_color->gobj());
 502         bright = (prolooks_hsv_to_gdk_color (hsv, &col2), col2);
 503         prolooks_hsv_set_saturation (hsv, 0.66);
 504         prolooks_hsv_set_value (hsv, 0.67);
 505         dark = (prolooks_hsv_to_gdk_color (hsv, &col3), col3);
 506
 507         cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, size * 64, size);
 508         cairo_t* cr = cairo_create (surface);
 509
 510         for (int i = 0; i < 64; ++i) {
 511                 cairo_save (cr);
 512                 core_draw (cr, i, size, 20, size*i, 0, &bright, &dark);
 513                 cairo_restore (cr);
 514         }
 515
 516         if (cairo_surface_write_to_png (surface, path) != CAIRO_STATUS_SUCCESS) {
 517                 error << string_compose (_("motionfeedback: could not save image set to %1"), path) << endmsg;
 518                 return pixbuf;
 519         }
 520
 521         cairo_destroy (cr);
 522         cairo_surface_destroy (surface);
 523
 524         try {
 525                 pixbuf = Gdk::Pixbuf::create_from_file (path);
 526         } catch (const Gdk::PixbufError &e) {
 527                 error << string_compose (_("motionfeedback: caught PixbufError: %1"), e.what()) << endmsg;
 528         } catch (...) {
 529                 error << _("motionfeedback: unknown exception") << endmsg;
 530         }
 531
 532         g_unlink (path);
 533         g_free (path);
 534
 535         return pixbuf;
 536 }
 537
 538 void
 539 MotionFeedback::core_draw (cairo_t* cr, int phase, double size, double progress_width, double xorigin, double yorigin,
 540                            const GdkColor* bright, const GdkColor* dark)
 541 {
 542         double xc;
 543         double yc;
 544         double start_angle;
 545         double end_angle;
 546         double value_angle;
 547         double value;
 548         double value_x;
 549         double value_y;
 550         double start_angle_x;
 551         double start_angle_y;
 552         double end_angle_x;
 553         double end_angle_y;
 554         double progress_radius;
 555         double progress_radius_inner;
 556         double progress_radius_outer;
 557
 558         g_return_if_fail (cr != NULL);
 559
 560         progress_radius = 40.0;
 561         progress_radius_inner = progress_radius - (progress_width / 2.0);
 562         progress_radius_outer = progress_radius + (progress_width / 2.0);
 563
 564         const double pad = 2.0; /* line width for boundary of progress ring */
 565         const double actual_width = ((2.0 * pad) + (2.0 * progress_radius_outer));
 566         const double scale_factor = size / actual_width;
 567
 568         /* knob center is at middle of the area bounded by (xorigin,yorigin) and (xorigin+size, yorigin+size)
 569            but the coordinates will be scaled by the scale factor when cairo uses them so first
 570            adjust them by the reciprocal of the scale factor.
 571         */
 572
 573         xc = (xorigin + (size / 2.0)) * (1.0/scale_factor);
 574         yc = (yorigin + (size / 2.0)) * (1.0/scale_factor);
 575
 576         value = (phase * 1.0) / (65 - 1);
 577
 578         start_angle = ((180 - 65) * G_PI) / 180;
 579         end_angle = ((360 + 65) * G_PI) / 180;
 580
 581         value_angle = start_angle + (value * (end_angle - start_angle));
 582         value_x = cos (value_angle);
 583         value_y = sin (value_angle);
 584         start_angle_x = cos (start_angle);
 585         start_angle_y = sin (start_angle);
 586         end_angle_x = cos (end_angle);
 587         end_angle_y = sin (end_angle);
 588
 589         cairo_scale (cr, scale_factor, scale_factor);
 590
 591         //dark arc background
 592         cairo_set_source_rgb (cr, 0.3, 0.3, 0.3 );
 593         cairo_set_line_width (cr, progress_width);
 594         cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
 595         cairo_stroke (cr);
 596
 597
 598         float r = (value) * (((float)bright->red)/G_MAXUINT16) + (1.0-value)*(((float)dark->red)/G_MAXUINT16);
 599         float g = (value) * (((float)bright->green)/G_MAXUINT16) + (1.0-value)*(((float)dark->green)/G_MAXUINT16);
 600         float b = (value) * (((float)bright->blue)/G_MAXUINT16) + (1.0-value)*(((float)dark->blue)/G_MAXUINT16);
 601
 602         //colored arc
 603         cairo_set_source_rgb (cr, r,g,b);
 604         cairo_set_line_width (cr, progress_width);
 605         cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle);
 606         cairo_stroke (cr);
 607
 608         //overall shade
 609         cairo_pattern_t* shade_pattern = cairo_pattern_create_linear (0.0, 0.0, 0.0, progress_radius_outer);
 610         cairo_pattern_add_color_stop_rgba (shade_pattern, 0, 1,1,1, 0.3);
 611         cairo_pattern_add_color_stop_rgba (shade_pattern, 1, 1,1,1, 0.0);
 612         cairo_set_source (cr, shade_pattern);
 613         cairo_arc (cr, xc, yc, progress_radius_outer-1, 0, 2.0*G_PI);
 614         cairo_fill (cr);
 615         cairo_pattern_destroy (shade_pattern);
 616
 617         //black border
 618         cairo_set_source_rgb (cr, 0, 0, 0 );
 619         cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 620         cairo_set_line_width (cr, 1.0/scale_factor);
 621         cairo_move_to (cr, xc + (progress_radius_outer * start_angle_x), yc + (progress_radius_outer * start_angle_y));
 622         cairo_line_to (cr, xc + (progress_radius_inner * start_angle_x), yc + (progress_radius_inner * start_angle_y));
 623         cairo_stroke (cr);
 624         cairo_move_to (cr, xc + (progress_radius_outer * end_angle_x), yc + (progress_radius_outer * end_angle_y));
 625         cairo_line_to (cr, xc + (progress_radius_inner * end_angle_x), yc + (progress_radius_inner * end_angle_y));
 626         cairo_stroke (cr);
 627         cairo_arc (cr, xc, yc, progress_radius_outer, start_angle, end_angle);
 628         cairo_stroke (cr);
 629         cairo_arc (cr, xc, yc, progress_radius_inner, start_angle, end_angle);
 630         cairo_stroke (cr);
 631
 632         //knob shadow
 633         cairo_save(cr);
 634         cairo_translate(cr, 6, 6 );
 635         cairo_set_source_rgba (cr, 0,0,0,0.1 );
 636         cairo_arc (cr, xc, yc, progress_radius_inner-1, 0, 2.0*G_PI);
 637         cairo_fill (cr);
 638         cairo_restore(cr);
 639
 640         //inner circle
 641         cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 1 );
 642         cairo_arc (cr, xc, yc, progress_radius_inner-1, 0, 2.0*G_PI);
 643         cairo_fill (cr);
 644
 645         //knob shade
 646         shade_pattern = cairo_pattern_create_linear (0.0, 0.0, 0.0, progress_radius_outer);
 647         cairo_pattern_add_color_stop_rgba (shade_pattern, 0, 1,1,1, 0.5);
 648         cairo_pattern_add_color_stop_rgba (shade_pattern, 1, 0,0,0, 0.3);
 649         cairo_set_source (cr, shade_pattern);
 650         cairo_arc (cr, xc, yc, progress_radius_inner-1, 0, 2.0*G_PI);
 651         cairo_fill (cr);
 652         cairo_pattern_destroy (shade_pattern);
 653
 654         //inner circle
 655         cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 0.5 );
 656         cairo_arc (cr, xc, yc, progress_radius_inner-5, 0, 2.0*G_PI);
 657         cairo_fill (cr);
 658
 659         //line
 660         cairo_save(cr);
 661         cairo_translate(cr, 2, 2 );
 662         cairo_set_source_rgba (cr, 0,0,0,0.5 );
 663         cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 664         cairo_set_line_width (cr, 4);
 665         cairo_move_to (cr, xc + (progress_radius_inner * value_x), yc + (progress_radius_inner * value_y));
 666         cairo_line_to (cr, xc + ((progress_radius_inner*0.4) * value_x), yc + ((progress_radius_inner*0.4) * value_y));
 667         cairo_stroke (cr);
 668         cairo_restore(cr);
 669         cairo_set_source_rgba (cr, 1,1,1,0.7 );
 670         cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 671         cairo_set_line_width (cr, 4.0);
 672         cairo_move_to (cr, xc + (progress_radius_inner * value_x), yc + (progress_radius_inner * value_y));
 673         cairo_line_to (cr, xc + ((progress_radius_inner*0.4) * value_x), yc + ((progress_radius_inner*0.4) * value_y));
 674         cairo_stroke (cr);
 675
 676
 677         //highlight if focused  (damn, this is a cached image which doesn't (yet) have a "focused" state
 678 //      if (pixwin.has_focus()) {
 679 //              cairo_set_source_rgba (cr, 1,1,1, 0.5 );
 680 //              cairo_arc (cr, xc, yc, progress_radius_inner-1, 0, 2.0*G_PI);
 681 //              cairo_fill (cr);
 682 //      }
 683 }
 684
 685 void
 686 MotionFeedback::set_lamp_color (const std::string& str)
 687 {
 688         if (base_color) {
 689                 *base_color = Gdk::Color (str);
 690         } else {
 691                 base_color = new Gdk::Color (str);
 692         }
 693 }