libs/gtkmm2ext/gtkmm2ext/fastmeter.h

   1 /*
   2     Copyright (C) 2003 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 */
  19
  20 #ifndef __gtkmm2ext_fastmeter_h__
  21 #define __gtkmm2ext_fastmeter_h__
  22
  23 #include <map>
  24 #include <boost/tuple/tuple.hpp>
  25 #include <boost/tuple/tuple_comparison.hpp>
  26 #include <cairomm/pattern.h>
  27 #include <gtkmm/drawingarea.h>
  28 #include <gdkmm/pixbuf.h>
  29
  30 namespace Gtkmm2ext {
  31
  32 class FastMeter : public Gtk::DrawingArea {
  33   public:
  34         enum Orientation {
  35                 Horizontal,
  36                 Vertical
  37         };
  38
  39         FastMeter (long hold_cnt, unsigned long width, Orientation, int len=0,
  40                         int clr0=0x008800ff, int clr1=0x008800ff,
  41                         int clr2=0x00ff00ff, int clr3=0x00ff00ff,
  42                         int clr4=0xffaa00ff, int clr5=0xffaa00ff,
  43                         int clr6=0xffff00ff, int clr7=0xffff00ff,
  44                         int clr8=0xff0000ff, int clr9=0xff0000ff,
  45                         int bgc0=0x333333ff, int bgc1=0x444444ff,
  46                         float stp0 = 55.0, // log_meter(-18);
  47                         float stp1 = 77.5, // log_meter(-9);
  48                         float stp2 = 92.5, // log_meter(-3); // 95.0, // log_meter(-2);
  49                         float stp3 = 100.0
  50                         );
  51         virtual ~FastMeter ();
  52
  53         void set (float level);
  54         void clear ();
  55
  56         float get_level() { return current_level; }
  57         float get_user_level() { return current_user_level; }
  58         float get_peak() { return current_peak; }
  59
  60         long hold_count() { return hold_cnt; }
  61         void set_hold_count (long);
  62
  63 protected:
  64         bool on_expose_event (GdkEventExpose*);
  65         void on_size_request (GtkRequisition*);
  66         void on_size_allocate (Gtk::Allocation&);
  67
  68 private:
  69
  70         Cairo::RefPtr<Cairo::Pattern> fgpattern;
  71         Cairo::RefPtr<Cairo::Pattern> bgpattern;
  72         gint pixheight;
  73         gint pixwidth;
  74
  75         float _stp[4];
  76         int _clr[10];
  77         int _bgc[2];
  78
  79         Orientation orientation;
  80         GdkRectangle pixrect;
  81         GdkRectangle last_peak_rect;
  82         gint request_width;
  83         gint request_height;
  84         unsigned long hold_cnt;
  85         unsigned long hold_state;
  86         float current_level;
  87         float current_peak;
  88         float current_user_level;
  89         bool resized;
  90
  91         bool vertical_expose (GdkEventExpose*);
  92         void queue_vertical_redraw (const Glib::RefPtr<Gdk::Window>&, float);
  93
  94         static Cairo::RefPtr<Cairo::Pattern> generate_meter_pattern (
  95                 int w, int h, int *clr, float *stp);
  96         static Cairo::RefPtr<Cairo::Pattern> request_vertical_meter (
  97                 int w, int h, int *clr, float *stp);
  98
  99         static Cairo::RefPtr<Cairo::Pattern> generate_meter_background (
 100                 int w, int h, int *bgc);
 101         static Cairo::RefPtr<Cairo::Pattern> request_vertical_background (
 102                 int w, int h, int *bgc);
 103
 104         struct Pattern10MapKey {
 105                 Pattern10MapKey (
 106                                 int w, int h,
 107                                 float stp0, float stp1, float stp2, float stp3,
 108                                 int c0, int c1, int c2, int c3,
 109                                 int c4, int c5, int c6, int c7,
 110                                 int c8, int c9
 111                                 )
 112                         : dim(w, h)
 113                         , stp(stp0, stp1, stp2, stp3)
 114                         , cols(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9)
 115                 {}
 116                 inline bool operator<(const Pattern10MapKey& rhs) const {
 117                         return (dim < rhs.dim)
 118                                 || (dim == rhs.dim && stp < rhs.stp)
 119                                 || (dim == rhs.dim && stp == rhs.stp && cols < rhs.cols);
 120                 }
 121                 boost::tuple<int, int> dim;
 122                 boost::tuple<float, float, float, float> stp;
 123                 boost::tuple<int, int, int, int, int, int, int, int, int, int> cols;
 124         };
 125         typedef std::map<Pattern10MapKey, Cairo::RefPtr<Cairo::Pattern> > Pattern10Map;
 126
 127         struct PatternBgMapKey {
 128                 PatternBgMapKey (int w, int h, int c0, int c1)
 129                         : dim(w, h)
 130                         , cols(c0, c1)
 131                 {}
 132                 inline bool operator<(const PatternBgMapKey& rhs) const {
 133                         return (dim < rhs.dim) || (dim == rhs.dim && cols < rhs.cols);
 134                 }
 135                 boost::tuple<int, int> dim;
 136                 boost::tuple<int, int> cols;
 137         };
 138         typedef std::map<PatternBgMapKey, Cairo::RefPtr<Cairo::Pattern> > PatternBgMap;
 139
 140         static Pattern10Map vm_pattern_cache;
 141         static PatternBgMap vb_pattern_cache;
 142         static int min_pattern_metric_size; // min dimension for axis that displays the meter level
 143         static int max_pattern_metric_size; // max dimension for axis that displays the meter level
 144 };
 145
 146
 147 } /* namespace */
 148
 149  #endif /* __gtkmm2ext_fastmeter_h__ */