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
  25 using namespace Gtkmm2ext;
  26 using namespace Gtk;
  27 using namespace Gdk;
  28 using namespace std;
  29
  30 PixFader::PixFader (Glib::RefPtr<Pixbuf> belt, Gtk::Adjustment& adj)
  31         : adjustment (adj),
  32           pixbuf (belt)
  33 {
  34         dragging = false;
  35         default_value = adjustment.get_value();
  36         last_drawn = -1;
  37         pixheight = pixbuf->get_height();
  38
  39         view.x = 0;
  40         view.y = 0;
  41         view.width  = pixbuf->get_width();
  42         view.height  = pixheight / 2;
  43
  44         unity_y = (int) rint (view.height - (default_value * view.height));
  45
  46         add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK|Gdk::SCROLL_MASK);
  47
  48         adjustment.signal_value_changed().connect (mem_fun (*this, &PixFader::adjustment_changed));
  49         adjustment.signal_changed().connect (mem_fun (*this, &PixFader::adjustment_changed));
  50 }
  51
  52 PixFader::~PixFader ()
  53 {
  54 }
  55
  56 bool
  57 PixFader::on_expose_event (GdkEventExpose* ev)
  58 {
  59         GdkRectangle intersection;
  60         int dh = display_height ();
  61         int offset_into_pixbuf = (int) floor (view.height / ((float) view.height / dh));
  62
  63         if (gdk_rectangle_intersect (&view, &ev->area, &intersection)) {
  64                 get_window()->draw_pixbuf(get_style()->get_fg_gc(get_state()), pixbuf,
  65                                           intersection.x, offset_into_pixbuf + intersection.y,
  66                                           0, 0,
  67                                           intersection.width, intersection.height,
  68                                           Gdk::RGB_DITHER_NONE, 0, 0);
  69         }
  70
  71         /* always draw the line */
  72
  73         get_window()->draw_line (get_style()->get_fg_gc(get_state()), 0, unity_y, view.width - 2, unity_y);
  74
  75         last_drawn = dh;
  76         return true;
  77 }
  78
  79 void
  80 PixFader::on_size_request (GtkRequisition* req)
  81 {
  82         req->width = view.width;
  83         req->height = view.height;
  84 }
  85
  86 bool
  87 PixFader::on_button_press_event (GdkEventButton* ev)
  88 {
  89         switch (ev->button) {
  90         case 1:
  91         case 2:
  92                 if (!(ev->state & Gdk::SHIFT_MASK)) {
  93                         add_modal_grab();
  94                         grab_y = ev->y;
  95                         grab_start = ev->y;
  96                         grab_window = ev->window;
  97                         dragging = true;
  98                 }
  99                 break;
 100         default:
 101                 break;
 102         }
 103
 104
 105         return false;
 106 }
 107
 108 bool
 109 PixFader::on_button_release_event (GdkEventButton* ev)
 110 {
 111         double scale;
 112         double fract;
 113
 114         if (ev->state & GDK_CONTROL_MASK) {
 115                 if (ev->state & GDK_MOD1_MASK) {
 116                         scale = 0.05;
 117                 } else {
 118                         scale = 0.1;
 119                 }
 120         } else {
 121                 scale = 1.0;
 122         }
 123
 124         switch (ev->button) {
 125         case 1:
 126                 if (dragging) {
 127                         remove_modal_grab();
 128                         dragging = false;
 129
 130                         if (ev->y == grab_start) {
 131                                 /* no motion - just a click */
 132
 133                                 if (ev->y < view.height - display_height()) {
 134                                         /* above the current display height, remember X Window coords */
 135                                         adjustment.set_value (adjustment.get_value() + adjustment.get_step_increment());
 136                                 } else {
 137                                         adjustment.set_value (adjustment.get_value() - adjustment.get_step_increment());
 138                                 }
 139                         }
 140
 141                 } else {
 142
 143                         if (ev->state & Gdk::SHIFT_MASK) {
 144                                 adjustment.set_value (default_value);
 145                         }
 146                 }
 147                 break;
 148
 149         case 2:
 150                 if (dragging) {
 151                         remove_modal_grab();
 152                         dragging = false;
 153
 154                         fract = 1.0 - (ev->y / view.height); // inverted X Window coordinates, grrr
 155
 156                         fract = min (1.0, fract);
 157                         fract = max (0.0, fract);
 158
 159                         adjustment.set_value (scale * fract * (adjustment.get_upper() - adjustment.get_lower()));
 160                 }
 161                 break;
 162
 163         default:
 164                 break;
 165         }
 166
 167         return false;
 168 }
 169
 170 bool
 171 PixFader::on_scroll_event (GdkEventScroll* ev)
 172 {
 173         double scale;
 174
 175         if (ev->state & GDK_CONTROL_MASK) {
 176                 if (ev->state & GDK_MOD1_MASK) {
 177                         scale = 0.05;
 178                 } else {
 179                         scale = 0.1;
 180                 }
 181         } else {
 182                 scale = 0.5;
 183         }
 184
 185         switch (ev->direction) {
 186
 187         case GDK_SCROLL_UP:
 188                 /* wheel up */
 189                 adjustment.set_value (adjustment.get_value() + (adjustment.get_page_increment() * scale));
 190                 break;
 191         case GDK_SCROLL_DOWN:
 192                 /* wheel down */
 193                 adjustment.set_value (adjustment.get_value() - (adjustment.get_page_increment() * scale));
 194                 break;
 195         default:
 196                 break;
 197         }
 198         return false;
 199 }
 200
 201 bool
 202 PixFader::on_motion_notify_event (GdkEventMotion* ev)
 203 {
 204         if (dragging) {
 205                 double fract;
 206                 double delta;
 207                 double scale;
 208
 209                 if (ev->window != grab_window) {
 210                         grab_y = ev->y;
 211                         grab_window = ev->window;
 212                         return true;
 213                 }
 214
 215                 if (ev->state & GDK_CONTROL_MASK) {
 216                         if (ev->state & GDK_MOD1_MASK) {
 217                                 scale = 0.05;
 218                         } else {
 219                                 scale = 0.1;
 220                         }
 221                 } else {
 222                         scale = 1.0;
 223                 }
 224
 225                 delta = ev->y - grab_y;
 226                 grab_y = ev->y;
 227
 228                 fract = (delta / view.height);
 229
 230                 fract = min (1.0, fract);
 231                 fract = max (-1.0, fract);
 232
 233                 // X Window is top->bottom for 0..Y
 234
 235                 fract = -fract;
 236
 237                 adjustment.set_value (adjustment.get_value() + scale * fract * (adjustment.get_upper() - adjustment.get_lower()));
 238         }
 239
 240         return true;
 241 }
 242
 243 void
 244 PixFader::adjustment_changed ()
 245 {
 246         if (display_height() != last_drawn) {
 247                 queue_draw ();
 248         }
 249 }
 250
 251 int
 252 PixFader::display_height ()
 253 {
 254         float fract = (adjustment.get_upper() - adjustment.get_value ()) / ((adjustment.get_upper() - adjustment.get_lower()));
 255         return (int) floor (view.height * (1.0 - fract));
 256 }