Merge lp:~aauzi/midori/fix-1179624 into lp:midori

Proposed by André Auzi
Status: Superseded
Proposed branch: lp:~aauzi/midori/fix-1179624
Merge into: lp:midori
Diff against target: 762 lines (+563/-20) (has conflicts)
6 files modified
katze/katze-item.c (+9/-3)
midori/midori-array.c (+150/-0)
midori/midori-array.h (+7/-0)
midori/midori-browser.c (+78/-9)
midori/midori-view.c (+6/-0)
panels/midori-bookmarks.c (+313/-8)
Text conflict in midori/midori-view.c
To merge this branch: bzr merge lp:~aauzi/midori/fix-1179624
Reviewer Review Type Date Requested Status
Cris Dywan Needs Fixing
Review via email: mp+164982@code.launchpad.net

This proposal has been superseded by a proposal from 2013-05-30.

To post a comment you must log in.
Revision history for this message
Cris Dywan (kalikiana) wrote :

385 + else if (!child_bookmarks_count && child_folders_count)
386 + text = g_strdup_printf(
387 + _("%s : folder, %d subfolders and no bookmark"),
388 + name, child_folders_count);

This should be done using ngettext, leaving gettext to figure out plural forms (there may be a dual form or other grammatical implications the code can't handle).

Is it necessary to implement midori_array_count_recursive using midori_array_query_recursive rather than asking SQlite to count rows? This seems a bit wasteful.

review: Needs Fixing
Revision history for this message
André Auzi (aauzi) wrote :

> 385 + else if (!child_bookmarks_count && child_folders_count)
> 386 + text = g_strdup_printf(
> 387 + _("%s : folder, %d subfolders and no bookmark"),
> 388 + name, child_folders_count);
>
> This should be done using ngettext, leaving gettext to figure out plural forms
> (there may be a dual form or other grammatical implications the code can't
> handle).

Interesting. I was not aware of ngettext existence. I will give it a try.

> Is it necessary to implement midori_array_count_recursive using
> midori_array_query_recursive rather than asking SQlite to count rows? This
> seems a bit wasteful.

Well, the count within a folder is done using a COUNT(*) sql statement but SQLite does not implement recursive queries therefore I had to implement recursion within the code.

I nevertheless agree, midori_array_query_recursive was the easy path and this has to be changed.
Especially if we consider the fact that I not only retrieve the sub folder id but also its *uri* (!!!goof!!!)

This being noticed I still have doubts about the feature, initially I thought we could need to implement fancy stuff like giving the counts for the whole tree depth if the user press the 'alt' or 'ctrl' modifiers but the feedback I get with one child level actually suits my needs, I wonder if the need of such feature would come up one day.

If nobody needs it, it's the whole idea of recursion that's wasteful and we could just get rid of it and stick to one child level count which is achieved with a single SQL statement.

I wonder if it was the meaning of the remark?

lp:~aauzi/midori/fix-1179624 updated
6171. By André Auzi

Take into account review comments

Implements:
 * use of ngettext for plural translations
 * use pure SGLite commands for midori_array_count_recursive_by

6172. By André Auzi

Take into account review remarks

6173. By André Auzi

Merge with lp:midori.

1 conflict solved:
 * remove of Open link as web application in link popup context menu

6174. By André Auzi

Fix potential memory leak in:

489 +static KatzeItem*
490 +midori_bookmarks_get_item_at_pos (GtkTreeView *treeview,
491 + gint x, gint y)
492 +{
493 + GtkTreeModel* model = gtk_tree_view_get_model (treeview);
494 + GtkTreePath* path;
495 + GtkTreeIter iter;
496 + KatzeItem* item;
497 +
498 + gtk_tree_view_get_path_at_pos (treeview, x, y,
499 + &path, NULL, NULL, NULL);
500 +
501 + if (!path)
502 + return NULL;
503 +
504 + if (!gtk_tree_model_get_iter (model, &iter, path))
505 + return NULL;
506 +
507 + gtk_tree_model_get (model, &iter, 0, &item, -1);
508 +
509 + gtk_tree_path_free (path); <= can leak if gtk_tree_model_get_iter returned FALSE
510 +
511 + return item;
512 +}

6175. By André Auzi

Complete remove of "app" related code

Take pfor's comments into account: texts simplifications and redundancy
reduced

6176. By André Auzi

Merge lp:midori

6177. By André Auzi

Remove change in midori_browser_bookmark_open_activate_cb

6178. By André Auzi

Change code style

6179. By André Auzi

merge lp:midori

6180. By André Auzi

Take into account review comments + merge lp:midori

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'katze/katze-item.c'
2--- katze/katze-item.c 2013-02-21 21:36:30 +0000
3+++ katze/katze-item.c 2013-05-30 22:02:27 +0000
4@@ -445,8 +445,13 @@
5
6 g_return_val_if_fail (KATZE_IS_ITEM (item), NULL);
7
8- if (widget && KATZE_ITEM_IS_FOLDER (item))
9- return gtk_widget_render_icon (widget, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
10+ if (widget)
11+ {
12+ if (KATZE_ITEM_IS_FOLDER (item))
13+ return gtk_widget_render_icon (widget, GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
14+ if (KATZE_ITEM_IS_BOOKMARK (item) && katze_item_get_meta_boolean (item, "app"))
15+ return gtk_widget_render_icon (widget, GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU, NULL);
16+ }
17 if ((pixbuf = midori_paths_get_icon (katze_item_get_icon (item), NULL)))
18 return pixbuf;
19 if ((pixbuf = midori_paths_get_icon (item->uri, widget)))
20@@ -526,7 +531,8 @@
21 gtk_widget_show (image);
22 if (pixbuf != NULL)
23 g_object_unref (pixbuf);
24- if (KATZE_ITEM_IS_FOLDER (item))
25+ if (KATZE_ITEM_IS_FOLDER (item)
26+ || (KATZE_ITEM_IS_BOOKMARK (item) && katze_item_get_meta_boolean (item, "app")))
27 return image;
28 g_object_set_data (G_OBJECT (image), "KatzeItem", g_object_ref (item));
29 g_signal_connect (image, "destroy",
30
31=== modified file 'midori/midori-array.c'
32--- midori/midori-array.c 2013-04-16 23:16:24 +0000
33+++ midori/midori-array.c 2013-05-30 22:02:27 +0000
34@@ -1194,3 +1194,153 @@
35 return midori_array_query_recursive (bookmarks, fields, condition, value, FALSE);
36 }
37
38+static gint64
39+count_from_sqlite (sqlite3* db,
40+ const gchar* sqlcmd)
41+{
42+ gint64 count = -1;
43+ sqlite3_stmt* stmt;
44+ gint result;
45+
46+ result = sqlite3_prepare_v2 (db, sqlcmd, -1, &stmt, NULL);
47+ if (result != SQLITE_OK)
48+ return -1;
49+
50+ g_assert (sqlite3_column_count (stmt) == 1);
51+
52+ if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
53+ count = sqlite3_column_int64(stmt, 0);
54+
55+ sqlite3_clear_bindings (stmt);
56+ sqlite3_reset (stmt);
57+
58+ return count;
59+}
60+
61+static gint64
62+midori_array_count_recursive_by_id (KatzeArray* bookmarks,
63+ const gchar* condition,
64+ const gchar* value,
65+ gint64 id,
66+ gboolean recursive)
67+{
68+ gint64 count = -1;
69+ sqlite3* db;
70+ gchar* sqlcmd;
71+ char* sqlcmd_value;
72+ sqlite3_stmt* stmt;
73+ gint result;
74+ GList* ids;
75+ GList* iter_ids;
76+
77+ g_return_val_if_fail (condition, -1);
78+ g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), -1);
79+ db = g_object_get_data (G_OBJECT (bookmarks), "db");
80+ g_return_val_if_fail (db != NULL, -1);
81+
82+ g_assert(!strstr("parentid", condition));
83+
84+ if (id > 0)
85+ sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
86+ "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
87+ id,
88+ condition);
89+ else
90+ sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
91+ "WHERE parentid IS NULL AND %s ",
92+ condition);
93+
94+ if (strstr (condition, "%q"))
95+ {
96+ sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
97+ count = count_from_sqlite (db, sqlcmd_value);
98+ sqlite3_free (sqlcmd_value);
99+ }
100+ else
101+ count = count_from_sqlite (db, sqlcmd);
102+
103+ g_free (sqlcmd);
104+
105+ if (!recursive || (count < 0))
106+ return count;
107+
108+ ids = NULL;
109+
110+ if (id > 0)
111+ sqlcmd_value = sqlite3_mprintf (
112+ "SELECT id FROM bookmarks "
113+ "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
114+ else
115+ sqlcmd_value = sqlite3_mprintf (
116+ "SELECT id FROM bookmarks "
117+ "WHERE parentid IS NULL AND uri = ''");
118+
119+ if (sqlite3_prepare_v2 (db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
120+ {
121+ g_assert (sqlite3_column_count (stmt) == 1);
122+
123+ if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
124+ {
125+ gint64* pid = g_new (gint64, 1);
126+
127+ *pid = sqlite3_column_int64(stmt, 0);
128+ ids = g_list_append (ids, pid);
129+ }
130+
131+ sqlite3_clear_bindings (stmt);
132+ sqlite3_reset (stmt);
133+ }
134+
135+ sqlite3_free (sqlcmd_value);
136+
137+ iter_ids = ids;
138+ while (iter_ids)
139+ {
140+ gint64 sub_count = midori_array_count_recursive_by_id (bookmarks,
141+ condition,
142+ value,
143+ *(gint64*)(iter_ids->data),
144+ recursive);
145+
146+ if (sub_count < 0)
147+ {
148+ g_list_free_full (ids, g_free);
149+ return -1;
150+ }
151+
152+ count += sub_count;
153+ iter_ids = g_list_next (iter_ids);
154+ }
155+
156+ g_list_free_full (ids, g_free);
157+ return count;
158+}
159+
160+/**
161+ * midori_array_count_recursive:
162+ * @array: the main bookmark array
163+ * @condition: condition, like "folder = '%q'"
164+ * @value: a value to be inserted if @condition contains %q
165+ * @recursive: if %TRUE include children
166+ *
167+ * Return value: the number of elements on success, -1 otherwise
168+ *
169+ * Since: 0.5.2
170+ **/
171+gint64
172+midori_array_count_recursive (KatzeArray* bookmarks,
173+ const gchar* condition,
174+ const gchar* value,
175+ KatzeItem* folder,
176+ gboolean recursive)
177+{
178+ gint64 id = -1;
179+
180+ g_return_val_if_fail (!folder || KATZE_ITEM_IS_FOLDER (folder), -1);
181+
182+ id = folder ? katze_item_get_meta_integer (folder, "id") : 0;
183+
184+ return midori_array_count_recursive_by_id (bookmarks, condition,
185+ value, id,
186+ recursive);
187+}
188
189=== modified file 'midori/midori-array.h'
190--- midori/midori-array.h 2012-01-03 20:15:19 +0000
191+++ midori/midori-array.h 2013-05-30 22:02:27 +0000
192@@ -47,4 +47,11 @@
193 katze_array_from_sqlite (sqlite3* db,
194 const gchar* sqlcmd);
195
196+gint64
197+midori_array_count_recursive (KatzeArray* bookmarks,
198+ const gchar* condition,
199+ const gchar* value,
200+ KatzeItem* folder,
201+ gboolean recursive);
202+
203 #endif /* !__MIDORI_ARRAY_H__ */
204
205=== modified file 'midori/midori-browser.c'
206--- midori/midori-browser.c 2013-05-28 20:02:29 +0000
207+++ midori/midori-browser.c 2013-05-30 22:02:27 +0000
208@@ -4132,7 +4132,10 @@
209 else if (!KATZE_IS_ARRAY (item) && strcmp (stock_id, GTK_STOCK_DELETE))
210 gtk_widget_set_sensitive (menuitem, uri != NULL);
211 g_object_set_data (G_OBJECT (menuitem), "KatzeItem", item);
212- g_signal_connect (menuitem, "activate", G_CALLBACK (callback), userdata);
213+ if (callback)
214+ g_signal_connect (menuitem, "activate", G_CALLBACK (callback), userdata);
215+ else
216+ gtk_widget_set_sensitive (menuitem, FALSE);
217 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
218 gtk_widget_show (menuitem);
219 }
220@@ -4141,8 +4144,43 @@
221 midori_browser_bookmark_open_activate_cb (GtkWidget* menuitem,
222 MidoriBrowser* browser)
223 {
224- KatzeItem* item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
225- midori_browser_open_bookmark (browser, item);
226+ KatzeItem* item;
227+ const gchar* uri;
228+
229+ item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
230+
231+ if ((uri = katze_item_get_uri (item)) && *uri)
232+ {
233+ gchar* uri_fixed = sokoke_magic_uri (uri, TRUE, FALSE);
234+ if (!uri_fixed)
235+ uri_fixed = g_strdup (uri);
236+
237+ midori_browser_set_current_uri (browser, uri_fixed);
238+ gtk_widget_grab_focus (midori_browser_get_current_tab (browser));
239+
240+ g_free (uri_fixed);
241+ }
242+}
243+
244+static void
245+midori_browser_bookmark_run_web_application_cb (GtkWidget* menuitem,
246+ MidoriBrowser* browser)
247+{
248+ KatzeItem* item;
249+ const gchar* uri;
250+
251+ item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
252+
253+ if ((uri = katze_item_get_uri (item)) && *uri)
254+ {
255+ gchar* uri_fixed = sokoke_magic_uri (uri, TRUE, FALSE);
256+ if (!uri_fixed)
257+ uri_fixed = g_strdup (uri);
258+
259+ sokoke_spawn_app (uri_fixed, FALSE);
260+
261+ g_free (uri_fixed);
262+ }
263 }
264
265 static void
266@@ -4222,14 +4260,43 @@
267 GtkWidget* menuitem;
268
269 menu = gtk_menu_new ();
270- if (!katze_item_get_uri (item))
271- midori_browser_bookmark_popup_item (menu,
272- STOCK_TAB_NEW, _("Open all in _Tabs"),
273- item, midori_browser_bookmark_open_in_tab_activate_cb, browser);
274+ if (KATZE_ITEM_IS_FOLDER (item))
275+ {
276+ gint child_bookmarks_count = midori_array_count_recursive(
277+ browser->bookmarks,
278+ "uri <> ''",
279+ NULL,
280+ item,
281+ FALSE);
282+
283+ if (!child_bookmarks_count)
284+ midori_browser_bookmark_popup_item (
285+ menu,
286+ STOCK_TAB_NEW, _("Open all in _Tabs"),
287+ item, NULL, browser);
288+ else
289+ midori_browser_bookmark_popup_item (
290+ menu,
291+ STOCK_TAB_NEW, _("Open all in _Tabs"),
292+ item, midori_browser_bookmark_open_in_tab_activate_cb, browser);
293+ }
294 else
295 {
296- midori_browser_bookmark_popup_item (menu, GTK_STOCK_OPEN, NULL,
297- item, midori_browser_bookmark_open_activate_cb, browser);
298+ if (katze_item_get_meta_boolean (item, "app"))
299+ {
300+ midori_browser_bookmark_popup_item (menu, GTK_STOCK_EXECUTE, _("Open as Web A_pplication"),
301+ item, midori_browser_bookmark_run_web_application_cb, browser);
302+ midori_browser_bookmark_popup_item (menu, GTK_STOCK_OPEN, NULL,
303+ item, midori_browser_bookmark_open_activate_cb, browser);
304+ }
305+ else
306+ {
307+ midori_browser_bookmark_popup_item (menu, GTK_STOCK_OPEN, NULL,
308+ item, midori_browser_bookmark_open_activate_cb, browser);
309+ midori_browser_bookmark_popup_item (menu, GTK_STOCK_EXECUTE, _("Open as Web A_pplication"),
310+ item, midori_browser_bookmark_run_web_application_cb, browser);
311+ }
312+
313 midori_browser_bookmark_popup_item (menu,
314 STOCK_TAB_NEW, _("Open in New _Tab"),
315 item, midori_browser_bookmark_open_in_tab_activate_cb, browser);
316@@ -4237,9 +4304,11 @@
317 STOCK_WINDOW_NEW, _("Open in New _Window"),
318 item, midori_browser_bookmark_open_in_window_activate_cb, browser);
319 }
320+
321 menuitem = gtk_separator_menu_item_new ();
322 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
323 gtk_widget_show (menuitem);
324+
325 midori_browser_bookmark_popup_item (menu, GTK_STOCK_EDIT, NULL,
326 item, midori_browser_bookmark_edit_activate_cb, widget);
327 midori_browser_bookmark_popup_item (menu, GTK_STOCK_DELETE, NULL,
328
329=== modified file 'midori/midori-view.c'
330--- midori/midori-view.c 2013-05-30 16:40:15 +0000
331+++ midori/midori-view.c 2013-05-30 22:02:27 +0000
332@@ -2747,6 +2747,12 @@
333 midori_view_insert_menu_item (menu_shell, -1,
334 _("Open Link in New _Window"), STOCK_WINDOW_NEW,
335 G_CALLBACK (midori_web_view_menu_new_window_activate_cb), widget);
336+<<<<<<< TREE
337+=======
338+ midori_view_insert_menu_item (menu_shell, -1,
339+ _("Open Link as Web A_pplication"), GTK_STOCK_EXECUTE,
340+ G_CALLBACK (midori_web_view_menu_web_app_activate_cb), widget);
341+>>>>>>> MERGE-SOURCE
342 }
343
344 midori_view_insert_menu_item (menu_shell, -1,
345
346=== modified file 'panels/midori-bookmarks.c'
347--- panels/midori-bookmarks.c 2013-02-11 21:49:41 +0000
348+++ panels/midori-bookmarks.c 2013-05-30 22:02:27 +0000
349@@ -39,7 +39,6 @@
350 struct _MidoriBookmarks
351 {
352 GtkVBox parent_instance;
353-
354 GtkWidget* toolbar;
355 GtkWidget* edit;
356 GtkWidget* delete;
357@@ -49,6 +48,8 @@
358
359 gint filter_timeout;
360 gchar* filter;
361+
362+ KatzeItem* hovering_item;
363 };
364
365 struct _MidoriBookmarksClass
366@@ -86,6 +87,9 @@
367 GParamSpec* pspec);
368
369 static void
370+midori_bookmarks_statusbar_update (MidoriBookmarks *bookmarks);
371+
372+static void
373 midori_bookmarks_class_init (MidoriBookmarksClass* class)
374 {
375 GObjectClass* gobject_class;
376@@ -441,6 +445,140 @@
377 gtk_widget_set_sensitive (GTK_WIDGET (bookmarks->edit), selected);
378 }
379
380+static gchar*
381+midori_bookmarks_statusbar_bookmarks_str (gint count)
382+{
383+ if (!count)
384+ return NULL;
385+
386+ return g_strdup_printf (ngettext ("%d bookmark", "%d bookmarks", count), count);
387+}
388+
389+static gchar*
390+midori_bookmarks_statusbar_subfolder_str (gint count)
391+{
392+ if (!count)
393+ return NULL;
394+
395+ return g_strdup_printf (ngettext ("%d subfolder", "%d subfolders", count), count);
396+}
397+
398+static void
399+midori_bookmarks_statusbar_update (MidoriBookmarks *bookmarks)
400+{
401+ gchar* text = NULL;
402+ GtkTreeModel* model;
403+ GtkTreeIter iter;
404+ gboolean selected;
405+
406+ if (bookmarks->hovering_item)
407+ {
408+ KatzeItem* item = bookmarks->hovering_item;
409+ const gchar* name;
410+
411+ g_assert (!KATZE_ITEM_IS_SEPARATOR (item));
412+
413+ name = katze_item_get_name (item);
414+
415+ if (KATZE_ITEM_IS_FOLDER (item))
416+ {
417+ gint child_folders_count = midori_array_count_recursive (
418+ bookmarks->array,
419+ "uri = ''",
420+ NULL,
421+ item,
422+ FALSE);
423+ gint child_bookmarks_count = midori_array_count_recursive (
424+ bookmarks->array,
425+ "uri <> ''",
426+ NULL,
427+ item,
428+ FALSE);
429+ gchar* child_folders_str = midori_bookmarks_statusbar_subfolder_str (child_folders_count);
430+ gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
431+
432+ if (!child_bookmarks_count && !child_folders_count)
433+ text = g_strdup_printf(
434+ _("%s : empty folder"),
435+ name);
436+ else if (!child_bookmarks_count && (child_folders_count >= 1))
437+ text = g_strdup_printf(
438+ _("%s : folder, %s and no bookmark"),
439+ name,
440+ child_folders_str);
441+ else if ((child_bookmarks_count >= 1) && !child_folders_count)
442+ text = g_strdup_printf(
443+ _("%s : folder, %s"),
444+ name,
445+ child_bookmarks_str);
446+ else if ((child_bookmarks_count >= 1) && (child_folders_count >= 1))
447+ text = g_strdup_printf(
448+ _("%s : folder, %s and %s"),
449+ name,
450+ child_bookmarks_str,
451+ child_folders_str);
452+
453+ g_free (child_folders_str);
454+ g_free (child_bookmarks_str);
455+ }
456+ else if (KATZE_ITEM_IS_BOOKMARK (item))
457+ {
458+ const gchar* uri = katze_item_get_uri (item);
459+
460+ if (katze_item_get_meta_boolean (item, "app"))
461+ text = g_strdup_printf (_("%s : web application bookmark to : %s"), name, uri);
462+ else
463+ text = g_strdup_printf (_("%s : bookmark to : %s"), name, uri);
464+ }
465+ }
466+ else
467+ {
468+ gint child_folders_count = midori_array_count_recursive (
469+ bookmarks->array,
470+ "uri = ''",
471+ NULL,
472+ NULL,
473+ FALSE);
474+ gint child_bookmarks_count = midori_array_count_recursive (
475+ bookmarks->array,
476+ "uri <> ''",
477+ NULL,
478+ NULL,
479+ FALSE);
480+ gchar* child_folders_str = midori_bookmarks_statusbar_subfolder_str (child_folders_count);
481+ gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
482+
483+ if (!child_bookmarks_count && !child_folders_count)
484+ text = g_strdup_printf(
485+ _("Bookmarks : empty"));
486+ else if (!child_bookmarks_count && (child_folders_count >= 1))
487+ text = g_strdup_printf(
488+ _("Bookmarks : %s and no bookmark"),
489+ child_folders_str);
490+ else if ((child_bookmarks_count >= 1) && !child_folders_count)
491+ text = g_strdup_printf(
492+ _("Bookmarks : %s"),
493+ child_bookmarks_str);
494+ else if ((child_bookmarks_count >= 1) && (child_folders_count >= 1))
495+ text = g_strdup_printf(
496+ _("Bookmarks : %s and %s"),
497+ child_bookmarks_str,
498+ child_folders_str);
499+
500+ g_free (child_folders_str);
501+ g_free (child_bookmarks_str);
502+ }
503+
504+ if (text)
505+ {
506+ MidoriBrowser* browser = midori_browser_get_for_widget (bookmarks->treeview);
507+
508+ g_object_set (browser, "statusbar-text", text, NULL);
509+
510+ g_free(text);
511+ }
512+}
513+
514 gboolean
515 midori_bookmarks_update_item_db (sqlite3* db,
516 KatzeItem* item)
517@@ -547,6 +685,7 @@
518 gtk_widget_show (GTK_WIDGET (toolitem));
519 bookmarks->delete = GTK_WIDGET (toolitem);
520 midori_bookmarks_toolbar_update (bookmarks);
521+ midori_bookmarks_statusbar_update (bookmarks);
522 toolitem = gtk_separator_tool_item_new ();
523 gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE);
524 gtk_tool_item_set_expand (toolitem, TRUE);
525@@ -745,7 +884,10 @@
526 else if (!KATZE_ITEM_IS_FOLDER (item) && strcmp (stock_id, GTK_STOCK_DELETE))
527 gtk_widget_set_sensitive (menuitem, uri != NULL);
528 g_object_set_data (G_OBJECT (menuitem), "KatzeItem", item);
529- g_signal_connect (menuitem, "activate", G_CALLBACK (callback), bookmarks);
530+ if (callback)
531+ g_signal_connect (menuitem, "activate", G_CALLBACK (callback), bookmarks);
532+ else
533+ gtk_widget_set_sensitive (menuitem, FALSE);
534 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
535 gtk_widget_show (menuitem);
536 }
537@@ -767,6 +909,27 @@
538 }
539
540 static void
541+midori_bookmarks_run_web_application_cb (GtkWidget* menuitem,
542+ MidoriBookmarks* bookmarks)
543+{
544+ KatzeItem* item;
545+ const gchar* uri;
546+
547+ item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
548+
549+ if ((uri = katze_item_get_uri (item)) && *uri)
550+ {
551+ gchar* uri_fixed = sokoke_magic_uri (uri, TRUE, FALSE);
552+ if (!uri_fixed)
553+ uri_fixed = g_strdup (uri);
554+
555+ sokoke_spawn_app (uri_fixed, FALSE);
556+
557+ g_free (uri_fixed);
558+ }
559+}
560+
561+static void
562 midori_bookmarks_open_in_tab_activate_cb (GtkWidget* menuitem,
563 MidoriBookmarks* bookmarks)
564 {
565@@ -831,21 +994,52 @@
566
567 menu = gtk_menu_new ();
568 if (KATZE_ITEM_IS_FOLDER (item))
569- midori_bookmarks_popup_item (menu,
570- STOCK_TAB_NEW, _("Open all in _Tabs"),
571- item, midori_bookmarks_open_in_tab_activate_cb, bookmarks);
572+ {
573+ gint child_bookmarks_count = midori_array_count_recursive(
574+ bookmarks->array,
575+ "uri <> ''",
576+ NULL,
577+ item,
578+ FALSE);
579+
580+ if (!child_bookmarks_count)
581+ midori_bookmarks_popup_item (menu,
582+ STOCK_TAB_NEW, _("Open all in _Tabs"),
583+ item, NULL, bookmarks);
584+ else
585+ midori_bookmarks_popup_item (menu,
586+ STOCK_TAB_NEW, _("Open all in _Tabs"),
587+ item, midori_bookmarks_open_in_tab_activate_cb, bookmarks);
588+ }
589 else
590 {
591- midori_bookmarks_popup_item (menu, GTK_STOCK_OPEN, NULL,
592- item, midori_bookmarks_open_activate_cb, bookmarks);
593+ if (katze_item_get_meta_boolean (item, "app"))
594+ {
595+ midori_bookmarks_popup_item (menu,
596+ GTK_STOCK_EXECUTE, _("Open as Web A_pplication"),
597+ item, midori_bookmarks_run_web_application_cb, bookmarks);
598+ midori_bookmarks_popup_item (menu, GTK_STOCK_OPEN, NULL,
599+ item, midori_bookmarks_open_activate_cb, bookmarks);
600+ }
601+ else
602+ {
603+ midori_bookmarks_popup_item (menu, GTK_STOCK_OPEN, NULL,
604+ item, midori_bookmarks_open_activate_cb, bookmarks);
605+ midori_bookmarks_popup_item (menu,
606+ GTK_STOCK_EXECUTE, _("Open as Web A_pplication"),
607+ item, midori_bookmarks_run_web_application_cb, bookmarks);
608+ }
609+
610 midori_bookmarks_popup_item (menu, STOCK_TAB_NEW, _("Open in New _Tab"),
611 item, midori_bookmarks_open_in_tab_activate_cb, bookmarks);
612 midori_bookmarks_popup_item (menu, STOCK_WINDOW_NEW, _("Open in New _Window"),
613 item, midori_bookmarks_open_in_window_activate_cb, bookmarks);
614 }
615+
616 menuitem = gtk_separator_menu_item_new ();
617 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
618 gtk_widget_show (menuitem);
619+
620 midori_bookmarks_popup_item (menu, GTK_STOCK_EDIT, NULL,
621 item, midori_bookmarks_edit_clicked_cb, bookmarks);
622 midori_bookmarks_popup_item (menu, GTK_STOCK_DELETE, NULL,
623@@ -960,6 +1154,105 @@
624 midori_bookmarks_toolbar_update (bookmarks);
625 }
626
627+static KatzeItem*
628+midori_bookmarks_get_item_at_pos (GtkTreeView *treeview,
629+ gint x, gint y)
630+{
631+ GtkTreeModel* model = gtk_tree_view_get_model (treeview);
632+ GtkTreePath* path;
633+ GtkTreeIter iter;
634+ KatzeItem* item;
635+
636+ gtk_tree_view_get_path_at_pos (treeview, x, y,
637+ &path, NULL, NULL, NULL);
638+
639+ if (!path)
640+ return NULL;
641+
642+ if (!gtk_tree_model_get_iter (model, &iter, path))
643+ return NULL;
644+
645+ gtk_tree_model_get (model, &iter, 0, &item, -1);
646+
647+ gtk_tree_path_free (path);
648+
649+ return item;
650+}
651+
652+static gboolean
653+midori_bookmarks_enter_notify_event_cb (GtkTreeView *treeview,
654+ GdkEventCrossing *event,
655+ MidoriBookmarks *bookmarks)
656+{
657+ KatzeItem* item = midori_bookmarks_get_item_at_pos (treeview, event->x, event->y);
658+
659+ if (bookmarks->hovering_item)
660+ g_object_unref (bookmarks->hovering_item);
661+
662+ bookmarks->hovering_item = item;
663+
664+ midori_bookmarks_statusbar_update (bookmarks);
665+
666+ return FALSE;
667+}
668+
669+static gboolean
670+midori_bookmarks_motion_notify_event_cb (GtkTreeView *treeview,
671+ GdkEventMotion *event,
672+ MidoriBookmarks *bookmarks)
673+{
674+ gboolean item_changed;
675+ KatzeItem* item;
676+ gint x;
677+ gint y;
678+
679+ if (event->is_hint)
680+ gtk_widget_get_pointer (GTK_WIDGET (treeview), &x, &y);
681+ else
682+ {
683+ x = event->x;
684+ y = event->y;
685+ }
686+
687+ item = midori_bookmarks_get_item_at_pos (treeview, x, y);
688+
689+ item_changed = (bookmarks->hovering_item != item) ? TRUE : FALSE;
690+
691+ if (!item_changed)
692+ {
693+ if (item)
694+ g_object_unref (item);
695+ }
696+ else
697+ {
698+ if (bookmarks->hovering_item)
699+ g_object_unref (bookmarks->hovering_item);
700+
701+ bookmarks->hovering_item = item;
702+
703+ midori_bookmarks_statusbar_update (bookmarks);
704+ }
705+
706+ return FALSE;
707+}
708+
709+static gboolean
710+midori_bookmarks_leave_notify_event_cb (GtkTreeView *treeview,
711+ GdkEventCrossing *event,
712+ MidoriBookmarks *bookmarks)
713+{
714+ MidoriBrowser* browser = midori_browser_get_for_widget (bookmarks->treeview);
715+
716+ if (bookmarks->hovering_item)
717+ g_object_unref (bookmarks->hovering_item);
718+
719+ bookmarks->hovering_item = NULL;
720+
721+ g_object_set (browser, "statusbar-text", "", NULL);
722+
723+ return FALSE;
724+}
725+
726 static gboolean
727 midori_bookmarks_filter_timeout_cb (gpointer data)
728 {
729@@ -1047,7 +1340,17 @@
730 midori_bookmarks_row_expanded_cb, bookmarks,
731 "signal::row-collapsed",
732 midori_bookmarks_row_collapsed_cb, bookmarks,
733+ "signal::enter-notify-event",
734+ midori_bookmarks_enter_notify_event_cb, bookmarks,
735+ "signal::motion-notify-event",
736+ midori_bookmarks_motion_notify_event_cb, bookmarks,
737+ "signal::leave-notify-event",
738+ midori_bookmarks_leave_notify_event_cb, bookmarks,
739 NULL);
740+ gtk_widget_add_events (GTK_WIDGET (treeview),
741+ GDK_POINTER_MOTION_MASK
742+ | GDK_POINTER_MOTION_HINT_MASK);
743+
744 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
745 g_signal_connect_after (selection, "changed",
746 G_CALLBACK (midori_bookmarks_selection_changed_cb),
747@@ -1055,6 +1358,7 @@
748 gtk_widget_show (treeview);
749 gtk_box_pack_start (GTK_BOX (bookmarks), treeview, TRUE, TRUE, 0);
750 bookmarks->treeview = treeview;
751+ bookmarks->hovering_item = NULL;
752 }
753
754 static void
755@@ -1064,5 +1368,6 @@
756
757 if (bookmarks->app)
758 g_object_unref (bookmarks->app);
759+ if (bookmarks->hovering_item)
760+ g_object_unref (bookmarks->hovering_item);
761 }
762-

Subscribers

People subscribed via source and target branches

to all changes: