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
  27 using namespace Gtkmm2ext;
  28 using namespace Gtk;
  29 using namespace std;
  30
  31 PixFader::PixFader (Glib::RefPtr<Gdk::Pixbuf> belt, Gtk::Adjustment& adj, int orientation, int fader_length)
  32
  33         : adjustment (adj),
  34           pixbuf (belt),
  35           _orien(orientation)
  36 {
  37         Cairo::Format format;
  38
  39         dragging = false;
  40         default_value = adjustment.get_value();
  41         last_drawn = -1;
  42
  43         view.x = 0;
  44         view.y = 0;
  45
  46         if (orientation == VERT) {
  47                 view.width = girth = pixbuf->get_width();
  48         } else {
  49                 view.height = girth = pixbuf->get_height();
  50         }
  51
  52         set_fader_length (fader_length);
  53
  54         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);
  55
  56         adjustment.signal_value_changed().connect (mem_fun (*this, &PixFader::adjustment_changed));
  57         adjustment.signal_changed().connect (mem_fun (*this, &PixFader::adjustment_changed));
  58
  59         if (pixbuf->get_has_alpha()) {
  60                 format = Cairo::FORMAT_ARGB32;
  61         } else {
  62                 format = Cairo::FORMAT_RGB24;
  63         }
  64         belt_surface = Cairo::ImageSurface::create  (format, pixbuf->get_width(), pixbuf->get_height());
  65         belt_context = Cairo::Context::create (belt_surface);
  66         Gdk::Cairo::set_source_pixbuf (belt_context, pixbuf, 0.0, 0.0);
  67         belt_context->paint();
  68
  69         left_r = 0;
  70         left_g = 0;
  71         left_b = 0;
  72
  73         right_r = 0;
  74         right_g = 0;
  75         right_b = 0;
  76 }
  77
  78 PixFader::~PixFader ()
  79 {
  80 }
  81
  82 void
  83 PixFader::set_border_colors (uint32_t left, uint32_t right)
  84 {
  85         int r, g, b;
  86         UINT_TO_RGB(left, &r, &g, &b);
  87         left_r = r/255.0;
  88         left_g = g/255.0;
  89         left_b = b/255.0;
  90         UINT_TO_RGB(right, &r, &g, &b);
  91         right_r = r/255.0;
  92         right_g = g/255.0;
  93         right_b = b/255.0;
  94 }
  95
  96 bool
  97 PixFader::on_expose_event (GdkEventExpose* ev)
  98 {
  99         Cairo::RefPtr<Cairo::Context> context = get_window()->create_cairo_context();
 100         int srcx, srcy;
 101         int const ds = display_span ();
 102         int offset_into_pixbuf = (int) floor (span / ((float) span / ds));
 103
 104         /* account for fader lengths that are shorter than the fader pixbuf */
 105         if (_orien == VERT) {
 106                 offset_into_pixbuf += pixbuf->get_height() / 2 - view.height;
 107         } else {
 108                 offset_into_pixbuf += pixbuf->get_width() / 2 - view.width;
 109         }
 110
 111         context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
 112         context->clip ();
 113
 114         if (_orien == VERT) {
 115                 srcx = 0;
 116                 srcy = offset_into_pixbuf;
 117         } else {
 118                 srcx = offset_into_pixbuf;
 119                 srcy = 0;
 120         }
 121
 122         /* fader */
 123
 124         context->save();
 125         context->set_source (belt_surface, -srcx, -srcy);
 126         context->rectangle (0, 0, get_width(), get_height());
 127         context->clip ();
 128         context->paint();
 129         context->restore();
 130
 131         /* bounding box lines (2 colors for nicer visuals) */
 132
 133         /* top and left side */
 134
 135         context->set_line_width (1);
 136         context->set_source_rgb (left_r, left_g, left_b);
 137         context->move_to (view.width - 1, 0); /* upper right */
 138         context->line_to (0, 0);              /* upper left */
 139         context->line_to (0, view.height - 1);/* lower left */
 140         context->stroke ();
 141
 142         /* bottom & right side */
 143
 144         context->set_line_width (1);
 145         context->set_source_rgb (right_r, right_g, right_b);
 146         context->move_to (0, view.height - 0.5); /* lower left */
 147         context->line_to (view.width - 0.5, view.height - 0.5); /* lower right */
 148         context->line_to (view.width - 0.5, 0); /* upper right */
 149         context->stroke ();
 150
 151         /* always draw the unity-position line */
 152
 153
 154         if (_orien == VERT) {
 155                 context->set_line_width (1);
 156                 context->set_source_rgb (0.0, 1.0, 0.0);
 157                 context->move_to (1, unity_loc);
 158                 context->line_to (girth, unity_loc);
 159                 context->stroke ();
 160         } else {
 161                 context->set_line_width (1);
 162                 context->set_source_rgb (0.0, 1.0, 0.0);
 163                 context->move_to (unity_loc, 1);
 164                 context->line_to (unity_loc, girth - 1);
 165                 context->stroke ();
 166         }
 167
 168         last_drawn = ds;
 169
 170         return true;
 171 }
 172
 173 void
 174 PixFader::on_size_request (GtkRequisition* req)
 175 {
 176         req->width = view.width;
 177         req->height = view.height;
 178 }
 179
 180 bool
 181 PixFader::on_button_press_event (GdkEventButton* ev)
 182 {
 183         if (ev->type != GDK_BUTTON_PRESS) {
 184                 return true;
 185         }
 186
 187         if (ev->button != 1 && ev->button != 2) {
 188                 return false;
 189         }
 190
 191         add_modal_grab ();
 192         grab_loc = (_orien == VERT) ? ev->y : ev->x;
 193         grab_start = (_orien == VERT) ? ev->y : ev->x;
 194         grab_window = ev->window;
 195         dragging = true;
 196
 197         if (ev->button == 2) {
 198                 set_adjustment_from_event (ev);
 199         }
 200
 201         return true;
 202 }
 203
 204 bool
 205 PixFader::on_button_release_event (GdkEventButton* ev)
 206 {
 207         double const ev_pos = (_orien == VERT) ? ev->y : ev->x;
 208
 209         switch (ev->button) {
 210         case 1:
 211                 if (dragging) {
 212                         remove_modal_grab();
 213                         dragging = false;
 214
 215                         if (ev_pos == grab_start) {
 216
 217                                 /* no motion - just a click */
 218
 219                                 if (ev->state & Keyboard::TertiaryModifier) {
 220                                         adjustment.set_value (default_value);
 221                                 } else if (ev->state & Keyboard::GainFineScaleModifier) {
 222                                         adjustment.set_value (adjustment.get_lower());
 223                                 } else if ((_orien == VERT && ev_pos < span - display_span()) || (_orien == HORIZ && ev_pos > span - display_span())) {
 224                                         /* above the current display height, remember X Window coords */
 225                                         adjustment.set_value (adjustment.get_value() + adjustment.get_step_increment());
 226                                 } else {
 227                                         adjustment.set_value (adjustment.get_value() - adjustment.get_step_increment());
 228                                 }
 229                         }
 230
 231                 }
 232                 break;
 233
 234         case 2:
 235                 if (dragging) {
 236                         remove_modal_grab();
 237                         dragging = false;
 238                         set_adjustment_from_event (ev);
 239                 }
 240                 break;
 241
 242         default:
 243                 break;
 244         }
 245
 246         return false;
 247 }
 248
 249 bool
 250 PixFader::on_scroll_event (GdkEventScroll* ev)
 251 {
 252         double scale;
 253         bool ret = false;
 254
 255         if (ev->state & Keyboard::GainFineScaleModifier) {
 256                 if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 257                         scale = 0.01;
 258                 } else {
 259                         scale = 0.05;
 260                 }
 261         } else {
 262                 scale = 0.25;
 263         }
 264
 265         if (_orien == VERT) {
 266
 267                 /* should left/right scroll affect vertical faders ? */
 268
 269                 switch (ev->direction) {
 270
 271                 case GDK_SCROLL_UP:
 272                         adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 273                         ret = true;
 274                         break;
 275                 case GDK_SCROLL_DOWN:
 276                         adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 277                         ret = true;
 278                         break;
 279                 default:
 280                         break;
 281                 }
 282         } else {
 283
 284                 /* up/down scrolls should definitely affect horizontal faders
 285                    because they are so much easier to use
 286                 */
 287
 288                 switch (ev->direction) {
 289
 290                 case GDK_SCROLL_RIGHT:
 291                 case GDK_SCROLL_UP:
 292                         adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 293                         ret = true;
 294                         break;
 295                 case GDK_SCROLL_LEFT:
 296                 case GDK_SCROLL_DOWN:
 297                         adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 298                         ret = true;
 299                         break;
 300                 default:
 301                         break;
 302                 }
 303         }
 304         return ret;
 305 }
 306
 307 bool
 308 PixFader::on_motion_notify_event (GdkEventMotion* ev)
 309 {
 310         if (dragging) {
 311                 double scale = 1.0;
 312                 double const ev_pos = (_orien == VERT) ? ev->y : ev->x;
 313
 314                 if (ev->window != grab_window) {
 315                         grab_loc = ev_pos;
 316                         grab_window = ev->window;
 317                         return true;
 318                 }
 319
 320                 if (ev->state & Keyboard::GainFineScaleModifier) {
 321                         if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 322                                 scale = 0.05;
 323                         } else {
 324                                 scale = 0.1;
 325                         }
 326                 }
 327
 328                 double const delta = ev_pos - grab_loc;
 329                 grab_loc = ev_pos;
 330
 331                 double fract = (delta / span);
 332
 333                 fract = min (1.0, fract);
 334                 fract = max (-1.0, fract);
 335
 336                 // X Window is top->bottom for 0..Y
 337
 338                 if (_orien == VERT) {
 339                         fract = -fract;
 340                 }
 341
 342                 adjustment.set_value (adjustment.get_value() + scale * fract * (adjustment.get_upper() - adjustment.get_lower()));
 343         }
 344
 345         return true;
 346 }
 347
 348 void
 349 PixFader::adjustment_changed ()
 350 {
 351         if (display_span() != last_drawn) {
 352                 queue_draw ();
 353         }
 354 }
 355
 356 /** @return pixel offset of the current value from the right or bottom of the fader */
 357 int
 358 PixFader::display_span ()
 359 {
 360         float fract = (adjustment.get_value () - adjustment.get_lower()) / ((adjustment.get_upper() - adjustment.get_lower()));
 361         return (_orien != VERT) ? (int)floor (span * (1.0 - fract)) : (int)floor (span * fract);
 362 }
 363
 364 void
 365 PixFader::set_fader_length (int l)
 366 {
 367         if (_orien == VERT) {
 368                 view.height = span = l;
 369         } else {
 370                 view.width = span = l;
 371         }
 372
 373         update_unity_position ();
 374
 375         queue_draw ();
 376 }
 377
 378 void
 379 PixFader::update_unity_position ()
 380 {
 381         if (_orien == VERT) {
 382                 unity_loc = (int) rint (view.height * (1 - (default_value / (adjustment.get_upper() - adjustment.get_lower())))) - 1;
 383         } else {
 384                 unity_loc = (int) rint (default_value * view.width);
 385         }
 386
 387         queue_draw ();
 388 }
 389
 390 bool
 391 PixFader::on_enter_notify_event (GdkEventCrossing*)
 392 {
 393         Keyboard::magic_widget_grab_focus ();
 394         return false;
 395 }
 396
 397 bool
 398 PixFader::on_leave_notify_event (GdkEventCrossing*)
 399 {
 400         Keyboard::magic_widget_drop_focus();
 401         return false;
 402 }
 403
 404 void
 405 PixFader::set_adjustment_from_event (GdkEventButton* ev)
 406 {
 407         double fract = (_orien == VERT) ? (1.0 - (ev->y / span)) : (ev->x / span);
 408
 409         fract = min (1.0, fract);
 410         fract = max (0.0, fract);
 411
 412         adjustment.set_value (fract * (adjustment.get_upper () - adjustment.get_lower ()));
 413 }
 414
 415 void
 416 PixFader::set_default_value (float d)
 417 {
 418         default_value = d;
 419         update_unity_position ();
 420 }