debian/midori
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Implement sorting location items by the number of visits

Browse source 
For the moment, a define in the code decides whether items
are sorted based on when they were added or how often
a page was visited. The 'visits' property and respective
database column is unused (we keep it for compatibility).
It turns out it's enough to store that information in
the tree model.

The visit based sorting is not enabled because it is
simply delaying startup incredibly. It will have to be
decided whether to introduce a preference, or always use
a visited based sorting once the startup delay is fixed.

History items are also deleted from the tree model now
if they are too old, according to the preference.
This commit is contained in:
Dale Whittaker 2008-11-08 02:23:08 +01:00 committed by Christian Dywan
parent 7ac9c7787b
commit 0246eeb124
8 changed files with 289 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
katze/katze-item.c
View file

@ -35,8 +35,7 @@ enum
PROP_URI, PROP_URI,
PROP_ICON, PROP_ICON,
PROP_TOKEN, PROP_TOKEN,
PROP_ADDED, PROP_ADDED
PROP_VISITS
}; };
static void static void
@ -123,17 +122,6 @@ katze_item_class_init (KatzeItemClass* class)
0, 0,
flags)); flags));
g_object_class_install_property (gobject_class,
PROP_VISITS,
g_param_spec_int (
"visits",
"Visits",
"The number of visits of the item",
G_MININT,
G_MAXINT,
0,
flags));
} }
@ -186,9 +174,6 @@ katze_item_set_property (GObject* object,
case PROP_ADDED: case PROP_ADDED:
item->added = g_value_get_int64 (value); item->added = g_value_get_int64 (value);
break; break;
case PROP_VISITS:
item->visits = g_value_get_int (value);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
@ -223,9 +208,6 @@ katze_item_get_property (GObject* object,
case PROP_ADDED: case PROP_ADDED:
g_value_set_int64 (value, item->added); g_value_set_int64 (value, item->added);
break; break;
case PROP_VISITS:
g_value_set_int (value, item->visits);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
@ -445,39 +427,6 @@ katze_item_set_added (KatzeItem* item,
g_object_notify (G_OBJECT (item), "added"); g_object_notify (G_OBJECT (item), "added");
} }
/**
* katze_item_get_visits:
* @item: a #KatzeItem
*
* Retrieves the number of visits of @item.
*
* Return value: the number of visits
**/
gint
katze_item_get_visits (KatzeItem* item)
{
g_return_val_if_fail (KATZE_IS_ITEM (item), -1);
return item->visits;
}
/**
* katze_item_set_visits:
* @item: a #KatzeItem
* @visits: an integer
*
* Sets the number of visits of @item.
**/
void
katze_item_set_visits (KatzeItem* item,
gint visits)
{
g_return_if_fail (KATZE_IS_ITEM (item));
item->visits = visits;
g_object_notify (G_OBJECT (item), "visits");
}
/** /**
* katze_item_get_parent: * katze_item_get_parent:
* @item: a #KatzeItem * @item: a #KatzeItem

8
katze/katze-item.h
View file

@ -42,7 +42,6 @@ struct _KatzeItem
gchar* icon; gchar* icon;
gchar* token; gchar* token;
gint64 added; gint64 added;
gint visits;
KatzeItem* parent; KatzeItem* parent;
}; };
@ -100,13 +99,6 @@ void
katze_item_set_added (KatzeItem* item, katze_item_set_added (KatzeItem* item,
gint64 added); gint64 added);
gint
katze_item_get_visits (KatzeItem* item);
void
katze_item_set_visits (KatzeItem* item,
gint visits);
gpointer gpointer
katze_item_get_parent (KatzeItem* item); katze_item_get_parent (KatzeItem* item);

18
midori/main.c
View file

@ -668,11 +668,10 @@ midori_history_remove_item_cb (KatzeArray* history,
sqlcmd = g_strdup_printf ( sqlcmd = g_strdup_printf (
"DELETE FROM history WHERE uri = '%s' AND" "DELETE FROM history WHERE uri = '%s' AND"
" title = '%s' AND date = %" G_GINT64_FORMAT " AND visits = %d", " title = '%s' AND date = %" G_GINT64_FORMAT,
katze_item_get_uri (item), katze_item_get_uri (item),
katze_item_get_name (item), katze_item_get_name (item),
katze_item_get_added (item), katze_item_get_added (item));
katze_item_get_visits (item));
success = db_exec (db, sqlcmd, &error); success = db_exec (db, sqlcmd, &error);
if (!success) if (!success)
{ {
@ -739,11 +738,10 @@ midori_history_add_item_cb (KatzeArray* array,
} }
} }
sqlcmd = g_strdup_printf ("INSERT INTO history VALUES" sqlcmd = g_strdup_printf ("INSERT INTO history VALUES"
"('%s', '%s', %" G_GUINT64_FORMAT ", %d)", "('%s', '%s', %" G_GUINT64_FORMAT ", -1)",
katze_item_get_uri (item), katze_item_get_uri (item),
katze_item_get_name (item), katze_item_get_name (item),
katze_item_get_added (item), katze_item_get_added (item));
katze_item_get_visits (item));
success = db_exec (db, sqlcmd, &error); success = db_exec (db, sqlcmd, &error);
g_free (sqlcmd); g_free (sqlcmd);
if (!success) if (!success)
@ -766,7 +764,7 @@ midori_history_add_items (void* data,
gint64 date; gint64 date;
time_t newdate; time_t newdate;
gint i, j, n; gint i, j, n;
gint ncols = 4; gint ncols = 3;
g_return_val_if_fail (KATZE_IS_ARRAY (array), 1); g_return_val_if_fail (KATZE_IS_ARRAY (array), 1);
@ -779,15 +777,13 @@ midori_history_add_items (void* data,
{ {
if (colname[i] && !g_ascii_strcasecmp (colname[i], "uri") && if (colname[i] && !g_ascii_strcasecmp (colname[i], "uri") &&
colname[i + 1] && !g_ascii_strcasecmp (colname[i + 1], "title") && colname[i + 1] && !g_ascii_strcasecmp (colname[i + 1], "title") &&
colname[i + 2] && !g_ascii_strcasecmp (colname[i + 2], "date") && colname[i + 2] && !g_ascii_strcasecmp (colname[i + 2], "date"))
colname[i + 3] && !g_ascii_strcasecmp (colname[i + 3], "visits"))
{ {
item = katze_item_new (); item = katze_item_new ();
katze_item_set_uri (item, argv[i]); katze_item_set_uri (item, argv[i]);
katze_item_set_name (item, argv[i + 1]); katze_item_set_name (item, argv[i + 1]);
date = g_ascii_strtoull (argv[i + 2], NULL, 10); date = g_ascii_strtoull (argv[i + 2], NULL, 10);
katze_item_set_added (item, date); katze_item_set_added (item, date);
katze_item_set_visits (item, atoi (argv[i + 3]));
n = katze_array_get_length (array); n = katze_array_get_length (array);
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
@ -829,7 +825,7 @@ midori_history_initialize (KatzeArray* array,
return NULL; return NULL;
if (!db_exec_callback (db, if (!db_exec_callback (db,
"SELECT uri, title, date, visits FROM history " "SELECT uri, title, date FROM history "
"ORDER BY date ASC", "ORDER BY date ASC",
midori_history_add_items, midori_history_add_items,
array, array,

26
midori/midori-browser.c
View file

@ -454,7 +454,6 @@ midori_view_notify_title_cb (GtkWidget* view,
item = katze_item_new (); item = katze_item_new ();
katze_item_set_uri (item, uri); katze_item_set_uri (item, uri);
katze_item_set_name (item, title); katze_item_set_name (item, title);
katze_item_set_visits (item, -1);
midori_browser_new_history_item (browser, item); midori_browser_new_history_item (browser, item);
} }
@ -2491,15 +2490,19 @@ midori_panel_history_key_release_event_cb (GtkWidget* widget,
GtkTreeModel* model; GtkTreeModel* model;
GtkTreeIter iter; GtkTreeIter iter;
KatzeItem* item; KatzeItem* item;
GtkAction* location_action;
if (event->keyval == GDK_Delete) if (event->keyval != GDK_Delete)
return FALSE;
treeview = GTK_TREE_VIEW (widget);
if (sokoke_tree_view_get_selected_iter (treeview, &model, &iter))
{ {
treeview = GTK_TREE_VIEW (widget); location_action = _action_by_name (browser, "Location");
if (sokoke_tree_view_get_selected_iter (treeview, &model, &iter)) gtk_tree_model_get (model, &iter, 0, &item, -1);
{ midori_browser_model_remove_item (model, item, &iter);
gtk_tree_model_get (model, &iter, 0, &item, -1); midori_location_action_delete_item_from_uri (
midori_browser_model_remove_item (model, item, &iter); MIDORI_LOCATION_ACTION (location_action), katze_item_get_uri (item));
}
} }
return FALSE; return FALSE;
@ -2913,12 +2916,16 @@ _action_history_delete_activate (GtkAction* action,
GtkTreeModel* model; GtkTreeModel* model;
GtkTreeIter iter; GtkTreeIter iter;
KatzeItem* item; KatzeItem* item;
GtkAction* location_action;
treeview = GTK_TREE_VIEW (browser->panel_history); treeview = GTK_TREE_VIEW (browser->panel_history);
if (sokoke_tree_view_get_selected_iter (treeview, &model, &iter)) if (sokoke_tree_view_get_selected_iter (treeview, &model, &iter))
{ {
location_action = _action_by_name (browser, "Location");
gtk_tree_model_get (model, &iter, 0, &item, -1); gtk_tree_model_get (model, &iter, 0, &item, -1);
midori_browser_model_remove_item (model, item, &iter); midori_browser_model_remove_item (model, item, &iter);
midori_location_action_delete_item_from_uri (
MIDORI_LOCATION_ACTION (location_action), katze_item_get_uri (item));
} }
} }
@ -2930,6 +2937,7 @@ _action_history_clear_activate (GtkAction* action,
GtkTreeView* tree_view; GtkTreeView* tree_view;
GtkTreeStore* store; GtkTreeStore* store;
KatzeItem* item; KatzeItem* item;
GtkAction* location_action;
gint i, n; gint i, n;
gint result; gint result;
@ -2945,6 +2953,7 @@ _action_history_clear_activate (GtkAction* action,
if (result != GTK_RESPONSE_YES) if (result != GTK_RESPONSE_YES)
return; return;
location_action = _action_by_name (browser, "Location");
tree_view = GTK_TREE_VIEW (browser->panel_history); tree_view = GTK_TREE_VIEW (browser->panel_history);
store = GTK_TREE_STORE (gtk_tree_view_get_model (tree_view)); store = GTK_TREE_STORE (gtk_tree_view_get_model (tree_view));
gtk_tree_store_clear (store); gtk_tree_store_clear (store);
@ -2956,6 +2965,7 @@ _action_history_clear_activate (GtkAction* action,
katze_array_clear (KATZE_ARRAY (item)); katze_array_clear (KATZE_ARRAY (item));
} }
katze_array_clear (browser->history); katze_array_clear (browser->history);
midori_location_action_clear (MIDORI_LOCATION_ACTION (location_action));
} }
static void static void

52
midori/midori-locationaction.c
View file

@ -456,7 +456,6 @@ midori_location_action_add_uri (MidoriLocationAction* location_action,
g_return_if_fail (MIDORI_IS_LOCATION_ACTION (location_action)); g_return_if_fail (MIDORI_IS_LOCATION_ACTION (location_action));
g_return_if_fail (uri != NULL); g_return_if_fail (uri != NULL);
katze_assign (location_action->uri, g_strdup (uri)); katze_assign (location_action->uri, g_strdup (uri));
proxies = gtk_action_get_proxies (GTK_ACTION (location_action)); proxies = gtk_action_get_proxies (GTK_ACTION (location_action));
@ -660,3 +659,54 @@ midori_location_action_set_secondary_icon (MidoriLocationAction* location_action
} }
while ((proxies = g_slist_next (proxies))); while ((proxies = g_slist_next (proxies)));
} }
void
midori_location_action_delete_item_from_uri (MidoriLocationAction* location_action,
const gchar* uri)
{
GSList* proxies;
GtkWidget* alignment;
GtkWidget* entry;
g_return_if_fail (MIDORI_IS_LOCATION_ACTION (location_action));
g_return_if_fail (uri != NULL);
proxies = gtk_action_get_proxies (GTK_ACTION (location_action));
if (!proxies)
return;
do
if (GTK_IS_TOOL_ITEM (proxies->data))
{
alignment = gtk_bin_get_child (GTK_BIN (proxies->data));
entry = gtk_bin_get_child (GTK_BIN (alignment));
midori_location_entry_delete_item_from_uri
(MIDORI_LOCATION_ENTRY (entry), uri);
}
while ((proxies = g_slist_next (proxies)));
}
void
midori_location_action_clear (MidoriLocationAction* location_action)
{
GSList* proxies;
GtkWidget* alignment;
GtkWidget* entry;
g_return_if_fail (MIDORI_IS_LOCATION_ACTION (location_action));
proxies = gtk_action_get_proxies (GTK_ACTION (location_action));
if (!proxies)
return;
do
if (GTK_IS_TOOL_ITEM (proxies->data))
{
alignment = gtk_bin_get_child (GTK_BIN (proxies->data));
entry = gtk_bin_get_child (GTK_BIN (alignment));
midori_location_entry_clear (MIDORI_LOCATION_ENTRY (entry));
}
while ((proxies = g_slist_next (proxies)));
}

49
midori/midori-locationaction.h
View file

@ -35,44 +35,51 @@ typedef struct _MidoriLocationAction MidoriLocationAction;
typedef struct _MidoriLocationActionClass MidoriLocationActionClass; typedef struct _MidoriLocationActionClass MidoriLocationActionClass;
GType GType
midori_location_action_get_type (void); midori_location_action_get_type (void);
const gchar* const gchar*
midori_location_action_get_uri (MidoriLocationAction* action); midori_location_action_get_uri (MidoriLocationAction* action);
void void
midori_location_action_set_uri (MidoriLocationAction* location_action, midori_location_action_set_uri (MidoriLocationAction* location_action,
const gchar* uri); const gchar* uri);
void void
midori_location_action_add_uri (MidoriLocationAction* location_action, midori_location_action_add_uri (MidoriLocationAction* location_action,
const gchar* uri); const gchar* uri);
void void
midori_location_action_add_item (MidoriLocationAction* location_action, midori_location_action_add_item (MidoriLocationAction* location_action,
const gchar* uri, const gchar* uri,
GdkPixbuf* icon, GdkPixbuf* icon,
const gchar* title); const gchar* title);
void void
midori_location_action_set_icon_for_uri (MidoriLocationAction* location_action, midori_location_action_set_icon_for_uri (MidoriLocationAction* location_action,
GdkPixbuf* icon, GdkPixbuf* icon,
const gchar* text); const gchar* text);
void void
midori_location_action_set_title_for_uri (MidoriLocationAction* location_action, midori_location_action_set_title_for_uri (MidoriLocationAction* location_action,
const gchar* title, const gchar* title,
const gchar* text); const gchar* text);
gdouble gdouble
midori_location_action_get_progress (MidoriLocationAction* location_action); midori_location_action_get_progress (MidoriLocationAction* location_action);
void void
midori_location_action_set_progress (MidoriLocationAction* location_action, midori_location_action_set_progress (MidoriLocationAction* location_action,
gdouble progress); gdouble progress);
void void
midori_location_action_set_secondary_icon (MidoriLocationAction* location_action, midori_location_action_set_secondary_icon (MidoriLocationAction* location_action,
const gchar* stock_id); const gchar* stock_id);
void
midori_location_action_delete_item_from_uri (MidoriLocationAction* location_action,
const gchar* uri);
void
midori_location_action_clear (MidoriLocationAction* location_action);
G_END_DECLS G_END_DECLS

187
midori/midori-locationentry.c
View file

@ -18,6 +18,7 @@
#define DEFAULT_ICON GTK_STOCK_FILE #define DEFAULT_ICON GTK_STOCK_FILE
#define MAX_ITEMS 25 #define MAX_ITEMS 25
/* #define ORDER_BY_VISITS 1 */
struct _MidoriLocationEntry struct _MidoriLocationEntry
{ {
@ -31,13 +32,15 @@ struct _MidoriLocationEntryClass
GtkComboBoxEntryClass parent_class; GtkComboBoxEntryClass parent_class;
}; };
G_DEFINE_TYPE (MidoriLocationEntry, midori_location_entry, GTK_TYPE_COMBO_BOX_ENTRY) G_DEFINE_TYPE (MidoriLocationEntry,
midori_location_entry, GTK_TYPE_COMBO_BOX_ENTRY)
enum enum
{ {
FAVICON_COL, FAVICON_COL,
URI_COL, URI_COL,
TITLE_COL, TITLE_COL,
VISITS_COL,
VISIBLE_COL, VISIBLE_COL,
N_COLS N_COLS
}; };
@ -74,18 +77,78 @@ midori_location_entry_class_init (MidoriLocationEntryClass* class)
} }
static GtkTreeModel* static GtkTreeModel*
midori_location_entry_get_model (MidoriLocationEntry* location_entry) midori_location_entry_get_filter_model (MidoriLocationEntry* location_entry)
{
return gtk_combo_box_get_model (GTK_COMBO_BOX (location_entry));
}
static GtkTreeModel*
midori_location_entry_get_sort_model (MidoriLocationEntry* location_entry)
{ {
GtkTreeModel* model; GtkTreeModel* model;
GtkTreeModelFilter* filter_model; GtkTreeModelFilter* filter_model;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (location_entry)); model = midori_location_entry_get_filter_model (location_entry);
filter_model = GTK_TREE_MODEL_FILTER (model); filter_model = GTK_TREE_MODEL_FILTER (model);
g_assert (filter_model); g_assert (filter_model);
return gtk_tree_model_filter_get_model (filter_model); return gtk_tree_model_filter_get_model (filter_model);
} }
static GtkTreeModel*
midori_location_entry_get_model (MidoriLocationEntry* location_entry)
{
GtkTreeModel* model;
#ifdef ORDER_BY_VISITS
GtkTreeModelSort* sort_model;
#endif
model = midori_location_entry_get_sort_model (location_entry);
#ifdef ORDER_BY_VISITS
sort_model = GTK_TREE_MODEL_SORT (model);
g_assert (sort_model);
return gtk_tree_model_sort_get_model (sort_model);
#else
return GTK_IS_TREE_MODEL (model) ? model : NULL;
#endif
}
static gboolean
midori_location_entry_child_iter_to_iter (MidoriLocationEntry* location_entry,
GtkTreeIter* iter,
GtkTreeIter* child_iter)
{
GtkTreeModel* filter_model;
#ifdef ORDER_BY_VISITS
GtkTreeModel* sort_model;
GtkTreeIter sort_iter;
#endif
GtkTreeIter* temp_iter;
temp_iter = child_iter;
filter_model = midori_location_entry_get_filter_model (location_entry);
#ifdef ORDER_BY_VISITS
sort_model = midori_location_entry_get_sort_model (location_entry);
g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter_model) &&
GTK_IS_TREE_MODEL_SORT (sort_model), FALSE);
gtk_tree_model_sort_convert_child_iter_to_iter
(GTK_TREE_MODEL_SORT (sort_model), &sort_iter, child_iter);
temp_iter = &sort_iter;
#endif
return gtk_tree_model_filter_convert_child_iter_to_iter
(GTK_TREE_MODEL_FILTER (filter_model), iter, temp_iter);
}
#define HAVE_ENTRY_PROGRESS 1 #define HAVE_ENTRY_PROGRESS 1
#ifdef HAVE_ENTRY_PROGRESS #ifdef HAVE_ENTRY_PROGRESS
@ -565,7 +628,7 @@ midori_location_entry_completion_init (MidoriLocationEntry* location_entry)
completion = gtk_entry_completion_new (); completion = gtk_entry_completion_new ();
gtk_entry_completion_set_model (GTK_ENTRY_COMPLETION (completion), gtk_entry_completion_set_model (GTK_ENTRY_COMPLETION (completion),
midori_location_entry_get_model (location_entry)); midori_location_entry_get_sort_model (location_entry));
gtk_entry_completion_set_text_column (GTK_ENTRY_COMPLETION (completion), gtk_entry_completion_set_text_column (GTK_ENTRY_COMPLETION (completion),
URI_COL); URI_COL);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (completion)); gtk_cell_layout_clear (GTK_CELL_LAYOUT (completion));
@ -597,6 +660,9 @@ midori_location_entry_init (MidoriLocationEntry* location_entry)
GtkListStore* store; GtkListStore* store;
GtkCellRenderer* renderer; GtkCellRenderer* renderer;
GtkTreeModel* filter_model; GtkTreeModel* filter_model;
#ifdef ORDER_BY_VISITS
GtkTreeModel* sort_model;
#endif
/* we want the widget to have appears-as-list applied */ /* we want the widget to have appears-as-list applied */
gtk_rc_parse_string ("style \"midori-location-entry-style\" {\n" gtk_rc_parse_string ("style \"midori-location-entry-style\" {\n"
@ -620,8 +686,18 @@ midori_location_entry_init (MidoriLocationEntry* location_entry)
gtk_container_add (GTK_CONTAINER (location_entry), entry); gtk_container_add (GTK_CONTAINER (location_entry), entry);
store = gtk_list_store_new (N_COLS, store = gtk_list_store_new (N_COLS,
GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_INT, G_TYPE_BOOLEAN);
#ifdef ORDER_BY_VISITS
sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
VISITS_COL, GTK_SORT_DESCENDING);
filter_model = gtk_tree_model_filter_new (GTK_TREE_MODEL (sort_model), NULL);
#else
filter_model = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); filter_model = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
#endif
gtk_tree_model_filter_set_visible_column ( gtk_tree_model_filter_set_visible_column (
GTK_TREE_MODEL_FILTER (filter_model), VISIBLE_COL); GTK_TREE_MODEL_FILTER (filter_model), VISIBLE_COL);
g_object_set (location_entry, "model", filter_model, NULL); g_object_set (location_entry, "model", filter_model, NULL);
@ -687,7 +763,8 @@ midori_location_entry_changed (GtkComboBox* combo_box,
{ {
pixbuf = NULL; pixbuf = NULL;
model = gtk_combo_box_get_model (combo_box); model = midori_location_entry_get_filter_model
(MIDORI_LOCATION_ENTRY (combo_box));
gtk_tree_model_get (model, &iter, FAVICON_COL, &pixbuf, -1); gtk_tree_model_get (model, &iter, FAVICON_COL, &pixbuf, -1);
gtk_icon_entry_set_icon_from_pixbuf (GTK_ICON_ENTRY (entry), gtk_icon_entry_set_icon_from_pixbuf (GTK_ICON_ENTRY (entry),
@ -736,22 +813,19 @@ midori_location_entry_set_active_iter (MidoriLocationEntry* location_entry,
GdkPixbuf* pixbuf; GdkPixbuf* pixbuf;
GtkTreeModel* model; GtkTreeModel* model;
GtkWidget* entry; GtkWidget* entry;
GtkTreeModel* filter_model; GtkTreeIter parent_iter;
GtkTreeIter filter_iter;
entry = gtk_bin_get_child (GTK_BIN (location_entry)); entry = gtk_bin_get_child (GTK_BIN (location_entry));
model = midori_location_entry_get_model (location_entry); model = midori_location_entry_get_model (location_entry);
filter_model = gtk_combo_box_get_model (GTK_COMBO_BOX (location_entry));
/* The filter iter must be set, not the child iter, /* The filter iter must be set, not the child iter,
* but the row must first be set as visible to * but the row must first be set as visible to
* convert to a filter iter without error. * convert to a filter iter without error.
*/ */
gtk_list_store_set (GTK_LIST_STORE (model), iter, VISIBLE_COL, TRUE, -1); gtk_list_store_set (GTK_LIST_STORE (model), iter, VISIBLE_COL, TRUE, -1);
gtk_tree_model_filter_convert_child_iter_to_iter ( if (midori_location_entry_child_iter_to_iter (
GTK_TREE_MODEL_FILTER (filter_model), &filter_iter, iter); location_entry, &parent_iter, iter))
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (location_entry), &filter_iter); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (location_entry), &parent_iter);
/* When setting the active iter (when adding or setting an item) /* When setting the active iter (when adding or setting an item)
* the favicon may have changed, so we must update the entry favicon. * the favicon may have changed, so we must update the entry favicon.
@ -777,7 +851,7 @@ midori_location_entry_set_active_iter (MidoriLocationEntry* location_entry,
GtkWidget* GtkWidget*
midori_location_entry_new (void) midori_location_entry_new (void)
{ {
return (g_object_new (MIDORI_TYPE_LOCATION_ENTRY, NULL)); return g_object_new (MIDORI_TYPE_LOCATION_ENTRY, NULL);
} }
/** /**
@ -878,13 +952,13 @@ midori_location_entry_set_text (MidoriLocationEntry* location_entry,
} }
/** /**
* midori_location_entry_clear: * midori_location_entry_reset:
* @location_entry: a #MidoriLocationEntry * @location_entry: a #MidoriLocationEntry
* *
* Clears the entry text and resets the entry favicon. * Clears the entry text and resets the entry favicon.
**/ **/
void void
midori_location_entry_clear (MidoriLocationEntry* location_entry) midori_location_entry_reset (MidoriLocationEntry* location_entry)
{ {
GtkWidget* entry; GtkWidget* entry;
@ -898,6 +972,23 @@ midori_location_entry_clear (MidoriLocationEntry* location_entry)
GTK_ICON_ENTRY_PRIMARY, DEFAULT_ICON); GTK_ICON_ENTRY_PRIMARY, DEFAULT_ICON);
} }
/**
* midori_location_entry_clear:
* @location_entry: a #MidoriLocationEntry
*
* Removes all items from @location_entry
**/
void
midori_location_entry_clear (MidoriLocationEntry* location_entry)
{
GtkTreeModel* model;
g_return_if_fail (MIDORI_IS_LOCATION_ENTRY (location_entry));
model = midori_location_entry_get_model (location_entry);
gtk_list_store_clear (GTK_LIST_STORE (model));
}
/** /**
* midori_location_entry_set_item_from_uri: * midori_location_entry_set_item_from_uri:
* @location_entry: a #MidoriLocationEntry * @location_entry: a #MidoriLocationEntry
@ -917,7 +1008,7 @@ midori_location_entry_set_item_from_uri (MidoriLocationEntry* location_entry,
if (midori_location_entry_item_iter (location_entry, uri, &iter)) if (midori_location_entry_item_iter (location_entry, uri, &iter))
midori_location_entry_set_active_iter (location_entry, &iter); midori_location_entry_set_active_iter (location_entry, &iter);
else else
midori_location_entry_clear (location_entry); midori_location_entry_reset (location_entry);
} }
@ -939,22 +1030,23 @@ midori_location_entry_prepend_item (MidoriLocationEntry* location_entry,
GtkTreeIter iter; GtkTreeIter iter;
GtkTreeIter index; GtkTreeIter index;
gint n; gint n;
gint visits = 0;
g_return_if_fail (MIDORI_IS_LOCATION_ENTRY (location_entry)); g_return_if_fail (MIDORI_IS_LOCATION_ENTRY (location_entry));
g_return_if_fail (item->uri != NULL); g_return_if_fail (item->uri != NULL);
filter_model = gtk_combo_box_get_model (GTK_COMBO_BOX (location_entry)); filter_model = midori_location_entry_get_filter_model (location_entry);
model = midori_location_entry_get_model (location_entry); model = midori_location_entry_get_model (location_entry);
if (!midori_location_entry_item_iter (location_entry, item->uri, &iter)) if (midori_location_entry_item_iter (location_entry, item->uri, &iter))
{
gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
}
else
{ {
gtk_tree_model_get_iter_first (model, &index); gtk_tree_model_get_iter_first (model, &index);
gtk_tree_model_get (model, &iter, VISITS_COL, &visits, -1);
gtk_list_store_move_before (GTK_LIST_STORE (model), &iter, &index); gtk_list_store_move_before (GTK_LIST_STORE (model), &iter, &index);
} }
else
gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
n = gtk_tree_model_iter_n_children (filter_model, NULL); n = gtk_tree_model_iter_n_children (filter_model, NULL);
if (n > MAX_ITEMS) if (n > MAX_ITEMS)
{ {
@ -962,7 +1054,11 @@ midori_location_entry_prepend_item (MidoriLocationEntry* location_entry,
gtk_list_store_set (GTK_LIST_STORE (model), gtk_list_store_set (GTK_LIST_STORE (model),
&index, VISIBLE_COL, FALSE, -1); &index, VISIBLE_COL, FALSE, -1);
} }
gtk_list_store_set (GTK_LIST_STORE (model), &iter, VISIBLE_COL, TRUE, -1);
/* Only increment the visits when we add the uri */
if (!item->title && !item->favicon)
gtk_list_store_set (GTK_LIST_STORE (model), &iter, VISITS_COL, ++visits,
VISIBLE_COL, TRUE, -1);
midori_location_entry_set_item (location_entry, &iter, item); midori_location_entry_set_item (location_entry, &iter, item);
} }
@ -981,6 +1077,7 @@ midori_location_entry_append_item (MidoriLocationEntry* location_entry,
GtkTreeModel* model; GtkTreeModel* model;
GtkTreeIter iter; GtkTreeIter iter;
gint n; gint n;
gint visits = 0;
g_return_if_fail (MIDORI_IS_LOCATION_ENTRY (location_entry)); g_return_if_fail (MIDORI_IS_LOCATION_ENTRY (location_entry));
g_return_if_fail (item->uri != NULL); g_return_if_fail (item->uri != NULL);
@ -989,12 +1086,46 @@ midori_location_entry_append_item (MidoriLocationEntry* location_entry,
if (!midori_location_entry_item_iter (location_entry, item->uri, &iter)) if (!midori_location_entry_item_iter (location_entry, item->uri, &iter))
{ {
gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_append (GTK_LIST_STORE (model), &iter);
n = gtk_tree_model_iter_n_children (model, NULL); n = gtk_tree_model_iter_n_children (model, NULL);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, VISIBLE_COL, gtk_list_store_set (GTK_LIST_STORE (model), &iter, VISIBLE_COL,
(n <= MAX_ITEMS), -1); (n <= MAX_ITEMS), -1);
} }
else
gtk_tree_model_get (model, &iter, VISITS_COL, &visits, -1);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, VISITS_COL, ++visits, -1);
midori_location_entry_set_item (location_entry, &iter, item); midori_location_entry_set_item (location_entry, &iter, item);
} }
/**
* midori_location_entry_set_item_from_uri:
* @location_entry: a #MidoriLocationEntry
* @uri: a string
*
* Finds the item from the list matching @uri
* and removes it if it is the last instance.
**/
void
midori_location_entry_delete_item_from_uri (MidoriLocationEntry* location_entry,
const gchar* uri)
{
GtkTreeModel* model;
GtkTreeIter iter;
gint visits = 0;
g_return_if_fail (MIDORI_IS_LOCATION_ENTRY (location_entry));
model = midori_location_entry_get_model (location_entry);
if (midori_location_entry_item_iter (location_entry, uri, &iter))
{
gtk_tree_model_get (model, &iter, VISITS_COL, &visits, -1);
if (visits > 1)
gtk_list_store_set (GTK_LIST_STORE (model),
&iter, VISITS_COL, --visits, -1);
else
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
}
}

