libs/gtkmm2ext/pixfader.cc

   1 /*
   2     Copyright (C) 2006 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: fastmeter.h 570 2006-06-07 21:21:21Z sampo $
  19 */
  20
  21
  22 #include <iostream>
  23
  24 #include "gtkmm2ext/pixfader.h"
  25 #include "gtkmm2ext/keyboard.h"
  26 #include "gtkmm2ext/rgb_macros.h"
  27 #include "gtkmm2ext/utils.h"
  28
  29 using namespace Gtkmm2ext;
  30 using namespace Gtk;
  31 using namespace std;
  32
  33 #define CORNER_RADIUS 4
  34 #define FADER_RESERVE (2*CORNER_RADIUS)
  35
  36 std::list<PixFader::FaderImage*> PixFader::_patterns;
  37
  38 PixFader::PixFader (Gtk::Adjustment& adj, int orientation, int fader_length, int fader_girth)
  39         : adjustment (adj)
  40         , span (fader_length)
  41         , girth (fader_girth)
  42         , _orien (orientation)
  43         , pattern (0)
  44         , _hovering (false)
  45         , last_drawn (-1)
  46         , dragging (false)
  47 {
  48         default_value = adjustment.get_value();
  49         update_unity_position ();
  50
  51         add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK|Gdk::SCROLL_MASK|Gdk::ENTER_NOTIFY_MASK|Gdk::LEAVE_NOTIFY_MASK);
  52
  53         adjustment.signal_value_changed().connect (mem_fun (*this, &PixFader::adjustment_changed));
  54         adjustment.signal_changed().connect (mem_fun (*this, &PixFader::adjustment_changed));
  55 }
  56
  57 PixFader::~PixFader ()
  58 {
  59 }
  60
  61 cairo_pattern_t*
  62 PixFader::find_pattern (double afr, double afg, double afb,
  63                         double abr, double abg, double abb,
  64                         int w, int h)
  65 {
  66         for (list<FaderImage*>::iterator f = _patterns.begin(); f != _patterns.end(); ++f) {
  67                 if ((*f)->matches (afr, afg, afb, abr, abg, abb, w, h)) {
  68                         return (*f)->pattern;
  69                 }
  70         }
  71         return 0;
  72 }
  73
  74 void
  75 PixFader::create_patterns ()
  76 {
  77         Gdk::Color c = get_style()->get_fg (get_state());
  78         float fr, fg, fb;
  79         float br, bg, bb;
  80
  81         fr = c.get_red_p ();
  82         fg = c.get_green_p ();
  83         fb = c.get_blue_p ();
  84
  85         c = get_style()->get_bg (get_state());
  86
  87         br = c.get_red_p ();
  88         bg = c.get_green_p ();
  89         bb = c.get_blue_p ();
  90
  91         cairo_surface_t* surface;
  92         cairo_t* tc = 0;
  93         float radius = CORNER_RADIUS;
  94
  95         double w = get_width();
  96
  97         if ((pattern = find_pattern (fr, fg, fb, br, bg, bb, get_width(), get_height())) != 0) {
  98                 /* found it - use it */
  99                 return;
 100         }
 101
 102         if (_orien == VERT) {
 103
 104                 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, get_width(), get_height() * 2.0);
 105                 tc = cairo_create (surface);
 106
 107                 /* paint background + border */
 108
 109                 cairo_pattern_t* shade_pattern = cairo_pattern_create_linear (0.0, 0.0, get_width(), 0);
 110                 cairo_pattern_add_color_stop_rgba (shade_pattern, 0, br*0.8,bg*0.8,bb*0.8, 1.0);
 111                 cairo_pattern_add_color_stop_rgba (shade_pattern, 1, br*0.6,bg*0.6,bb*0.6, 1.0);
 112                 cairo_set_source (tc, shade_pattern);
 113                 cairo_rectangle (tc, 0, 0, get_width(), get_height() * 2.0);
 114                 cairo_fill (tc);
 115
 116                 cairo_pattern_destroy (shade_pattern);
 117
 118                 /* paint lower shade */
 119
 120                 w -= 2.0;
 121
 122                 shade_pattern = cairo_pattern_create_linear (0.0, 0.0, w, 0);
 123                 cairo_pattern_add_color_stop_rgba (shade_pattern, 0, fr*0.8,fg*0.8,fb*0.8, 1.0);
 124                 cairo_pattern_add_color_stop_rgba (shade_pattern, 1, fr*0.6,fg*0.6,fb*0.6, 1.0);
 125                 cairo_set_source (tc, shade_pattern);
 126                 Gtkmm2ext::rounded_top_half_rectangle (tc, 1.0, get_height(), w, get_height(), radius-1.5);
 127                 cairo_fill (tc);
 128
 129                 cairo_pattern_destroy (shade_pattern);
 130
 131                 pattern = cairo_pattern_create_for_surface (surface);
 132
 133         } else {
 134
 135                 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, get_width() * 2.0, get_height());
 136                 tc = cairo_create (surface);
 137
 138                 /* paint right shade (background section)*/
 139
 140                 cairo_pattern_t* shade_pattern = cairo_pattern_create_linear (0.0, 0.0, 0.0, get_height());
 141                 cairo_pattern_add_color_stop_rgba (shade_pattern, 0, br*0.8,bg*0.8,bb*0.8, 1.0);
 142                 cairo_pattern_add_color_stop_rgba (shade_pattern, 1, br*0.6,bg*0.6,bb*0.6, 1.0);
 143                 cairo_set_source (tc, shade_pattern);
 144                 cairo_rectangle (tc, 0, 0, get_width() * 2.0, get_height());
 145                 cairo_fill (tc);
 146
 147                 /* paint left shade (active section/foreground) */
 148
 149                 shade_pattern = cairo_pattern_create_linear (0.0, 0.0, 0.0, get_height());
 150                 cairo_pattern_add_color_stop_rgba (shade_pattern, 0, fr*0.8,fg*0.8,fb*0.8, 1.0);
 151                 cairo_pattern_add_color_stop_rgba (shade_pattern, 1, fr*0.6,fg*0.6,fb*0.6, 1.0);
 152                 cairo_set_source (tc, shade_pattern);
 153                 Gtkmm2ext::rounded_right_half_rectangle (tc, 0, 1, get_width(), get_height() - 2.0, radius-1.5);
 154                 cairo_fill (tc);
 155                 cairo_pattern_destroy (shade_pattern);
 156
 157                 pattern = cairo_pattern_create_for_surface (surface);
 158         }
 159
 160         /* cache it for others to use */
 161
 162         _patterns.push_back (new FaderImage (pattern, fr, fg, fb, br, bg, bb, get_width(), get_height()));
 163
 164         cairo_destroy (tc);
 165         cairo_surface_destroy (surface);
 166
 167         if ( !_text.empty()) {
 168                 _layout->get_pixel_size (_text_width, _text_height);
 169         } else {
 170                 _text_width = 0;
 171                 _text_height = 0;
 172         }
 173
 174         c = get_style()->get_text (get_state());
 175
 176         text_r = c.get_red_p ();
 177         text_g = c.get_green_p ();
 178         text_b = c.get_blue_p ();
 179 }
 180
 181 bool
 182 PixFader::on_expose_event (GdkEventExpose* ev)
 183 {
 184         Cairo::RefPtr<Cairo::Context> context = get_window()->create_cairo_context();
 185         cairo_t* cr = context->cobj();
 186
 187         cairo_rectangle (cr, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
 188         cairo_clip (cr);
 189
 190         if (!pattern) {
 191                 create_patterns();
 192         }
 193
 194         int ds = display_span ();
 195         float w = get_width();
 196         float h = get_height();
 197
 198         cairo_matrix_t matrix;
 199
 200         if (_orien == VERT) {
 201
 202                 if (ds > h - FADER_RESERVE) {
 203                         ds = h - FADER_RESERVE;
 204                 }
 205
 206                 cairo_set_source (cr, pattern);
 207                 cairo_matrix_init_translate (&matrix, 0, (h - ds));
 208                 cairo_pattern_set_matrix (pattern, &matrix);
 209                 Gtkmm2ext::rounded_rectangle (cr, 0, 0, w, h, CORNER_RADIUS-1.5);
 210                 cairo_fill (cr);
 211
 212         } else {
 213
 214                 if (ds < FADER_RESERVE) {
 215                         ds = FADER_RESERVE;
 216                 }
 217
 218                 /*
 219                   if ds == w, the pattern does not need to be translated
 220                   if ds == 0 (or FADER_RESERVE), the pattern needs to be moved
 221                       w to the left, which is -w in pattern space, and w in
 222                       user space
 223                   if ds == 10, then the pattern needs to be moved w - 10
 224                       to the left, which is -(w-10) in pattern space, which
 225                       is (w - 10) in user space
 226
 227                   thus: translation = (w - ds)
 228                  */
 229
 230                 cairo_set_source (cr, pattern);
 231                 cairo_matrix_init_translate (&matrix, w - ds, 0);
 232                 cairo_pattern_set_matrix (pattern, &matrix);
 233                 Gtkmm2ext::rounded_rectangle (cr, 0, 0, w, h, CORNER_RADIUS-1.5);
 234                 cairo_fill (cr);
 235         }
 236
 237         /* draw the unity-position line if it's not at either end*/
 238         if (unity_loc > 0) {
 239                 if ( _orien == VERT) {
 240                         if (unity_loc < h ) {
 241                                         context->set_line_width (1);
 242                                         context->set_source_rgb (0.0, 1.0, 0.0);
 243                                         context->move_to (1, unity_loc);
 244                                         context->line_to (girth - 2.0, unity_loc);
 245                                         context->stroke ();
 246                         }
 247                 } else {
 248                         if ( unity_loc < w ){
 249                                 context->set_line_width (1);
 250                                 context->set_source_rgb (0.0, 1.0, 0.0);
 251                                 context->move_to (unity_loc, 1);
 252                                 context->line_to (unity_loc, girth - 2.0);
 253                                 context->stroke ();
 254                         }
 255                 }
 256         }
 257
 258         if ( !_text.empty() ) {
 259
 260                 cairo_new_path (cr);
 261
 262                 /* center text */
 263                 cairo_move_to (cr, (get_width() - _text_width)/2.0, get_height()/2.0 - _text_height/2.0);
 264
 265                 cairo_set_source_rgba (cr, text_r, text_g, text_b, 0.9);
 266                 pango_cairo_show_layout (cr, _layout->gobj());
 267         }
 268
 269 //      if (Config->get_widget_prelight()) {  //pixfader does not have access to config
 270                 if (_hovering) {
 271                         Gtkmm2ext::rounded_rectangle (cr, 0, 0, get_width(), get_height(), 3);
 272                         cairo_set_source_rgba (cr, 0.905, 0.917, 0.925, 0.1);
 273                         cairo_fill (cr);
 274                 }
 275 //      }
 276
 277         last_drawn = ds;
 278
 279         return true;
 280 }
 281
 282 void
 283 PixFader::on_size_request (GtkRequisition* req)
 284 {
 285         if (_orien == VERT) {
 286                 req->width = girth;
 287                 req->height = span;
 288         } else {
 289                 req->height = girth;
 290                 req->width = span;
 291         }
 292 }
 293
 294 void
 295 PixFader::on_size_allocate (Gtk::Allocation& alloc)
 296 {
 297         DrawingArea::on_size_allocate(alloc);
 298
 299         if (_orien == VERT) {
 300                 girth = alloc.get_width ();
 301                 span = alloc.get_height ();
 302         } else {
 303                 girth = alloc.get_height ();
 304                 span = alloc.get_width ();
 305         }
 306
 307         update_unity_position ();
 308
 309         if (is_realized()) {
 310                 create_patterns();
 311                 queue_draw ();
 312         }
 313 }
 314
 315 bool
 316 PixFader::on_button_press_event (GdkEventButton* ev)
 317 {
 318         if (ev->type != GDK_BUTTON_PRESS) {
 319                 return true;
 320         }
 321
 322         if (ev->button != 1 && ev->button != 2) {
 323                 return false;
 324         }
 325
 326         add_modal_grab ();
 327         grab_loc = (_orien == VERT) ? ev->y : ev->x;
 328         grab_start = (_orien == VERT) ? ev->y : ev->x;
 329         grab_window = ev->window;
 330         dragging = true;
 331         gdk_pointer_grab(ev->window,false,
 332                         GdkEventMask( Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK |Gdk::BUTTON_RELEASE_MASK),
 333                         NULL,NULL,ev->time);
 334
 335         if (ev->button == 2) {
 336                 set_adjustment_from_event (ev);
 337         }
 338
 339         return true;
 340 }
 341
 342 bool
 343 PixFader::on_button_release_event (GdkEventButton* ev)
 344 {
 345         double const ev_pos = (_orien == VERT) ? ev->y : ev->x;
 346
 347         switch (ev->button) {
 348         case 1:
 349                 if (dragging) {
 350                         remove_modal_grab();
 351                         dragging = false;
 352                         gdk_pointer_ungrab (GDK_CURRENT_TIME);
 353
 354                         if (!_hovering) {
 355                                 Keyboard::magic_widget_drop_focus();
 356                                 queue_draw ();
 357                         }
 358
 359                         if (ev_pos == grab_start) {
 360
 361                                 /* no motion - just a click */
 362
 363                                 if (ev->state & Keyboard::TertiaryModifier) {
 364                                         adjustment.set_value (default_value);
 365                                 } else if (ev->state & Keyboard::GainFineScaleModifier) {
 366                                         adjustment.set_value (adjustment.get_lower());
 367                                 } else if ((_orien == VERT && ev_pos < display_span()) || (_orien == HORIZ && ev_pos > display_span())) {
 368                                         /* above the current display height, remember X Window coords */
 369                                         adjustment.set_value (adjustment.get_value() + adjustment.get_step_increment());
 370                                 } else {
 371                                         adjustment.set_value (adjustment.get_value() - adjustment.get_step_increment());
 372                                 }
 373                         }
 374                         return true;
 375                 }
 376                 break;
 377
 378         case 2:
 379                 if (dragging) {
 380                         remove_modal_grab();
 381                         dragging = false;
 382                         set_adjustment_from_event (ev);
 383                         gdk_pointer_ungrab (GDK_CURRENT_TIME);
 384                         return true;
 385                 }
 386                 break;
 387
 388         default:
 389                 break;
 390         }
 391
 392         return false;
 393 }
 394
 395 bool
 396 PixFader::on_scroll_event (GdkEventScroll* ev)
 397 {
 398         double scale;
 399         bool ret = false;
 400
 401         if (ev->state & Keyboard::GainFineScaleModifier) {
 402                 if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 403                         scale = 0.01;
 404                 } else {
 405                         scale = 0.05;
 406                 }
 407         } else {
 408                 scale = 0.25;
 409         }
 410
 411         if (_orien == VERT) {
 412
 413                 /* should left/right scroll affect vertical faders ? */
 414
 415                 switch (ev->direction) {
 416
 417                 case GDK_SCROLL_UP:
 418                         adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 419                         ret = true;
 420                         break;
 421                 case GDK_SCROLL_DOWN:
 422                         adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 423                         ret = true;
 424                         break;
 425                 default:
 426                         break;
 427                 }
 428         } else {
 429
 430                 /* up/down scrolls should definitely affect horizontal faders
 431                    because they are so much easier to use
 432                 */
 433
 434                 switch (ev->direction) {
 435
 436                 case GDK_SCROLL_RIGHT:
 437                 case GDK_SCROLL_UP:
 438                         adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 439                         ret = true;
 440                         break;
 441                 case GDK_SCROLL_LEFT:
 442                 case GDK_SCROLL_DOWN:
 443                         adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 444                         ret = true;
 445                         break;
 446                 default:
 447                         break;
 448                 }
 449         }
 450         return ret;
 451 }
 452
 453 bool
 454 PixFader::on_motion_notify_event (GdkEventMotion* ev)
 455 {
 456         if (dragging) {
 457                 double scale = 1.0;
 458                 double const ev_pos = (_orien == VERT) ? ev->y : ev->x;
 459
 460                 if (ev->window != grab_window) {
 461                         grab_loc = ev_pos;
 462                         grab_window = ev->window;
 463                         return true;
 464                 }
 465
 466                 if (ev->state & Keyboard::GainFineScaleModifier) {
 467                         if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 468                                 scale = 0.05;
 469                         } else {
 470                                 scale = 0.1;
 471                         }
 472                 }
 473
 474                 double const delta = ev_pos - grab_loc;
 475                 grab_loc = ev_pos;
 476
 477                 double fract = (delta / span);
 478
 479                 fract = min (1.0, fract);
 480                 fract = max (-1.0, fract);
 481
 482                 // X Window is top->bottom for 0..Y
 483
 484                 if (_orien == VERT) {
 485                         fract = -fract;
 486                 }
 487
 488                 adjustment.set_value (adjustment.get_value() + scale * fract * (adjustment.get_upper() - adjustment.get_lower()));
 489         }
 490
 491         return true;
 492 }
 493
 494 void
 495 PixFader::adjustment_changed ()
 496 {
 497         if (display_span() != last_drawn) {
 498                 queue_draw ();
 499         }
 500 }
 501
 502 /** @return pixel offset of the current value from the right or bottom of the fader */
 503 int
 504 PixFader::display_span ()
 505 {
 506         float fract = (adjustment.get_value () - adjustment.get_lower()) / ((adjustment.get_upper() - adjustment.get_lower()));
 507         int ds;
 508         if (_orien == VERT) {
 509                 ds = (int)floor ( span * (1.0 - fract));
 510         } else {
 511                 ds = (int)floor (span * fract);
 512         }
 513
 514         return ds;
 515 }
 516
 517 void
 518 PixFader::set_fader_length (int l)
 519 {
 520         span = l;
 521         update_unity_position ();
 522         queue_resize ();
 523 }
 524
 525 void
 526 PixFader::update_unity_position ()
 527 {
 528         if (_orien == VERT) {
 529                 unity_loc = (int) rint (span * (1 - (default_value / (adjustment.get_upper() - adjustment.get_lower())))) - 1;
 530         } else {
 531                 unity_loc = (int) rint (default_value * span / (adjustment.get_upper() - adjustment.get_lower()));
 532         }
 533
 534         queue_draw ();
 535 }
 536
 537 bool
 538 PixFader::on_enter_notify_event (GdkEventCrossing*)
 539 {
 540         _hovering = true;
 541         Keyboard::magic_widget_grab_focus ();
 542         queue_draw ();
 543         return false;
 544 }
 545
 546 bool
 547 PixFader::on_leave_notify_event (GdkEventCrossing*)
 548 {
 549         if (!dragging) {
 550                 _hovering = false;
 551                 Keyboard::magic_widget_drop_focus();
 552                 queue_draw ();
 553         }
 554         return false;
 555 }
 556
 557 void
 558 PixFader::set_adjustment_from_event (GdkEventButton* ev)
 559 {
 560         double fract = (_orien == VERT) ? (1.0 - (ev->y / span)) : (ev->x / span);
 561
 562         fract = min (1.0, fract);
 563         fract = max (0.0, fract);
 564
 565         adjustment.set_value (fract * (adjustment.get_upper () - adjustment.get_lower ()));
 566 }
 567
 568 void
 569 PixFader::set_default_value (float d)
 570 {
 571         default_value = d;
 572         update_unity_position ();
 573 }
 574
 575 void
 576 PixFader::set_text (const std::string& str)
 577 {
 578         _text = str;
 579
 580         if (!_layout && !_text.empty()) {
 581                 _layout = Pango::Layout::create (get_pango_context());
 582         }
 583
 584         if (_layout) {
 585                 _layout->set_text (str);
 586         }
 587
 588         queue_resize ();
 589 }
 590
 591 void
 592 PixFader::on_state_changed (Gtk::StateType old_state)
 593 {
 594         Widget::on_state_changed (old_state);
 595         create_patterns ();
 596 }