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