43
midori/midori-locationentry.h
View file

@ -35,44 +35,51 @@ struct _MidoriLocationEntryItem
}; };
GType GType
midori_location_entry_get_type (void); midori_location_entry_get_type (void);
GtkWidget* GtkWidget*
midori_location_entry_new (void); midori_location_entry_new (void);
gboolean gboolean
midori_location_entry_item_iter (MidoriLocationEntry* location_entry, midori_location_entry_item_iter (MidoriLocationEntry* location_entry,
const gchar* uri, const gchar* uri,
GtkTreeIter* iter); GtkTreeIter* iter);
const gchar* const gchar*
midori_location_entry_get_text (MidoriLocationEntry* location_entry); midori_location_entry_get_text (MidoriLocationEntry* location_entry);
void void
midori_location_entry_set_text (MidoriLocationEntry* location_entry, midori_location_entry_set_text (MidoriLocationEntry* location_entry,
const gchar* text); const gchar* text);
void void
midori_location_entry_clear (MidoriLocationEntry* location_entry); midori_location_entry_reset (MidoriLocationEntry* location_entry);
void void
midori_location_entry_set_item_from_uri (MidoriLocationEntry* location_entry, midori_location_entry_clear (MidoriLocationEntry* location_entry);
const gchar* uri);
void void
midori_location_entry_prepend_item (MidoriLocationEntry* location_entry, midori_location_entry_set_item_from_uri (MidoriLocationEntry* location_entry,
MidoriLocationEntryItem* item); const gchar* uri);
void void
midori_location_entry_append_item (MidoriLocationEntry* location_entry, midori_location_entry_prepend_item (MidoriLocationEntry* location_entry,
MidoriLocationEntryItem* item); MidoriLocationEntryItem* item);
void
midori_location_entry_append_item (MidoriLocationEntry* location_entry,
MidoriLocationEntryItem* item);
void
midori_location_entry_delete_item_from_uri (MidoriLocationEntry* location_entry,
const gchar* uri);
gdouble gdouble
midori_location_entry_get_progress (MidoriLocationEntry* location_entry); midori_location_entry_get_progress (MidoriLocationEntry* location_entry);
void void
midori_location_entry_set_progress (MidoriLocationEntry* location_entry, midori_location_entry_set_progress (MidoriLocationEntry* location_entry,
gdouble progress); gdouble progress);
G_END_DECLS G_END_DECLS