src/LineGraph.vala

   1 /*
   2     Copyright 2009 by Hans Baier, Krzysztof Foltman
   3     License: LGPLv2+
   4 */
   5
   6 using Gtk;
   7 using Gdk;
   8 using Cairo;
   9
  10 namespace Prolooks {
  11
  12 public interface ILineProperties : GLib.Object {
  13     public abstract void set_line_color (float r, float g, float b, float a = 1.0f);
  14     public abstract void set_line_width (float width);
  15 }
  16
  17 public class CairoLineProperties : GLib.Object, ILineProperties {
  18     public Context context { get; set; }
  19     public void set_line_color (float r, float g, float b, float a = 1.0f) { context.set_source_rgba (r, g, b, a); }
  20     public void set_line_width (float width) { context.set_line_width (width); }
  21 }
  22
  23 public interface IGraphSource : GLib.Object {
  24     /** Obtain subindex'th graph of parameter 'index'
  25      *   @param index parameter/graph number (usually tied to particular plugin control port)
  26      *   @param subindex graph number (there may be multiple overlaid graphs for one parameter, eg. for monosynth 2x12dB filters)
  27      *   @param data buffer for normalized output values
  28      *   @param points number of points to fill
  29      *   @param line_props line properties to adjust (for multicolour graphs etc.)
  30      *   @retval true graph data was returned; subindex+1 graph may or may not be available
  31      *  @retval false graph data was not returned; subindex+1 graph does not exist either
  32      */
  33     public abstract bool get_graph (int index, int subindex, ref float[] data, int points, ref ILineProperties line_props);
  34
  35     /** Obtain subindex'th dot of parameter 'index'
  36      *   @param index parameter/dot number (usually tied to particular plugin control port)
  37      *   @param subindex dot number (there may be multiple dots graphs for one parameter)
  38      */
  39     public abstract bool get_dot (int index, int subindex, ref float x, ref float y, ref int size, ref ILineProperties line_props);
  40
  41      /** Obtain subindex'th dot of parameter 'index'
  42      *   @param index parameter/dot number (usually tied to particular plugin control port)
  43      *   @param subindex dot number (there may be multiple dots graphs for one parameter)
  44      */
  45
  46         /** Defines how the graph line of the given subindex will look like
  47         */
  48     public abstract void set_subindex_look (ILineProperties line_props, int subindex);
  49
  50     public abstract bool get_gridline (int index, int subindex, ref float pos, ref bool vertical, ref string legend, ref ILineProperties line_props);
  51
  52      /** Obtain subindex'th static graph of parameter index (static graphs are only dependent on parameter value, not plugin state)
  53      *   @param index parameter/graph number (usually tied to particular plugin control port)
  54      *   @param subindex graph number (there may be multiple overlaid graphs for one parameter, eg. for monosynth 2x12dB filters)
  55      *   @param value parameter value to pick the graph for
  56      *   @param data buffer for normalized output values
  57      *   @param points number of points to fill
  58      *   @param line_props line properties to adjust (for multicolour graphs etc.)
  59      *   @retval true graph data was returned; subindex+1 graph may or may not be available
  60      *   @retval false graph data was not returned; subindex+1 graph does not exist either
  61      */
  62     public abstract bool get_static_graph (int index, int subindex, float value, ref float[] data, int points, ref ILineProperties line_props);
  63
  64      /** Return which graphs need to be redrawn and which can be cached for later reuse
  65      *   @param generation 0 (at start) or the last value returned by the function (corresponds to a set of input values)
  66      *   @param subindex_graph First graph that has to be redrawn (because it depends on values that might have changed)
  67      *   @param subindex_dot First dot that has to be redrawn
  68      *   @param subindex_gridline First gridline/legend that has to be redrawn
  69      *   @retval Current generation (to pass when calling the function next time); if different than passed generation value, call the function again to retrieve which graph  offsets should be put into cache
  70      */
  71     public abstract int get_changed_offsets (int generation, ref int subindex_graph, ref int subindex_dot, ref int subindex_gridline);
  72 }
  73
  74 public class DefaultGraphSource : GLib.Object, IGraphSource {
  75     public virtual bool get_graph (int index, int subindex, ref float[] data, int points, ref ILineProperties line_props) {
  76         return false;
  77     }
  78
  79     public virtual bool get_dot (int index, int subindex, ref float x, ref float y, ref int size, ref ILineProperties line_props) {
  80         return false;
  81     }
  82
  83         public virtual void set_subindex_look (ILineProperties line_props, int subindex)
  84     {
  85         if ((subindex & 1) != 0) {
  86                         RGBA c = rgba_from_string (DisplayBase.text_color_default);
  87             line_props.set_line_color ((float) c.red, (float) c.green, (float) c.blue);
  88                 } else {
  89             line_props.set_line_color (0.62f, 0.78f, 0.09f);
  90                 }
  91         line_props.set_line_width (1.5f);
  92     }
  93
  94     public virtual bool get_gridline (int index, int subindex, ref float pos, ref bool vertical, ref string legend, ref ILineProperties line_props) {
  95         return false;
  96     }
  97
  98     public virtual bool get_static_graph (int index, int subindex, float value, ref float[] data, int points, ref ILineProperties line_props)  {
  99         return false;
 100     }
 101
 102     public virtual int get_changed_offsets (int generation, ref int subindex_graph, ref int subindex_dot, ref int subindex_gridline) {
 103         subindex_graph = subindex_dot = subindex_gridline = 0;
 104         return 0;
 105     }
 106 }
 107
 108 public interface IHasFrequencyResponse : GLib.Object {
 109     public abstract float freq_gain (int subindex, float freq, float srate);
 110     public abstract int   sampling_rate ();
 111 }
 112
 113 public class TestFrequencyResponseSource : IHasFrequencyResponse, GLib.Object {
 114     public float freq_gain (int subindex, float freq, float srate) {
 115         return freq / srate;
 116     }
 117     public int   sampling_rate() {
 118         return 44100;
 119     }
 120 }
 121
 122 public class FrequencyResponseGraphSource : DefaultGraphSource {
 123     public int max_index     { get; set; }
 124     public int max_subindex  { get; set ;}
 125
 126     construct {
 127         max_index    = 1;
 128         max_subindex = 1;
 129         _freq_response_source = new TestFrequencyResponseSource ();
 130     }
 131
 132     private IHasFrequencyResponse _freq_response_source;
 133
 134     public IHasFrequencyResponse freq_response_source {
 135         get {
 136             return _freq_response_source;
 137         }
 138         set {
 139             _freq_response_source = value;
 140         }
 141     }
 142
 143     public static inline float dB_grid (float amp) {
 144         return Math.logf (amp) / Math.logf (256.0f) + 0.4f;
 145     }
 146
 147     public static bool get_freq_graph (IHasFrequencyResponse fx, int subindex, ref float[] data, int points)
 148     {
 149         for (int i = 0; i < points; i++)
 150         {
 151             double freq = 20.0f * Math.pow (20000.0f / 20.0f, i * 1.0f / (float)points);
 152             data[i] = dB_grid (fx.freq_gain (subindex, (float)freq, fx.sampling_rate ()));
 153         }
 154         return true;
 155     }
 156
 157     public override bool get_graph (int index, int subindex, ref float[] data, int points, ref ILineProperties line_props) {
 158         if (_freq_response_source != null && index <= max_index && subindex <= max_subindex) {
 159             return get_freq_graph (_freq_response_source, subindex, ref data, points);
 160         } else {
 161             return false;
 162         }
 163     }
 164
 165     public override bool get_gridline (int index, int subindex, ref float pos, ref bool vertical, ref string legend, ref ILineProperties line_props) {
 166         return get_gridline_use (index, subindex, ref pos, ref vertical, ref legend, ref line_props, true);
 167     }
 168
 169     public bool get_gridline_use (int index, int subindex, ref float pos, ref bool vertical, ref string legend, ref ILineProperties line_props, bool use_frequencies = true) {
 170         if (subindex < 0 )
 171         return false;
 172
 173         if (use_frequencies)
 174         {
 175             if (subindex < 28)
 176             {
 177                 vertical = true;
 178                 if (subindex == 9) legend = "100 Hz";
 179                 if (subindex == 18) legend = "1 kHz";
 180                 if (subindex == 27) legend = "10 kHz";
 181                 float freq = 100;
 182                 if (subindex < 9)
 183                     freq = 10 * (subindex + 1);
 184                 else if (subindex < 18)
 185                     freq = 100 * (subindex - 9 + 1);
 186                 else if (subindex < 27)
 187                     freq = 1000 * (subindex - 18 + 1);
 188                 else
 189                     freq = 10000 * (subindex - 27 + 1);
 190                 pos = Math.logf (freq / 20.0f) / Math.logf (1000f);
 191                 if (legend.length != 0)
 192                     line_props.set_line_color (0.25f, 0.25f, 0.25f, 0.75f);
 193                 else
 194                     line_props.set_line_color (0.25f, 0.25f, 0.25f, 0.5f);
 195                 return true;
 196             }
 197             subindex -= 28;
 198         }
 199         if (subindex >= 32)
 200             return false;
 201         float gain = 16.0f / (float) (1 << subindex);
 202         pos = dB_grid (gain);
 203         if (pos < -1)
 204             return false;
 205         if (subindex != 4)
 206             line_props.set_line_color (0.25f, 0.25f, 0.25f, ((subindex & 1) != 0) ? 0.5f : 0.75f);
 207         if ((subindex & 1) == 0)
 208         {
 209             legend = "%d dB".printf (24 - 6 * subindex);
 210         }
 211         vertical = false;
 212         return true;
 213     }
 214
 215     int get_changed_offsets (int generation, ref int subindex_graph, ref int subindex_dot, ref int subindex_gridline)
 216     {
 217         subindex_graph = 0;
 218         subindex_dot = 0;
 219         subindex_gridline = (generation != 0) ? int.MAX : 0;
 220         return 1;
 221     }
 222 }
 223
 224 public class LineGraph : DrawingArea {
 225
 226     public  IGraphSource source { get; set; }
 227
 228     private int          source_id;
 229     private bool         is_square;
 230     private Surface?     cache_surface;
 231     private int          last_generation;
 232
 233     construct {
 234         set_size_request (50, 50);
 235         cache_surface = null;
 236         last_generation = 0;
 237         var src = new FrequencyResponseGraphSource();
 238                 source = src;
 239                 draw.connect(on_draw);
 240                 size_allocate.connect(on_size_allocate);
 241     }
 242
 243     private void copy_cache_to_window (Context c) {
 244         c.save ();
 245         c.set_source_surface (cache_surface, 0, 0);
 246         c.paint ();
 247         c.restore ();
 248     }
 249
 250     /* unused
 251     private void copy_window_to_cache (Context c) {
 252         Context cache_cr = new Context (cache_surface);
 253         Surface window_surface = c.get_target ();
 254         cache_cr.set_source_surface (window_surface, 0, 0);
 255         cache_cr.paint ();
 256     }
 257     */
 258
 259     public static void draw_grid (Context c, ref string legend, bool vertical, float pos, int phase, int sx, int sy) {
 260         int ox = 1, oy = 1;
 261         TextExtents tx = TextExtents ();
 262
 263         if (legend.length != 0) {
 264             c.text_extents (legend, out tx);
 265         }
 266
 267         if (vertical)
 268         {
 269             float x = Math.floorf (ox + pos * sx) + 0.5f;
 270
 271             if (phase == 1)
 272             {
 273                 c.move_to (x, oy);
 274                 c.line_to (x, oy + sy);
 275                 c.stroke ();
 276             }
 277
 278             if (phase == 2 && (legend.length != 0)) {
 279
 280                 c.set_source_rgba (1.0, 1.0, 1.0, 0.75);
 281                 c.move_to (x - (tx.x_bearing + tx.width / 2.0), oy + sy - 2);
 282                 c.show_text (legend);
 283             }
 284         }
 285         else
 286         {
 287             float y = Math.floorf (oy + sy / 2 - (sy / 2 - 1) * pos) + 0.5f;
 288
 289             if (phase == 1)
 290             {
 291                 c.move_to (ox, y);
 292                 c.line_to (ox + sx, y);
 293                 c.stroke ();
 294             }
 295
 296             if (phase == 2 && (legend.length != 0)) {
 297                 c.set_source_rgba (1.0, 1.0, 1.0, 0.75);
 298                 c.move_to (ox + sx - 2 - tx.width, y + tx.height/2 - 1);
 299                 c.show_text (legend);
 300             }
 301         }
 302     }
 303
 304
 305     static void draw_graph (Context c, ref float[] data, int sx, int sy) {
 306         int ox=1, oy=1;
 307
 308         for (int i = 0; i < 2 * sx; i++)
 309         {
 310             int y = (int) (oy + sy / 2 - (sy / 2 - 1) * data[i]);
 311             //if (y < oy) y = oy;
 312             //if (y >= oy + sy) y = oy + sy - 1;
 313             if (i != 0) {
 314                 c.line_to (ox + i * 0.5, y);
 315             } else {
 316                 c.move_to (ox, y);
 317             }
 318         }
 319         c.stroke ();
 320     }
 321
 322         public bool on_draw (Cairo.Context c) {
 323                 Gtk.Allocation allocation;
 324                 get_allocation(out allocation);
 325
 326                 int ox = 1, oy = 1;
 327         int sx = allocation.width - 2, sy = allocation.height - 2;
 328
 329         Gdk.RGBA sc = { 0, 0, 0 };
 330
 331         bool cache_dirty = false;
 332
 333         if (cache_surface == null) {
 334             // looks like its either first call or the widget has been resized.
 335             // create the cache_surface.
 336             Surface window_surface = c.get_target ();
 337             cache_surface = new Surface.similar (window_surface,
 338                                                  Content.COLOR,
 339                                                  allocation.width,
 340                                                  allocation.height);
 341
 342                         //Context cache_cr = new Context (cache_surface);
 343             //cache_cr.set_source_surface (window_surface, 0,0);
 344             //cache_cr.paint ();
 345
 346             cache_dirty = true;
 347         }
 348
 349         c.select_font_face ("Bitstream Vera Sans", FontSlant.NORMAL, FontWeight.NORMAL);
 350         c.set_font_size (9);
 351
 352         cairo_set_source_rgba (c, sc);
 353         c.rectangle (ox, oy, sx, sy);
 354         c.clip ();
 355
 356         CairoLineProperties cairoimpl = new CairoLineProperties ();
 357         cairoimpl.context = c;
 358                 ILineProperties cimpl = cairoimpl;
 359
 360         if (source != null) {
 361             float pos = 0;
 362             bool vertical = false;
 363             string legend;
 364             float[] data = new float[2 * sx];
 365             Gdk.RGBA sc2 = { 0, 1.0, 0 };
 366             float x = 0, y = 0;
 367             int size = 0;
 368             Gdk.RGBA sc3 = { 0.5, 1.0, 0.0 };
 369
 370             int graph_n = 0, grid_n = 0, dot_n = 0, grid_n_save = 0;
 371
 372             int cache_graph_index = 0, cache_dot_index = 0, cache_grid_index = 0;
 373             int gen_index = source.get_changed_offsets (last_generation, ref cache_graph_index, ref cache_dot_index, ref cache_grid_index);
 374
 375             if (cache_dirty || (gen_index != last_generation)) {
 376                 Context cache_cr = new Context (cache_surface);
 377                 cache_cr.select_font_face ("Bitstream Vera Sans", FontSlant.NORMAL, FontWeight.NORMAL);
 378                 cache_cr.set_font_size (9);
 379
 380                 cairo_set_source_rgba (cache_cr, sc);
 381                 cache_cr.rectangle (ox, oy, sx, sy);
 382                 cache_cr.clip_preserve ();
 383                 cache_cr.fill ();
 384
 385                                 { //Display
 386                                         bool show_matrix = true;
 387                                         bool show_glass_rim = false;
 388                                         double inner_width  = show_glass_rim ? (sx - 14) : (sx - 6);
 389                                         double inner_height = show_glass_rim ? (sy - 13) : (sy - 6);
 390                                         cache_cr.save();
 391
 392                                         set_line_width_from_device (cache_cr);
 393
 394                                         DisplayBase.outer_rim_for_display (cache_cr, 0, 0, sx, sy, gdk_color_to_rgba(style.bg[(int)Gtk.StateType.NORMAL]));
 395
 396                                         if (show_glass_rim) {
 397                                                 cache_cr.translate (4.5, 3.5);
 398                                                 DisplayBase.inner_glass_rim (cache_cr, 0, 0, sx - 8, sy - 9, 2);
 399                                         }
 400
 401                                         cache_cr.translate (3.0, 3.0);
 402
 403                                         DisplayBase.lcd(cache_cr, inner_width, inner_height, sy > 30 ? 5.0 : 3.0);
 404
 405                                         if (show_matrix) {
 406                                                 DisplayBase.dot_matrix (cache_cr, show_glass_rim ? 0 : 0.5, show_glass_rim ? 0 : 0.5, inner_width, inner_height, DisplayBase.matrix_dot_color ());
 407                                         }
 408
 409                                         DisplayBase.reflection(cache_cr, inner_width, inner_height, inner_height / 2.0);
 410
 411                                         cache_cr.restore();
 412                                 }
 413
 414
 415                 CairoLineProperties cache_cairoimpl = new CairoLineProperties ();
 416                 cache_cairoimpl.context = cache_cr;
 417                                 ILineProperties cache_cimpl = cache_cairoimpl;
 418
 419                 source.get_changed_offsets (gen_index, ref cache_graph_index, ref cache_dot_index, ref cache_grid_index);
 420                 last_generation = gen_index;
 421
 422                 cache_cr.set_line_width (1);
 423                 for (int phase = 1; phase <= 2; phase++)
 424                 {
 425                     for (grid_n = 0;; grid_n++)
 426                     {
 427                         legend = "";
 428                         cache_cr.set_source_rgba (1, 1, 1, 0.5);
 429                         if ((grid_n < cache_grid_index) &&
 430                             source.get_gridline (source_id, grid_n, ref pos, ref vertical, ref legend, ref cache_cimpl)) {
 431                             draw_grid (cache_cr, ref legend, vertical, pos, phase, sx, sy);
 432                         } else {
 433                             break;
 434                         }
 435                     }
 436                 }
 437                 grid_n_save = grid_n;
 438
 439                 cairo_set_source_rgba (cache_cr, sc2);
 440                 cache_cr.set_line_join (LineJoin.MITER);
 441                 cache_cr.set_line_width (1);
 442
 443                 for (graph_n = 0;
 444                      (graph_n<cache_graph_index) &&
 445                          source.get_graph (source_id, graph_n, ref data, 2 * sx,  ref cache_cimpl);
 446                      graph_n++)
 447                 {
 448                     draw_graph (cache_cr, ref data, sx, sy);
 449                 }
 450
 451                 cairo_set_source_rgba (cache_cr, sc3);
 452
 453                 for (dot_n = 0;; dot_n++)
 454                 {
 455                     size = 3;
 456                     if ((dot_n<cache_dot_index) &&
 457                         source.get_dot (source_id, dot_n, ref x, ref y, ref size, ref cache_cimpl)) {
 458
 459                         int yv = (int) (oy + sy / 2 - (sy / 2 - 1) * y);
 460                         cache_cr.arc (ox + x * sx, yv, size, 0, 2 * Math.PI);
 461                         cache_cr.fill ();
 462                     } else {
 463                         break;
 464                     }
 465                 }
 466
 467                 cache_cr = null;
 468                 copy_cache_to_window (c);
 469
 470             } else {
 471                 grid_n_save = cache_grid_index;
 472                 graph_n = cache_graph_index;
 473                 dot_n = cache_dot_index;
 474                 copy_cache_to_window (c);
 475             }
 476
 477             c.set_line_width (1);
 478
 479             for (int phase = 1; phase <= 2; phase++)
 480             {
 481                 for (int gn = grid_n_save;; gn++)
 482                 {
 483                     legend = "";
 484                     c.set_source_rgba (1, 1, 1, 0.5);
 485                     if (source.get_gridline (source_id, gn, ref pos, ref vertical, ref legend, ref cimpl)) {
 486                         draw_grid (c, ref legend, vertical, pos, phase, sx, sy);
 487                     } else {
 488                         break;
 489                     }
 490                 }
 491             }
 492
 493             cairo_set_source_rgba (c, sc2);
 494             c.set_line_join (LineJoin.MITER);
 495             c.set_line_width (1);
 496
 497             for (int gn = graph_n;
 498                  source.get_graph (source_id, gn, ref data, 2 * sx, ref cimpl);
 499                  gn++)
 500             {
 501                                 source.set_subindex_look (cimpl, gn);
 502                 draw_graph (c, ref data, sx, sy);
 503             }
 504
 505             cairo_set_source_rgba (c, sc3);
 506             for (int gn = dot_n;; gn++)
 507             {
 508                 size = 3;
 509                 if (source.get_dot (source_id, gn, ref x, ref y, ref size, ref cimpl)) {
 510                     int yv = (int) (oy + sy / 2 - (sy / 2 - 1) * y);
 511                     c.arc (ox + x * sx, yv, size, 0, 2 * Math.PI);
 512                     c.fill ();
 513                 } else {
 514                     break;
 515                 }
 516             }
 517         }
 518
 519
 520                 get_style_context().render_frame(c, ox - 1, oy - 1, sx + 2, sy + 2);
 521         //stderr.printf ("exposed %p %dx%d %d+%d\n", window, event.area.x, event.area.y, event.area.width, event.area.height);
 522
 523         return true;
 524     }
 525
 526     /* unused
 527     int update_if (int last_drawn_generation)
 528     {
 529         int generation = last_drawn_generation;
 530         if (source != null)
 531         {
 532             int subgraph = 0, dot = 0, gridline = 0;
 533             generation = source.get_changed_offsets (generation, ref subgraph, ref dot, ref gridline);
 534             if (subgraph == int.MAX && dot == int.MAX && gridline == int.MAX && generation == last_drawn_generation) {
 535                 return generation;
 536             }
 537
 538             queue_draw ();
 539         }
 540         return generation;
 541     }
 542     */
 543
 544     public void on_size_allocate (Gtk.Allocation allocation) {
 545                 set_allocation(allocation);
 546
 547                 Gtk.Allocation a = allocation;
 548
 549         if (is_square)
 550         {
 551             if (a.width > a.height)
 552             {
 553                 a.x += (a.width - a.height) / 2;
 554                 a.width = a.height;
 555             }
 556             if (a.width < a.height)
 557             {
 558                 a.y += (a.height - a.width) / 2;
 559                 a.height = a.width;
 560             }
 561         }
 562
 563         base.size_allocate (a);
 564         cache_surface = null;
 565     }
 566 }
 567
 568 } // namespace Prolooks