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