Don't squeeze tiny labels too much
[gregoa/zavai.git] / src / fisheye.vala
1 /*
2  * zavai - simple interface to the OpenMoko (or to the FSO stack)
3  *
4  * Copyright (C) 2009  Enrico Zini <enrico@enricozini.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 using GLib;
22
23 public class FisheyeList : Gtk.DrawingArea
24 {
25         protected Gtk.TreeModel model;
26         protected Gdk.Pixmap background;
27         protected Gdk.Pixmap backing_store;
28
29         // Pango layouts cached for speed
30         protected const int steps = 5;
31         protected Gtk.CellRendererText[] renderers;
32
33         // Labels to show, extracted from the model
34         protected string[] label_cache;
35         protected bool base_layout_needed;
36
37         protected int cur_el;
38
39         // Layout information
40         protected int focus_first;
41         protected int focus_end;
42         protected int[] focus_starts;
43         protected bool focus_locked;
44         protected bool focus_layout_needed;
45
46         protected int _focus_size;
47         public int focus_size {
48                 get { return _focus_size; }
49                 set {
50                         _focus_size = value;
51                         focus_starts = new int[value+1];
52                         focus_layout_needed = true;
53                         queue_draw();
54                 }
55         }
56
57         protected int _label_column;
58         public int label_column {
59                 get { return _label_column; }
60                 set {
61                         _label_column = value;
62                         base_layout_needed = true;
63                         queue_draw();
64                 }
65         }
66
67         //public virtual signal void cursor_changed ();
68         public signal void row_activated(Gtk.TreePath path);
69
70         public FisheyeList()
71         {
72                 model = null;
73                 backing_store = null;
74
75                 label_cache = null;
76
77                 renderers = new Gtk.CellRendererText[steps];
78
79                 // Defaults for properties
80                 focus_size = 21;
81                 label_column = 0;
82
83                 cur_el = 0;
84                 focus_locked = false;
85
86                 add_events(Gdk.EventMask.POINTER_MOTION_MASK
87                          | Gdk.EventMask.BUTTON_PRESS_MASK
88                          | Gdk.EventMask.BUTTON_RELEASE_MASK);
89         }
90
91         public unowned Gtk.TreeModel get_model() { return model; }
92         public void set_model (Gtk.TreeModel? model)
93         {
94                 if (this.model != null)
95                 {
96                         this.model.row_changed -= on_row_changed;
97                         this.model.row_deleted -= on_row_deleted;
98                         this.model.row_has_child_toggled -= on_row_has_child_toggled;
99                         this.model.row_inserted -= on_row_inserted;
100                         this.model.rows_reordered -= on_rows_reordered;
101                 }
102                 this.model = model;
103                 this.model.row_changed += on_row_changed;
104                 this.model.row_deleted += on_row_deleted;
105                 this.model.row_has_child_toggled += on_row_has_child_toggled;
106                 this.model.row_inserted += on_row_inserted;
107                 this.model.rows_reordered += on_rows_reordered;
108                 base_layout_needed = true;
109                 queue_draw();
110         }
111
112         private void on_row_changed(Gtk.TreePath path, Gtk.TreeIter iter) { base_layout_needed = true; }
113         private void on_row_deleted(Gtk.TreePath path) { base_layout_needed = true; }
114         private void on_row_has_child_toggled(Gtk.TreePath path, Gtk.TreeIter iter) { base_layout_needed = true; }
115         private void on_row_inserted(Gtk.TreePath path, Gtk.TreeIter iter) { base_layout_needed = true; }
116         private void on_rows_reordered(Gtk.TreePath path, Gtk.TreeIter iter, void* new_order) { base_layout_needed = true; }
117
118         /* Mouse button got pressed over widget */
119         /*
120         public override bool button_press_event(Gdk.EventButton event)
121         {
122                 stderr.printf("Mouse pressed on %d %s\n", cur_el, label_cache[cur_el]);
123                 return false;
124         }
125         */
126
127         /* Mouse button got released */
128         public override bool button_release_event(Gdk.EventButton event)
129         {
130                 stderr.printf("Mouse released on %d %s\n", cur_el, label_cache[cur_el]);
131
132                 // Emit row_activated if applicable
133                 if (model != null)
134                 {
135                         Gtk.TreeIter iter;
136                         if (model.iter_nth_child(out iter, null, cur_el))
137                         {
138                                 Gtk.TreePath path = model.get_path(iter);
139                                 row_activated(path);
140                         }
141                 }
142                 return false;
143         }
144
145         /* Mouse pointer moved over widget */
146         public override bool motion_notify_event(Gdk.EventMotion event)
147         {
148                 int old_cur_el = cur_el;
149                 int x = (int)event.x;
150                 int y = (int)event.y;
151
152                 focus_locked = !focus_layout_needed && x < allocation.width/2 && y >= focus_starts[0] && y < focus_starts[focus_end - focus_first];
153
154                 if (focus_locked)
155                 {
156                         for (int idx = focus_first; idx < focus_end; ++idx)
157                                 if (y < focus_starts[idx-focus_first+1])
158                                 {
159                                         cur_el = idx;
160                                         break;
161                                 }
162
163                 } else {
164                         cur_el = y * label_cache.length / allocation.height;
165                         if (old_cur_el != cur_el)
166                                 focus_layout_needed = true;
167                 }
168
169                 //stderr.printf("MOTION %f %f CE %d\n", event.x, event.y, cur_el);
170                 if (old_cur_el != cur_el)
171                 {
172                         queue_draw();
173                         old_cur_el = cur_el;
174                 }
175                 return false;
176         }
177
178         public override bool configure_event (Gdk.EventConfigure event)
179         {
180                 base_layout_needed = true;
181                 queue_draw();
182                 return false;
183         }
184
185         /* Widget is asked to draw itself */
186         public override bool expose_event (Gdk.EventExpose event)
187         {
188                 draw();
189
190                 window.draw_drawable(
191                         get_style().fg_gc[Gtk.StateType.NORMAL],
192                         backing_store,
193                         event.area.x, event.area.y,
194                         event.area.x, event.area.y,
195                         event.area.width, event.area.height);
196
197                 return false;
198         }
199
200         public override void style_set(Gtk.Style? previous_style)
201         {
202                 base_layout_needed = true;
203         }
204         public override void direction_changed(Gtk.TextDirection previous_direction)
205         {
206                 base_layout_needed = true;
207         }
208
209         protected int el_y(int idx)
210         {
211                 // Distorted position
212                 int pos = fisheye(idx);
213                 //stderr.printf("%d %f %f\n", idx, undy, pos);
214                 return pos;
215         }
216
217         protected Gtk.CellRendererText make_cell_renderer()
218         {
219                 var res = new Gtk.CellRendererText();
220                 res.font_desc = get_style().font_desc;
221                 res.ypad = 0;
222                 return res;
223         }
224
225         protected void base_layout()
226         {
227                 background = new Gdk.Pixmap(window, allocation.width, allocation.height, -1);
228                 backing_store = new Gdk.Pixmap(window, allocation.width, allocation.height, -1);
229
230                 // Recreate the renderers
231                 renderers[renderers.length-1] = make_cell_renderer();
232                 renderers[renderers.length-1].set_fixed_height_from_font(1);
233
234                 renderers[0] = make_cell_renderer();
235                 renderers[0].size = Pango.SCALE;
236                 renderers[0].set_fixed_height_from_font(1);
237
238                 for (int i = 1; i < renderers.length-1; ++i)
239                 {
240                         renderers[i] = make_cell_renderer();
241                         renderers[i].scale = (double)i / renderers.length;
242                         renderers[i].set_fixed_height_from_font(1);
243                 }
244
245                 if (model == null)
246                 {
247                         label_cache = new string[0];
248                 } else {
249                         Gtk.TreeIter iter;
250                         if (!model.get_iter_first(out iter))
251                         {
252                                 label_cache = new string[0];
253                         }
254                         else
255                         {
256                                 int count = model.iter_n_children(null);
257                                 label_cache = new string[count];
258
259                                 int i = 0;
260                                 do {
261                                         string val;
262                                         model.get(iter, _label_column, out val, -1);
263                                         label_cache[i] = val;
264                                         ++i;
265                                 } while (model.iter_next(ref iter));
266                         }
267                 }
268
269                 // Draw background
270                 draw_background(background);
271
272                 base_layout_needed = false;
273                 focus_layout_needed = true;
274         }
275
276         protected void focus_layout()
277         {
278                 if (label_cache.length == 0)
279                 {
280                         focus_first = 0;
281                         focus_end = 0;
282                         focus_starts[0] = 0;
283                 } else {
284                         if (_focus_size >= label_cache.length)
285                         {
286                                 focus_first = 0;
287                                 focus_end = label_cache.length;
288                         } else {
289                                 focus_first = cur_el -_focus_size/2;
290                                 if (focus_first < 0) focus_first = 0;
291
292                                 focus_end = focus_first + _focus_size;
293                                 if (focus_end > label_cache.length)
294                                 {
295                                         focus_end = label_cache.length;
296                                         focus_first = focus_end - _focus_size;
297                                 }
298                         }
299
300                         // Compute starting positions for all items in focus
301                         for (int idx = focus_first; idx <= focus_end; ++idx)
302                                 focus_starts[idx - focus_first] = el_y(idx);
303                 }
304                 focus_layout_needed = false;
305         }
306
307         protected void draw_background(Gdk.Drawable drawable)
308         {
309                 Gtk.Style style = get_style();
310
311                 // Background
312                 drawable.draw_rectangle(style.bg_gc[Gtk.StateType.NORMAL], true, 0, 0, allocation.width, allocation.height);
313
314                 // Focus movement area
315                 drawable.draw_rectangle(style.bg_gc[Gtk.StateType.INSENSITIVE], true,
316                         allocation.width/2, 0, allocation.width, allocation.height);
317
318                 for (int y = 0; y < allocation.height/2 - 30; y += 30)
319                 {
320                         Gtk.paint_arrow(style, (Gdk.Window*)drawable, Gtk.StateType.INSENSITIVE, Gtk.ShadowType.NONE,
321                                 null, this, null, Gtk.ArrowType.UP, false,
322                                 allocation.width/2, y, allocation.width/2, 10);
323                         Gtk.paint_arrow(style, (Gdk.Window*)drawable, Gtk.StateType.INSENSITIVE, Gtk.ShadowType.NONE,
324                                 null, this, null, Gtk.ArrowType.DOWN, false,
325                                 allocation.width/2, allocation.height-y-30, allocation.width/2, 10);
326                 }
327
328                 Gdk.Rectangle expose_area = Gdk.Rectangle();
329                 expose_area.x = expose_area.y = 0;
330                 expose_area.width = allocation.width;
331                 expose_area.height = allocation.height;
332
333                 Gdk.Rectangle cell_area = Gdk.Rectangle();
334                 cell_area.x = 0;
335                 cell_area.width = allocation.width;
336                 renderers[0].get_size(this, null, null, null, null, out cell_area.height);
337                 if (label_cache.length * cell_area.height >= allocation.height)
338                 {
339                         for (int y = 0; y < allocation.height; y += cell_area.height)
340                         {
341                                 int idx = y * label_cache.length / allocation.height;
342                                 cell_area.y = y;
343                                 renderers[0].text = label_cache[idx];
344                                 renderers[0].render((Gdk.Window*)drawable, this, 
345                                                 cell_area,
346                                                 cell_area,
347                                                 expose_area,
348                                                 0);
349                         }
350                 } else {
351                         int count = int.min(allocation.height/(2*cell_area.height), label_cache.length);
352                         for (int idx = 0; idx < count; ++idx)
353                         {
354                                 cell_area.y = idx * cell_area.height;
355                                 renderers[0].text = label_cache[idx];
356                                 renderers[0].render((Gdk.Window*)drawable, this, 
357                                                 cell_area,
358                                                 cell_area,
359                                                 expose_area,
360                                                 0);
361
362                                 cell_area.y = allocation.height-cell_area.y;
363                                 renderers[0].text = label_cache[label_cache.length-idx];
364                                 renderers[0].render((Gdk.Window*)drawable, this, 
365                                                 cell_area,
366                                                 cell_area,
367                                                 expose_area,
368                                                 0);
369                         }
370                 }
371         }
372
373         protected void draw()
374         {
375                 if (base_layout_needed)
376                         base_layout();
377                 if (focus_layout_needed)
378                         focus_layout();
379
380                 var drawable = backing_store;
381                 Gtk.Style style = get_style();
382                 Gdk.Rectangle expose_area = Gdk.Rectangle();
383                 expose_area.x = expose_area.y = 0;
384                 expose_area.width = allocation.width;
385                 expose_area.height = allocation.height;
386
387                 // Background
388                 drawable.draw_drawable(
389                         get_style().fg_gc[Gtk.StateType.NORMAL],
390                         background,
391                         0, 0, 0, 0,
392                         allocation.width, allocation.height);
393
394                 // Focus lock area
395                 drawable.draw_rectangle(style.bg_gc[Gtk.StateType.ACTIVE], true,
396                         0, focus_starts[0], allocation.width/2, focus_starts[focus_end - focus_first]-focus_starts[0]);
397
398                 // Paint items around focus
399                 Gdk.Rectangle cell_area = Gdk.Rectangle();
400                 cell_area.x = 0;
401                 cell_area.width = allocation.width;
402                 for (int idx = 0; idx < focus_end-focus_first; ++idx)
403                 {
404                         int y0 = focus_starts[idx];
405                         int y1 = focus_starts[idx + 1];
406                         cell_area.y = y0;
407                         cell_area.height = y1-y0;
408
409                         Gtk.CellRendererState rflags = 0;
410                         if (idx + focus_first == cur_el)
411                         {
412                                 rflags |= Gtk.CellRendererState.SELECTED | Gtk.CellRendererState.FOCUSED;
413                                 drawable.draw_rectangle(style.bg_gc[Gtk.StateType.SELECTED], true,
414                                                 cell_area.x, cell_area.y, cell_area.width, cell_area.height);
415                         }
416                 
417                         int size = (y1-y0);
418                         if (size <= 0) size = 1;
419                         if (size >= renderers.length) size = renderers.length - 1;
420                         renderers[size].text = label_cache[idx + focus_first];
421                         renderers[size].render((Gdk.Window*)drawable, this, 
422                                         cell_area,
423                                         cell_area,
424                                         expose_area,
425                                         rflags);
426
427                         //Gdk.draw_line(drawable, style.fg_gc[itemState], 0, y0, allocation.width, y0);
428                 }
429         }
430
431         /*
432          * The following function is adapted from Prefuse's FisheyeDistortion.java.
433          *
434          * A relevant annotation from Prefuse:
435          *
436          * For more details on this form of transformation, see Manojit Sarkar and 
437          * Marc H. Brown, "Graphical Fisheye Views of Graphs", in Proceedings of 
438          * CHI'92, Human Factors in Computing Systems, p. 83-91, 1992. Available
439          * online at <a href="http://citeseer.ist.psu.edu/sarkar92graphical.html">
440          * http://citeseer.ist.psu.edu/sarkar92graphical.html</a>. 
441          */
442
443         /*
444          * Distorts an item's coordinate.
445          * @param x the undistorted coordinate
446          * @param coordinate of the anchor or focus point
447          * @param d disortion factor
448          * @param min the beginning of the display
449          * @param max the end of the display
450          * @return the distorted coordinate
451          */
452         private int fisheye(int idx)
453         {
454                 // Autocompute distortion factor
455                 // 20 is the pixel size of the item at centre of focus
456                 double d = label_cache.length * 20 / allocation.height;
457                 if ( d <= 1 )
458                         return idx * allocation.height / label_cache.length;
459
460                 double a = (double)cur_el * allocation.height / label_cache.length;
461                 double x = (double)idx * allocation.height / label_cache.length;
462                 double max = (double)allocation.height;
463
464                 if (idx < cur_el)
465                 {
466                         double m = a;
467                         if ( m == 0 ) m = max;
468                         double v = (double)(a - x) / m;
469                         v = (double)(d+1)/(d+(1/v));
470                         return (int)Math.round(a - m*v);
471                 } else {
472                         double m = max-a;
473                         if ( m == 0 ) m = max;
474                         double v = (double)(x - a) / m;
475                         v = (double)(d+1)/(d+(1/v));
476                         return (int)Math.round(a + m*v);
477                 }
478         }
479 }
480
481 public class Fisheye : Gtk.Window
482 {
483         public Fisheye()
484         {
485                 title = "Fisheye";
486                 destroy += Gtk.main_quit;
487
488                 var list = new FisheyeList();
489                 add(list);
490
491                 var store = new Gtk.ListStore(1, typeof(string));
492                 Gtk.TreeIter iter;
493                 var infd = FileStream.open("/tmp/names", "r");
494                 if (infd == null)
495                 {
496                         for (int i = 0; i < 300; ++i)
497                         {
498                                 store.append(out iter);
499                                 store.set(iter, 0, "Antani %d".printf(i), -1);
500                         }
501                 } else {
502                         char buf[255];
503                         while (true)
504                         {
505                                 string line = infd.gets(buf);
506                                 if (line == null)
507                                         break;
508                                 store.append(out iter);
509                                 store.set(iter, 0, line, -1);
510                         }
511                 }
512
513                 list.set_model(store);
514         }
515 }
516
517 static int main (string[] args) {
518         Gtk.init (ref args);
519
520         var fe = new Fisheye();
521         fe.set_size_request(200, 300);
522         fe.show_all();
523
524         Gtk.main();
525
526         return 0;
527 }