#include "gtkseparatormenuitem.h"
#include "gtkmenu.h"
#include "gtkimage.h"
+#include "gtklabel.h"
#include "gtkobject.h"
-#include "gtktooltips.h"
+#include "gtktooltip.h"
#include "gtktypebuiltins.h"
-
-#include "gtkrecentmanager.h"
-#include "gtkrecentfilter.h"
-#include "gtkrecentchooser.h"
-#include "gtkrecentchooserutils.h"
-#include "gtkrecentchooserprivate.h"
-#include "gtkrecentchoosermenu.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
struct _GtkRecentChooserMenuPrivate
/* size of the icons of the menu items */
gint icon_size;
+ /* max size of the menu item label */
+ gint label_width;
+
+ gint first_recent_item_pos;
+ GtkWidget *placeholder;
+
/* RecentChooser properties */
gint limit;
guint show_private : 1;
guint local_manager : 1;
gulong manager_changed_id;
- /* tooltips for our bookmark items*/
- GtkTooltips *tooltips;
+ gulong populate_id;
};
enum {
#define FALLBACK_ICON_SIZE 32
#define FALLBACK_ITEM_LIMIT 10
+#define DEFAULT_LABEL_WIDTH 30
#define GTK_RECENT_CHOOSER_MENU_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RECENT_CHOOSER_MENU, GtkRecentChooserMenuPrivate))
static void gtk_recent_chooser_menu_finalize (GObject *object);
+static void gtk_recent_chooser_menu_dispose (GObject *object);
static GObject *gtk_recent_chooser_menu_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params);
static void gtk_recent_chooser_menu_set_current_filter (GtkRecentChooserMenu *menu,
GtkRecentFilter *filter);
-static void gtk_recent_chooser_menu_map (GtkWidget *widget);
+static void gtk_recent_chooser_menu_populate (GtkRecentChooserMenu *menu);
static void gtk_recent_chooser_menu_set_show_tips (GtkRecentChooserMenu *menu,
gboolean show_tips);
gtk_recent_chooser_menu,
GTK_TYPE_MENU,
G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
- gtk_recent_chooser_iface_init));
+ gtk_recent_chooser_iface_init))
static void
gtk_recent_chooser_menu_class_init (GtkRecentChooserMenuClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
- GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
-
+
gobject_class->constructor = gtk_recent_chooser_menu_constructor;
+ gobject_class->dispose = gtk_recent_chooser_menu_dispose;
gobject_class->finalize = gtk_recent_chooser_menu_finalize;
gobject_class->set_property = gtk_recent_chooser_menu_set_property;
gobject_class->get_property = gtk_recent_chooser_menu_get_property;
- widget_class->map = gtk_recent_chooser_menu_map;
-
_gtk_recent_chooser_install_properties (gobject_class);
/**
P_("Show Numbers"),
P_("Whether the items should be displayed with a number"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (GtkRecentChooserMenuPrivate));
}
priv->show_icons= TRUE;
priv->show_numbers = FALSE;
priv->show_tips = FALSE;
- priv->show_not_found = FALSE;
+ priv->show_not_found = TRUE;
priv->show_private = FALSE;
priv->local_only = TRUE;
priv->limit = FALLBACK_ITEM_LIMIT;
-
priv->sort_type = GTK_RECENT_SORT_NONE;
-
priv->icon_size = FALLBACK_ICON_SIZE;
+ priv->label_width = DEFAULT_LABEL_WIDTH;
+ priv->first_recent_item_pos = -1;
+ priv->placeholder = NULL;
+
priv->current_filter = NULL;
-
- priv->tooltips = gtk_tooltips_new ();
- g_object_ref_sink (priv->tooltips);
}
static void
GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
GtkRecentChooserMenuPrivate *priv = menu->priv;
- g_signal_handler_disconnect (priv->manager, priv->manager_changed_id);
- priv->manager_changed_id = 0;
-
priv->manager = NULL;
if (priv->sort_data_destroy)
{
priv->sort_data_destroy (priv->sort_data);
-
priv->sort_data_destroy = NULL;
- priv->sort_data = NULL;
- priv->sort_func = NULL;
}
+
+ priv->sort_data = NULL;
+ priv->sort_func = NULL;
- if (priv->tooltips)
- g_object_unref (priv->tooltips);
+ G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class)->finalize (object);
+}
+
+static void
+gtk_recent_chooser_menu_dispose (GObject *object)
+{
+ GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
+
+ if (priv->manager_changed_id)
+ {
+ if (priv->manager)
+ g_signal_handler_disconnect (priv->manager, priv->manager_changed_id);
+
+ priv->manager_changed_id = 0;
+ }
+ if (priv->populate_id)
+ {
+ g_source_remove (priv->populate_id);
+ priv->populate_id = 0;
+ }
+
if (priv->current_filter)
- g_object_unref (priv->current_filter);
+ {
+ g_object_unref (priv->current_filter);
+ priv->current_filter = NULL;
+ }
- G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class)->finalize;
+ G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class)->dispose (object);
}
static GObject *
gtk_recent_chooser_menu_constructor (GType type,
- guint n_construct_properties,
- GObjectConstructParam *construct_params)
+ guint n_params,
+ GObjectConstructParam *params)
{
GtkRecentChooserMenu *menu;
+ GtkRecentChooserMenuPrivate *priv;
+ GObjectClass *parent_class;
GObject *object;
- object = G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class)->constructor (type,
- n_construct_properties,
- construct_params);
+ parent_class = G_OBJECT_CLASS (gtk_recent_chooser_menu_parent_class);
+ object = parent_class->constructor (type, n_params, params);
menu = GTK_RECENT_CHOOSER_MENU (object);
+ priv = menu->priv;
- g_assert (menu->priv->manager);
-
+ g_assert (priv->manager);
+
+ /* we create a placeholder menuitem, to be used in case
+ * the menu is empty. this placeholder will stay around
+ * for the entire lifetime of the menu, and we just hide it
+ * when it's not used. we have to do this, and do it here,
+ * because we need a marker for the beginning of the recent
+ * items list, so that we can insert the new items at the
+ * right place when idly populating the menu in case the
+ * user appended or prepended custom menu items to the
+ * recent chooser menu widget.
+ */
+ priv->placeholder = gtk_menu_item_new_with_label (_("No items found"));
+ gtk_widget_set_sensitive (priv->placeholder, FALSE);
+ g_object_set_data (G_OBJECT (priv->placeholder),
+ "gtk-recent-menu-placeholder",
+ GINT_TO_POINTER (TRUE));
+
+ gtk_menu_shell_insert (GTK_MENU_SHELL (menu), priv->placeholder, 0);
+ gtk_widget_show (priv->placeholder);
+
+ /* (re)populate the menu */
+ gtk_recent_chooser_menu_populate (menu);
+
return object;
}
GParamSpec *pspec)
{
GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
switch (prop_id)
{
case PROP_SHOW_NUMBERS:
- menu->priv->show_numbers = g_value_get_boolean (value);
+ priv->show_numbers = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER:
set_recent_manager (menu, g_value_get_object (value));
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE:
- menu->priv->show_private = g_value_get_boolean (value);
+ priv->show_private = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND:
- menu->priv->show_not_found = g_value_get_boolean (value);
+ priv->show_not_found = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_TIPS:
gtk_recent_chooser_menu_set_show_tips (menu, g_value_get_boolean (value));
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_ICONS:
- menu->priv->show_icons = g_value_get_boolean (value);
+ priv->show_icons = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE:
- g_warning ("%s: RecentChoosers of type `%s' do not support "
- "selecting multiple items.",
+ g_warning ("%s: Choosers of type `%s' do not support selecting multiple items.",
G_STRFUNC,
G_OBJECT_TYPE_NAME (object));
break;
case GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY:
- menu->priv->local_only = g_value_get_boolean (value);
+ priv->local_only = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_LIMIT:
- menu->priv->limit = g_value_get_int (value);
+ priv->limit = g_value_get_int (value);
break;
case GTK_RECENT_CHOOSER_PROP_SORT_TYPE:
chooser_set_sort_type (menu, g_value_get_enum (value));
GParamSpec *pspec)
{
GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (object);
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
switch (prop_id)
{
case PROP_SHOW_NUMBERS:
- g_value_set_boolean (value, menu->priv->show_numbers);
+ g_value_set_boolean (value, priv->show_numbers);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_TIPS:
- g_value_set_boolean (value, menu->priv->show_tips);
+ g_value_set_boolean (value, priv->show_tips);
break;
case GTK_RECENT_CHOOSER_PROP_LIMIT:
- g_value_set_int (value, menu->priv->limit);
+ g_value_set_int (value, priv->limit);
break;
case GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY:
- g_value_set_boolean (value, menu->priv->local_only);
+ g_value_set_boolean (value, priv->local_only);
+ break;
case GTK_RECENT_CHOOSER_PROP_SORT_TYPE:
- g_value_set_enum (value, menu->priv->sort_type);
+ g_value_set_enum (value, priv->sort_type);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE:
- g_value_set_boolean (value, menu->priv->show_private);
+ g_value_set_boolean (value, priv->show_private);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND:
- g_value_set_boolean (value, menu->priv->show_not_found);
+ g_value_set_boolean (value, priv->show_not_found);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_ICONS:
- g_value_set_boolean (value, menu->priv->show_icons);
+ g_value_set_boolean (value, priv->show_icons);
break;
case GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE:
- g_warning ("%s: Recent Choosers of type `%s' do not support "
- "selecting multiple items.",
- G_STRFUNC,
- G_OBJECT_TYPE_NAME (object));
+ g_value_set_boolean (value, FALSE);
break;
case GTK_RECENT_CHOOSER_PROP_FILTER:
- g_value_set_object (value, menu->priv->current_filter);
+ g_value_set_object (value, priv->current_filter);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
gboolean found = FALSE;
children = gtk_container_get_children (GTK_CONTAINER (menu));
+
for (l = children; l != NULL; l = l->next)
{
GtkRecentInfo *info;
if (!info)
continue;
- if (0 == strcmp (uri, gtk_recent_info_get_uri (info)))
- found = TRUE;
+ if (strcmp (uri, gtk_recent_info_get_uri (info)) == 0)
+ {
+ gtk_menu_shell_activate_item (GTK_MENU_SHELL (menu),
+ menu_item,
+ TRUE);
+ found = TRUE;
+
+ break;
+ }
}
g_list_free (children);
GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
_("No recently used resource found with URI `%s'"),
uri);
- return FALSE;
- }
- else
- {
- gtk_menu_shell_activate_item (GTK_MENU_SHELL (menu), menu_item, TRUE);
-
- return TRUE;
}
+
+ return found;
}
static gchar *
gtk_recent_chooser_menu_unselect_all (GtkRecentChooser *chooser)
{
g_warning (_("This function is not implemented for "
- "widgets of class '%s'."),
+ "widgets of class '%s'"),
g_type_name (G_OBJECT_TYPE (chooser)));
}
if (priv->sort_data_destroy)
{
priv->sort_data_destroy (priv->sort_data);
-
- priv->sort_func = NULL;
- priv->sort_data = NULL;
priv->sort_data_destroy = NULL;
}
+
+ priv->sort_func = NULL;
+ priv->sort_data = NULL;
+ priv->sort_data_destroy = NULL;
if (sort_func)
{
}
}
-static gint
-sort_recent_items_mru (GtkRecentInfo *a,
- GtkRecentInfo *b,
- gpointer unused)
-{
- g_assert (a != NULL && b != NULL);
-
- return (gtk_recent_info_get_modified (a) < gtk_recent_info_get_modified (b));
-}
-
-static gint
-sort_recent_items_lru (GtkRecentInfo *a,
- GtkRecentInfo *b,
- gpointer unused)
-{
- g_assert (a != NULL && b != NULL);
-
- return (gtk_recent_info_get_modified (a) > gtk_recent_info_get_modified (b));
-}
-
-/* our proxy sorting function */
-static gint
-sort_recent_items_proxy (gpointer *a,
- gpointer *b,
- gpointer user_data)
-{
- GtkRecentInfo *info_a = (GtkRecentInfo *) a;
- GtkRecentInfo *info_b = (GtkRecentInfo *) b;
- GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (user_data);
-
- if (menu->priv->sort_func)
- return (* menu->priv->sort_func) (info_a,
- info_b,
- menu->priv->sort_data);
-
- /* fallback */
- return 0;
-}
-
static void
chooser_set_sort_type (GtkRecentChooserMenu *menu,
GtkRecentSortType sort_type)
gtk_recent_chooser_menu_get_items (GtkRecentChooser *chooser)
{
GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (chooser);
- GtkRecentChooserMenuPrivate *priv;
- gint limit;
- GtkRecentSortType sort_type;
- GList *items;
- GCompareDataFunc compare_func;
- gint length;
-
- priv = menu->priv;
-
- if (!priv->manager)
- return NULL;
-
- limit = gtk_recent_chooser_get_limit (chooser);
- sort_type = gtk_recent_chooser_get_sort_type (chooser);
-
- switch (sort_type)
- {
- case GTK_RECENT_SORT_NONE:
- compare_func = NULL;
- break;
- case GTK_RECENT_SORT_MRU:
- compare_func = (GCompareDataFunc) sort_recent_items_mru;
- break;
- case GTK_RECENT_SORT_LRU:
- compare_func = (GCompareDataFunc) sort_recent_items_lru;
- break;
- case GTK_RECENT_SORT_CUSTOM:
- compare_func = (GCompareDataFunc) sort_recent_items_proxy;
- break;
- default:
- g_assert_not_reached ();
- break;
- }
-
- items = gtk_recent_manager_get_items (priv->manager);
- if (!items)
- return NULL;
-
- if (compare_func)
- items = g_list_sort_with_data (items, compare_func, menu);
-
- length = g_list_length (items);
- if ((limit != -1) && (length > limit))
- {
- GList *clamp, *l;
-
- clamp = g_list_nth (items, limit - 1);
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
- l = clamp->next;
- clamp->next = NULL;
-
- g_list_foreach (l, (GFunc) gtk_recent_info_unref, NULL);
- g_list_free (l);
- }
-
- return items;
+ return _gtk_recent_chooser_get_items (chooser,
+ priv->current_filter,
+ priv->sort_func,
+ priv->sort_data);
}
static GtkRecentManager *
gtk_recent_chooser_menu_add_filter (GtkRecentChooser *chooser,
GtkRecentFilter *filter)
{
- g_warning (_("This function is not implemented for "
- "widgets of class '%s'"),
- g_type_name (G_OBJECT_TYPE (chooser)));
+ GtkRecentChooserMenu *menu;
+
+ menu = GTK_RECENT_CHOOSER_MENU (chooser);
+
+ gtk_recent_chooser_menu_set_current_filter (menu, filter);
}
static void
gtk_recent_chooser_menu_remove_filter (GtkRecentChooser *chooser,
GtkRecentFilter *filter)
{
- g_warning (_("This function is not implemented for "
- "widgets of class '%s'"),
- g_type_name (G_OBJECT_TYPE (chooser)));
+ GtkRecentChooserMenu *menu;
+
+ menu = GTK_RECENT_CHOOSER_MENU (chooser);
+
+ if (filter == menu->priv->current_filter)
+ {
+ g_object_unref (menu->priv->current_filter);
+ menu->priv->current_filter = NULL;
+
+ g_object_notify (G_OBJECT (menu), "filter");
+ }
}
static GSList *
-gtk_recent_chooser_menu_list_filters (GtkRecentChooser *chooser)
+gtk_recent_chooser_menu_list_filters (GtkRecentChooser *chooser)
{
- g_warning (_("This function is not implemented for "
- "widgets of class '%s'"),
- g_type_name (G_OBJECT_TYPE (chooser)));
+ GtkRecentChooserMenu *menu;
+ GSList *retval = NULL;
+
+ menu = GTK_RECENT_CHOOSER_MENU (chooser);
+
+ if (menu->priv->current_filter)
+ retval = g_slist_prepend (retval, menu->priv->current_filter);
- return NULL;
+ return retval;
}
static void
if (priv->current_filter)
g_object_unref (G_OBJECT (priv->current_filter));
- priv->current_filter = filter;
- g_object_ref_sink (priv->current_filter);
-
- g_object_notify (G_OBJECT (menu), "filter");
-}
-
-static gboolean
-get_is_recent_filtered (GtkRecentChooserMenu *menu,
- GtkRecentInfo *info)
-{
- GtkRecentChooserMenuPrivate *priv;
- GtkRecentFilter *current_filter;
- GtkRecentFilterInfo filter_info;
- GtkRecentFilterFlags needed;
- gboolean retval;
-
- g_assert (info != NULL);
-
- priv = menu->priv;
-
- if (!priv->current_filter)
- return FALSE;
-
- current_filter = priv->current_filter;
- needed = gtk_recent_filter_get_needed (current_filter);
-
- filter_info.contains = GTK_RECENT_FILTER_URI | GTK_RECENT_FILTER_MIME_TYPE;
-
- filter_info.uri = gtk_recent_info_get_uri (info);
- filter_info.mime_type = gtk_recent_info_get_mime_type (info);
-
- if (needed & GTK_RECENT_FILTER_DISPLAY_NAME)
- {
- filter_info.display_name = gtk_recent_info_get_display_name (info);
- filter_info.contains |= GTK_RECENT_FILTER_DISPLAY_NAME;
- }
- else
- filter_info.uri = NULL;
-
- if (needed & GTK_RECENT_FILTER_APPLICATION)
+ if (filter)
{
- filter_info.applications = (const gchar **) gtk_recent_info_get_applications (info, NULL);
- filter_info.contains |= GTK_RECENT_FILTER_APPLICATION;
+ priv->current_filter = filter;
+ g_object_ref_sink (priv->current_filter);
}
- else
- filter_info.applications = NULL;
- if (needed & GTK_RECENT_FILTER_GROUP)
- {
- filter_info.groups = (const gchar **) gtk_recent_info_get_groups (info, NULL);
- filter_info.contains |= GTK_RECENT_FILTER_GROUP;
- }
- else
- filter_info.groups = NULL;
+ gtk_recent_chooser_menu_populate (menu);
- if (needed & GTK_RECENT_FILTER_AGE)
- {
- filter_info.age = gtk_recent_info_get_age (info);
- filter_info.contains |= GTK_RECENT_FILTER_AGE;
- }
- else
- filter_info.age = -1;
-
- retval = gtk_recent_filter_filter (current_filter, &filter_info);
-
- /* this we own */
- if (filter_info.applications)
- g_strfreev ((gchar **) filter_info.applications);
-
- return !retval;
+ g_object_notify (G_OBJECT (menu), "filter");
}
/* taken from libeel/eel-strings.c */
GtkWidget *item)
{
GtkRecentChooserMenuPrivate *priv;
- gchar *path, *tip_text;
+ gchar *path;
g_assert (info != NULL);
g_assert (item != NULL);
priv = menu->priv;
- if (!priv->tooltips)
- return;
-
path = gtk_recent_info_get_uri_display (info);
-
- tip_text = g_strdup_printf (_("Open '%s'"), path);
-
- gtk_tooltips_set_tip (priv->tooltips,
- item,
- tip_text,
- NULL);
+ if (path)
+ {
+ gchar *tip_text = g_strdup_printf (_("Open '%s'"), path);
- g_free (path);
- g_free (tip_text);
+ gtk_widget_set_tooltip_text (item, tip_text);
+ gtk_widget_set_has_tooltip (item, priv->show_tips);
+
+ g_free (path);
+ g_free (tip_text);
+ }
}
static GtkWidget *
gint count)
{
GtkRecentChooserMenuPrivate *priv;
- gchar *label;
- GtkWidget *item, *image;
+ gchar *text;
+ GtkWidget *item, *image, *label;
GdkPixbuf *icon;
g_assert (info != NULL);
/* avoid clashing mnemonics */
if (count <= 10)
- label = g_strdup_printf ("_%d. %s", count, escaped);
+ /* This is the label format that is used for the first 10 items
+ * in a recent files menu. The %d is the number of the item,
+ * the %s is the name of the item. Please keep the _ in front
+ * of the number to give these menu items a mnemonic.
+ *
+ * Don't include the prefix "recent menu label|" in the translation.
+ */
+ text = g_strdup_printf (Q_("recent menu label|_%d. %s"), count, escaped);
else
- label = g_strdup_printf ("%d. %s", count, escaped);
+ /* This is the format that is used for items in a recent files menu.
+ * The %d is the number of the item, the %s is the name of the item.
+ *
+ * Don't include the prefix "recent menu label|" in the translation.
+ */
+ text = g_strdup_printf (Q_("recent menu label|%d. %s"), count, escaped);
- item = gtk_image_menu_item_new_with_mnemonic (label);
+ item = gtk_image_menu_item_new_with_mnemonic (text);
g_free (escaped);
g_free (name);
}
else
{
- label = g_strdup (gtk_recent_info_get_display_name (info));
- item = gtk_image_menu_item_new_with_label (label);
+ text = g_strdup (gtk_recent_info_get_display_name (info));
+ item = gtk_image_menu_item_new_with_label (text);
+ }
+
+ g_free (text);
+
+ /* ellipsize the menu item label, in case the recent document
+ * display name is huge.
+ */
+ label = GTK_BIN (item)->child;
+ if (GTK_IS_LABEL (label))
+ {
+ gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
+ gtk_label_set_max_width_chars (GTK_LABEL (label), priv->label_width);
}
if (priv->show_icons)
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
+ g_object_unref (icon);
}
-
- if (!gtk_recent_info_exists (info))
- {
- gtk_widget_set_sensitive (item, FALSE);
-
- goto out;
- }
-
+
g_signal_connect (item, "activate",
G_CALLBACK (item_activate_cb),
menu);
-out:
- g_free (label);
-
return item;
}
+static void
+gtk_recent_chooser_menu_insert_item (GtkRecentChooserMenu *menu,
+ GtkWidget *menuitem,
+ gint position)
+{
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
+ gint real_position;
+
+ if (priv->first_recent_item_pos == -1)
+ {
+ GList *children, *l;
+
+ children = gtk_container_get_children (GTK_CONTAINER (menu));
+
+ for (real_position = 0, l = children;
+ l != NULL;
+ real_position += 1, l = l->next)
+ {
+ GObject *child = l->data;
+ gboolean is_placeholder = FALSE;
+
+ is_placeholder =
+ GPOINTER_TO_INT (g_object_get_data (child, "gtk-recent-menu-placeholder"));
+
+ if (is_placeholder)
+ break;
+ }
+
+ g_list_free (children);
+ priv->first_recent_item_pos = real_position;
+ }
+ else
+ real_position = priv->first_recent_item_pos;
+
+ gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem,
+ real_position + position);
+ gtk_widget_show (menuitem);
+}
+
/* removes the items we own from the menu */
static void
gtk_recent_chooser_menu_dispose_items (GtkRecentChooserMenu *menu)
for (l = children; l != NULL; l = l->next)
{
GtkWidget *menu_item = GTK_WIDGET (l->data);
- gint mark = 0;
+ gboolean has_mark = FALSE;
/* check for our mark, in order to remove just the items we own */
- mark = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item),
- "gtk-recent-menu-mark"));
- if (mark == 1)
+ has_mark =
+ GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "gtk-recent-menu-mark"));
+
+ if (has_mark)
{
GtkRecentInfo *info;
}
}
+ /* recalculate the position of the first recent item */
+ menu->priv->first_recent_item_pos = -1;
+
g_list_free (children);
}
-/* GtkWidget::map method override
- *
- * We override this method in order to populate the menu with our
- * menu items linked to the recently used resources.
- */
-static void
-gtk_recent_chooser_menu_map (GtkWidget *widget)
+typedef struct
{
- GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (widget);
- GtkRecentChooserMenuPrivate *priv = menu->priv;
- GList *items, *l;
- gint count;
- gboolean has_items = FALSE;
-
- if (GTK_WIDGET_CLASS (gtk_recent_chooser_menu_parent_class)->map)
- GTK_WIDGET_CLASS (gtk_recent_chooser_menu_parent_class)->map (widget);
-
- priv->icon_size = get_icon_size_for_widget (widget);
-
- /* dispose our menu items first */
- gtk_recent_chooser_menu_dispose_items (menu);
-
- items = gtk_recent_chooser_get_items (GTK_RECENT_CHOOSER (menu));
-
- count = g_list_length (items);
- items = g_list_reverse (items);
+ GList *items;
+ gint n_items;
+ gint loaded_items;
+ gint displayed_items;
+ GtkRecentChooserMenu *menu;
+ GtkWidget *placeholder;
+} MenuPopulateData;
- for (l = items; l != NULL; l = l->next)
+static gboolean
+idle_populate_func (gpointer data)
+{
+ MenuPopulateData *pdata;
+ GtkRecentChooserMenuPrivate *priv;
+ GtkRecentInfo *info;
+ gboolean retval;
+ GtkWidget *item;
+
+ pdata = (MenuPopulateData *) data;
+ priv = pdata->menu->priv;
+
+ if (!pdata->items)
{
- GtkRecentInfo *info = (GtkRecentInfo *) l->data;
- GtkWidget *item;
+ pdata->items = gtk_recent_chooser_get_items (GTK_RECENT_CHOOSER (pdata->menu));
+ if (!pdata->items)
+ {
+ /* show the placeholder here */
+ gtk_widget_show (pdata->placeholder);
+ pdata->displayed_items = 1;
+ priv->populate_id = 0;
- g_assert (info != NULL);
-
- /* skip non-local items on request */
- if (priv->local_only && !gtk_recent_info_is_local (info))
- continue;
+ return FALSE;
+ }
- /* skip private items on request */
- if (!priv->show_private && gtk_recent_info_get_private_hint (info))
- continue;
-
- /* skip non-existing items on request */
- if (!priv->show_not_found && !gtk_recent_info_exists (info))
- continue;
+ pdata->n_items = g_list_length (pdata->items);
+ pdata->loaded_items = 0;
+ }
- /* filter items based on the currently set filter object */
- if (get_is_recent_filtered (menu, info))
- continue;
-
- item = gtk_recent_chooser_menu_create_item (menu, info, count);
- if (!item)
- continue;
+ info = g_list_nth_data (pdata->items, pdata->loaded_items);
+ item = gtk_recent_chooser_menu_create_item (pdata->menu,
+ info,
+ pdata->displayed_items);
+ if (!item)
+ goto check_and_return;
- gtk_recent_chooser_menu_add_tip (menu, info, item);
-
- /* FIXME
- *
- * We should really place our items taking into account user
- * defined menu items; this would also remove the need of
- * reverting the scan order.
- */
- gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
- gtk_widget_show (item);
-
- /* mark the menu item as one of our own */
- g_object_set_data (G_OBJECT (item), "gtk-recent-menu-mark",
- GINT_TO_POINTER (1));
+ gtk_recent_chooser_menu_add_tip (pdata->menu, info, item);
+ gtk_recent_chooser_menu_insert_item (pdata->menu, item,
+ pdata->displayed_items);
+
+ pdata->displayed_items += 1;
- /* attach the RecentInfo object to the menu item, and own a reference
- * to it, so that it will be destroyed with the menu item when it's
- * not needed anymore.
- */
- g_object_set_data_full (G_OBJECT (item), "gtk-recent-info",
- gtk_recent_info_ref (info),
- (GDestroyNotify) gtk_recent_info_unref);
+ /* mark the menu item as one of our own */
+ g_object_set_data (G_OBJECT (item),
+ "gtk-recent-menu-mark",
+ GINT_TO_POINTER (TRUE));
- /* we have at least one item */
- if (!has_items)
- has_items = TRUE;
- }
+ /* attach the RecentInfo object to the menu item, and own a reference
+ * to it, so that it will be destroyed with the menu item when it's
+ * not needed anymore.
+ */
+ g_object_set_data_full (G_OBJECT (item), "gtk-recent-info",
+ gtk_recent_info_ref (info),
+ (GDestroyNotify) gtk_recent_info_unref);
- /* now, the RecentInfo objects are bound to the lifetime of the menu */
- if (items)
+check_and_return:
+ pdata->loaded_items += 1;
+
+ if (pdata->loaded_items == pdata->n_items)
{
- g_list_foreach (items,
- (GFunc) gtk_recent_info_unref,
- NULL);
- g_list_free (items);
+ g_list_foreach (pdata->items, (GFunc) gtk_recent_info_unref, NULL);
+ g_list_free (pdata->items);
+
+ priv->populate_id = 0;
+
+ retval = FALSE;
}
+ else
+ retval = TRUE;
- /* no recently used resources were found, or they were filtered out, so
- * we build an item stating that no recently used resources were found
- * (as night follows the day...).
- */
- if (!has_items)
+ return retval;
+}
+
+static void
+idle_populate_clean_up (gpointer data)
+{
+ MenuPopulateData *pdata = data;
+
+ if (pdata->menu->priv->populate_id == 0)
{
- GtkWidget *item;
-
- item = gtk_menu_item_new_with_label ("No items found");
- gtk_widget_set_sensitive (item, FALSE);
-
- /* we also mark this item, so that it gets removed when rebuilding
- * the menu on the next map event
+ /* show the placeholder in case no item survived
+ * the filtering process in the idle loop
*/
- g_object_set_data (G_OBJECT (item), "gtk-recent-menu-mark",
- GINT_TO_POINTER (1));
-
- gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item);
- gtk_widget_show (item);
+ if (!pdata->displayed_items)
+ gtk_widget_show (pdata->placeholder);
+ g_object_unref (pdata->placeholder);
+
+ g_slice_free (MenuPopulateData, data);
}
}
+static void
+gtk_recent_chooser_menu_populate (GtkRecentChooserMenu *menu)
+{
+ MenuPopulateData *pdata;
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
+
+ if (menu->priv->populate_id)
+ return;
+
+ pdata = g_slice_new (MenuPopulateData);
+ pdata->items = NULL;
+ pdata->n_items = 0;
+ pdata->loaded_items = 0;
+ pdata->displayed_items = 0;
+ pdata->menu = menu;
+ pdata->placeholder = g_object_ref (priv->placeholder);
+
+ priv->icon_size = get_icon_size_for_widget (GTK_WIDGET (menu));
+
+ /* remove our menu items first and hide the placeholder */
+ gtk_recent_chooser_menu_dispose_items (menu);
+ gtk_widget_hide (priv->placeholder);
+
+ priv->populate_id = gdk_threads_add_idle_full (G_PRIORITY_HIGH_IDLE + 30,
+ idle_populate_func,
+ pdata,
+ idle_populate_clean_up);
+}
+
/* bounce activate signal from the recent menu item widget
* to the recent menu widget
*/
manager_changed_cb (GtkRecentManager *manager,
gpointer user_data)
{
- gtk_widget_queue_draw (GTK_WIDGET (user_data));
+ GtkRecentChooserMenu *menu = GTK_RECENT_CHOOSER_MENU (user_data);
+
+ gtk_recent_chooser_menu_populate (menu);
}
static void
set_recent_manager (GtkRecentChooserMenu *menu,
GtkRecentManager *manager)
{
- if (menu->priv->manager)
- g_signal_handler_disconnect (menu, menu->priv->manager_changed_id);
-
- menu->priv->manager = NULL;
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
+
+ if (priv->manager)
+ {
+ if (priv->manager_changed_id)
+ {
+ g_signal_handler_disconnect (priv->manager, priv->manager_changed_id);
+ priv->manager_changed_id = 0;
+ }
+
+ if (priv->populate_id)
+ {
+ g_source_remove (priv->populate_id);
+ priv->populate_id = 0;
+ }
+
+ priv->manager = NULL;
+ }
if (manager)
- menu->priv->manager = manager;
+ priv->manager = manager;
else
- menu->priv->manager = gtk_recent_manager_get_default ();
+ priv->manager = gtk_recent_manager_get_default ();
- if (menu->priv->manager)
- menu->priv->manager_changed_id = g_signal_connect (menu->priv->manager, "changed",
- G_CALLBACK (manager_changed_cb),
- menu);
+ if (priv->manager)
+ priv->manager_changed_id = g_signal_connect (priv->manager, "changed",
+ G_CALLBACK (manager_changed_cb),
+ menu);
}
static gint
return FALLBACK_ICON_SIZE;
}
+static void
+foreach_set_shot_tips (GtkWidget *widget,
+ gpointer user_data)
+{
+ GtkRecentChooserMenu *menu = user_data;
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
+ gboolean has_mark;
+
+ /* toggle the tooltip only on the items we create */
+ has_mark =
+ GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "gtk-recent-menu-mark"));
+
+ if (has_mark)
+ gtk_widget_set_has_tooltip (widget, priv->show_tips);
+}
+
static void
gtk_recent_chooser_menu_set_show_tips (GtkRecentChooserMenu *menu,
gboolean show_tips)
{
- if (menu->priv->show_tips == show_tips)
+ GtkRecentChooserMenuPrivate *priv = menu->priv;
+
+ if (priv->show_tips == show_tips)
return;
- g_assert (menu->priv->tooltips != NULL);
-
- if (show_tips)
- gtk_tooltips_enable (menu->priv->tooltips);
- else
- gtk_tooltips_disable (menu->priv->tooltips);
-
- menu->priv->show_tips = show_tips;
+ priv->show_tips = show_tips;
+ gtk_container_foreach (GTK_CONTAINER (menu), foreach_set_shot_tips, menu);
}
/*
GtkWidget *
gtk_recent_chooser_menu_new_for_manager (GtkRecentManager *manager)
{
- g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), NULL);
+ g_return_val_if_fail (manager == NULL || GTK_IS_RECENT_MANAGER (manager), NULL);
return g_object_new (GTK_TYPE_RECENT_CHOOSER_MENU,
"recent-manager", manager,
*
* Sets whether a number should be added to the items of @menu. The
* numbers are shown to provide a unique character for a mnemonic to
- * be used inside the menu item's label. Only the first the items
+ * be used inside ten menu item's label. Only the first the items
* get a number to avoid clashes.
*
* Since: 2.10