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