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 (!_hovering) {
 309                                 Keyboard::magic_widget_drop_focus();
 310                                 queue_draw ();
 311                         }
 312
 313                         if (ev_pos == grab_start) {
 314
 315                                 /* no motion - just a click */
 316
 317                                 if (ev->state & Keyboard::TertiaryModifier) {
 318                                         adjustment.set_value (default_value);
 319                                 } else if (ev->state & Keyboard::GainFineScaleModifier) {
 320                                         adjustment.set_value (adjustment.get_lower());
 321                                 } else if ((_orien == VERT && ev_pos < span - display_span()) || (_orien == HORIZ && ev_pos > span - display_span())) {
 322                                         /* above the current display height, remember X Window coords */
 323                                         adjustment.set_value (adjustment.get_value() + adjustment.get_step_increment());
 324                                 } else {
 325                                         adjustment.set_value (adjustment.get_value() - adjustment.get_step_increment());
 326                                 }
 327                         }
 328
 329                 }
 330                 break;
 331
 332         case 2:
 333                 if (dragging) {
 334                         remove_modal_grab();
 335                         dragging = false;
 336                         set_adjustment_from_event (ev);
 337                 }
 338                 break;
 339
 340         default:
 341                 break;
 342         }
 343
 344         return false;
 345 }
 346
 347 bool
 348 PixFader::on_scroll_event (GdkEventScroll* ev)
 349 {
 350         double scale;
 351         bool ret = false;
 352
 353         if (ev->state & Keyboard::GainFineScaleModifier) {
 354                 if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 355                         scale = 0.01;
 356                 } else {
 357                         scale = 0.05;
 358                 }
 359         } else {
 360                 scale = 0.25;
 361         }
 362
 363         if (_orien == VERT) {
 364
 365                 /* should left/right scroll affect vertical faders ? */
 366
 367                 switch (ev->direction) {
 368
 369                 case GDK_SCROLL_UP:
 370                         adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 371                         ret = true;
 372                         break;
 373                 case GDK_SCROLL_DOWN:
 374                         adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 375                         ret = true;
 376                         break;
 377                 default:
 378                         break;
 379                 }
 380         } else {
 381
 382                 /* up/down scrolls should definitely affect horizontal faders
 383                    because they are so much easier to use
 384                 */
 385
 386                 switch (ev->direction) {
 387
 388                 case GDK_SCROLL_RIGHT:
 389                 case GDK_SCROLL_UP:
 390                         adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 391                         ret = true;
 392                         break;
 393                 case GDK_SCROLL_LEFT:
 394                 case GDK_SCROLL_DOWN:
 395                         adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 396                         ret = true;
 397                         break;
 398                 default:
 399                         break;
 400                 }
 401         }
 402         return ret;
 403 }
 404
 405 bool
 406 PixFader::on_motion_notify_event (GdkEventMotion* ev)
 407 {
 408         if (dragging) {
 409                 double scale = 1.0;
 410                 double const ev_pos = (_orien == VERT) ? ev->y : ev->x;
 411
 412                 if (ev->window != grab_window) {
 413                         grab_loc = ev_pos;
 414                         grab_window = ev->window;
 415                         return true;
 416                 }
 417
 418                 if (ev->state & Keyboard::GainFineScaleModifier) {
 419                         if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 420                                 scale = 0.05;
 421                         } else {
 422                                 scale = 0.1;
 423                         }
 424                 }
 425
 426                 double const delta = ev_pos - grab_loc;
 427                 grab_loc = ev_pos;
 428
 429                 double fract = (delta / span);
 430
 431                 fract = min (1.0, fract);
 432                 fract = max (-1.0, fract);
 433
 434                 // X Window is top->bottom for 0..Y
 435
 436                 if (_orien == VERT) {
 437                         fract = -fract;
 438                 }
 439
 440                 adjustment.set_value (adjustment.get_value() + scale * fract * (adjustment.get_upper() - adjustment.get_lower()));
 441         }
 442
 443         return true;
 444 }
 445
 446 void
 447 PixFader::adjustment_changed ()
 448 {
 449         if (display_span() != last_drawn) {
 450                 queue_draw ();
 451         }
 452 }
 453
 454 /** @return pixel offset of the current value from the right or bottom of the fader */
 455 int
 456 PixFader::display_span ()
 457 {
 458         float fract = (adjustment.get_value () - adjustment.get_lower()) / ((adjustment.get_upper() - adjustment.get_lower()));
 459         int ds;
 460         if (_orien == VERT) {
 461                 ds = (int)floor ( span * (1.0 - fract));
 462         } else {
 463                 ds = (int)floor (span * fract);
 464         }
 465
 466         return ds;
 467 }
 468
 469 void
 470 PixFader::set_fader_length (int l)
 471 {
 472         if (_orien == VERT) {
 473                 view.height = span = l;
 474         } else {
 475                 view.width = span = l;
 476         }
 477
 478         update_unity_position ();
 479
 480         queue_draw ();
 481 }
 482
 483 void
 484 PixFader::update_unity_position ()
 485 {
 486         if (_orien == VERT) {
 487                 unity_loc = (int) rint (view.height * (1 - (default_value / (adjustment.get_upper() - adjustment.get_lower())))) - 1;
 488         } else {
 489                 unity_loc = (int) rint (default_value * view.width);
 490         }
 491
 492         queue_draw ();
 493 }
 494
 495 bool
 496 PixFader::on_enter_notify_event (GdkEventCrossing*)
 497 {
 498         _hovering = true;
 499         Keyboard::magic_widget_grab_focus ();
 500         queue_draw ();
 501         return false;
 502 }
 503
 504 bool
 505 PixFader::on_leave_notify_event (GdkEventCrossing*)
 506 {
 507         if (!dragging) {
 508                 _hovering = false;
 509                 Keyboard::magic_widget_drop_focus();
 510                 queue_draw ();
 511         }
 512         return false;
 513 }
 514
 515 void
 516 PixFader::set_adjustment_from_event (GdkEventButton* ev)
 517 {
 518         double fract = (_orien == VERT) ? (1.0 - (ev->y / span)) : (ev->x / span);
 519
 520         fract = min (1.0, fract);
 521         fract = max (0.0, fract);
 522
 523         adjustment.set_value (fract * (adjustment.get_upper () - adjustment.get_lower ()));
 524 }
 525
 526 void
 527 PixFader::set_default_value (float d)
 528 {
 529         default_value = d;
 530         update_unity_position ();
 531 }
 532
 533 void
 534 PixFader::set_text (const std::string& str)
 535 {
 536         _text = str;
 537
 538         if (!_layout && !_text.empty()) {
 539                 _layout = Pango::Layout::create (get_pango_context());
 540         }
 541
 542         if (_layout) {
 543                 _layout->set_text (str);
 544         }
 545
 546         queue_resize ();
 547 }
 548