cut-n-paste/recent-files/egg-recent-view-gtk.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of the
   6  * License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16  *
  17  * Authors:
  18  *   James Willcox <jwillcox@cs.indiana.edu>
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <gtk/gtk.h>
  29 #include <libgnomevfs/gnome-vfs.h>
  30 #ifndef USE_STABLE_LIBGNOMEUI
  31 #include <libgnomeui/gnome-icon-theme.h>
  32 #endif
  33 #include <gconf/gconf-client.h>
  34 #include "egg-recent-model.h"
  35 #include "egg-recent-view.h"
  36 #include "egg-recent-view-gtk.h"
  37 #include "egg-recent-util.h"
  38 #include "egg-recent-item.h"
  39
  40 #define DEFAULT_LABEL_WIDTH 30
  41
  42 struct _EggRecentViewGtk {
  43         GObject parent_instance;        /* We emit signals */
  44
  45         GtkWidget *menu;
  46         GtkWidget *start_menu_item;
  47
  48         gboolean leading_sep;
  49         gboolean trailing_sep;
  50
  51         gulong changed_cb_id;
  52
  53         gchar *uid;
  54
  55         gboolean show_icons;
  56         gboolean show_numbers;
  57 #ifndef USE_STABLE_LIBGNOMEUI
  58         GnomeIconTheme *theme;
  59 #endif
  60
  61         GtkTooltips *tooltips;
  62         EggRecentViewGtkTooltipFunc tooltip_func;
  63         gpointer tooltip_func_data;
  64
  65         EggRecentModel *model;
  66         GConfClient *client;
  67         GtkIconSize icon_size;
  68
  69         gint label_width;
  70 };
  71
  72
  73
  74 struct _EggRecentViewGtkMenuData {
  75         EggRecentViewGtk *view;
  76         EggRecentItem *item;
  77 };
  78
  79 typedef struct _EggRecentViewGtkMenuData EggRecentViewGtkMenuData;
  80
  81 enum {
  82         ACTIVATE,
  83         LAST_SIGNAL
  84 };
  85
  86 /* GObject properties */
  87 enum {
  88         PROP_BOGUS,
  89         PROP_MENU,
  90         PROP_START_MENU_ITEM,
  91         PROP_SHOW_ICONS,
  92         PROP_SHOW_NUMBERS,
  93         PROP_LABEL_WIDTH
  94 };
  95
  96 static guint view_signals[LAST_SIGNAL] = { 0 };
  97
  98
  99 static void
 100 egg_recent_view_gtk_clear (EggRecentViewGtk *view)
 101 {
 102         GList *menu_children;
 103         GList *p;
 104         GObject *menu_item;
 105         gint *menu_data=NULL;
 106
 107         if (view->menu == NULL)
 108                 return;
 109
 110         menu_children = gtk_container_get_children (GTK_CONTAINER (view->menu));
 111
 112         p = menu_children;
 113         while (p != NULL) {
 114                 menu_item = (GObject *)p->data;
 115
 116                 menu_data = (gint *)g_object_get_data (menu_item,
 117                                                        view->uid);
 118
 119                 if (menu_data) {
 120                         gtk_container_remove (GTK_CONTAINER (view->menu),
 121                                              GTK_WIDGET (menu_item));
 122
 123                 }
 124
 125                 p = p->next;
 126         }
 127 }
 128
 129
 130 static gint
 131 egg_recent_view_gtk_find_menu_offset (EggRecentViewGtk *view)
 132 {
 133         gint i;
 134         GList *menu_children;
 135         GList *p;
 136         GtkWidget *menu_item;
 137         gint menu_loc=-1;
 138
 139         g_return_val_if_fail (view, 0);
 140
 141         menu_children = GTK_MENU_SHELL (view->menu)->children;
 142
 143         i = 0;
 144         p = menu_children;
 145         while (p != NULL) {
 146                 menu_item = (GtkWidget *)p->data;
 147
 148                 if (menu_item == view->start_menu_item) {
 149                         menu_loc = i;
 150                         break;
 151                 }
 152
 153                 p = p->next;
 154                 i++;
 155         }
 156
 157         return menu_loc;
 158 }
 159
 160 static void
 161 egg_recent_view_gtk_menu_cb (GtkWidget *menu, gpointer data)
 162 {
 163         EggRecentViewGtkMenuData *md = (EggRecentViewGtkMenuData *) data;
 164         EggRecentItem *item;
 165
 166         g_return_if_fail (md);
 167         g_return_if_fail (md->item);
 168         g_return_if_fail (md->view);
 169         g_return_if_fail (EGG_IS_RECENT_VIEW_GTK (md->view));
 170
 171         item = md->item;
 172
 173         egg_recent_item_ref (item);
 174
 175         g_signal_emit (G_OBJECT(md->view), view_signals[ACTIVATE], 0,
 176                        item);
 177
 178         egg_recent_item_unref (item);
 179 }
 180
 181 static void
 182 egg_recent_view_gtk_destroy_cb (gpointer data, GClosure *closure)
 183 {
 184         EggRecentViewGtkMenuData *md = data;
 185
 186         egg_recent_item_unref (md->item);
 187         g_free (md);
 188 }
 189
 190 static GtkWidget *
 191 egg_recent_view_gtk_new_separator (EggRecentViewGtk *view)
 192 {
 193         GtkWidget *retval;
 194
 195         g_return_val_if_fail (view, NULL);
 196
 197         retval = gtk_separator_menu_item_new ();
 198
 199         /*
 200          * this is a tag so we can distinguish our menu items
 201          * from others that may be in the menu.
 202          */
 203         g_object_set_data (G_OBJECT (retval),
 204                            view->uid,
 205                            GINT_TO_POINTER (1));
 206
 207
 208         gtk_widget_show (retval);
 209
 210         return retval;
 211 }
 212
 213 static GtkWidget *
 214 egg_recent_view_gtk_new_menu_item (EggRecentViewGtk *view,
 215                                    EggRecentItem *item,
 216                                    gint index)
 217 {
 218         GtkWidget *menu_item;
 219         EggRecentViewGtkMenuData *md;
 220         gchar *mime_type;
 221         GtkWidget *image;
 222         GtkWidget *label;
 223         GdkPixbuf *pixbuf;
 224         gchar *text;
 225         gchar *short_name;
 226         gchar *escaped;
 227
 228         g_return_val_if_fail (view, NULL);
 229         g_return_val_if_fail (item, NULL);
 230
 231         short_name = egg_recent_item_get_short_name (item);
 232         if (!short_name)
 233                 return NULL;
 234
 235         escaped = egg_recent_util_escape_underlines (short_name);
 236         g_free (short_name);
 237
 238         if (view->show_numbers) {
 239                 /* avoid having conflicting mnemonics */
 240                 if (index >= 10)
 241                         text = g_strdup_printf ("%d.  %s", index,
 242                                                 escaped);
 243                 else
 244                         text = g_strdup_printf ("_%d.  %s", index,
 245                                                 escaped);
 246                 g_free (escaped);
 247         } else {
 248                 text = escaped;
 249         }
 250
 251         mime_type = egg_recent_item_get_mime_type (item);
 252 #ifndef USE_STABLE_LIBGNOMEUI
 253         {
 254                 int width, height;
 255                 gchar *uri;
 256
 257                 gtk_icon_size_lookup_for_settings
 258                         (gtk_widget_get_settings (view->menu),
 259                          view->icon_size,
 260                          &width, &height);
 261
 262                 uri = egg_recent_item_get_uri (item);
 263                 pixbuf = egg_recent_util_get_icon (view->theme, uri,
 264                                                    mime_type,
 265                                                    height);
 266                 g_free (uri);
 267         }
 268 #else
 269         pixbuf = NULL;
 270 #endif
 271         image = gtk_image_new_from_pixbuf (pixbuf);
 272         if (pixbuf)
 273                 g_object_unref (pixbuf);
 274
 275         if (view->show_icons)
 276                 gtk_widget_show (image);
 277
 278         menu_item = gtk_image_menu_item_new_with_mnemonic (text);
 279         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
 280                                        image);
 281
 282         label = GTK_BIN (menu_item)->child;
 283         gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
 284         gtk_label_set_max_width_chars (GTK_LABEL (label), view->label_width);
 285
 286         md = g_new0 (EggRecentViewGtkMenuData, 1);
 287         md->view = view;
 288         md->item = egg_recent_item_ref (item);
 289
 290         g_signal_connect_data (G_OBJECT (menu_item), "activate",
 291                                G_CALLBACK (egg_recent_view_gtk_menu_cb),
 292                                md,
 293                                (GClosureNotify)egg_recent_view_gtk_destroy_cb,
 294                                0);
 295
 296         g_free (mime_type);
 297         g_free (text);
 298
 299         /*
 300          * this is a tag so we can distinguish our menu items
 301          * from others that may be in the menu.
 302          */
 303         g_object_set_data (G_OBJECT (menu_item),
 304                            view->uid,
 305                            GINT_TO_POINTER (1));
 306
 307
 308         gtk_widget_show (menu_item);
 309
 310         return menu_item;
 311 }
 312
 313 static void
 314 egg_recent_view_gtk_add_to_menu (EggRecentViewGtk *view,
 315                                  EggRecentItem *item,
 316                                  gint display,
 317                                  gint index)
 318 {
 319         GtkWidget *menu_item;
 320         gint menu_offset;
 321
 322         g_return_if_fail (view);
 323         g_return_if_fail (view->menu);
 324
 325         menu_offset = egg_recent_view_gtk_find_menu_offset (view);
 326
 327         if (item != NULL)
 328                 menu_item = egg_recent_view_gtk_new_menu_item (view, item, display);
 329         else
 330                 menu_item = egg_recent_view_gtk_new_separator (view);
 331
 332         if (view->tooltip_func != NULL && menu_item != NULL) {
 333                 view->tooltip_func (view->tooltips, menu_item,
 334                                     item, view->tooltip_func_data);
 335         }
 336
 337         if (menu_item)
 338                 gtk_menu_shell_insert (GTK_MENU_SHELL (view->menu), menu_item,
 339                                menu_offset+index);
 340 }
 341
 342 static void
 343 egg_recent_view_gtk_set_list (EggRecentViewGtk *view, GList *list)
 344 {
 345         EggRecentItem *item;
 346         GList *p;
 347         gint display=1;
 348         gint index=1;
 349
 350         if (view->menu == NULL)
 351                 return;
 352
 353         egg_recent_view_gtk_clear (view);
 354
 355         if (view->leading_sep) {
 356                 egg_recent_view_gtk_add_to_menu (view, NULL, display, index);
 357                 index++;
 358         }
 359
 360         p = list;
 361         while (p != NULL) {
 362                 item = (EggRecentItem *)p->data;
 363
 364                 egg_recent_view_gtk_add_to_menu (view, item, display, index);
 365
 366                 p = p->next;
 367                 display++;
 368                 index++;
 369         }
 370
 371         if (view->trailing_sep)
 372                 egg_recent_view_gtk_add_to_menu (view, NULL, display, index);
 373 }
 374
 375 static void
 376 model_changed_cb (EggRecentModel *model, GList *list, EggRecentViewGtk *view)
 377 {
 378         if (list != NULL)
 379                 egg_recent_view_gtk_set_list (view, list);
 380         else
 381                 egg_recent_view_gtk_clear (view);
 382 }
 383
 384 static EggRecentModel *
 385 egg_recent_view_gtk_get_model (EggRecentView *view_parent)
 386 {
 387         EggRecentViewGtk *view;
 388
 389         g_return_val_if_fail (view_parent != NULL, NULL);
 390         view = EGG_RECENT_VIEW_GTK (view_parent);
 391         return view->model;
 392 }
 393
 394 static void
 395 egg_recent_view_gtk_set_model (EggRecentView *view_parent,
 396                                  EggRecentModel *model)
 397 {
 398         EggRecentViewGtk *view;
 399
 400         g_return_if_fail (view_parent != NULL);
 401         view = EGG_RECENT_VIEW_GTK (view_parent);
 402
 403         if (view->model != NULL) {
 404                 g_object_unref (view->model);
 405                 g_signal_handler_disconnect (G_OBJECT (model),
 406                                              view->changed_cb_id);
 407         }
 408
 409         view->model = model;
 410         g_object_ref (view->model);
 411
 412         view->changed_cb_id = g_signal_connect_object (G_OBJECT (model),
 413                                                 "changed",
 414                                                 G_CALLBACK (model_changed_cb),
 415                                                 view, 0);
 416
 417         egg_recent_model_changed (view->model);
 418 }
 419
 420 void
 421 egg_recent_view_gtk_set_leading_sep (EggRecentViewGtk *view, gboolean val)
 422 {
 423         view->leading_sep = val;
 424
 425         egg_recent_view_gtk_clear (view);
 426
 427         if (view->model)
 428                 egg_recent_model_changed (view->model);
 429 }
 430
 431 void
 432 egg_recent_view_gtk_set_trailing_sep (EggRecentViewGtk *view, gboolean val)
 433 {
 434         view->trailing_sep = val;
 435
 436         egg_recent_view_gtk_clear (view);
 437
 438         if (view->model)
 439                 egg_recent_model_changed (view->model);
 440 }
 441
 442 static void
 443 egg_recent_view_gtk_set_property (GObject *object,
 444                            guint prop_id,
 445                            const GValue *value,
 446                            GParamSpec *pspec)
 447 {
 448         EggRecentViewGtk *view = EGG_RECENT_VIEW_GTK (object);
 449
 450         switch (prop_id)
 451         {
 452                 case PROP_MENU:
 453                         egg_recent_view_gtk_set_menu (view,
 454                                                GTK_WIDGET (g_value_get_object (value)));
 455                 break;
 456                 case PROP_START_MENU_ITEM:
 457                         egg_recent_view_gtk_set_start_menu_item (view,
 458                                         g_value_get_object (value));
 459                 break;
 460                 case PROP_SHOW_ICONS:
 461                         egg_recent_view_gtk_show_icons (view,
 462                                         g_value_get_boolean (value));
 463                 break;
 464                 case PROP_SHOW_NUMBERS:
 465                         egg_recent_view_gtk_show_numbers (view,
 466                                         g_value_get_boolean (value));
 467                 break;
 468                 case PROP_LABEL_WIDTH:
 469                         egg_recent_view_gtk_set_label_width (view,
 470                                         g_value_get_int (value));
 471                 break;
 472                 default:
 473                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 474                 break;
 475         }
 476 }
 477
 478 static void
 479 egg_recent_view_gtk_get_property (GObject *object,
 480                            guint prop_id,
 481                            GValue *value,
 482                            GParamSpec *pspec)
 483 {
 484         EggRecentViewGtk *view = EGG_RECENT_VIEW_GTK (object);
 485
 486         switch (prop_id)
 487         {
 488                 case PROP_MENU:
 489                         g_value_set_object (value, view->menu);
 490                 break;
 491                 case PROP_START_MENU_ITEM:
 492                         g_value_set_object (value, view->start_menu_item);
 493                 break;
 494                 case PROP_SHOW_ICONS:
 495                         g_value_set_boolean (value, view->show_icons);
 496                 break;
 497                 case PROP_SHOW_NUMBERS:
 498                         g_value_set_boolean (value, view->show_numbers);
 499                 break;
 500                 case PROP_LABEL_WIDTH:
 501                         g_value_set_int (value, view->label_width);
 502                 break;
 503                 default:
 504                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 505                 break;
 506         }
 507 }
 508
 509 static void
 510 egg_recent_view_gtk_finalize (GObject *object)
 511 {
 512         EggRecentViewGtk *view = EGG_RECENT_VIEW_GTK (object);
 513
 514         g_signal_handler_disconnect (G_OBJECT (view->model),
 515                                      view->changed_cb_id);
 516
 517         g_free (view->uid);
 518
 519         g_object_unref (view->model);
 520 #ifndef USE_STABLE_LIBGNOMEUI
 521         g_object_unref (view->theme);
 522 #endif
 523         g_object_unref (view->client);
 524
 525         g_object_unref (view->tooltips);
 526
 527         egg_recent_view_gtk_clear (view);
 528 }
 529
 530 static void
 531 egg_recent_view_gtk_class_init (EggRecentViewGtkClass * klass)
 532 {
 533         GObjectClass *object_class;
 534
 535         object_class = G_OBJECT_CLASS (klass);
 536
 537         object_class->set_property = egg_recent_view_gtk_set_property;
 538         object_class->get_property = egg_recent_view_gtk_get_property;
 539         object_class->finalize     = egg_recent_view_gtk_finalize;
 540
 541         view_signals[ACTIVATE] = g_signal_new ("activate",
 542                         G_OBJECT_CLASS_TYPE (object_class),
 543                         G_SIGNAL_RUN_LAST,
 544                         G_STRUCT_OFFSET (EggRecentViewGtkClass, activate),
 545                         NULL, NULL,
 546                         g_cclosure_marshal_VOID__BOXED,
 547                         G_TYPE_NONE, 1,
 548                         EGG_TYPE_RECENT_ITEM);
 549
 550         g_object_class_install_property (object_class,
 551                                          PROP_MENU,
 552                                          g_param_spec_object ("menu",
 553                                                               "Menu",
 554                                                               "The GtkMenuShell this object will update.",
 555                                                               gtk_menu_get_type(),
 556                                                               G_PARAM_READWRITE));
 557         g_object_class_install_property (object_class,
 558                                          PROP_START_MENU_ITEM,
 559                                          g_param_spec_object ("start-menu-item",
 560                                                               "Start Menu Item",
 561                                                               "The menu item that precedes where are menu items will go",
 562                                                               gtk_menu_item_get_type (),
 563                                                               G_PARAM_READWRITE));
 564
 565         g_object_class_install_property (object_class,
 566                                          PROP_SHOW_ICONS,
 567                                          g_param_spec_boolean ("show-icons",
 568                                            "Show Icons",
 569                                            "Whether or not to show icons",
 570                                            FALSE,
 571                                            G_PARAM_READWRITE));
 572
 573         g_object_class_install_property (object_class,
 574                                          PROP_SHOW_NUMBERS,
 575                                          g_param_spec_boolean ("show-numbers",
 576                                            "Show Numbers",
 577                                            "Whether or not to show numbers",
 578                                            TRUE,
 579                                            G_PARAM_READWRITE));
 580
 581         g_object_class_install_property (object_class,
 582                                          PROP_LABEL_WIDTH,
 583                                          g_param_spec_int ("label-width",
 584                                            "Label Width",
 585                                            "The desired width of the menu label, in characters",
 586                                            -1,
 587                                            G_MAXINT,
 588                                            DEFAULT_LABEL_WIDTH,
 589                                            G_PARAM_READWRITE));
 590
 591         klass->activate = NULL;
 592 }
 593
 594 static void
 595 egg_recent_view_init (EggRecentViewClass *iface)
 596 {
 597         iface->do_get_model = egg_recent_view_gtk_get_model;
 598         iface->do_set_model = egg_recent_view_gtk_set_model;
 599 }
 600
 601 static void
 602 show_menus_changed_cb (GConfClient *client,
 603                        guint cnxn_id,
 604                        GConfEntry *entry,
 605                        EggRecentViewGtk *view)
 606 {
 607         GConfValue *value;
 608
 609         value = gconf_entry_get_value (entry);
 610
 611         g_return_if_fail (value->type == GCONF_VALUE_BOOL);
 612
 613         egg_recent_view_gtk_show_icons (view,
 614                                 gconf_value_get_bool (value));
 615
 616 }
 617
 618 #ifndef USE_STABLE_LIBGNOMEUI
 619 static void
 620 theme_changed_cb (GnomeIconTheme *theme, EggRecentViewGtk *view)
 621 {
 622         if (view->model != NULL)
 623                 egg_recent_model_changed (view->model);
 624 }
 625 #endif
 626
 627 static void
 628 egg_recent_view_gtk_init (EggRecentViewGtk * view)
 629 {
 630         view->client = gconf_client_get_default ();
 631
 632         view->show_icons =
 633                 gconf_client_get_bool (view->client,
 634                         "/desktop/gnome/interface/menus_have_icons",
 635                         NULL);
 636
 637         gconf_client_add_dir (view->client, "/desktop/gnome/interface",
 638                               GCONF_CLIENT_PRELOAD_NONE,
 639                               NULL);
 640         gconf_client_notify_add (view->client,
 641                         "/desktop/gnome/interface/menus_have_icons",
 642                         (GConfClientNotifyFunc)show_menus_changed_cb,
 643                         view, NULL, NULL);
 644
 645
 646         view->leading_sep = FALSE;
 647         view->trailing_sep = FALSE;
 648
 649         view->uid = egg_recent_util_get_unique_id ();
 650 #ifndef USE_STABLE_LIBGNOMEUI
 651         view->theme = gnome_icon_theme_new ();
 652         gnome_icon_theme_set_allow_svg (view->theme, TRUE);
 653         g_signal_connect_object (view->theme, "changed",
 654                                  G_CALLBACK (theme_changed_cb), view, 0);
 655 #endif
 656         view->tooltips = gtk_tooltips_new ();
 657         g_object_ref (view->tooltips);
 658         gtk_object_sink (GTK_OBJECT (view->tooltips));
 659         view->tooltip_func = NULL;
 660         view->tooltip_func_data = NULL;
 661
 662         view->icon_size = GTK_ICON_SIZE_MENU;
 663
 664         view->label_width = DEFAULT_LABEL_WIDTH;
 665 }
 666
 667 void
 668 egg_recent_view_gtk_set_icon_size (EggRecentViewGtk *view,
 669                                    GtkIconSize icon_size)
 670 {
 671         if (view->icon_size != icon_size) {
 672                 view->icon_size = icon_size;
 673                 egg_recent_model_changed (view->model);
 674         } else {
 675                 view->icon_size = icon_size;
 676         }
 677 }
 678
 679 GtkIconSize
 680 egg_recent_view_gtk_get_icon_size (EggRecentViewGtk *view)
 681 {
 682         return view->icon_size;
 683 }
 684
 685 void
 686 egg_recent_view_gtk_show_icons (EggRecentViewGtk *view, gboolean show)
 687 {
 688         view->show_icons = show;
 689
 690         if (view->model)
 691                 egg_recent_model_changed (view->model);
 692 }
 693
 694 void
 695 egg_recent_view_gtk_show_numbers (EggRecentViewGtk *view, gboolean show)
 696 {
 697         view->show_numbers = show;
 698
 699         if (view->model)
 700                 egg_recent_model_changed (view->model);
 701 }
 702
 703 void
 704 egg_recent_view_gtk_set_tooltip_func (EggRecentViewGtk *view,
 705                                       EggRecentViewGtkTooltipFunc func,
 706                                       gpointer user_data)
 707 {
 708         view->tooltip_func = func;
 709         view->tooltip_func_data = user_data;
 710
 711         if (view->model)
 712                 egg_recent_model_changed (view->model);
 713 }
 714
 715 void
 716 egg_recent_view_gtk_set_label_width (EggRecentViewGtk *view,
 717                                      gint              chars)
 718 {
 719         g_return_if_fail (EGG_IS_RECENT_VIEW_GTK (view));
 720
 721         view->label_width = chars;
 722 }
 723
 724 gint
 725 egg_recent_view_gtk_get_label_width (EggRecentViewGtk *view)
 726 {
 727         g_return_val_if_fail (EGG_IS_RECENT_VIEW_GTK (view), -1);
 728
 729         return view->label_width;
 730 }
 731
 732 /**
 733  * egg_recent_view_gtk_set_menu:
 734  * @view: A EggRecentViewGtk object.
 735  * @menu: The GtkMenuShell to put the menu items in.
 736  *
 737  * Use this function to change the GtkMenuShell that the recent
 738  * documents appear in.
 739  *
 740  */
 741 void
 742 egg_recent_view_gtk_set_menu (EggRecentViewGtk *view,
 743                                 GtkWidget *menu)
 744 {
 745         g_return_if_fail (view);
 746         g_return_if_fail (EGG_IS_RECENT_VIEW_GTK (view));
 747
 748         if (view->menu != NULL)
 749                 g_object_remove_weak_pointer (G_OBJECT (view->menu),
 750                                               (gpointer *) &view->menu);
 751
 752         view->menu = menu;
 753
 754         if (view->menu != NULL)
 755                 g_object_add_weak_pointer (G_OBJECT (view->menu),
 756                                            (gpointer *) &view->menu);
 757 }
 758
 759 /**
 760  * egg_recent_view_gtk_set_start_menu_item:
 761  * @view: A EggRecentViewGtk object.
 762  * @start_menu_item: The menu item that appears just before where our menu
 763  * items should appear
 764  *
 765  */
 766 void
 767 egg_recent_view_gtk_set_start_menu_item (EggRecentViewGtk *view,
 768                                          GtkWidget *menu_item)
 769 {
 770         g_return_if_fail (view);
 771         g_return_if_fail (EGG_IS_RECENT_VIEW_GTK (view));
 772
 773         view->start_menu_item = menu_item;
 774 }
 775
 776 /**
 777  * egg_recent_view_gtk_get_menu:
 778  * @view: A EggRecentViewGtk object.
 779  *
 780  */
 781 GtkWidget *
 782 egg_recent_view_gtk_get_menu (EggRecentViewGtk *view)
 783 {
 784         return view->menu;
 785 }
 786
 787 /**
 788  * egg_recent_view_gtk_get_start_menu_item
 789  * @view: A EggRecentViewGtk object.
 790  *
 791  */
 792 GtkWidget *
 793 egg_recent_view_gtk_get_start_menu_item (EggRecentViewGtk *view)
 794 {
 795         return view->start_menu_item;
 796 }
 797
 798
 799 /**
 800  * egg_recent_view_gtk_new:
 801  * @appname: The name of your application.
 802  * @limit:  The maximum number of items allowed.
 803  *
 804  * This creates a new EggRecentViewGtk object.
 805  *
 806  * Returns: a EggRecentViewGtk object
 807  */
 808 EggRecentViewGtk *
 809 egg_recent_view_gtk_new (GtkWidget *menu, GtkWidget *start_menu_item)
 810 {
 811         EggRecentViewGtk *view;
 812
 813         g_return_val_if_fail (menu, NULL);
 814
 815         view = EGG_RECENT_VIEW_GTK (g_object_new (egg_recent_view_gtk_get_type (),
 816                                            "start-menu-item",
 817                                            start_menu_item,
 818                                            "menu", menu,
 819                                            "show-numbers", TRUE, NULL));
 820
 821         g_return_val_if_fail (view, NULL);
 822
 823         return view;
 824 }
 825
 826 /**
 827  * egg_recent_view_gtk_get_type:
 828  *
 829  * This returns a GType representing a EggRecentViewGtk object.
 830  *
 831  * Returns: a GType
 832  */
 833 GType
 834 egg_recent_view_gtk_get_type (void)
 835 {
 836         static GType egg_recent_view_gtk_type = 0;
 837
 838         if(!egg_recent_view_gtk_type) {
 839                 static const GTypeInfo egg_recent_view_gtk_info = {
 840                         sizeof (EggRecentViewGtkClass),
 841                         NULL, /* base init */
 842                         NULL, /* base finalize */
 843                         (GClassInitFunc)egg_recent_view_gtk_class_init, /* class init */
 844                         NULL, /* class finalize */
 845                         NULL, /* class data */
 846                         sizeof (EggRecentViewGtk),
 847                         0,
 848                         (GInstanceInitFunc) egg_recent_view_gtk_init
 849                 };
 850
 851                 static const GInterfaceInfo view_info =
 852                 {
 853                         (GInterfaceInitFunc) egg_recent_view_init,
 854                         NULL,
 855                         NULL
 856                 };
 857
 858                 egg_recent_view_gtk_type = g_type_register_static (G_TYPE_OBJECT,
 859                                                         "EggRecentViewGtk",
 860                                                         &egg_recent_view_gtk_info, 0);
 861                 g_type_add_interface_static (egg_recent_view_gtk_type,
 862                                              EGG_TYPE_RECENT_VIEW,
 863                                              &view_info);
 864         }
 865
 866         return egg_recent_view_gtk_type;
 867 }
 868