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 <gdk/gdkkeysyms.h>
  29 #include <gtkmm.h>
  30
  31 #include "pbd/controllable.h"
  32
  33 #include "gtkmm2ext/motionfeedback.h"
  34 #include "gtkmm2ext/keyboard.h"
  35 #include "gtkmm2ext/prolooks-helpers.h"
  36 #include "gtkmm2ext/gui_thread.h"
  37
  38 using namespace Gtk;
  39 using namespace Gtkmm2ext;
  40 using namespace sigc;
  41
  42 MotionFeedback::MotionFeedback (Glib::RefPtr<Gdk::Pixbuf> pix,
  43                                 Type t,
  44                                 boost::shared_ptr<PBD::Controllable> c,
  45                                 double default_val,
  46                                 double step_increment,
  47                                 double page_increment,
  48                                 const char *widget_name,
  49                                 bool with_numeric_display,
  50                                 int subw,
  51                                 int subh)
  52         : _controllable (c)
  53         , value (0)
  54         , default_value (default_val)
  55         , step_inc (step_increment)
  56         , page_inc (page_increment)
  57         , type (t)
  58         , value_packer (0)
  59         , pixbuf (pix)
  60         , subwidth (subw)
  61         , subheight (subh)
  62 {
  63         char value_name[1024];
  64
  65         print_func = default_printer;
  66         print_arg = 0;
  67
  68
  69         HBox* hpacker = manage (new HBox);
  70         hpacker->pack_start (pixwin, true, true);
  71         hpacker->show ();
  72         pack_start (*hpacker, false, false);
  73         pixwin.show ();
  74
  75         if (with_numeric_display) {
  76
  77                 value_packer = new EventBox;
  78                 value_packer->set_name ("MotionControllerValue");
  79                 value_packer->show ();
  80                 value_packer->set_border_width (6);
  81
  82                 value = new Label;
  83                 value->set_justify (Gtk::JUSTIFY_RIGHT);
  84                 value->show ();
  85
  86                 value_packer->add (*value);
  87
  88                 hpacker = manage (new HBox);
  89                 hpacker->pack_start (*value_packer, true, false);
  90                 hpacker->show ();
  91
  92                 pack_start (*hpacker, false, false);
  93
  94                 if (widget_name) {
  95                         snprintf (value_name, sizeof(value_name), "%sValue", widget_name);
  96                         value->set_name (value_name);
  97                 }
  98
  99                 if (_controllable) {
 100                         char buf[32];
 101                         print_func (buf, _controllable, print_arg);
 102                         value->set_text (buf);
 103                 }
 104         }
 105
 106         pixwin.set_events (Gdk::BUTTON_PRESS_MASK|
 107                            Gdk::BUTTON_RELEASE_MASK|
 108                            Gdk::POINTER_MOTION_MASK|
 109                            Gdk::ENTER_NOTIFY_MASK|
 110                            Gdk::LEAVE_NOTIFY_MASK|
 111                            Gdk::SCROLL_MASK|
 112                            Gdk::KEY_PRESS_MASK|
 113                            Gdk::KEY_RELEASE_MASK);
 114
 115         pixwin.set_flags (CAN_FOCUS);
 116
 117         /* Proxy all important events on the pixwin to ourselves */
 118
 119         pixwin.signal_button_press_event().connect(mem_fun (*this,&MotionFeedback::pixwin_button_press_event));
 120         pixwin.signal_button_release_event().connect(mem_fun (*this,&MotionFeedback::pixwin_button_release_event));
 121         pixwin.signal_motion_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_motion_notify_event));
 122         pixwin.signal_enter_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_enter_notify_event));
 123         pixwin.signal_leave_notify_event().connect(mem_fun (*this,&MotionFeedback::pixwin_leave_notify_event));
 124         pixwin.signal_key_press_event().connect(mem_fun (*this,&MotionFeedback::pixwin_key_press_event));
 125         pixwin.signal_scroll_event().connect(mem_fun (*this,&MotionFeedback::pixwin_scroll_event));
 126         pixwin.signal_expose_event().connect(mem_fun (*this,&MotionFeedback::pixwin_expose_event), true);
 127         pixwin.signal_size_request().connect(mem_fun (*this,&MotionFeedback::pixwin_size_request));
 128 }
 129
 130 MotionFeedback::~MotionFeedback()
 131 {
 132         delete value;
 133         delete value_packer;
 134 }
 135
 136 bool
 137 MotionFeedback::pixwin_button_press_event (GdkEventButton *ev)
 138 {
 139         if (binding_proxy.button_press_handler (ev)) {
 140                 return true;
 141         }
 142
 143         switch (ev->button) {
 144         case 1:
 145                 grab_is_fine = false;
 146                 break;
 147         case 2:
 148                 grab_is_fine = true;
 149                 break;
 150         case 3:
 151                 return false;
 152         }
 153
 154         gtk_grab_add(GTK_WIDGET(pixwin.gobj()));
 155
 156         grabbed_y = ev->y_root;
 157         grabbed_x = ev->x_root;
 158
 159         return false;
 160 }
 161
 162 bool
 163 MotionFeedback::pixwin_button_release_event (GdkEventButton *ev)
 164 {
 165         if (!_controllable) {
 166                 return false;
 167         }
 168
 169         switch (ev->button) {
 170         case 1:
 171                 if (pixwin.has_grab()) {
 172                         if (!grab_is_fine) {
 173                                 gtk_grab_remove
 174                                         (GTK_WIDGET(pixwin.gobj()));
 175                         }
 176                 }
 177                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 178                         /* shift click back to the default */
 179                         _controllable->set_value (default_value);
 180                         return true;
 181                 }
 182                 break;
 183
 184         case 3:
 185                 if (pixwin.has_grab()) {
 186                         if (grab_is_fine) {
 187                                 gtk_grab_remove
 188                                         (GTK_WIDGET(pixwin.gobj()));
 189                         }
 190                 }
 191                 break;
 192         }
 193
 194         return VBox::on_button_release_event (ev);
 195 }
 196
 197 bool
 198 MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev)
 199 {
 200         if (!_controllable) {
 201                 return false;
 202         }
 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::PrimaryModifier) ? 10 : 1) *
 214                 ((ev->state & Keyboard::SecondaryModifier) ? 0.1 : 1);
 215
 216         if (ev->state & Gdk::BUTTON1_MASK) {
 217
 218                 /* vertical control */
 219
 220                 y_delta = grabbed_y - ev->y_root;
 221                 grabbed_y = ev->y_root;
 222
 223                 x_delta = ev->x_root - grabbed_x;
 224
 225                 if (y_delta == 0) return TRUE;
 226
 227                 y_delta *= 1 + (x_delta/100);
 228                 y_delta *= multiplier;
 229                 y_delta /= 10;
 230
 231                 _controllable->set_value (adjust ((grab_is_fine ? step_inc : page_inc) * y_delta));
 232
 233         } else if (ev->state & Gdk::BUTTON2_MASK) {
 234
 235                 /* rotary control */
 236
 237                 double x = ev->x - subwidth/2;
 238                 double y = - ev->y + subwidth/2;
 239                 double angle = std::atan2 (y, x) / M_PI;
 240
 241                 if (angle < -0.5) {
 242                         angle += 2.0;
 243                 }
 244
 245                 angle = -(2.0/3.0) * (angle - 1.25);
 246                 angle *= multiplier;
 247
 248                 _controllable->set_value (to_control_value (angle));
 249         }
 250
 251
 252         return true;
 253 }
 254
 255 bool
 256 MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing *ev)
 257 {
 258         pixwin.grab_focus();
 259         return false;
 260 }
 261
 262 bool
 263 MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing *ev)
 264 {
 265         pixwin.unset_flags (HAS_FOCUS);
 266         return false;
 267 }
 268
 269 bool
 270 MotionFeedback::pixwin_key_press_event (GdkEventKey *ev)
 271 {
 272         if (!_controllable) {
 273                 return false;
 274         }
 275
 276         bool retval = false;
 277         double multiplier;
 278
 279         multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100.0 : 1.0) *
 280                 ((ev->state & Keyboard::SecondaryModifier) ? 10.0 : 1.0) *
 281                 ((ev->state & Keyboard::PrimaryModifier) ? 2.0 : 1.0);
 282
 283         switch (ev->keyval) {
 284         case GDK_Page_Up:
 285                 retval = true;
 286                 _controllable->set_value (adjust (multiplier * page_inc));
 287                 break;
 288
 289         case GDK_Page_Down:
 290                 retval = true;
 291                 _controllable->set_value (adjust (multiplier * page_inc));
 292                 break;
 293
 294         case GDK_Up:
 295                 retval = true;
 296                 _controllable->set_value (adjust (multiplier * step_inc));
 297                 break;
 298
 299         case GDK_Down:
 300                 retval = true;
 301                 _controllable->set_value (adjust (multiplier * step_inc));
 302                 break;
 303
 304         case GDK_Home:
 305                 retval = true;
 306                 _controllable->set_value (_controllable->lower());
 307                 break;
 308
 309         case GDK_End:
 310                 retval = true;
 311                 _controllable->set_value (_controllable->upper());
 312                 break;
 313         }
 314
 315         return retval;
 316 }
 317
 318 bool
 319 MotionFeedback::pixwin_expose_event (GdkEventExpose* ev)
 320 {
 321         if (!_controllable) {
 322                 return true;
 323         }
 324
 325         GdkWindow *window = pixwin.get_window()->gobj();
 326         double display_val = to_display_value (_controllable->get_value());
 327         int32_t phase = lrint (display_val * 64.0);
 328
 329         // skip middle phase except for true middle value
 330
 331         if (type == Rotary && phase == 32) {
 332                 double pt = (display_val * 2.0) - 1.0;
 333                 if (pt < 0)
 334                         phase = 31;
 335                 if (pt > 0)
 336                         phase = 33;
 337         }
 338
 339         // endless knob: skip 90deg highlights unless the value is really a multiple of 90deg
 340
 341         if (type == Endless && !(phase % 16)) {
 342                 if (phase == 64) {
 343                         phase = 0;
 344                 }
 345
 346                 double nom = phase / 64.0;
 347                 double diff = display_val - nom;
 348
 349                 if (diff > 0.0001)
 350                         phase = (phase + 1) % 64;
 351                 if (diff < -0.0001)
 352                         phase = (phase + 63) % 64;
 353         }
 354
 355         phase = std::min (phase, (int32_t) 63);
 356
 357         GtkWidget* widget = GTK_WIDGET(pixwin.gobj());
 358         gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0],
 359                          pixbuf->gobj(),
 360                          phase * subwidth, type * subheight,
 361                          /* center image in allocated area */
 362                          (get_width() - subwidth)/2,
 363                          0,
 364                          subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0);
 365
 366         return true;
 367 }
 368
 369 bool
 370 MotionFeedback::pixwin_scroll_event (GdkEventScroll* ev)
 371 {
 372         double scale;
 373
 374         if (!_controllable) {
 375                 return false;
 376         }
 377
 378         if ((ev->state & (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier)) == (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier)) {
 379                 scale = 0.01;
 380         } else if (ev->state & Keyboard::PrimaryModifier) {
 381                 scale = 0.1;
 382         } else {
 383                 scale = 1.0;
 384         }
 385
 386         switch (ev->direction) {
 387         case GDK_SCROLL_UP:
 388         case GDK_SCROLL_RIGHT:
 389                 _controllable->set_value (adjust (scale * step_inc));
 390                 break;
 391
 392         case GDK_SCROLL_DOWN:
 393         case GDK_SCROLL_LEFT:
 394                 _controllable->set_value (adjust (-scale * step_inc));
 395                 break;
 396         }
 397
 398         return true;
 399 }
 400
 401 void
 402 MotionFeedback::pixwin_size_request (GtkRequisition* req)
 403 {
 404         req->width = subwidth;
 405         req->height = subheight;
 406 }
 407
 408
 409 void
 410 MotionFeedback::controllable_value_changed ()
 411 {
 412         if (value) {
 413                 char buf[32];
 414                 print_func (buf, _controllable, print_arg);
 415                 value->set_text (buf);
 416         }
 417
 418         pixwin.queue_draw ();
 419 }
 420
 421 void
 422 MotionFeedback::set_controllable (boost::shared_ptr<PBD::Controllable> c)
 423 {
 424         _controllable = c;
 425         binding_proxy.set_controllable (c);
 426         controller_connection.disconnect ();
 427
 428         if (c) {
 429                 c->Changed.connect (controller_connection, MISSING_INVALIDATOR, boost::bind (&MotionFeedback::controllable_value_changed, this), gui_context());
 430
 431                 char buf[32];
 432                 print_func (buf, _controllable, print_arg);
 433                 value->set_text (buf);
 434         }
 435
 436         pixwin.queue_draw ();
 437 }
 438
 439 boost::shared_ptr<PBD::Controllable>
 440 MotionFeedback::controllable () const
 441 {
 442         return _controllable;
 443 }
 444
 445 void
 446 MotionFeedback::default_printer (char buf[32], const boost::shared_ptr<PBD::Controllable>& c, void *)
 447 {
 448         if (c) {
 449                 sprintf (buf, "%.2f", c->get_value());
 450         } else {
 451                 buf[0] = '\0';
 452         }
 453 }
 454
 455 Glib::RefPtr<Gdk::Pixbuf>
 456 MotionFeedback::render_pixbuf (int size)
 457 {
 458         Glib::RefPtr<Gdk::Pixbuf> pixbuf;
 459         char path[32];
 460         int fd;
 461
 462         snprintf (path, sizeof (path), "/tmp/mfimg%dXXXXXX", size);
 463
 464         if ((fd = mkstemp (path)) < 0) {
 465                 return pixbuf;
 466         }
 467
 468         GdkColor col2 = {0,0,0,0};
 469         GdkColor col3 = {0,0,0,0};
 470         Gdk::Color base ("#b9feff");
 471         GdkColor dark;
 472         GdkColor bright;
 473         ProlooksHSV* hsv;
 474
 475         hsv = prolooks_hsv_new_for_gdk_color (base.gobj());
 476         bright = (prolooks_hsv_to_gdk_color (hsv, &col2), col2);
 477         prolooks_hsv_set_saturation (hsv, 0.66);
 478         prolooks_hsv_set_value (hsv, 0.67);
 479         dark = (prolooks_hsv_to_gdk_color (hsv, &col3), col3);
 480
 481         cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, size * 64, size);
 482         cairo_t* cr = cairo_create (surface);
 483
 484         for (int i = 0; i < 64; ++i) {
 485                 cairo_save (cr);
 486                 core_draw (cr, i, size, 20, size*i, 0, &bright, &dark);
 487                 cairo_restore (cr);
 488         }
 489
 490         if (cairo_surface_write_to_png (surface, path) != CAIRO_STATUS_SUCCESS) {
 491                 std::cerr << "could not save image set to " << path << std::endl;
 492                 return pixbuf;
 493         }
 494
 495         close (fd);
 496
 497         cairo_destroy (cr);
 498         cairo_surface_destroy (surface);
 499
 500         try {
 501                 pixbuf = Gdk::Pixbuf::create_from_file (path);
 502         } catch (const Gdk::PixbufError &e) {
 503                 std::cerr << "Caught PixbufError: " << e.what() << std::endl;
 504                 unlink (path);
 505                 throw;
 506         } catch (...) {
 507                 unlink (path);
 508                 g_message("Caught ... ");
 509                 throw;
 510         }
 511
 512         unlink (path);
 513
 514         return pixbuf;
 515 }
 516
 517 void
 518 MotionFeedback::core_draw (cairo_t* cr, int phase, double size, double progress_width, double xorigin, double yorigin,
 519                            const GdkColor* bright, const GdkColor* dark)
 520 {
 521         double xc;
 522         double yc;
 523         double start_angle;
 524         double end_angle;
 525         double value_angle;
 526         double value;
 527         double value_x;
 528         double value_y;
 529         double start_angle_x;
 530         double start_angle_y;
 531         double end_angle_x;
 532         double end_angle_y;
 533         double progress_radius;
 534         double progress_radius_inner;
 535         double progress_radius_outer;
 536         double knob_disc_radius;
 537         cairo_pattern_t* pattern;
 538         double progress_rim_width;
 539         cairo_pattern_t* progress_shine;
 540         double degrees;
 541         cairo_pattern_t* knob_ripples;
 542         double pxs;
 543         double pys;
 544
 545         g_return_if_fail (cr != NULL);
 546
 547         progress_radius = 40.0;
 548         progress_radius_inner = progress_radius - (progress_width / 2.0);
 549         progress_radius_outer = progress_radius + (progress_width / 2.0);
 550         knob_disc_radius = progress_radius_inner - 5.0;
 551
 552         const double pad = 2.0; /* line width for boundary of progress ring */
 553         const double actual_width = ((2.0 * pad) + (2.0 * progress_radius_outer));
 554         const double scale_factor = size / actual_width;
 555
 556         /* knob center is at middle of the area bounded by (xorigin,yorigin) and (xorigin+size, yorigin+size)
 557            but the coordinates will be scaled by the scale factor when cairo uses them so first
 558            adjust them by the reciprocal of the scale factor.
 559         */
 560
 561         xc = (xorigin + (size / 2.0)) * (1.0/scale_factor);
 562         yc = (yorigin + (size / 2.0)) * (1.0/scale_factor);
 563
 564         pxs = xorigin * (1.0/scale_factor);
 565         pys = yorigin * (1.0/scale_factor);
 566
 567         start_angle = 0.0;
 568         end_angle = 0.0;
 569         value_angle = 0.0;
 570         value = (phase * 1.0) / (65 - 1);
 571
 572         start_angle = ((180 - 65) * G_PI) / 180;
 573         end_angle = ((360 + 65) * G_PI) / 180;
 574
 575         value_angle = start_angle + (value * (end_angle - start_angle));
 576         value_x = cos (value_angle);
 577         value_y = sin (value_angle);
 578         start_angle_x = cos (start_angle);
 579         start_angle_y = sin (start_angle);
 580         end_angle_x = cos (end_angle);
 581         end_angle_y = sin (end_angle);
 582
 583         cairo_scale (cr, scale_factor, scale_factor);
 584
 585         pattern = prolooks_create_gradient_str (pxs + 32.0, pys + 16.0, pxs + 75.0, pys + 16.0, "#d4c8b9", "#ae977b", 1.0, 1.0);
 586         cairo_set_source (cr, pattern);
 587         cairo_pattern_destroy (pattern);
 588         cairo_set_line_width (cr, 2.0);
 589         cairo_arc (cr, xc, yc, 31.5, 0.0, 2 * G_PI);
 590         cairo_stroke (cr);
 591
 592         pattern = prolooks_create_gradient_str (pxs + 20.0, pys + 20.0, pxs + 89.0, pys + 87.0, "#2f2f4c", "#090a0d", 1.0, 1.0);
 593         cairo_set_source (cr, pattern);
 594         cairo_pattern_destroy (pattern);
 595         cairo_set_line_width (cr, progress_width);
 596         cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
 597         cairo_stroke (cr);
 598
 599         pattern = prolooks_create_gradient (pxs + 20.0, pys + 20.0, pxs + 89.0, pys + 87.0, bright, dark, 1.0, 1.0);
 600         cairo_set_source (cr, pattern);
 601         cairo_pattern_destroy (pattern);
 602         cairo_set_line_width (cr, progress_width);
 603         cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle);
 604         cairo_stroke (cr);
 605
 606         cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 607         progress_rim_width = 2.0;
 608         cairo_set_line_width (cr, progress_rim_width);
 609         pattern = prolooks_create_gradient_str (pxs + 18.0, pys + 79.0, pxs + 35.0, pys + 79.0, "#dfd5c9", "#dfd5c9", 1.0, 0.0);
 610         cairo_set_source (cr, pattern);
 611         cairo_pattern_destroy (pattern);
 612         cairo_move_to (cr, xc + (progress_radius_outer * start_angle_x), yc + (progress_radius_outer * start_angle_y));
 613         cairo_line_to (cr, xc + (progress_radius_inner * start_angle_x), yc + (progress_radius_inner * start_angle_y));
 614         cairo_stroke (cr);
 615
 616         prolooks_set_source_color_string (cr, "#000000", 1.0);
 617         cairo_move_to (cr, xc + (progress_radius_outer * end_angle_x), yc + (progress_radius_outer * end_angle_y));
 618         cairo_line_to (cr, xc + (progress_radius_inner * end_angle_x), yc + (progress_radius_inner * end_angle_y));
 619         cairo_stroke (cr);
 620
 621         // pattern = prolooks_create_gradient_str (95.0, 6.0, 5.0, 44.0, "#dfd5c9", "#b0a090", 1.0, 1.0);
 622         pattern = prolooks_create_gradient_str (pxs + 95.0, pys + 6.0, pxs + 5.0, pys + 44.0, "#000000", "#000000", 1.0, 1.0);
 623         cairo_set_source (cr, pattern);
 624         cairo_pattern_destroy (pattern);
 625         cairo_arc (cr, xc, yc, progress_radius_outer, start_angle, end_angle);
 626         cairo_stroke (cr);
 627
 628         cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
 629         pattern = prolooks_create_gradient (pxs + 20.0, pys + 20.0, pxs + 89.0, pys + 87.0, bright, dark, 0.25, 0.25);
 630         cairo_set_source (cr, pattern);
 631         cairo_pattern_destroy (pattern);
 632         cairo_set_line_width (cr, progress_width);
 633         cairo_arc (cr, xc, yc, progress_radius, start_angle, value_angle + (G_PI / 180.0));
 634         cairo_stroke (cr);
 635
 636         progress_shine = prolooks_create_gradient_str (pxs + 89.0, pys + 73.0, pxs + 34.0, pys + 16.0, "#ffffff", "#ffffff", 0.3, 0.04);
 637         cairo_pattern_add_color_stop_rgba (progress_shine, 0.5, 1.0, 1.0, 1.0, 0.0);
 638         if (size > 50) {
 639                 cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.3);
 640         } else {
 641                 cairo_pattern_add_color_stop_rgba (progress_shine, 0.75, 1.0, 1.0, 1.0, 0.2);
 642         }
 643         cairo_set_source (cr, progress_shine);
 644         cairo_set_line_width (cr, progress_width);
 645         cairo_arc (cr, xc, yc, progress_radius, start_angle, end_angle);
 646         cairo_stroke (cr);
 647         cairo_pattern_destroy (progress_shine);
 648
 649         cairo_set_line_width (cr, 1.0);
 650         cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 651         cairo_arc (cr, xc, yc, progress_radius_inner, 0.0, 2 * G_PI);
 652         pattern = prolooks_create_gradient_str (pxs + 35.0, pys + 31.0, pxs + 75.0, pys + 72.0, "#68625c", "#44494b", 1.0, 1.0);
 653         cairo_set_source (cr, pattern);
 654         cairo_pattern_destroy (pattern);
 655         cairo_fill (cr);
 656         cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 657         cairo_arc (cr, xc, yc, progress_radius_inner, 0.0, 2 * G_PI);
 658         cairo_stroke (cr);
 659
 660         pattern = prolooks_create_gradient_str (pxs + 42.0, pys + 34.0, pxs + 68.0, pys + 70.0, "#e7ecef", "#9cafb8", 1.0, 1.0);
 661         cairo_set_source (cr, pattern);
 662         cairo_pattern_destroy (pattern);
 663         cairo_arc (cr, xc, yc, knob_disc_radius, 0.0, 2 * G_PI);
 664         cairo_fill (cr);
 665
 666         cairo_set_line_width (cr, 2.0);
 667         degrees = G_PI / 180.0;
 668         pattern = prolooks_create_gradient_str (pxs + 38.0, pys + 34.0, pxs + 70.0, pys + 68.0, "#ffffff", "#caddf2", 0.2, 0.2);
 669         cairo_set_source (cr, pattern);
 670         cairo_pattern_destroy (pattern);
 671         cairo_move_to (cr, xc, yc);
 672         cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-154) * degrees, (-120) * degrees);
 673         cairo_move_to (cr, xc, yc);
 674         cairo_arc (cr, xc, yc, knob_disc_radius - 1, (G_PI / 2.0) - (60 * degrees), (G_PI / 2.0) - (29 * degrees));
 675         cairo_fill (cr);
 676
 677         pattern = prolooks_create_gradient_str (pxs + 50.0, pys + 40.0, pxs + 62.0, pys + 60.0, "#a1adb6", "#47535c", 0.07, 0.15);
 678         cairo_set_source (cr, pattern);
 679         cairo_pattern_destroy (pattern);
 680         cairo_move_to (cr, xc, yc);
 681         cairo_arc (cr, xc, yc, knob_disc_radius - 1, (-67) * degrees, (-27) * degrees);
 682         cairo_move_to (cr, xc, yc);
 683         cairo_arc (cr, xc, yc, knob_disc_radius - 1, G_PI - (67 * degrees), G_PI - (27 * degrees));
 684         cairo_fill (cr);
 685
 686         knob_ripples = cairo_pattern_create_radial (xc, yc, 0.0, xc, yc, 4.0);
 687         prolooks_add_color_stop_str (knob_ripples, 0.0, "#e7ecef", 0.05);
 688         prolooks_add_color_stop_str (knob_ripples, 0.5, "#58717d", 0.05);
 689         prolooks_add_color_stop_str (knob_ripples, 0.75, "#d1d9de", 0.05);
 690         prolooks_add_color_stop_str (knob_ripples, 1.0, "#5d7682", 0.05);
 691         cairo_pattern_set_extend (knob_ripples, CAIRO_EXTEND_REPEAT);
 692         cairo_set_line_width (cr, 0.0);
 693         cairo_set_source (cr, knob_ripples);
 694         cairo_arc (cr, xc, yc, knob_disc_radius, 0.0, 2 * G_PI);
 695         cairo_fill (cr);
 696
 697         cairo_save (cr);
 698         cairo_translate (cr, xc + (knob_disc_radius * value_x), yc + (knob_disc_radius * value_y));
 699         cairo_rotate (cr, value_angle - G_PI);
 700         pattern = prolooks_create_gradient_str (pxs + 16.0, pys + -2.0, pxs + 9.0, pys + 13.0, "#e7ecef", "#9cafb8", 0.8, 0.8);
 701         cairo_set_source (cr, pattern);
 702         cairo_pattern_destroy (pattern);
 703         cairo_move_to (cr, 0.0, 4.0);
 704         cairo_line_to (cr, 17.0, 4.0);
 705         cairo_curve_to (cr, 19.0, 4.0, 21.0, 2.0, 21.0, 0.0);
 706         cairo_curve_to (cr, 21.0, -2.0, 19.0, -4.0, 17.0, -4.0);
 707         cairo_line_to (cr, 0.0, -4.0);
 708         cairo_close_path (cr);
 709         cairo_fill (cr);
 710
 711         pattern = prolooks_create_gradient_str (pxs + 9.0, pys + -2.0, pxs + 9.0, pys + 2.0, "#68625c", "#44494b", 1.0, 1.0);
 712         cairo_set_source (cr, pattern);
 713         cairo_pattern_destroy (pattern);
 714         cairo_move_to (cr, 0.0, 2.0);
 715         cairo_line_to (cr, 16.0, 2.0);
 716         cairo_curve_to (cr, 17.0, 2.0, 18.0, 1.0, 18.0, 0.0);
 717         cairo_curve_to (cr, 18.0, -1.0, 17.0, -2.0, 16.0, -2.0);
 718         cairo_line_to (cr, 0.0, -2.0);
 719         cairo_close_path (cr);
 720         cairo_fill (cr);
 721
 722         cairo_restore (cr);
 723         cairo_set_line_width (cr, 2.0);
 724         pattern = prolooks_create_gradient_str (pxs + 38.0, pys + 32.0, pxs + 70.0, pys + 67.0, "#3d3d3d", "#000000", 1.0, 1.0);
 725         cairo_set_source (cr, pattern);
 726         cairo_pattern_destroy (pattern);
 727         cairo_arc (cr, xc, yc, knob_disc_radius, 0.0, 2 * G_PI);
 728         cairo_stroke (cr);
 729
 730         cairo_pattern_destroy (knob_ripples);
 731 }