src/Fl_Panzoomer.cxx

   1
   2 /*******************************************************************************/
   3 /* Copyright (C) 2012 Jonathan Moore Liles                                     */
   4 /*                                                                             */
   5 /* This program is free software; you can redistribute it and/or modify it     */
   6 /* under the terms of the GNU General Public License as published by the       */
   7 /* Free Software Foundation; either version 2 of the License, or (at your      */
   8 /* option) any later version.                                                  */
   9 /*                                                                             */
  10 /* This program is distributed in the hope that it will be useful, but WITHOUT */
  11 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       */
  12 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for   */
  13 /* more details.                                                               */
  14 /*                                                                             */
  15 /* You should have received a copy of the GNU General Public License along     */
  16 /* with This program; see the file COPYING.  If not,write to the Free Software */
  17 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18 /*******************************************************************************/
  19
  20 #include <FL/Fl.H>
  21 #include <FL/fl_draw.H>
  22 #include <FL/Fl_Panzoomer.H>
  23
  24 Fl_Panzoomer::Fl_Panzoomer ( int X, int Y, int W, int H, const char *L ) :
  25     Fl_Valuator( X,Y,W,H,L )
  26 {
  27     _zoom = 1;
  28     _zoom_min = 0;
  29     _zoom_max = 4;
  30     _zoom_changed = false;
  31
  32     _ymin = _ymax = _xmin = _xmax = _ysize = _xsize =
  33     _xpos = _ypos = 0;
  34
  35     step( 1 );
  36 }
  37
  38 int
  39 Fl_Panzoomer::x_value ( int pos, int size, int first, int total )
  40 {
  41     if ( pos + size > first + total )
  42         total = pos+size-first;
  43
  44     if ( (int)_xmin == first &&
  45          (int)_xmax == total &&
  46          (int)_xpos == pos &&
  47          (int)_xsize == size )
  48         return pos;
  49
  50     damage( FL_DAMAGE_USER1 );
  51
  52     _xmin = first;
  53     _xmax = total;
  54     _xpos = pos;
  55     _xsize = size;
  56
  57     return pos;
  58 }
  59
  60 int
  61 Fl_Panzoomer::y_value ( int pos, int size, int first, int total )
  62 {
  63     if ( pos + size > first + total )
  64         total = pos+size-first;
  65
  66     if ( (int)_ymin == first &&
  67          (int)_ymax == total &&
  68          (int)_ypos == pos &&
  69          (int)_ysize == size )
  70         return pos;
  71
  72     damage( FL_DAMAGE_USER1 );
  73
  74     _ymin = first;
  75     _ymax = total;
  76     _ypos = pos;
  77     _ysize = size;
  78
  79     return pos;
  80 }
  81
  82 void
  83 Fl_Panzoomer::x_value ( double v )
  84 {
  85     if ( _xpos == v )
  86         return;
  87
  88     _xpos = v;
  89     if ( _xpos < _xmin )
  90         _xpos = _xmin;
  91     else if ( _xpos > _xmax - _xsize)
  92         _xpos = _xmax - _xsize;
  93
  94     damage( FL_DAMAGE_USER1 );
  95 }
  96
  97 void
  98 Fl_Panzoomer::y_value ( double v )
  99 {
 100     if ( _ypos == v )
 101         return;
 102
 103     _ypos = v;
 104
 105     if ( _ypos < _ymin )
 106         _ypos = _ymin;
 107     else if ( _ypos > _ymax - _ysize )
 108         _ypos = _ymax - _ysize;
 109
 110     damage( FL_DAMAGE_USER1 );
 111 }
 112
 113 void
 114 Fl_Panzoomer::zoom ( int v )
 115 {
 116         int z = _zoom;
 117
 118         _zoom = v;
 119
 120         if ( _zoom > _zoom_max )
 121             _zoom = _zoom_max;
 122         else
 123             if ( _zoom < _zoom_min )
 124                 _zoom = _zoom_min;
 125
 126         if ( z != _zoom )
 127         {
 128             _zoom_changed = true;
 129             do_callback();
 130             _zoom_changed = false;
 131         }
 132 }
 133
 134 void
 135 Fl_Panzoomer::draw ( void )
 136 {
 137     draw(x(),y(),w(),h());
 138 }
 139
 140 void
 141 Fl_Panzoomer::draw ( int X, int Y, int W, int H )
 142 {
 143     fl_draw_box( box(), X,Y,W,H,color());
 144
 145     X += Fl::box_dx( box() );
 146     Y += Fl::box_dy( box() );
 147     W -= Fl::box_dw( box() );
 148     H -= Fl::box_dh( box() );
 149
 150     fl_push_clip( X,Y,W,H );
 151
 152     draw_background( X,Y,W,H );
 153     draw_cursor( X,Y,W,H );
 154
 155     fl_pop_clip();
 156
 157     draw_label();
 158 }
 159
 160 void
 161 Fl_Panzoomer::draw_background ( int X, int Y, int W, int H )
 162 {
 163 }
 164
 165 void
 166 Fl_Panzoomer::draw_cursor ( int X, int Y, int W, int H )
 167 {
 168     int cx,cy,cw,ch;
 169
 170     cx = X; cy = Y; cw = W; ch = H;
 171
 172     cursor_bounds( cx,cy,cw,ch );
 173
 174     fl_rectf( cx,cy,cw,ch,
 175               fl_color_add_alpha( FL_WHITE, 40 ));
 176
 177     fl_rect( cx,cy,cw,ch,
 178               fl_color_add_alpha( FL_WHITE, 200 ));
 179 }
 180
 181 void
 182 Fl_Panzoomer::cursor_bounds ( int &cx, int &cy, int &cw, int &ch ) const
 183 {
 184     const int minh = 12;
 185     const int minw = 12;
 186
 187     int X,Y,W,H;
 188
 189     X = cx;
 190     Y = cy;
 191     W = cw;
 192     H = ch;
 193
 194     double hval;
 195     if ( _xmin == _xmax )
 196         hval = 0.5;
 197     else
 198     {
 199         hval = (_xpos-_xmin)/(_xmax-_xmin);
 200
 201         if (hval > 1.0) hval = 1.0;
 202         else if (hval < 0.0) hval = 0.0;
 203     }
 204
 205     double vval;
 206     if ( _ymin == _ymax )
 207         vval = 0.5;
 208     else
 209     {
 210         vval = (_ypos-_ymin)/(_ymax-_ymin);
 211
 212         if (vval > 1.0) vval = 1.0;
 213         else if (vval < 0.0) vval = 0.0;
 214     }
 215
 216     cx = X + (hval) * W + .5;
 217     cy = _ymax ? Y + (vval) * H + .5 : Y;
 218     cw = W * (_xsize/_xmax);
 219     ch = _ymax ? H * (_ysize/_ymax) : H;
 220
 221     cw = cw < minw ? minw : cw;
 222     ch = ch < minh ? minh : ch;
 223 }
 224
 225 int
 226 Fl_Panzoomer::handle ( int m )
 227 {
 228     return handle( m, x(),y(),w(),h());
 229 }
 230
 231 int
 232 Fl_Panzoomer::handle ( int m, int X, int Y, int W, int H )
 233 {
 234     static int xoffset;
 235     static int yoffset;
 236     static bool drag;
 237
 238     X += Fl::box_dx( box() );
 239     Y += Fl::box_dy( box() );
 240     W -= Fl::box_dw( box() );
 241     H -= Fl::box_dh( box() );
 242
 243     switch ( m )
 244     {
 245         case FL_ENTER:
 246         case FL_LEAVE:
 247             return 1;
 248         case FL_PUSH:
 249         {
 250             int cx,cy,cw,ch;
 251
 252             cx = X; cy = Y; cw = W; ch = H;
 253
 254             cursor_bounds( cx,cy,cw,ch );
 255
 256             if ( Fl::event_inside( cx,cy,cw,ch ) )
 257             {
 258                 xoffset = Fl::event_x() - cx;
 259                 yoffset = Fl::event_y() - cy;
 260             }
 261             else
 262             {
 263                 xoffset = cw / 2;
 264                 yoffset = ch / 2;
 265             }
 266
 267             if (// Fl::event_inside( cx,cy,cw,ch ) &&
 268                  Fl::event_button1() )
 269                 drag = true;
 270
 271             /* fallthrough */
 272 //            return 1;
 273         }
 274         case FL_DRAG:
 275         {
 276             int cx,cy,cw,ch;
 277
 278             cx = X; cy = Y; cw = W; ch = H;
 279
 280             cursor_bounds( cx,cy,cw,ch );
 281
 282             if ( drag )
 283             {
 284                 x_value((((double)Fl::event_x() - X - xoffset) / W) * _xmax);
 285                 y_value( (((double)Fl::event_y() - Y - yoffset) / H) * _ymax );
 286
 287                 if ( when() & FL_WHEN_CHANGED )
 288                     do_callback();
 289             }
 290
 291             damage( FL_DAMAGE_USER1 );
 292
 293             return 1;
 294             break;
 295         }
 296         case FL_MOUSEWHEEL:
 297         {
 298             const int dy = Fl::event_dy();
 299             const int dx = Fl::event_dx();
 300
 301             if ( dy && Fl::event_ctrl() )
 302             {
 303                 zoom( _zoom + dy );
 304
 305                 damage( FL_DAMAGE_USER1 );
 306
 307                 return 1;
 308             }
 309
 310             if ( Fl::event_alt() )
 311                 return 0;
 312
 313             if ( Fl::event_shift())
 314             {
 315                 if ( dx )
 316                     y_value( _ypos + ( (double)dx*5 / H ) * _ymax );
 317
 318                 if ( dy )
 319                     x_value( _xpos + ( (double)dy*5 / W ) * _xmax );
 320
 321                 if ( when() & FL_WHEN_CHANGED )
 322                     do_callback();
 323
 324                 damage( FL_DAMAGE_USER1 );
 325
 326                 return 1;
 327             }
 328             else
 329             {
 330                 if ( dy )
 331                     y_value( _ypos + ( (double)dy*5 / H ) * _ymax );
 332
 333                 if ( dx )
 334                     x_value( _xpos + ( (double)dx*5 / W ) * _xmax );
 335
 336                 if ( when() & FL_WHEN_CHANGED )
 337                     do_callback();
 338
 339                 damage( FL_DAMAGE_USER1 );
 340
 341                 return 1;
 342             }
 343
 344             return 0;
 345             break;
 346         }
 347         case FL_RELEASE:
 348         {
 349             if ( drag )
 350             {
 351                 drag = false;
 352
 353                 if ( when() & FL_WHEN_RELEASE )
 354                     do_callback();
 355             }
 356
 357             return 1;
 358         }
 359         case FL_KEYBOARD:
 360         {
 361             if ( Fl::event_shift() || Fl::event_ctrl() || Fl::event_alt() )
 362                 return 0;
 363
 364             double xv = _xpos;
 365             double yv = _ypos;
 366
 367             /* FIXME: hack */
 368             int xls = _xsize / 50;
 369             int yls = _ysize / 50;
 370
 371             switch ( Fl::event_key() )
 372             {
 373                 case FL_Up:
 374                     yv -= yls;
 375                     break;
 376                 case FL_Down:
 377                     yv += yls;
 378                     break;
 379                 case FL_Left:
 380                     xv -= xls;
 381                     break;
 382                 case FL_Right:
 383                     xv += xls;
 384                     break;
 385                 default:
 386                     return 0;
 387             }
 388
 389             x_value( xv );
 390             y_value( yv );
 391
 392             do_callback();
 393
 394             redraw();
 395
 396             return 1;
 397
 398             break;
 399         }
 400     }
 401
 402     return 0;
 403 }
 404