Fix PostScript output of multiple charts.
[pspp] / lib / gtksheet / gtkiconlist.c
1 /* gtkiconlist - gtkiconlist widget for gtk+
2  * Copyright 1999-2001  Adrian E. Feiguin <feiguin@ifir.edu.ar>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library 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 GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <gtk/gtk.h>
24 #include <gdk/gdkkeysyms.h>
25 #include <pango/pango.h>
26 #include "gtkitementry.h"
27 #include "gtkiconlist.h"
28 #include "gtkextra-marshal.h"
29 #include <math.h>
30
31 #define DEFAULT_ROW_SPACING     4
32 #define DEFAULT_COL_SPACING     10      
33 #define DEFAULT_TEXT_SPACE      60
34 #define DEFAULT_ICON_BORDER     2
35 #define DEFAULT_WIDTH 150
36 #define DEFAULT_HEIGHT 120
37
38 #define EVENTS_MASK    (GDK_EXPOSURE_MASK |             \
39                        GDK_POINTER_MOTION_MASK |        \
40                        GDK_POINTER_MOTION_HINT_MASK |   \
41                        GDK_BUTTON_PRESS_MASK |          \
42                        GDK_BUTTON_RELEASE_MASK)
43
44 /* Signals */
45
46 extern void 
47 _gtkextra_signal_emit(GtkObject *object, guint signal_id, ...);
48
49 enum{
50       SELECT_ICON,                       
51       UNSELECT_ICON,                       
52       TEXT_CHANGED,                       
53       ACTIVATE_ICON,                       
54       DEACTIVATE_ICON,                       
55       CLICK_EVENT,                       
56       LAST_SIGNAL,
57 };
58
59 static guint signals[LAST_SIGNAL] = {0};
60
61 static void gtk_icon_list_class_init            (GtkIconListClass *class);
62 static void gtk_icon_list_init                  (GtkIconList *icon_list);
63 static void gtk_icon_list_destroy               (GtkObject *object);
64 static void gtk_icon_list_finalize              (GObject *object);
65
66 static void gtk_icon_list_size_allocate         (GtkWidget *widget,
67                                                  GtkAllocation *allocation);
68
69 static void gtk_icon_list_realize               (GtkWidget *widget);
70 static gint gtk_icon_list_expose                (GtkWidget *widget, 
71                                                  GdkEventExpose *event);
72 static gint gtk_icon_list_button_press          (GtkWidget *widget, 
73                                                  GdkEventButton *event);
74 static gint deactivate_entry                    (GtkIconList *iconlist);
75 static gint entry_in                            (GtkWidget *widget,
76                                                  GdkEventButton *event,
77                                                  gpointer data);
78 static gint entry_changed                       (GtkWidget *widget, 
79                                                  gpointer data);
80 static void select_icon                         (GtkIconList *iconlist, 
81                                                  GtkIconListItem *item,
82                                                  GdkEvent *event);
83 static void unselect_icon                       (GtkIconList *iconlist, 
84                                                  GtkIconListItem *item,
85                                                  GdkEvent *event);
86 static void unselect_all                        (GtkIconList *iconlist); 
87 static void set_labels                          (GtkIconList *iconlist, 
88                                                  GtkIconListItem *item, 
89                                                  const gchar *label); 
90 static GtkIconListItem *get_icon_from_entry     (GtkIconList *iconlist, 
91                                                  GtkWidget *widget);
92 static void reorder_icons                       (GtkIconList *iconlist);
93 static void item_size_request                   (GtkIconList *iconlist, 
94                                                  GtkIconListItem *item,
95                                                  GtkRequisition *requisition);
96 static void gtk_icon_list_move                  (GtkIconList *iconlist, 
97                                                  GtkIconListItem *icon, 
98                                                  guint x, guint y);
99 static GtkIconListItem *gtk_icon_list_real_add  (GtkIconList *iconualist,
100                                                  GdkPixmap *pixmap,
101                                                  GdkBitmap *mask,
102                                                  const gchar *label,
103                                                  gpointer data);
104 static GtkIconListItem *gtk_icon_list_put       (GtkIconList *iconlist, 
105                                                  guint x, guint y, 
106                                                  GdkPixmap *pixmap,
107                                                  GdkBitmap *mask,
108                                                  const gchar *label,
109                                                  gpointer data);
110 static gint icon_key_press                      (GtkWidget *widget, 
111                                                  GdkEventKey *key, 
112                                                  gpointer data);
113 static gint sort_list                           (gpointer a, gpointer b);
114 static void pixmap_destroy                      (GtkPixmap* pixmap);
115
116
117 static GtkFixedClass *parent_class = NULL;
118
119 static inline guint STRING_WIDTH(GtkWidget *widget,
120                                  PangoFontDescription *font, const gchar *text)
121 {
122   PangoRectangle rect;
123   PangoLayout *layout;
124
125   layout = gtk_widget_create_pango_layout (widget, text);
126   pango_layout_set_font_description (layout, font);
127
128   pango_layout_get_pixel_extents (layout, NULL, &rect);
129
130   g_object_unref(G_OBJECT(layout));
131   return rect.width;
132 }
133
134
135 GtkType
136 gtk_icon_list_get_type (void)
137 {
138   static GtkType icon_list_type = 0;
139
140   if (!icon_list_type)
141     {
142       static const GtkTypeInfo icon_list_info =
143       {
144         "GtkIconList",
145         sizeof (GtkIconList),
146         sizeof (GtkIconListClass),
147         (GtkClassInitFunc) gtk_icon_list_class_init,
148         (GtkObjectInitFunc) gtk_icon_list_init,
149         /* reserved 1*/ NULL,
150         /* reserved 2 */ NULL,
151         (GtkClassInitFunc) NULL,
152       };
153
154       icon_list_type = gtk_type_unique (GTK_TYPE_FIXED, &icon_list_info);
155     }
156   return icon_list_type;
157 }
158
159 static GtkIconListItem*
160 gtk_icon_list_item_copy (const GtkIconListItem *item)
161 {
162   GtkIconListItem *new_item;
163
164   g_return_val_if_fail (item != NULL, NULL);
165
166   new_item = g_new (GtkIconListItem, 1);
167
168   *new_item = *item;
169
170   return new_item;
171 }
172
173 static void
174 gtk_icon_list_item_free (GtkIconListItem *item)
175 {
176   g_return_if_fail (item != NULL);
177
178   g_free (item);
179 }
180
181
182 GType
183 gtk_icon_list_item_get_type (void)
184 {
185   static GType icon_list_item_type;
186
187   if(!icon_list_item_type)
188   {
189     icon_list_item_type = g_boxed_type_register_static("GtkIconListItem", (GBoxedCopyFunc)gtk_icon_list_item_copy, (GBoxedFreeFunc)gtk_icon_list_item_free);
190   }
191   return icon_list_item_type;
192 }
193  
194
195 static void
196 gtk_icon_list_class_init (GtkIconListClass *klass)
197 {
198   GtkObjectClass *object_class;
199   GObjectClass *gobject_class;
200   GtkWidgetClass *widget_class;
201
202   parent_class = gtk_type_class (GTK_TYPE_FIXED);
203
204   object_class = (GtkObjectClass *) klass;
205   gobject_class = (GObjectClass *) klass;
206   widget_class = (GtkWidgetClass *) klass;
207
208   object_class->destroy = gtk_icon_list_destroy;
209   gobject_class->finalize = gtk_icon_list_finalize;
210
211   widget_class->realize = gtk_icon_list_realize;
212
213   widget_class->size_allocate = gtk_icon_list_size_allocate;
214
215   widget_class->expose_event = gtk_icon_list_expose;
216   widget_class->button_press_event = gtk_icon_list_button_press;
217
218   signals[SELECT_ICON] =
219       gtk_signal_new("select_icon",
220                      GTK_RUN_LAST,
221                      GTK_CLASS_TYPE(object_class),
222                      GTK_SIGNAL_OFFSET(GtkIconListClass, select_icon),
223                      gtkextra_BOOLEAN__BOXED_BOXED,
224                      GTK_TYPE_BOOL, 2,
225                      GTK_TYPE_ICON_LIST_ITEM, GDK_TYPE_EVENT); 
226
227   signals[UNSELECT_ICON] =
228       gtk_signal_new("unselect_icon",
229                      GTK_RUN_FIRST,
230                      GTK_CLASS_TYPE(object_class),
231                      GTK_SIGNAL_OFFSET(GtkIconListClass, unselect_icon),
232                      gtkextra_VOID__BOXED_BOXED,
233                      GTK_TYPE_NONE, 2,
234                      GTK_TYPE_ICON_LIST_ITEM, GDK_TYPE_EVENT); 
235
236   signals[TEXT_CHANGED] =
237       gtk_signal_new("text_changed",
238                      GTK_RUN_LAST,
239                      GTK_CLASS_TYPE(object_class),
240                      GTK_SIGNAL_OFFSET(GtkIconListClass, text_changed),
241                      gtkextra_BOOLEAN__BOXED_STRING,
242                      GTK_TYPE_BOOL, 2,
243                      GTK_TYPE_ICON_LIST_ITEM, GTK_TYPE_STRING); 
244
245   signals[ACTIVATE_ICON] =
246       gtk_signal_new("activate_icon",
247                      GTK_RUN_LAST,
248                      GTK_CLASS_TYPE(object_class),
249                      GTK_SIGNAL_OFFSET(GtkIconListClass, activate_icon),
250                      gtkextra_BOOLEAN__BOXED,
251                      GTK_TYPE_BOOL, 1,
252                      GTK_TYPE_ICON_LIST_ITEM); 
253
254   signals[DEACTIVATE_ICON] =
255       gtk_signal_new("deactivate_icon",
256                      GTK_RUN_LAST,
257                      GTK_CLASS_TYPE(object_class),
258                      GTK_SIGNAL_OFFSET(GtkIconListClass, deactivate_icon),
259                      gtkextra_BOOLEAN__BOXED,
260                      GTK_TYPE_BOOL, 1,
261                      GTK_TYPE_ICON_LIST_ITEM); 
262
263   signals[CLICK_EVENT] =
264       gtk_signal_new("click_event",
265                      GTK_RUN_LAST,
266                      GTK_CLASS_TYPE(object_class),
267                      GTK_SIGNAL_OFFSET(GtkIconListClass, click_event),
268                      gtkextra_VOID__BOXED,
269                      GTK_TYPE_NONE, 1,
270                      GDK_TYPE_EVENT); 
271  
272 }
273
274 void
275 gtk_icon_list_freeze(GtkIconList *iconlist)
276 {
277  iconlist->freeze_count++;
278 }
279
280 void
281 gtk_icon_list_thaw(GtkIconList *iconlist)
282 {
283  if(iconlist->freeze_count == 0) return;
284  iconlist->freeze_count--;
285  if(iconlist->freeze_count == 0)
286                reorder_icons(iconlist);
287 }
288
289 void
290 gtk_icon_list_update(GtkIconList *iconlist)
291 {
292   reorder_icons(iconlist);
293 }
294
295 static void
296 reorder_icons(GtkIconList *iconlist)
297 {
298   GtkWidget *widget;
299   GtkIconListItem *item;
300   GtkRequisition req;
301   GList *icons;
302   gint hspace = 0;
303   gint vspace = 0;
304   gint x = 0;
305   gint y = 0;
306   gint old_width, old_height;
307
308   widget = GTK_WIDGET(iconlist);
309
310   if(iconlist->freeze_count > 0) return;
311
312 /*
313   gdk_threads_enter();
314 */
315
316   old_width = widget->allocation.width;
317   old_height = widget->allocation.height;
318   if(GTK_WIDGET_REALIZED(widget)){
319     if(GTK_IS_VIEWPORT(widget->parent))
320      gdk_window_get_size(GTK_VIEWPORT(widget->parent)->view_window, &old_width, &old_height);
321   }
322
323   y = iconlist->row_spacing;
324   x = iconlist->col_spacing;
325
326   icons = iconlist->icons;
327   while(icons){
328     item = (GtkIconListItem *) icons->data;
329
330     gtk_icon_list_move(iconlist, item, x, y);
331
332     item_size_request(iconlist, item, &req);
333  
334     vspace = req.height + iconlist->row_spacing;
335     hspace = req.width + iconlist->col_spacing;
336
337     switch(iconlist->mode){
338       case GTK_ICON_LIST_TEXT_RIGHT:
339         y += vspace;
340         if(y + vspace >= old_height - DEFAULT_COL_SPACING){
341                 x += hspace;
342                 y = iconlist->row_spacing;
343         }
344         break;
345       case GTK_ICON_LIST_TEXT_BELOW:
346       case GTK_ICON_LIST_ICON:
347       default:
348         x += hspace;
349         if(x + hspace >= old_width - DEFAULT_COL_SPACING){
350                 x = iconlist->col_spacing;
351                 y += vspace;
352         }
353         break;
354     }
355
356     icons = icons->next;
357
358    }
359 /*
360   gdk_threads_leave();
361 */
362 }
363
364
365 static void
366 gtk_icon_list_move(GtkIconList *iconlist, GtkIconListItem *icon, 
367                    guint x, guint y)
368 {
369   GtkRequisition req1, req2;
370   GtkRequisition req;
371   GtkAllocation a;
372   const gchar *text;
373   gint old_width, old_height, width, height;
374   gint old_x, old_y;
375   gint size;
376
377   old_x = icon->x;
378   old_y = icon->y;
379
380   icon->x = x;
381   icon->y = y;
382
383   if(x == old_x && y == old_y) return;
384
385   item_size_request(iconlist, icon, &req);
386   req1 = icon->pixmap->requisition;
387   req2 = icon->entry->requisition;
388   req2.width = iconlist->text_space;
389
390   req1.width += 2*iconlist->icon_border;
391   req1.height += 2*iconlist->icon_border;
392   if(iconlist->mode == GTK_ICON_LIST_TEXT_BELOW){
393      req1.width = MAX(req1.width, req.width);
394   }
395
396   if(iconlist->mode == GTK_ICON_LIST_ICON) 
397           req2.width = req2.height = 0;
398
399   old_width = width = GTK_WIDGET(iconlist)->allocation.width;
400   old_height = height = GTK_WIDGET(iconlist)->allocation.height;
401
402   gtk_fixed_move(GTK_FIXED(iconlist), icon->pixmap, 
403                  x + req1.width/2 - icon->pixmap->requisition.width/2, 
404                  y + iconlist->icon_border);
405
406   icon->pixmap->allocation.x += (x - old_x);
407   icon->pixmap->allocation.y += (y - old_y);
408   icon->entry->allocation.x += (x - old_x);
409   icon->entry->allocation.y += (y - old_y);
410   icon->entry->allocation.width = req2.width;
411
412
413   switch(iconlist->mode){
414    case GTK_ICON_LIST_TEXT_BELOW:
415         text = gtk_entry_get_text(GTK_ENTRY(icon->entry));
416         size = STRING_WIDTH(icon->entry, icon->entry->style->font_desc, text);
417         size = MIN(size, req2.width);
418
419         gtk_fixed_move(GTK_FIXED(iconlist), icon->entry, 
420                         x - req2.width/2 + req1.width/2, 
421                         y + req1.height + iconlist->icon_border);
422
423         if(y + req.height > height) 
424            height += req.height;
425         break;
426    case GTK_ICON_LIST_TEXT_RIGHT:
427         gtk_fixed_move(GTK_FIXED(iconlist), icon->entry, 
428                         x + req1.width + iconlist->icon_border, 
429                         y + req1.height/2 - req2.height/2); 
430
431         if(x + req.width > width) 
432             width += req.width;
433         break;
434    case GTK_ICON_LIST_ICON:
435    default: ;
436   }
437
438   a = icon->entry->allocation;
439
440   gtk_widget_size_allocate(icon->pixmap, &icon->pixmap->allocation);
441   if(icon->entry){
442     gtk_widget_size_allocate(icon->entry, &a);
443     gtk_widget_draw(icon->entry, NULL);
444   }
445
446 }
447
448
449 static void
450 gtk_icon_list_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
451 {
452   GtkAllocation *old = gtk_object_get_data(GTK_OBJECT(widget),"viewport");
453   GTK_WIDGET_CLASS(parent_class)->size_allocate(widget, allocation);
454   if(GTK_WIDGET_REALIZED(widget) && old){
455     gint new_width, new_height;
456     gdk_window_get_size(GTK_VIEWPORT(widget->parent)->view_window, &new_width, &new_height);
457     if(old->width != new_width || old->height != new_height)
458       reorder_icons(GTK_ICON_LIST(widget));
459     old->width = new_width; 
460     old->height = new_height; 
461   }
462 }
463
464
465 static void
466 gtk_icon_list_realize(GtkWidget *widget)
467 {
468   GList *icons;
469   GtkIconList *iconlist;
470   GtkIconListItem *item;
471   GtkStyle *style;
472   
473   GTK_WIDGET_CLASS(parent_class)->realize (widget);
474
475   iconlist = GTK_ICON_LIST(widget);
476
477   style = gtk_style_copy(widget->style);
478
479   style->bg[0] = iconlist->background;
480   gtk_widget_set_style(widget, style);
481   gtk_style_set_background(style, widget->window, GTK_STATE_NORMAL);
482   gtk_style_set_background(style, widget->window, GTK_STATE_ACTIVE);
483
484   icons = iconlist->icons;
485   while(icons){
486     item = (GtkIconListItem *) icons->data;
487     gtk_widget_draw(item->pixmap, NULL);
488     if(iconlist->mode != GTK_ICON_LIST_ICON){
489       GtkStyle *style;
490
491       gtk_widget_realize(item->entry);
492
493       style = gtk_style_copy(item->entry->style);
494       style->bg[GTK_STATE_ACTIVE] = iconlist->background;
495       style->bg[GTK_STATE_NORMAL] = iconlist->background;
496       gtk_widget_set_style(item->entry, style);
497       gtk_widget_show(item->entry);
498     }
499     if(item->entry) gtk_widget_draw(item->entry, NULL);
500     icons = icons->next;
501   }
502
503 /*  
504   if(GTK_IS_VIEWPORT(widget->parent) && GTK_WIDGET_REALIZED(widget->parent)){
505     GtkAllocation *allocation = gtk_object_get_data(GTK_OBJECT(widget),"viewport");
506     gdk_window_get_size(GTK_VIEWPORT(widget->parent)->view_window, &allocation->width, &allocation->height);
507   }
508   reorder_icons(iconlist);
509 */
510 }
511
512
513 static void
514 gtk_icon_list_init (GtkIconList *icon_list)
515 {
516   GtkWidget *widget;
517   widget = GTK_WIDGET(icon_list);
518
519   gtk_widget_ensure_style(widget);
520   gdk_color_black(gtk_widget_get_colormap(widget), &widget->style->black);
521   gdk_color_white(gtk_widget_get_colormap(widget), &widget->style->white);
522
523   gtk_fixed_set_has_window(GTK_FIXED(widget), TRUE);
524
525   gtk_widget_set_events (widget, gtk_widget_get_events(widget)|
526                          EVENTS_MASK);
527
528   icon_list->selection = NULL;
529   icon_list->is_editable = TRUE;
530
531   icon_list->num_icons = 0;
532   icon_list->background = widget->style->white;
533
534   icon_list->row_spacing = DEFAULT_ROW_SPACING;
535   icon_list->col_spacing = DEFAULT_COL_SPACING;
536   icon_list->text_space = DEFAULT_TEXT_SPACE;
537   icon_list->icon_border = DEFAULT_ICON_BORDER;
538
539   icon_list->active_icon = NULL;
540   icon_list->compare_func = (GCompareFunc)sort_list;
541 }
542
543 static gint 
544 sort_list(gpointer a, gpointer b)
545 {
546   GtkIconListItem *itema;
547   GtkIconListItem *itemb;
548
549   itema = (GtkIconListItem *)a;
550   itemb = (GtkIconListItem *)b;
551
552   return (strcmp(itema->label, itemb->label));
553 }
554
555 static gboolean
556 gtk_icon_list_expose (GtkWidget *widget, GdkEventExpose *event)
557 {
558   GtkIconList *icon_list;
559
560   icon_list = GTK_ICON_LIST(widget);
561
562   if(!GTK_WIDGET_DRAWABLE(widget)) return FALSE;
563
564   gtk_paint_flat_box (widget->style, widget->window, GTK_STATE_NORMAL,
565                       GTK_SHADOW_NONE, &event->area, widget, "base", 0, 0, -1, -1);
566
567   GTK_WIDGET_CLASS(parent_class)->expose_event(widget, event);
568
569   if(icon_list->active_icon && icon_list->active_icon->entry){
570         gdk_draw_rectangle(widget->window,
571                            widget->style->black_gc,
572                            FALSE,
573                            icon_list->active_icon->entry->allocation.x-2,
574                            icon_list->active_icon->entry->allocation.y-2,
575                            icon_list->active_icon->entry->allocation.width+4,
576                            icon_list->active_icon->entry->allocation.height+4);
577   }
578
579   return FALSE;
580 }
581
582 static gint
583 gtk_icon_list_button_press(GtkWidget *widget, GdkEventButton *event)
584 {
585   GtkIconList *iconlist;
586   GtkIconListItem *item;
587   gint x, y;
588   GtkAllocation *allocation;
589
590   if(!GTK_IS_ICON_LIST(widget)) return FALSE;
591
592   iconlist = GTK_ICON_LIST(widget);
593
594
595   gtk_widget_get_pointer(widget, &x, &y);
596   item = gtk_icon_list_get_icon_at(iconlist, x , y );
597
598   if(!item){ 
599      gtk_signal_emit(GTK_OBJECT(iconlist), signals[CLICK_EVENT],
600                      event);
601      return FALSE;
602   }
603
604   if(item->entry){
605     allocation = &item->entry->allocation;
606     if(x >= allocation->x &&
607        x <= allocation->x + allocation->width &&
608        y >= allocation->y &&
609        y <= allocation->y + allocation->height) return FALSE;
610   }
611
612   if(item)
613    switch(iconlist->selection_mode){
614      case GTK_SELECTION_SINGLE:
615      case GTK_SELECTION_BROWSE:
616         unselect_all(iconlist);
617      case GTK_SELECTION_MULTIPLE:
618         select_icon(iconlist, item, (GdkEvent *)event);
619      case GTK_SELECTION_NONE:
620         break;
621    }
622
623   return FALSE;
624 }
625
626
627 static gint 
628 deactivate_entry(GtkIconList *iconlist)
629 {
630   GdkGC *gc;
631   GtkEntry *entry;
632   gboolean veto = TRUE;
633
634   if(iconlist->active_icon) {
635      _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[DEACTIVATE_ICON], 
636                      iconlist->active_icon, &veto);
637      if(!veto) return FALSE;
638
639      entry = GTK_ENTRY(iconlist->active_icon->entry);
640
641      if(!entry || !GTK_WIDGET_REALIZED(entry)) return TRUE;
642      gtk_entry_set_editable(entry, FALSE);    
643      gtk_entry_select_region(entry, 0, 0);
644      gtk_item_entry_set_cursor_visible(GTK_ITEM_ENTRY(entry), FALSE);
645
646      switch(iconlist->mode){
647        case GTK_ICON_LIST_TEXT_RIGHT:
648          gtk_item_entry_set_text(GTK_ITEM_ENTRY(entry), 
649                                  iconlist->active_icon->entry_label,
650                                  GTK_JUSTIFY_LEFT);
651          break;
652        case GTK_ICON_LIST_TEXT_BELOW:
653          gtk_item_entry_set_text(GTK_ITEM_ENTRY(entry), 
654                                  iconlist->active_icon->entry_label,
655                                  GTK_JUSTIFY_CENTER);
656          break;
657        case GTK_ICON_LIST_ICON:
658        default:
659          break;
660      }
661
662      if(GTK_WIDGET_REALIZED(iconlist->active_icon->entry)){
663        gc = gdk_gc_new(GTK_WIDGET(iconlist)->window);
664        gdk_gc_set_foreground(gc, &iconlist->background);
665        gdk_draw_rectangle(GTK_WIDGET(iconlist)->window,
666                           gc,
667                           FALSE,
668                           GTK_WIDGET(entry)->allocation.x-2,
669                           GTK_WIDGET(entry)->allocation.y-2,
670                           GTK_WIDGET(entry)->allocation.width+4,
671                           GTK_WIDGET(entry)->allocation.height+4);
672        gdk_gc_unref(gc);
673      }
674
675      iconlist->active_icon->state = GTK_STATE_NORMAL;
676      iconlist->active_icon = NULL;
677   }
678
679   return TRUE;
680 }
681
682
683 static void
684 select_icon(GtkIconList *iconlist, GtkIconListItem *item, GdkEvent *event)
685 {
686   gboolean veto = TRUE;
687
688   if(item == NULL) return;
689
690   _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[SELECT_ICON], item, 
691                   event, &veto);                        
692
693   if(!veto) return;
694
695   if(iconlist->mode != GTK_ICON_LIST_ICON){ 
696     if(!deactivate_entry(iconlist)) return;
697
698     if(item->entry && GTK_WIDGET_REALIZED(item->entry)){
699       GtkStyle *style = gtk_style_copy(item->entry->style);
700       style->bg[GTK_STATE_ACTIVE] = style->base[GTK_STATE_SELECTED];
701       style->bg[GTK_STATE_NORMAL] = style->base[GTK_STATE_SELECTED];
702       style->text[GTK_STATE_ACTIVE] = style->text[GTK_STATE_SELECTED];
703       style->text[GTK_STATE_NORMAL] = style->text[GTK_STATE_SELECTED];
704       gtk_widget_set_style(item->entry, style);
705       gtk_style_unref(style);
706
707       switch(iconlist->mode){
708         case GTK_ICON_LIST_TEXT_RIGHT:
709           gtk_item_entry_set_text(GTK_ITEM_ENTRY(item->entry), 
710                                   item->label,
711                                   GTK_JUSTIFY_LEFT);
712           break;
713         case GTK_ICON_LIST_TEXT_BELOW:
714           gtk_item_entry_set_text(GTK_ITEM_ENTRY(item->entry), 
715                                   item->label,
716                                   GTK_JUSTIFY_CENTER);
717           break;
718         case GTK_ICON_LIST_ICON:
719         default:
720           break;
721       }
722     }
723   }
724   if(item->state == GTK_STATE_SELECTED) return;
725   iconlist->selection = g_list_append(iconlist->selection, item);
726
727   item->state = GTK_STATE_SELECTED;  
728   if(item->entry) gtk_widget_grab_focus(item->entry);
729 }
730
731 static void
732 unselect_icon(GtkIconList *iconlist, GtkIconListItem *item, GdkEvent *event)
733 {
734   GList *selection;
735   GtkIconListItem *icon;
736
737   if(!item) return;
738
739   if(item->state == GTK_STATE_NORMAL) return;
740
741   selection = iconlist->selection;
742   while(selection){
743     icon = (GtkIconListItem *)selection->data; 
744     if(item == icon) break;
745     selection = selection->next;
746   }
747
748   if(selection){
749        iconlist->selection = g_list_remove_link(iconlist->selection, selection);
750   }
751  
752   item->state = GTK_STATE_NORMAL;
753
754   if(iconlist->mode != GTK_ICON_LIST_ICON){
755    if(item->entry && GTK_WIDGET_REALIZED(item->entry)){
756      GtkStyle *style = gtk_style_copy(item->entry->style);
757
758      style->bg[GTK_STATE_ACTIVE] = iconlist->background;
759      style->bg[GTK_STATE_NORMAL] = iconlist->background;
760      style->text[GTK_STATE_ACTIVE] = GTK_WIDGET(iconlist)->style->text[GTK_STATE_ACTIVE];
761      style->text[GTK_STATE_NORMAL] = GTK_WIDGET(iconlist)->style->text[GTK_STATE_NORMAL];
762      gtk_widget_set_style(item->entry, style);
763      gtk_style_unref(style);
764
765      gtk_entry_select_region(GTK_ENTRY(item->entry), 0, 0);
766      gtk_entry_set_text(GTK_ENTRY(item->entry), item->entry_label);
767      gtk_entry_set_editable(GTK_ENTRY(item->entry), FALSE);
768      gtk_widget_draw(item->entry, NULL);
769
770    }
771   }
772
773   gtk_signal_emit(GTK_OBJECT(iconlist), signals[UNSELECT_ICON], item, event);                        
774 }
775
776 static void
777 unselect_all(GtkIconList *iconlist)
778 {
779   GList *selection;
780   GtkIconListItem *item;
781
782   selection = iconlist->selection;
783   while(selection){
784     item = (GtkIconListItem *)selection->data;
785     unselect_icon(iconlist, item, NULL);
786     selection = iconlist->selection;
787   }
788
789   g_list_free(iconlist->selection);
790   iconlist->selection = NULL;
791 }
792
793 GtkWidget*
794 gtk_icon_list_new (guint icon_width, GtkIconListMode mode)
795 {
796   GtkIconList *icon_list;
797   GtkAllocation *allocation;
798
799   icon_list = gtk_type_new (gtk_icon_list_get_type ());
800
801   gtk_icon_list_construct(icon_list, icon_width, mode);
802   allocation = g_new0(GtkAllocation, 1);
803   gtk_object_set_data(GTK_OBJECT(icon_list), "viewport", allocation);
804
805   return GTK_WIDGET (icon_list);
806 }
807
808 void
809 gtk_icon_list_construct (GtkIconList *icon_list, guint icon_width, GtkIconListMode mode)
810 {
811   icon_list->icon_width = icon_width;
812   icon_list->mode = mode;
813   icon_list->icons = NULL;
814   icon_list->selection = NULL;
815   icon_list->selection_mode = GTK_SELECTION_SINGLE;
816 }
817
818 void
819 gtk_icon_list_set_mode (GtkIconList *iconlist, GtkIconListMode mode)
820 {
821   GList *icons;
822
823   iconlist->mode = mode;
824
825   icons = iconlist->icons;
826   while(icons){
827     GtkIconListItem *item;
828
829     item = (GtkIconListItem *)icons->data;
830
831     switch(mode){
832       case GTK_ICON_LIST_TEXT_RIGHT:
833         gtk_item_entry_set_justification(GTK_ITEM_ENTRY(item->entry), 
834                                          GTK_JUSTIFY_LEFT);
835         break;
836       case GTK_ICON_LIST_TEXT_BELOW:
837         gtk_item_entry_set_justification(GTK_ITEM_ENTRY(item->entry), 
838                                          GTK_JUSTIFY_CENTER);
839         break;
840       case GTK_ICON_LIST_ICON:
841       default:
842         break;
843     }
844     
845     icons = icons->next;
846   }
847  
848   reorder_icons(iconlist); 
849 }
850
851 GtkIconListMode
852 gtk_icon_list_get_mode (GtkIconList *iconlist)
853 {
854   return(iconlist->mode);
855 }
856
857 void
858 gtk_icon_list_set_text_space (GtkIconList *iconlist, guint text_space)
859 {
860   GList *icons;
861
862   iconlist->text_space = text_space;
863
864   icons = iconlist->icons;
865   while(icons){
866     GtkIconListItem *item;
867
868     item = (GtkIconListItem *)icons->data;
869     
870     if(item->entry) GTK_ITEM_ENTRY(item->entry)->text_max_size = text_space;
871     
872     icons = icons->next;
873   }
874  
875   reorder_icons(iconlist); 
876 }
877
878
879 static void
880 gtk_icon_list_destroy (GtkObject *object)
881 {
882   GtkIconList *icon_list;
883
884   g_return_if_fail (object != NULL);
885   g_return_if_fail (GTK_IS_ICON_LIST (object));
886
887   icon_list = GTK_ICON_LIST (object);
888
889   gtk_icon_list_clear(icon_list);
890
891   if (GTK_OBJECT_CLASS (parent_class)->destroy)
892     (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
893 }
894
895 static void
896 gtk_icon_list_finalize (GObject *object)
897 {
898   GtkIconList *icon_list;
899   GtkAllocation *allocation;
900
901   icon_list = GTK_ICON_LIST (object);
902
903   allocation = gtk_object_get_data(GTK_OBJECT(icon_list), "viewport");
904   if(allocation) g_free(allocation);
905   gtk_object_set_data(GTK_OBJECT(icon_list), "viewport", NULL);
906
907   if (G_OBJECT_CLASS (parent_class)->finalize)
908     (*G_OBJECT_CLASS (parent_class)->finalize) (object);
909 }
910
911 void
912 gtk_icon_list_set_background (GtkIconList *iconlist, GdkColor *color)
913 {
914   GtkWidget *widget;
915   GtkStyle *style;
916   
917   g_return_if_fail (iconlist != NULL);
918   g_return_if_fail (GTK_IS_ICON_LIST (iconlist));
919
920   widget = GTK_WIDGET(iconlist);
921
922   iconlist->background = *color;
923
924   style = gtk_style_copy(widget->style);
925   style->bg[0] = iconlist->background;
926
927   gtk_widget_set_style(widget, style);
928   if(widget->window) gdk_window_set_background(widget->window, color);
929   gtk_style_unref(style);
930
931 }
932
933 static gint
934 entry_changed (GtkWidget *widget, gpointer data)
935 {
936   GtkIconList *iconlist;
937   GtkIconListItem *item;
938   gboolean veto = TRUE;
939   const gchar *text;
940
941   iconlist = GTK_ICON_LIST(data);
942   item = get_icon_from_entry(iconlist, widget);
943   text = gtk_entry_get_text(GTK_ENTRY(widget));
944
945   _gtkextra_signal_emit(GTK_OBJECT(data), signals[TEXT_CHANGED],
946                   item, text, &veto);
947
948   if(!veto) return veto; 
949
950   if(item->entry && gtk_editable_get_editable(GTK_EDITABLE(item->entry))){
951     if(item->label) g_free(item->label);
952     if(text) item->label = g_strdup(text); 
953     if(item->entry_label) g_free(item->entry_label);
954     set_labels(iconlist, item, text); 
955   }
956
957   return veto;
958
959                   
960 static gint
961 entry_in (GtkWidget *widget, GdkEventButton *event, gpointer data)
962 {
963   GtkIconList *iconlist;
964   GtkIconListItem *item;
965   gboolean veto = TRUE;
966
967   if(!GTK_IS_ENTRY(widget)) return FALSE;
968   iconlist = GTK_ICON_LIST(data);
969
970   item = get_icon_from_entry(iconlist, widget);
971   if(iconlist->active_icon && iconlist->active_icon->entry == widget) 
972           return FALSE;
973
974   _gtkextra_signal_emit(GTK_OBJECT(iconlist), signals[ACTIVATE_ICON], &item, &veto);
975
976   if(!veto) return FALSE; 
977   if(!deactivate_entry(iconlist)) return FALSE;
978
979   if(item->state == GTK_STATE_SELECTED){
980    if(iconlist->is_editable && !gtk_editable_get_editable(GTK_EDITABLE(widget))){
981      unselect_all(iconlist);
982
983      gtk_entry_set_editable(GTK_ENTRY(widget), TRUE);
984      gtk_item_entry_set_cursor_visible(GTK_ITEM_ENTRY(widget), TRUE);
985      if(item->label) gtk_entry_set_text(GTK_ENTRY(widget), item->label);
986      iconlist->active_icon = item;
987      item->state = GTK_STATE_NORMAL;
988
989      if(GTK_WIDGET_DRAWABLE(widget)) 
990        gdk_draw_rectangle(GTK_WIDGET(iconlist)->window,
991                           widget->style->black_gc,
992                           FALSE,
993                           iconlist->active_icon->entry->allocation.x-2,
994                           iconlist->active_icon->entry->allocation.y-2,
995                           iconlist->active_icon->entry->allocation.width+4,
996                           iconlist->active_icon->entry->allocation.height+4);
997    }else{
998      gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "button_press_event"); 
999      if(iconlist->selection_mode == GTK_SELECTION_SINGLE ||
1000         iconlist->selection_mode == GTK_SELECTION_BROWSE) 
1001           unselect_all(iconlist);
1002      select_icon(iconlist, item, (GdkEvent *)event);
1003    }
1004   }else{
1005      if(iconlist->selection_mode == GTK_SELECTION_SINGLE ||
1006         iconlist->selection_mode == GTK_SELECTION_BROWSE) 
1007           unselect_all(iconlist);
1008      select_icon(iconlist, item, (GdkEvent *)event);
1009   }
1010
1011   return FALSE;
1012 }
1013
1014 GtkIconListItem *
1015 gtk_icon_list_get_active_icon(GtkIconList *iconlist)
1016 {
1017   return iconlist->active_icon;
1018 }
1019
1020 static GtkIconListItem *
1021 get_icon_from_entry(GtkIconList *iconlist, GtkWidget *widget)
1022 {
1023   GList *icons;
1024   GtkIconListItem *item;
1025
1026   icons = iconlist->icons;
1027   while(icons){
1028     item = (GtkIconListItem *) icons->data;
1029     if(widget == item->entry) return item;
1030     icons = icons->next;
1031   }
1032
1033   return NULL;
1034 }
1035
1036 GtkIconListItem *
1037 gtk_icon_list_get_icon_at(GtkIconList *iconlist, gint x, gint y)
1038 {
1039   GList *icons;
1040   GtkIconListItem *item;
1041   GtkRequisition req;
1042
1043   icons = iconlist->icons;
1044   while(icons){
1045     item = (GtkIconListItem *) icons->data;
1046     item_size_request(iconlist, item, &req);
1047     if(x >= item->x && x <= item->x + req.width &&
1048        y >= item->y && y <= item->y + req.height) return item;
1049     icons = icons->next;
1050   }
1051
1052   return NULL;
1053 }
1054
1055 GtkIconListItem *
1056 gtk_icon_list_add (GtkIconList *iconlist, 
1057                    const gchar *file,
1058                    const gchar *label,
1059                    gpointer link)
1060 {
1061   GtkIconListItem *item;
1062   GdkColormap *colormap;
1063   GdkPixmap *pixmap;
1064   GdkBitmap *mask;
1065
1066   colormap = gdk_colormap_get_system();
1067   pixmap = gdk_pixmap_colormap_create_from_xpm(NULL, colormap, &mask, NULL, 
1068                                                file);
1069   item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link);
1070   return item;
1071 }
1072
1073 GtkIconListItem *
1074 gtk_icon_list_add_from_data (GtkIconList *iconlist, 
1075                              gchar **data,
1076                              const gchar *label,
1077                              gpointer link)
1078 {
1079   GtkIconListItem *item;
1080   GdkColormap *colormap;
1081   GdkPixmap *pixmap;
1082   GdkBitmap *mask;
1083
1084   colormap = gdk_colormap_get_system();
1085   pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &mask, NULL, 
1086                                                  data);
1087   item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link);
1088   return item;
1089 }
1090
1091 GtkIconListItem *
1092 gtk_icon_list_add_from_pixmap (GtkIconList *iconlist, 
1093                                GdkPixmap *pixmap,
1094                                GdkBitmap *mask,
1095                                const gchar *label,
1096                                gpointer link)
1097 {
1098   GtkIconListItem *item;
1099
1100   gdk_pixmap_ref(pixmap);
1101   if(mask) gdk_bitmap_ref(mask);
1102   item = gtk_icon_list_real_add(iconlist, pixmap, mask, label, link);
1103   return item;
1104 }
1105
1106
1107 static GtkIconListItem*
1108 gtk_icon_list_real_add (GtkIconList *iconlist, 
1109                         GdkPixmap *pixmap,
1110                         GdkBitmap *mask,
1111                         const gchar *label,
1112                         gpointer data)
1113 {
1114   GtkIconListItem *item;
1115   GtkRequisition requisition;
1116   gint hspace = 0;
1117   gint vspace = 0;
1118   gint x = 0;
1119   gint y = 0;
1120   gint width, height;
1121
1122   width = GTK_WIDGET(iconlist)->allocation.width;
1123   height = GTK_WIDGET(iconlist)->allocation.height;
1124
1125   if(iconlist->num_icons > 0){
1126     item = gtk_icon_list_get_nth(iconlist, iconlist->num_icons-1);
1127     x = item->x;
1128     y = item->y;
1129     item_size_request(iconlist, item, &requisition);
1130  
1131     vspace = requisition.height + iconlist->row_spacing;
1132     hspace = requisition.width + iconlist->col_spacing;
1133
1134     switch(iconlist->mode){
1135       case GTK_ICON_LIST_TEXT_RIGHT:
1136         y += vspace;
1137         if(y >= height){
1138                 x += hspace;
1139                 y = iconlist->row_spacing;
1140         }
1141         break;
1142       case GTK_ICON_LIST_TEXT_BELOW:
1143       case GTK_ICON_LIST_ICON:
1144       default:
1145         x += hspace;
1146         if(x >= width){
1147                 x = iconlist->col_spacing;
1148                 y += vspace;
1149         }
1150         break;
1151     }
1152   } else {
1153     y = iconlist->row_spacing;
1154     x = iconlist->col_spacing;
1155   }
1156
1157   item = gtk_icon_list_put(iconlist, x, y, pixmap, mask, label, data);
1158   return item;
1159 }
1160
1161 static GtkIconListItem *
1162 gtk_icon_list_put (GtkIconList *iconlist, 
1163                    guint x, guint y, 
1164                    GdkPixmap *pixmap,
1165                    GdkBitmap *mask,
1166                    const gchar *label,
1167                    gpointer data)
1168 {
1169   GtkIconListItem *icon;
1170   GtkIconListItem *active_icon;
1171   GtkWidget *widget;
1172   GtkRequisition req, req1, req2;
1173   gint text_width;
1174   gint width, height, old_width, old_height;
1175   GtkAllocation alloc;
1176
1177   widget = GTK_WIDGET(iconlist);
1178
1179   old_width = width = GTK_WIDGET(iconlist)->allocation.width;
1180   old_height = height = GTK_WIDGET(iconlist)->allocation.height;
1181
1182   active_icon = iconlist->active_icon;
1183   gtk_icon_list_set_active_icon(iconlist, NULL);
1184
1185   icon = g_new(GtkIconListItem, 1);
1186   icon->x = x;
1187   icon->y = y;
1188   icon->state = GTK_STATE_NORMAL;
1189   icon->label = NULL;
1190   icon->entry_label = NULL;
1191   if(label) icon->label = g_strdup(label);
1192   icon->entry = gtk_item_entry_new();
1193   icon->pixmap = gtk_pixmap_new(pixmap, mask);
1194   icon->link = data;
1195
1196   GTK_ITEM_ENTRY(icon->entry)->text_max_size = iconlist->text_space; 
1197   item_size_request(iconlist, icon, &req);
1198   req1 = icon->pixmap->requisition;
1199   req2 = icon->entry->requisition;
1200   req2.width = iconlist->text_space; 
1201
1202   req1.width += 2*iconlist->icon_border;
1203   req1.height += 2*iconlist->icon_border;
1204   if(iconlist->mode == GTK_ICON_LIST_TEXT_BELOW){
1205      req1.width = MAX(req1.width, req.width);
1206   }
1207
1208   if(iconlist->mode == GTK_ICON_LIST_ICON) 
1209           req2.width = req2.height = 0;
1210   else
1211           set_labels(iconlist, icon, label);
1212
1213   text_width = 0;
1214   if(label) text_width = STRING_WIDTH(icon->entry, icon->entry->style->font_desc, label);
1215
1216   gtk_fixed_put(GTK_FIXED(iconlist), icon->pixmap, 
1217                  x + req1.width/2 - icon->pixmap->requisition.width/2, 
1218                  y + iconlist->icon_border);
1219
1220   alloc.x = x + req1.width/2 - icon->pixmap->requisition.width/2; 
1221   alloc.y = y + iconlist->icon_border; 
1222   alloc.width =  req1.width;
1223   alloc.height =  req1.height;
1224   gtk_widget_size_allocate(icon->pixmap, &alloc);
1225
1226   switch(iconlist->mode){
1227    case GTK_ICON_LIST_TEXT_BELOW:
1228         gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label, 
1229                                 GTK_JUSTIFY_CENTER);
1230         gtk_fixed_put(GTK_FIXED(iconlist), icon->entry, 
1231                        x - req2.width/2 + req1.width/2, 
1232                        y + req1.height + iconlist->icon_border);
1233         alloc.x = x - req2.width/2 + req1.width/2; 
1234         alloc.y = y + req1.height + iconlist->icon_border;
1235         alloc.width = req2.width;
1236         alloc.height = req2.height;
1237         gtk_widget_size_allocate(icon->entry, &alloc);
1238
1239         if(y + req1.height + iconlist->icon_border + req2.height > height) 
1240            height += req1.height + iconlist->icon_border + req2.height;
1241         break;
1242    case GTK_ICON_LIST_TEXT_RIGHT:
1243         gtk_item_entry_set_text(GTK_ITEM_ENTRY(icon->entry), icon->entry_label, 
1244                                 GTK_JUSTIFY_LEFT);
1245         gtk_fixed_put(GTK_FIXED(iconlist), icon->entry, 
1246                        x + req1.width + iconlist->icon_border, 
1247                        y + req1.height/2 - req2.height/2); 
1248         alloc.x = x + req1.width + iconlist->icon_border; 
1249         alloc.y = y + req1.height/2 - req2.height/2; 
1250         alloc.width = req2.width;
1251         alloc.height = req2.height;
1252         gtk_widget_size_allocate(icon->entry, &alloc);
1253
1254         if(x + req1.width + iconlist->icon_border + text_width > width) 
1255             width += req1.width + iconlist->icon_border + text_width;
1256         break;
1257    case GTK_ICON_LIST_ICON:
1258    default: ;
1259   }
1260
1261   if(GTK_WIDGET_REALIZED(iconlist))
1262     if(iconlist->mode != GTK_ICON_LIST_ICON){
1263       GtkStyle *style = gtk_style_copy(icon->entry->style);
1264       style->bg[GTK_STATE_ACTIVE] = iconlist->background;
1265       style->bg[GTK_STATE_NORMAL] = iconlist->background;
1266       gtk_widget_set_style(icon->entry, style);
1267       gtk_style_unref(style);
1268       gtk_widget_show(icon->entry);
1269     }
1270
1271   gtk_widget_show(icon->pixmap);
1272
1273   if(iconlist->compare_func)
1274     iconlist->icons = g_list_insert_sorted(iconlist->icons, icon, iconlist->compare_func);
1275   else
1276     iconlist->icons = g_list_append(iconlist->icons, icon);
1277
1278   iconlist->num_icons++;
1279
1280   if(GTK_WIDGET_REALIZED(iconlist))
1281                 reorder_icons(iconlist);
1282
1283   gtk_entry_set_editable(GTK_ENTRY(icon->entry), FALSE);
1284
1285   gtk_signal_connect(GTK_OBJECT(icon->entry), "key_press_event",
1286                     (GtkSignalFunc)icon_key_press, iconlist);
1287   gtk_signal_connect(GTK_OBJECT(icon->entry), "button_press_event", 
1288                      (GtkSignalFunc)entry_in, iconlist);
1289   gtk_signal_connect(GTK_OBJECT(icon->entry), "changed", 
1290                      (GtkSignalFunc)entry_changed, iconlist);
1291
1292   gtk_icon_list_set_active_icon(iconlist, active_icon);
1293   return icon;
1294 }
1295
1296 static void 
1297 set_labels(GtkIconList *iconlist, GtkIconListItem *icon, const gchar *label)
1298 {
1299   gint text_width;
1300   gint point_width;
1301   gint max_width;
1302   gchar *entry_label = NULL;
1303   gint n, space;
1304
1305   if(!label) return;
1306
1307   entry_label = (gchar *)g_malloc(strlen(label) + 5);
1308   entry_label[0] = label[0];
1309   entry_label[1] = '\0';
1310
1311   text_width = STRING_WIDTH(icon->entry, icon->entry->style->font_desc, label);
1312   point_width = STRING_WIDTH(icon->entry, icon->entry->style->font_desc, "X");
1313
1314   max_width = iconlist->text_space;
1315
1316   for(n = 0; n < strlen(label); n++){
1317      space = strlen(label) - n + 1;
1318      if(space > 3 && 
1319         STRING_WIDTH(icon->entry, icon->entry->style->font_desc, entry_label) +
1320         3 * point_width > max_width) 
1321                                                    break;
1322      entry_label[n] = label[n];
1323      entry_label[n + 1] = '\0';
1324   }
1325
1326
1327   if(strlen(entry_label) < strlen(label))
1328       sprintf(entry_label,"%s...", entry_label);
1329
1330   icon->entry_label = g_strdup(entry_label);
1331
1332   g_free(entry_label);
1333 }
1334
1335 static gint
1336 icon_key_press(GtkWidget *widget, GdkEventKey *key, gpointer data)
1337 {
1338   GtkIconList *iconlist;
1339
1340   iconlist = GTK_ICON_LIST(data);
1341   if(key->keyval != GDK_Return) return FALSE;
1342
1343   if(iconlist->active_icon)
1344           select_icon(iconlist, iconlist->active_icon, NULL);
1345
1346   return FALSE;
1347 }
1348
1349 static void
1350 item_size_request(GtkIconList *iconlist, 
1351                   GtkIconListItem *item,
1352                   GtkRequisition *requisition)
1353 {
1354   GtkRequisition req2;
1355
1356   gtk_widget_size_request(item->entry, &req2);
1357   req2.width = iconlist->text_space;
1358
1359   gtk_widget_size_request(item->pixmap, requisition);
1360   requisition->width = MAX(iconlist->icon_width, requisition->width);
1361   requisition->width += 2*iconlist->icon_border;
1362   requisition->height += 2*iconlist->icon_border;
1363
1364   switch(iconlist->mode){
1365    case GTK_ICON_LIST_TEXT_BELOW:
1366         requisition->height += req2.height;
1367         requisition->width = MAX(requisition->width, req2.width);
1368         break;
1369    case GTK_ICON_LIST_TEXT_RIGHT:
1370         requisition->width += req2.width;
1371         break;
1372    case GTK_ICON_LIST_ICON:
1373    default: ;
1374   }
1375
1376 }
1377
1378                   
1379 void
1380 gtk_icon_list_set_editable (GtkIconList *iconlist, gboolean editable)
1381 {
1382   GList *icons;
1383   GtkIconListItem *item;
1384   
1385   icons = iconlist->icons;
1386   while(icons){
1387     item = (GtkIconListItem *) icons->data;
1388     gtk_entry_set_editable(GTK_ENTRY(item->entry), editable);
1389     icons = icons->next;
1390   }
1391
1392   iconlist->is_editable = editable;
1393
1394
1395 GtkIconListItem *
1396 gtk_icon_list_get_nth(GtkIconList *iconlist, guint n)
1397 {
1398   return (GtkIconListItem *)g_list_nth_data(iconlist->icons, n);
1399 }
1400
1401 gint
1402 gtk_icon_list_get_index(GtkIconList *iconlist, GtkIconListItem *item)
1403 {
1404   GList *icons;
1405   GtkIconListItem *icon;
1406   gint n = 0;
1407
1408   if(item == NULL) return -1;
1409  
1410   icons = iconlist->icons;
1411   while(icons){
1412     n++;
1413     icon = (GtkIconListItem *) icons->data;
1414     if(item == icon) break;
1415     icons = icons->next;
1416   }
1417
1418   if(icons) return n;
1419
1420   return -1;
1421 }
1422
1423 static void
1424 remove_from_fixed(GtkIconList *iconlist, GtkWidget *widget)
1425 {
1426   GtkFixed *fixed;
1427   GList *children;
1428
1429   fixed = GTK_FIXED(iconlist);
1430   children = fixed->children;
1431   while(children){
1432     GtkFixedChild *child;
1433
1434     child = children->data;
1435
1436     if(child->widget == widget){
1437       gtk_widget_unparent(widget);
1438       fixed->children = g_list_remove_link (fixed->children, children);
1439       g_list_free (children);
1440       g_free (child);
1441
1442       break;
1443     }
1444
1445     children = children->next;
1446   }
1447 }
1448
1449 static void
1450 pixmap_destroy(GtkPixmap* pixmap)
1451 {
1452   /* release pixmap */
1453   if (pixmap){
1454     GdkPixmap* pm = NULL;
1455     GdkBitmap* bm = NULL;
1456
1457     gtk_pixmap_get(pixmap, &pm, &bm);
1458
1459     /* HB: i don't know enough about Gtk+ to call this a design flaw, but it
1460      * appears the pixmaps need to be destroyed by hand ...
1461      */
1462     if (pm) gdk_pixmap_unref(pm);
1463     if (bm) gdk_pixmap_unref(bm);
1464   }
1465 }
1466   
1467 void
1468 gtk_icon_list_remove (GtkIconList *iconlist, GtkIconListItem *item)
1469 {
1470   GList *icons;
1471   GtkIconListItem *icon = 0;
1472
1473   if(item == NULL) return;
1474  
1475   icons = iconlist->icons;
1476   while(icons){
1477     icon = (GtkIconListItem *) icons->data;
1478     if(item == icon) break;
1479     icons = icons->next;
1480   }
1481
1482   if(icons){
1483      if(icon->state == GTK_STATE_SELECTED) unselect_icon(iconlist, icon, NULL);
1484      if(icon == iconlist->active_icon) deactivate_entry(iconlist);
1485      pixmap_destroy(GTK_PIXMAP(icon->pixmap));
1486      if(icon->entry && iconlist->mode != GTK_ICON_LIST_ICON){
1487        remove_from_fixed(iconlist, icon->entry);
1488        icon->entry = NULL;
1489      }
1490      if(icon->pixmap){
1491        remove_from_fixed(iconlist, icon->pixmap);
1492        icon->pixmap = NULL;
1493      }
1494      if(icon->label){
1495         g_free(icon->label);
1496         icon->label = NULL;
1497      }
1498      if(icon->entry_label){
1499         g_free(icon->entry_label);
1500         icon->entry_label = NULL;
1501      }
1502
1503      g_free(icon);
1504      iconlist->icons = g_list_remove_link(iconlist->icons, icons);
1505      g_list_free_1(icons);
1506      iconlist->num_icons--;
1507   }
1508
1509   if(iconlist->num_icons == 0){
1510       iconlist->icons = NULL;
1511       iconlist->selection = NULL;
1512   }
1513 }
1514
1515 void
1516 gtk_icon_list_remove_nth (GtkIconList *iconlist, guint n)
1517 {
1518   GtkIconListItem *item;
1519
1520   item = gtk_icon_list_get_nth(iconlist, n);
1521   gtk_icon_list_remove(iconlist, item);
1522 }
1523
1524 void
1525 gtk_icon_list_clear(GtkIconList *iconlist)
1526 {
1527   GList *icons;
1528   GtkIconListItem *icon;
1529
1530   if(iconlist->num_icons == 0) return;
1531   if(!deactivate_entry(iconlist)) return;
1532
1533   unselect_all(iconlist);
1534
1535   icons = iconlist->icons;
1536
1537   while(icons){
1538     icon = (GtkIconListItem *) icons->data;
1539     pixmap_destroy(GTK_PIXMAP(icon->pixmap));
1540     if(icon->entry && iconlist->mode != GTK_ICON_LIST_ICON){
1541       remove_from_fixed(iconlist, icon->entry);
1542       icon->entry = NULL;
1543     }
1544     if(icon->pixmap){
1545       gtk_widget_hide(icon->pixmap);
1546       remove_from_fixed(iconlist, icon->pixmap);
1547       icon->pixmap = NULL;
1548     }
1549     if(icon->label){
1550         g_free(icon->label);
1551         icon->label = NULL;
1552     }
1553     if(icon->entry_label){
1554         g_free(icon->entry_label);
1555         icon->entry_label = NULL;
1556     }
1557
1558     g_free(icon);
1559     icon = NULL;
1560
1561     iconlist->icons = g_list_remove_link(iconlist->icons, icons);
1562     g_list_free_1(icons);
1563     icons = iconlist->icons;
1564   }
1565
1566   iconlist->icons = NULL;
1567   iconlist->selection = NULL;
1568   iconlist->active_icon = NULL;
1569   iconlist->num_icons = 0;
1570 }    
1571
1572 void
1573 gtk_icon_list_link(GtkIconListItem *item, gpointer data)
1574 {
1575   item->link = data;
1576
1577
1578 gpointer
1579 gtk_icon_list_get_link(GtkIconListItem *item)
1580 {
1581   return item->link;
1582 }
1583
1584 GtkIconListItem *
1585 gtk_icon_list_get_icon_from_link(GtkIconList *iconlist, gpointer data)
1586 {
1587   GList *icons;
1588   GtkIconListItem *item;
1589
1590   icons = iconlist->icons;
1591   while(icons){
1592     item = (GtkIconListItem *) icons->data;
1593     if(data == item->link) return item;
1594     icons = icons->next;
1595   }
1596
1597   return NULL;
1598 }
1599
1600 GtkWidget *
1601 gtk_icon_list_get_entry(GtkIconListItem *item)
1602 {
1603   return item->entry;
1604 }
1605
1606 GtkWidget *
1607 gtk_icon_list_get_pixmap(GtkIconListItem *item)
1608 {
1609   return item->pixmap;
1610 }
1611
1612 void
1613 gtk_icon_list_set_pixmap(GtkIconListItem *item, 
1614                          GdkPixmap *pixmap, 
1615                          GdkBitmap *mask)
1616 {
1617
1618   if(item->pixmap) gtk_widget_destroy(item->pixmap);  
1619   item->pixmap = gtk_pixmap_new(pixmap, mask);
1620
1621 }
1622
1623 void 
1624 gtk_icon_list_set_label(GtkIconList *iconlist, GtkIconListItem *item, const gchar *label)
1625 {
1626   if(item->label){
1627       g_free(item->label);
1628       item->label = NULL;
1629   }
1630   if(item->entry_label){
1631       g_free(item->entry_label);
1632       item->entry_label = NULL;
1633   }
1634   if(label) item->label = g_strdup(label);
1635   gtk_entry_set_text(GTK_ENTRY(item->entry), label);
1636   set_labels(iconlist, item, label);
1637 }
1638  
1639 /**********************************
1640  * gtk_icon_list_set_icon_width
1641  * gtk_icon_list_set_row_spacing
1642  * gtk_icon_list_set_col_spacing
1643  * gtk_icon_list_set_text_space
1644  * gtk_icon_list_icon_border
1645  **********************************/
1646
1647 void
1648 gtk_icon_list_set_icon_width(GtkIconList *iconlist, guint width)
1649 {
1650   iconlist->icon_width = width;
1651   reorder_icons(iconlist);
1652 }
1653
1654 void
1655 gtk_icon_list_set_icon_border(GtkIconList *iconlist, guint border)
1656 {
1657   iconlist->icon_border = border;
1658   reorder_icons(iconlist);
1659 }
1660
1661 void
1662 gtk_icon_list_set_row_spacing(GtkIconList *iconlist, guint spacing)
1663 {
1664   iconlist->row_spacing = spacing;
1665   reorder_icons(iconlist);
1666 }
1667
1668 void
1669 gtk_icon_list_set_col_spacing(GtkIconList *iconlist, guint spacing)
1670 {
1671   iconlist->col_spacing = spacing;
1672   reorder_icons(iconlist);
1673 }
1674
1675
1676 /**********************************
1677  * gtk_icon_list_set_selection_mode
1678  * gtk_icon_list_select_icon
1679  * gtk_icon_list_unselect_icon
1680  * gtk_icon_list_unselect_all
1681  **********************************/
1682
1683 void
1684 gtk_icon_list_set_selection_mode(GtkIconList *iconlist, gint mode)
1685 {
1686   iconlist->selection_mode = mode;
1687 }
1688
1689 void
1690 gtk_icon_list_select_icon(GtkIconList *iconlist, GtkIconListItem *item)
1691 {
1692   select_icon(iconlist, item, NULL);
1693 }
1694
1695 void
1696 gtk_icon_list_unselect_icon(GtkIconList *iconlist, GtkIconListItem *item)
1697 {
1698   unselect_icon(iconlist, item, NULL);
1699 }
1700
1701 void
1702 gtk_icon_list_unselect_all(GtkIconList *iconlist)
1703 {
1704   unselect_all(iconlist);
1705 }
1706
1707 void
1708 gtk_icon_list_set_active_icon(GtkIconList *iconlist, GtkIconListItem *icon)
1709 {
1710   if(!icon){
1711     deactivate_entry(iconlist);
1712     unselect_all(iconlist);
1713     return;
1714   }
1715
1716   if(icon->entry){
1717     icon->state = GTK_STATE_SELECTED;
1718     entry_in(icon->entry, NULL, iconlist);
1719     gtk_widget_grab_focus(icon->entry);
1720   }
1721 }
1722
1723
1724 gboolean
1725 gtk_icon_list_is_editable       (GtkIconList *iconlist)
1726 {
1727   return (iconlist->is_editable);
1728 }
1729
1730 guint
1731 gtk_icon_list_get_row_spacing       (GtkIconList *iconlist)
1732 {
1733   return(iconlist->row_spacing);
1734 }
1735
1736 guint
1737 gtk_icon_list_get_col_spacing       (GtkIconList *iconlist)
1738 {
1739   return(iconlist->col_spacing);
1740 }
1741
1742 guint
1743 gtk_icon_list_get_text_space       (GtkIconList *iconlist)
1744 {
1745   return(iconlist->text_space);
1746 }
1747
1748 guint
1749 gtk_icon_list_get_icon_border       (GtkIconList *iconlist)
1750 {
1751   return(iconlist->icon_border);
1752 }
1753
1754 guint
1755 gtk_icon_list_get_icon_width       (GtkIconList *iconlist)
1756 {
1757   return(iconlist->icon_width);
1758 }
1759