Midori Web Browser

Merge lp:~aauzi/midori/fix-1179200-6 into lp:midori

  1. fix-1179200-6
  2. Merge into trunk
Proposed by André Auzi
Status: Superseded
Proposed branch: lp:~aauzi/midori/fix-1179200-6
Merge into: lp:midori
Diff against target: 2064 lines (+996/-348)
10 files modified
katze/katze-array.c (+29/-48)
katze/katze-array.h (+30/-0)
katze/katze-item.c (+6/-0)
midori/midori-array.c (+11/-1)
midori/midori-bookmarks-db.c (+779/-196)
midori/midori-bookmarks-db.h (+52/-25)
midori/midori-browser.c (+30/-26)
midori/midori-frontend.c (+4/-4)
panels/midori-bookmarks.c (+27/-25)
tests/bookmarks.c (+28/-23)
To merge this branch: bzr merge lp:~aauzi/midori/fix-1179200-6
Reviewer Review Type Date Requested Status
Midori Devs Pending
Review via email: mp+186166@code.launchpad.net

This proposal has been superseded by a proposal from 2013-09-18.

Description of the change

Sixth step for the merge of fix-1179200

This step cache all bookmark items in order to avoid their recreation on database reads.

The cache is recursively populated and cleared for folders addition or removals.

Thanks tp this change, items are consistent in bookmark bar and panel and the following use case/sequence works.

Having a bookmark that's not in the boolùark bar, visible in the panel
Edit it from the panel and add it to the bookmark bar
It appears in the bookmark bar
Edit it from the bar and remove it from the bar
Edit it from the panel

Without the fix:
  the item appears with the bookmark bar state checked (the last state it had when it was edited in the panel)

With the fix:
  the item appears with the current bookmark bar state: unchecked

To post a comment you must log in.

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'katze/katze-array.c'
2--- katze/katze-array.c 2012-08-08 23:02:56 +0000
3+++ katze/katze-array.c 2013-09-17 21:28:04 +0000
4@@ -25,38 +25,14 @@
5 * #KatzeArray is a type aware container for items.
6 */
7
8-struct _KatzeArray
9+G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
10+
11+struct _KatzeArrayPrivate
12 {
13- KatzeItem parent_instance;
14-
15 GType type;
16 GList* items;
17 };
18
19-struct _KatzeArrayClass
20-{
21- KatzeItemClass parent_class;
22-
23- /* Signals */
24- void
25- (*add_item) (KatzeArray* array,
26- gpointer item);
27- void
28- (*remove_item) (KatzeArray* array,
29- gpointer item);
30- void
31- (*move_item) (KatzeArray* array,
32- gpointer item,
33- gint index);
34- void
35- (*clear) (KatzeArray* array);
36-
37- void
38- (*update) (KatzeArray* array);
39-};
40-
41-G_DEFINE_TYPE (KatzeArray, katze_array, KATZE_TYPE_ITEM);
42-
43 enum {
44 ADD_ITEM,
45 REMOVE_ITEM,
46@@ -90,7 +66,7 @@
47 if (g_type_is_a (type, KATZE_TYPE_ITEM))
48 katze_item_set_parent (item, array);
49
50- array->items = g_list_append (array->items, item);
51+ array->priv->items = g_list_append (array->priv->items, item);
52 _katze_array_update (array);
53 }
54
55@@ -98,7 +74,7 @@
56 _katze_array_remove_item (KatzeArray* array,
57 gpointer item)
58 {
59- array->items = g_list_remove (array->items, item);
60+ array->priv->items = g_list_remove (array->priv->items, item);
61
62 if (KATZE_IS_ITEM (item))
63 katze_item_set_parent (item, NULL);
64@@ -111,8 +87,8 @@
65 gpointer item,
66 gint position)
67 {
68- array->items = g_list_remove (array->items, item);
69- array->items = g_list_insert (array->items, item, position);
70+ array->priv->items = g_list_remove (array->priv->items, item);
71+ array->priv->items = g_list_insert (array->priv->items, item, position);
72 _katze_array_update (array);
73 }
74
75@@ -121,10 +97,10 @@
76 {
77 GObject* item;
78
79- while ((item = g_list_nth_data (array->items, 0)))
80+ while ((item = g_list_nth_data (array->priv->items, 0)))
81 g_signal_emit (array, signals[REMOVE_ITEM], 0, item);
82- g_list_free (array->items);
83- array->items = NULL;
84+ g_list_free (array->priv->items);
85+ array->priv->items = NULL;
86 _katze_array_update (array);
87 }
88
89@@ -217,13 +193,18 @@
90 class->move_item = _katze_array_move_item;
91 class->clear = _katze_array_clear;
92 class->update = _katze_array_update;
93+
94+ g_type_class_add_private (class, sizeof (KatzeArrayPrivate));
95 }
96
97 static void
98 katze_array_init (KatzeArray* array)
99 {
100- array->type = G_TYPE_OBJECT;
101- array->items = NULL;
102+ array->priv = G_TYPE_INSTANCE_GET_PRIVATE (array,
103+ KATZE_TYPE_ARRAY, KatzeArrayPrivate);
104+
105+ array->priv->type = G_TYPE_OBJECT;
106+ array->priv->items = NULL;
107 }
108
109 static void
110@@ -232,9 +213,9 @@
111 KatzeArray* array = KATZE_ARRAY (object);
112 GList* items;
113
114- for (items = array->items; items; items = g_list_next (items))
115+ for (items = array->priv->items; items; items = g_list_next (items))
116 g_object_unref (items->data);
117- g_list_free (array->items);
118+ g_list_free (array->priv->items);
119
120 G_OBJECT_CLASS (katze_array_parent_class)->finalize (object);
121 }
122@@ -258,7 +239,7 @@
123 g_return_val_if_fail (g_type_is_a (type, G_TYPE_OBJECT), NULL);
124
125 array = g_object_new (KATZE_TYPE_ARRAY, NULL);
126- array->type = type;
127+ array->priv->type = type;
128
129 return array;
130 }
131@@ -279,7 +260,7 @@
132 {
133 g_return_val_if_fail (KATZE_IS_ARRAY (array), FALSE);
134
135- return g_type_is_a (array->type, is_a_type);
136+ return g_type_is_a (array->priv->type, is_a_type);
137 }
138
139 /**
140@@ -333,7 +314,7 @@
141 {
142 g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
143
144- return g_list_nth_data (array->items, n);
145+ return g_list_nth_data (array->priv->items, n);
146 }
147
148 /**
149@@ -349,7 +330,7 @@
150 {
151 g_return_val_if_fail (KATZE_IS_ARRAY (array), TRUE);
152
153- return !g_list_nth_data (array->items, 0);
154+ return !g_list_nth_data (array->priv->items, 0);
155 }
156
157 /**
158@@ -367,7 +348,7 @@
159 {
160 g_return_val_if_fail (KATZE_IS_ARRAY (array), -1);
161
162- return g_list_index (array->items, item);
163+ return g_list_index (array->priv->items, item);
164 }
165
166 /**
167@@ -401,7 +382,7 @@
168 if (token_length < 1)
169 token_length = strlen (token);
170
171- for (items = array->items; items; items = g_list_next (items))
172+ for (items = array->priv->items; items; items = g_list_next (items))
173 {
174 const gchar* found_token = ((KatzeItem*)items->data)->token;
175 if (found_token != NULL)
176@@ -439,7 +420,7 @@
177 g_return_val_if_fail (katze_array_is_a (array, KATZE_TYPE_ITEM), NULL);
178 g_return_val_if_fail (uri != NULL, NULL);
179
180- for (items = array->items; items; items = g_list_next (items))
181+ for (items = array->priv->items; items; items = g_list_next (items))
182 {
183 const gchar* found_uri = ((KatzeItem*)items->data)->uri;
184 if (found_uri != NULL && !strcmp (found_uri, uri))
185@@ -461,7 +442,7 @@
186 {
187 g_return_val_if_fail (KATZE_IS_ARRAY (array), 0);
188
189- return g_list_length (array->items);
190+ return g_list_length (array->priv->items);
191 }
192
193 /**
194@@ -499,7 +480,7 @@
195 {
196 g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
197
198- return g_list_copy (array->items);
199+ return g_list_copy (array->priv->items);
200 }
201
202 GList*
203@@ -507,7 +488,7 @@
204 {
205 g_return_val_if_fail (KATZE_IS_ARRAY (array), NULL);
206
207- return array->items;
208+ return array->priv->items;
209 }
210
211 /**
212
213=== modified file 'katze/katze-array.h'
214--- katze/katze-array.h 2011-01-19 20:58:26 +0000
215+++ katze/katze-array.h 2013-09-17 21:28:04 +0000
216@@ -31,6 +31,36 @@
217
218 typedef struct _KatzeArray KatzeArray;
219 typedef struct _KatzeArrayClass KatzeArrayClass;
220+typedef struct _KatzeArrayPrivate KatzeArrayPrivate;
221+
222+struct _KatzeArray
223+{
224+ KatzeItem parent_instance;
225+
226+ KatzeArrayPrivate* priv;
227+};
228+
229+struct _KatzeArrayClass
230+{
231+ KatzeItemClass parent_class;
232+
233+ /* Signals */
234+ void
235+ (*add_item) (KatzeArray* array,
236+ gpointer item);
237+ void
238+ (*remove_item) (KatzeArray* array,
239+ gpointer item);
240+ void
241+ (*move_item) (KatzeArray* array,
242+ gpointer item,
243+ gint index);
244+ void
245+ (*clear) (KatzeArray* array);
246+
247+ void
248+ (*update) (KatzeArray* array);
249+};
250
251 GType
252 katze_array_get_type (void) G_GNUC_CONST;
253
254=== modified file 'katze/katze-item.c'
255--- katze/katze-item.c 2013-07-27 12:35:55 +0000
256+++ katze/katze-item.c 2013-09-17 21:28:04 +0000
257@@ -314,6 +314,9 @@
258 {
259 g_return_if_fail (KATZE_IS_ITEM (item));
260
261+ if (!g_strcmp0 (item->name, name))
262+ return;
263+
264 katze_assign (item->name, g_strdup (name));
265 if (item->parent)
266 katze_array_update ((KatzeArray*)item->parent);
267@@ -418,6 +421,9 @@
268 {
269 g_return_if_fail (KATZE_IS_ITEM (item));
270
271+ if (!g_strcmp0 (katze_item_get_meta_string (item, "icon"), icon))
272+ return;
273+
274 katze_item_set_meta_string (item, "icon", icon);
275 if (item->parent)
276 katze_array_update ((KatzeArray*)item->parent);
277
278=== modified file 'midori/midori-array.c'
279--- midori/midori-array.c 2013-08-05 12:50:34 +0000
280+++ midori/midori-array.c 2013-09-17 21:28:04 +0000
281@@ -986,7 +986,17 @@
282 return FALSE;
283 }
284
285-static void
286+/**
287+ * katze_item_set_value_from_columne:
288+ * @stmt: prepared statement
289+ * @column: column to read
290+ * @item: #KatzeItem to populate
291+ *
292+ * Stores the column in the given #KatzeItem.
293+ *
294+ * Since: 0.2.7
295+ **/
296+void
297 katze_item_set_value_from_column (sqlite3_stmt* stmt,
298 gint column,
299 KatzeItem* item)
300
301=== modified file 'midori/midori-bookmarks-db.c'
302--- midori/midori-bookmarks-db.c 2013-09-08 10:53:32 +0000
303+++ midori/midori-bookmarks-db.c 2013-09-17 21:28:04 +0000
304@@ -25,14 +25,428 @@
305 #include <unistd.h>
306 #endif
307
308-static gboolean
309-midori_bookmarks_update_item_db (sqlite3* db,
310- KatzeItem* item);
311-
312-gint64
313-midori_bookmarks_insert_item_db (sqlite3* db,
314- KatzeItem* item,
315- gint64 parentid)
316+/**
317+ * SECTION:midory-bookmarks-db
318+ * @short_description: A #KatzeArray connected to a database
319+ * @see_also: #KatzeArray
320+ *
321+ * #MidoriBookmarksDb is a #KatzeArray specialized for database
322+ * interraction.
323+ */
324+
325+struct _MidoriBookmarksDb
326+{
327+ KatzeArray parent_instance;
328+
329+ sqlite3* db;
330+ GHashTable* all_items;
331+};
332+
333+struct _MidoriBookmarksDbClass
334+{
335+ KatzeArrayClass parent_class;
336+
337+ /* Signals */
338+ void
339+ (*update_item) (MidoriBookmarksDb* bookmarks,
340+ gpointer item);
341+};
342+
343+G_DEFINE_TYPE (MidoriBookmarksDb, midori_bookmarks_db, KATZE_TYPE_ARRAY);
344+
345+enum {
346+ UPDATE_ITEM,
347+
348+ LAST_SIGNAL
349+};
350+
351+static guint signals[LAST_SIGNAL];
352+
353+static void
354+_midori_bookmarks_db_add_item (KatzeArray* array,
355+ gpointer item);
356+
357+static void
358+_midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks,
359+ gpointer item);
360+
361+static void
362+_midori_bookmarks_db_remove_item (KatzeArray* array,
363+ gpointer item);
364+
365+static void
366+_midori_bookmarks_db_move_item (KatzeArray* array,
367+ gpointer item,
368+ gint position);
369+
370+static void
371+_midori_bookmarks_db_clear (KatzeArray* array);
372+
373+static void
374+midori_bookmarks_db_finalize (GObject* object);
375+
376+static gint64
377+midori_bookmarks_db_insert_item_db (sqlite3* db,
378+ KatzeItem* item,
379+ gint64 parentid);
380+
381+static gboolean
382+midori_bookmarks_db_update_item_db (sqlite3* db,
383+ KatzeItem* item);
384+
385+static gboolean
386+midori_bookmarks_db_remove_item_db (sqlite3* db,
387+ KatzeItem* item);
388+
389+static guint
390+item_hash (gconstpointer item)
391+{
392+ gint64 id = katze_item_get_meta_integer (KATZE_ITEM (item), "id");
393+ return g_int64_hash (&id);
394+}
395+
396+static gboolean
397+item_equal (gconstpointer item_a, gconstpointer item_b)
398+{
399+ gint64 id_a = katze_item_get_meta_integer (KATZE_ITEM (item_a), "id");
400+ gint64 id_b = katze_item_get_meta_integer (KATZE_ITEM (item_b), "id");
401+ return (id_a == id_b)? TRUE : FALSE;
402+}
403+
404+static void
405+midori_bookmarks_db_class_init (MidoriBookmarksDbClass* class)
406+{
407+ GObjectClass* gobject_class;
408+ KatzeArrayClass* katze_array_class;
409+
410+ gobject_class = G_OBJECT_CLASS (class);
411+ gobject_class->finalize = midori_bookmarks_db_finalize;
412+
413+ signals[UPDATE_ITEM] = g_signal_new (
414+ "update-item",
415+ G_TYPE_FROM_CLASS (class),
416+ (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
417+ G_STRUCT_OFFSET (MidoriBookmarksDbClass, update_item),
418+ 0,
419+ NULL,
420+ g_cclosure_marshal_VOID__POINTER,
421+ G_TYPE_NONE, 1,
422+ G_TYPE_POINTER);
423+
424+ katze_array_class = KATZE_ARRAY_CLASS (class);
425+
426+ katze_array_class->add_item = _midori_bookmarks_db_add_item;
427+ katze_array_class->remove_item = _midori_bookmarks_db_remove_item;
428+ katze_array_class->move_item = _midori_bookmarks_db_move_item;
429+ katze_array_class->clear = _midori_bookmarks_db_clear;
430+
431+ class->update_item = _midori_bookmarks_db_update_item;
432+}
433+
434+static void
435+midori_bookmarks_db_init (MidoriBookmarksDb* bookmarks)
436+{
437+ bookmarks->db = NULL;
438+ bookmarks->all_items = g_hash_table_new (item_hash, item_equal);
439+
440+ katze_item_set_meta_integer (KATZE_ITEM (bookmarks), "id", 0);
441+ katze_item_set_name (KATZE_ITEM (bookmarks), _("Bookmarks"));
442+ g_hash_table_insert (bookmarks->all_items, bookmarks, bookmarks);
443+ /* g_object_ref (bookmarks); */
444+}
445+
446+static void
447+midori_bookmarks_db_finalize (GObject* object)
448+{
449+ MidoriBookmarksDb* bookmarks = MIDORI_BOOKMARKS_DB (object);
450+
451+ if (bookmarks->db)
452+ {
453+ sqlite3_close (bookmarks->db);
454+ }
455+
456+ g_hash_table_unref (bookmarks->all_items);
457+
458+ G_OBJECT_CLASS (midori_bookmarks_db_parent_class)->finalize (object);
459+}
460+
461+/**
462+ * midori_bookmarks_db_get_item_parent:
463+ * @bookmarks: the main bookmarks array
464+ * @item: a #KatzeItem
465+ *
466+ * Internal function that find the parent of the @item thanks to its %parentid
467+ **/
468+static KatzeArray*
469+midori_bookmarks_db_get_item_parent (MidoriBookmarksDb* bookmarks,
470+ gpointer item)
471+{
472+ KatzeArray* parent;
473+ gint64 parentid;
474+
475+ parentid = katze_item_get_meta_integer (KATZE_ITEM (item), "parentid");
476+
477+ if (parentid == 0)
478+ {
479+ parent = KATZE_ARRAY (bookmarks);
480+ }
481+ else
482+ {
483+ KatzeItem *search = katze_item_new ();
484+
485+ katze_item_set_meta_integer(search, "id", parentid);
486+
487+ parent = KATZE_ARRAY (g_hash_table_lookup (bookmarks->all_items, search));
488+
489+ g_object_unref (search);
490+ }
491+
492+ return parent;
493+}
494+
495+/**
496+ * _midori_bookmarks_db_add_item:
497+ * @array: the main bookmarks array
498+ * @item: a #KatzeItem
499+ *
500+ * Internal function that overloads the #KatzeArray %katze_array_add_item().
501+ * It relays the add item to the appropriate #KatzeArray.
502+ **/
503+static void
504+_midori_bookmarks_db_add_item (KatzeArray* array,
505+ gpointer item)
506+{
507+ MidoriBookmarksDb *bookmarks;
508+ KatzeArray* parent;
509+ KatzeArray* db_parent;
510+
511+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
512+ g_return_if_fail (KATZE_IS_ITEM (item));
513+
514+ bookmarks = MIDORI_BOOKMARKS_DB (array);
515+
516+ parent = katze_item_get_parent (KATZE_ITEM (item));
517+
518+ db_parent = midori_bookmarks_db_get_item_parent (bookmarks, item);
519+
520+ g_return_if_fail (db_parent);
521+
522+ if (parent == db_parent)
523+ {
524+ if (IS_MIDORI_BOOKMARKS_DB (parent))
525+ KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->update (parent);
526+ else
527+ katze_array_update (parent);
528+ return;
529+ }
530+
531+ if (IS_MIDORI_BOOKMARKS_DB (parent))
532+ KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->add_item (parent, item);
533+ else if (KATZE_IS_ARRAY (parent))
534+ katze_array_add_item (parent, item);
535+}
536+
537+/**
538+ * _midori_bookmarks_db_update_item:
539+ * @array: the main bookmarks array
540+ * @item: a #KatzeItem
541+ *
542+ * Internal function that implements the %midori_bookmarks_db_update_item() post-processing.
543+ * It relays an update to the appropriate #KatzeArray.
544+ **/
545+static void
546+_midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks,
547+ gpointer item)
548+{
549+ KatzeArray* parent;
550+
551+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
552+ g_return_if_fail (KATZE_IS_ITEM (item));
553+
554+ parent = katze_item_get_parent (KATZE_ITEM (item));
555+
556+ g_return_if_fail (parent);
557+
558+ katze_array_update (parent);
559+}
560+
561+/**
562+ * _midori_bookmarks_db_remove_item:
563+ * @array: the main bookmarks array
564+ * @item: a #KatzeItem
565+ *
566+ * Internal function that overloads the #KatzeArray %katze_array_remove_item().
567+ * It relays the remove item to the appropriate #KatzeArray.
568+ **/
569+static void
570+_midori_bookmarks_db_remove_item (KatzeArray* array,
571+ gpointer item)
572+{
573+ KatzeArray* parent;
574+
575+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
576+ g_return_if_fail (KATZE_IS_ITEM (item));
577+
578+ parent = katze_item_get_parent (KATZE_ITEM (item));
579+
580+ g_return_if_fail (parent);
581+
582+ if (IS_MIDORI_BOOKMARKS_DB (parent))
583+ KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->remove_item (parent, item);
584+ else if (KATZE_IS_ARRAY (parent))
585+ katze_array_remove_item (parent, item);
586+}
587+
588+/**
589+ * _midori_bookmarks_db_move_item:
590+ * @array: the main bookmarks array
591+ * @item: a #KatzeItem
592+ * @position: the new @item position
593+ *
594+ * Internal function that overloads the #KatzeArray %katze_array_move_item().
595+ * It relays the move @item to the appropriate #KatzeArray.
596+ **/
597+static void
598+_midori_bookmarks_db_move_item (KatzeArray* array,
599+ gpointer item,
600+ gint position)
601+{
602+ MidoriBookmarksDb *bookmarks;
603+ KatzeArray* parent;
604+
605+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
606+ g_return_if_fail (KATZE_IS_ITEM (item));
607+
608+ parent = katze_item_get_parent (KATZE_ITEM (item));
609+
610+ g_return_if_fail (parent);
611+
612+ KATZE_ARRAY_CLASS (midori_bookmarks_db_parent_class)->move_item (parent, item, position);
613+}
614+
615+/**
616+ * _midori_bookmarks_db_clear:
617+ * @array: the main bookmarks array
618+ *
619+ * Internal function that overloads the #KatzeArray %katze_array_clear().
620+ * It deletes the whole bookmarks data.
621+ **/
622+static void
623+_midori_bookmarks_db_clear (KatzeArray* array)
624+{
625+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
626+
627+ g_critical ("_midori_bookmarks_db_clear: not implemented\n");
628+}
629+
630+/**
631+ * midori_bookmarks_db_signal_update_item:
632+ * @array: a #KatzeArray
633+ * @item: an item
634+ *
635+ * Notify an update of the item of the array.
636+ *
637+ **/
638+static void
639+midori_bookmarks_db_signal_update_item (MidoriBookmarksDb* array,
640+ gpointer item)
641+{
642+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (array));
643+
644+ g_signal_emit (array, signals[UPDATE_ITEM], 0, item);
645+}
646+
647+/**
648+ * midori_bookmarks_db_add_item_recursive:
649+ * @item: the removed #KatzeItem
650+ * @bookmarks : the main bookmarks array
651+ *
652+ * Internal function that creates memory records of the added @item.
653+ * If @item is a #KatzeArray, the function recursiveley adds records
654+ * of all its childs.
655+ **/
656+static gint
657+midori_bookmarks_db_add_item_recursive (MidoriBookmarksDb* bookmarks,
658+ KatzeItem* item)
659+{
660+ GList* list;
661+ KatzeArray* array;
662+ gint64 id = 0;
663+ gint count = 0;
664+ gint64 parentid = katze_item_get_meta_integer (item, "parentid");
665+
666+ id = midori_bookmarks_db_insert_item_db (bookmarks->db, item, parentid);
667+ count++;
668+
669+ g_object_ref (item);
670+ g_hash_table_insert (bookmarks->all_items, item, item);
671+
672+ if (!KATZE_IS_ARRAY (item))
673+ return count;
674+
675+ array = KATZE_ARRAY (item);
676+
677+ KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
678+ {
679+ katze_item_set_meta_integer (item, "parentid", id);
680+ count += midori_bookmarks_db_add_item_recursive (bookmarks, item);
681+ }
682+
683+ g_list_free (list);
684+ return count;
685+}
686+
687+/**
688+ * midori_bookmarks_db_remove_item_recursive:
689+ * @item: the removed #KatzeItem
690+ * @bookmarks : the main bookmarks array
691+ *
692+ * Internal function that removes memory records of the removed @item.
693+ * If @item is a #KatzeArray, the function recursiveley removes records
694+ * of all its childs.
695+ **/
696+static void
697+midori_bookmarks_db_remove_item_recursive (KatzeItem* item,
698+ MidoriBookmarksDb* bookmarks)
699+{
700+ GHashTableIter hash_iter;
701+ gpointer found;
702+ KatzeArray* array;
703+ KatzeItem* child;
704+ GList* list;
705+
706+ if (NULL != (found = g_hash_table_lookup (bookmarks->all_items, item)))
707+ {
708+ g_hash_table_remove (bookmarks->all_items, found);
709+ g_object_unref (found);
710+ }
711+
712+ if (!KATZE_IS_ARRAY (item))
713+ return;
714+
715+ array = KATZE_ARRAY (item);
716+
717+ KATZE_ARRAY_FOREACH_ITEM_L (child, array, list)
718+ {
719+ midori_bookmarks_db_remove_item_recursive (child, bookmarks);
720+ }
721+
722+ g_list_free (list);
723+}
724+
725+/**
726+ * midori_bookmarks_db_insert_item_db:
727+ * @db: the #sqlite3
728+ * @item: #KatzeItem the item to insert
729+ *
730+ * Internal function that does the actual SQL INSERT of the @item in @db.
731+ *
732+ * Since: 0.5.2
733+ **/
734+static gint64
735+midori_bookmarks_db_insert_item_db (sqlite3* db,
736+ KatzeItem* item,
737+ gint64 parentid)
738 {
739 gchar* sqlcmd;
740 char* errmsg = NULL;
741@@ -70,15 +484,15 @@
742 new_parentid = g_strdup_printf ("NULL");
743
744 sqlcmd = sqlite3_mprintf (
745- "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
746- "VALUES (%q, %q, '%q', '%q', '%q', %d, %d)",
747- id,
748- new_parentid,
749- katze_item_get_name (item),
750- katze_str_non_null (uri),
751- katze_str_non_null (desc),
752- katze_item_get_meta_boolean (item, "toolbar"),
753- katze_item_get_meta_boolean (item, "app"));
754+ "INSERT INTO bookmarks (id, parentid, title, uri, desc, toolbar, app) "
755+ "VALUES (%q, %q, '%q', '%q', '%q', %d, %d)",
756+ id,
757+ new_parentid,
758+ katze_item_get_name (item),
759+ katze_str_non_null (uri),
760+ katze_str_non_null (desc),
761+ katze_item_get_meta_boolean (item, "toolbar"),
762+ katze_item_get_meta_boolean (item, "app"));
763
764 if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) == SQLITE_OK)
765 {
766@@ -89,7 +503,7 @@
767
768 sqlite3_free (sqlcmd);
769 sqlcmd = sqlite3_mprintf (
770- "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
771+ "SELECT seq FROM sqlite_sequence WHERE name = 'bookmarks'");
772
773 seq_array = katze_array_from_sqlite (db, sqlcmd);
774 if (katze_array_get_nth_item (seq_array, 0))
775@@ -115,8 +529,17 @@
776 return seq;
777 }
778
779-gboolean
780-midori_bookmarks_update_item_db (sqlite3* db,
781+/**
782+ * midori_bookmarks_db_update_item_db:
783+ * @db: the #sqlite3
784+ * @item: #KatzeItem the item to update
785+ *
786+ * Internal function that does the actual SQL UPDATE of the @item in @db.
787+ *
788+ * Since: 0.5.2
789+ **/
790+static gboolean
791+midori_bookmarks_db_update_item_db (sqlite3* db,
792 KatzeItem* item)
793 {
794 gchar* sqlcmd;
795@@ -126,7 +549,7 @@
796 gchar* id;
797
798 id = g_strdup_printf ("%" G_GINT64_FORMAT,
799- katze_item_get_meta_integer (item, "id"));
800+ katze_item_get_meta_integer (item, "id"));
801
802 if (katze_item_get_meta_integer (item, "parentid") > 0)
803 parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
804@@ -135,16 +558,16 @@
805 parentid = g_strdup_printf ("NULL");
806
807 sqlcmd = sqlite3_mprintf (
808- "UPDATE bookmarks SET "
809- "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
810- "WHERE id = %q ;",
811- parentid,
812- katze_item_get_name (item),
813- katze_str_non_null (katze_item_get_uri (item)),
814- katze_str_non_null (katze_item_get_meta_string (item, "desc")),
815- katze_item_get_meta_boolean (item, "toolbar"),
816- katze_item_get_meta_boolean (item, "app"),
817- id);
818+ "UPDATE bookmarks SET "
819+ "parentid=%q, title='%q', uri='%q', desc='%q', toolbar=%d, app=%d "
820+ "WHERE id = %q ;",
821+ parentid,
822+ katze_item_get_name (item),
823+ katze_str_non_null (katze_item_get_uri (item)),
824+ katze_str_non_null (katze_item_get_meta_string (item, "desc")),
825+ katze_item_get_meta_boolean (item, "toolbar"),
826+ katze_item_get_meta_boolean (item, "app"),
827+ id);
828
829 updated = TRUE;
830 if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
831@@ -162,68 +585,104 @@
832 }
833
834 /**
835+ * midori_bookmarks_db_remove_item_db:
836+ * @db: the #sqlite3
837+ * @item: #KatzeItem the item to delete
838+ *
839+ * Internal function that does the actual SQL DELETE of the @item in @db.
840+ *
841+ * Since: 0.5.2
842+ **/
843+static gboolean
844+midori_bookmarks_db_remove_item_db (sqlite3* db,
845+ KatzeItem* item)
846+{
847+ char* errmsg = NULL;
848+ gchar* sqlcmd;
849+ gboolean removed = TRUE;
850+ gchar* id;
851+
852+ id = g_strdup_printf ("%" G_GINT64_FORMAT,
853+ katze_item_get_meta_integer (item, "id"));
854+
855+ sqlcmd = sqlite3_mprintf ("DELETE FROM bookmarks WHERE id = %q", id);
856+
857+ if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
858+ {
859+ g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
860+ sqlite3_free (errmsg);
861+ removed = FALSE;
862+ }
863+
864+ sqlite3_free (sqlcmd);
865+ g_free (id);
866+ return removed;
867+}
868+
869+/**
870+ * midori_bookmarks_db_add_item:
871+ * @bookmarks: the main bookmark array
872+ * @item: #KatzeItem the item to update
873+ *
874+ * Adds the @item in the bookmark data base.
875+ *
876+ * Since: 0.5.2
877+ **/
878+void
879+midori_bookmarks_db_add_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
880+{
881+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
882+ g_return_if_fail (KATZE_IS_ITEM (item));
883+ g_return_if_fail (NULL == katze_item_get_meta_string (item, "id"));
884+
885+ midori_bookmarks_db_add_item_recursive (bookmarks, item);
886+
887+ katze_array_add_item (KATZE_ARRAY (bookmarks), item);
888+}
889+
890+/**
891 * midori_bookmarks_db_update_item:
892 * @bookmarks: the main bookmark array
893 * @item: #KatzeItem the item to update
894 *
895 * Updates the @item in the bookmark data base.
896 *
897- * Since: 0.5.5
898- **/
899-void
900-midori_array_update_item (KatzeArray* bookmarks,
901- KatzeItem* item)
902-{
903- g_return_if_fail (KATZE_IS_ARRAY (bookmarks));
904- g_return_if_fail (KATZE_IS_ITEM (item));
905- g_return_if_fail (katze_item_get_meta_string (item, "id"));
906- g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
907-
908- sqlite3* db = g_object_get_data (G_OBJECT (bookmarks), "db");
909-
910- g_return_if_fail (db);
911-
912- midori_bookmarks_update_item_db (db, item);
913-}
914-
915-void
916-midori_bookmarks_dbtracer (void* dummy,
917- const char* query)
918-{
919- g_printerr ("%s\n", query);
920-}
921-
922-static void
923-midori_bookmarks_add_item_cb (KatzeArray* array,
924- KatzeItem* item,
925- sqlite3* db)
926-{
927- midori_bookmarks_insert_item_db (db, item,
928- katze_item_get_meta_integer (item, "parentid"));
929-}
930-
931-static void
932-midori_bookmarks_remove_item_cb (KatzeArray* array,
933- KatzeItem* item,
934- sqlite3* db)
935-{
936- gchar* sqlcmd;
937- char* errmsg = NULL;
938- gchar* id;
939-
940- id = g_strdup_printf ("%" G_GINT64_FORMAT,
941- katze_item_get_meta_integer (item, "id"));
942-
943- sqlcmd = sqlite3_mprintf ("DELETE FROM bookmarks WHERE id = %q", id);
944-
945- if (sqlite3_exec (db, sqlcmd, NULL, NULL, &errmsg) != SQLITE_OK)
946- {
947- g_printerr (_("Failed to remove bookmark item: %s\n"), errmsg);
948- sqlite3_free (errmsg);
949- }
950-
951- sqlite3_free (sqlcmd);
952- g_free (id);
953+ * Since: 0.5.2
954+ **/
955+void
956+midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
957+{
958+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
959+ g_return_if_fail (KATZE_IS_ITEM (item));
960+ g_return_if_fail (katze_item_get_meta_string (item, "id"));
961+ g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
962+
963+ midori_bookmarks_db_update_item_db (bookmarks->db, item);
964+
965+ midori_bookmarks_db_signal_update_item (bookmarks, item);
966+}
967+
968+/**
969+ * midori_bookmarks_db_remove_item:
970+ * @bookmarks: the main bookmark array
971+ * @item: #KatzeItem the item to remove
972+ *
973+ * Removes the @item from the bookmark data base.
974+ *
975+ * Since: 0.5.2
976+ **/
977+void
978+midori_bookmarks_db_remove_item (MidoriBookmarksDb* bookmarks, KatzeItem* item)
979+{
980+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
981+ g_return_if_fail (KATZE_IS_ITEM (item));
982+ g_return_if_fail (katze_item_get_meta_string (item, "id"));
983+ g_return_if_fail (0 != katze_item_get_meta_integer (item, "id"));
984+
985+ midori_bookmarks_db_remove_item_recursive (item, bookmarks);
986+ midori_bookmarks_db_remove_item_db (bookmarks->db, item);
987+
988+ katze_array_remove_item (KATZE_ARRAY (bookmarks), item);
989 }
990
991 #define _APPEND_TO_SQL_ERRORMSG(custom_errmsg) \
992@@ -237,8 +696,8 @@
993 g_string_append (errmsg_str, custom_errmsg); \
994 } while (0)
995
996-gboolean
997-midori_bookmarks_import_from_old_db (sqlite3* db,
998+static gboolean
999+midori_bookmarks_db_import_from_old_db (sqlite3* db,
1000 const gchar* oldfile,
1001 gchar** errmsg)
1002 {
1003@@ -293,8 +752,24 @@
1004 }
1005 #undef _APPEND_TO_SQL_ERRORMSG
1006
1007-KatzeArray*
1008-midori_bookmarks_new (char** errmsg)
1009+static void
1010+midori_bookmarks_db_dbtracer (void* dummy,
1011+ const char* query)
1012+{
1013+ g_printerr ("%s\n", query);
1014+}
1015+
1016+/**
1017+ * midori_bookmarks_db_new:
1018+ *
1019+ * Initializes the bookmark data base.
1020+ *
1021+ * Returns: the main bookmarks array
1022+ *
1023+ * Since: 0.5.2
1024+ **/
1025+MidoriBookmarksDb*
1026+midori_bookmarks_db_new (char** errmsg)
1027 {
1028 sqlite3* db;
1029 gchar* oldfile;
1030@@ -304,6 +779,7 @@
1031 gchar* sql_errmsg = NULL;
1032 gchar* import_errmsg = NULL;
1033 KatzeArray* array;
1034+ MidoriBookmarksDb* bookmarks;
1035
1036 g_return_val_if_fail (errmsg != NULL, NULL);
1037
1038@@ -321,7 +797,7 @@
1039 }
1040
1041 if (midori_debug ("bookmarks"))
1042- sqlite3_trace (db, midori_bookmarks_dbtracer, NULL);
1043+ sqlite3_trace (db, midori_bookmarks_db_dbtracer, NULL);
1044
1045 create_stmt = /* Table structure */
1046 "CREATE TABLE IF NOT EXISTS bookmarks "
1047@@ -442,7 +918,7 @@
1048
1049 if (oldfile_exists)
1050 /* import from old db */
1051- if (!midori_bookmarks_import_from_old_db (db, oldfile, &import_errmsg))
1052+ if (!midori_bookmarks_db_import_from_old_db (db, oldfile, &import_errmsg))
1053 {
1054 *errmsg = g_strdup_printf (_("Couldn't import from old database: %s\n"),
1055 import_errmsg ? import_errmsg : "(err = NULL)");
1056@@ -452,13 +928,11 @@
1057 init_success:
1058 g_free (newfile);
1059 g_free (oldfile);
1060- array = katze_array_new (KATZE_TYPE_ARRAY);
1061- g_signal_connect (array, "add-item",
1062- G_CALLBACK (midori_bookmarks_add_item_cb), db);
1063- g_signal_connect (array, "remove-item",
1064- G_CALLBACK (midori_bookmarks_remove_item_cb), db);
1065- g_object_set_data (G_OBJECT (array), "db", db);
1066- return array;
1067+ bookmarks = MIDORI_BOOKMARKS_DB (g_object_new (TYPE_MIDORI_BOOKMARKS_DB, NULL));
1068+ bookmarks->db = db;
1069+
1070+ g_object_set_data (G_OBJECT (bookmarks), "db", db);
1071+ return bookmarks;
1072
1073 init_failed:
1074 g_free (newfile);
1075@@ -470,40 +944,154 @@
1076 return NULL;
1077 }
1078
1079+/**
1080+ * midori_bookmarks_db_on_quit:
1081+ * @bookmarks: the main bookmark array
1082+ *
1083+ * Delete the main bookmark array.
1084+ *
1085+ * Since: 0.5.2
1086+ **/
1087 void
1088-midori_bookmarks_on_quit (KatzeArray* array)
1089+midori_bookmarks_db_on_quit (MidoriBookmarksDb* bookmarks)
1090 {
1091- g_return_if_fail (KATZE_IS_ARRAY (array));
1092+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
1093
1094- sqlite3* db = g_object_get_data (G_OBJECT (array), "db");
1095- g_return_if_fail (db != NULL);
1096- sqlite3_close (db);
1097+ g_object_unref (bookmarks);
1098 }
1099
1100+/**
1101+ * midori_bookmarks_db_import_array:
1102+ * @array: the main bookmark array
1103+ * @array: #KatzeArray containing the items to import
1104+ * @parentid: the id of folder
1105+ *
1106+ * Imports the items of @array as childs of the folder
1107+ * identfied by @parentid.
1108+ *
1109+ * Since: 0.5.2
1110+ **/
1111 void
1112-midori_bookmarks_import_array (KatzeArray* bookmarks,
1113+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
1114 KatzeArray* array,
1115 gint64 parentid)
1116 {
1117 GList* list;
1118 KatzeItem* item;
1119
1120- if (!bookmarks)
1121- return;
1122+ g_return_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks));
1123+ g_return_if_fail (KATZE_IS_ARRAY (array));
1124
1125 KATZE_ARRAY_FOREACH_ITEM_L (item, array, list)
1126 {
1127 katze_item_set_meta_integer (item, "parentid", parentid);
1128- katze_array_add_item (bookmarks, item);
1129- if (KATZE_IS_ARRAY (item))
1130- midori_bookmarks_import_array (bookmarks, KATZE_ARRAY (item),
1131- katze_item_get_meta_integer(item, "id"));
1132+ midori_bookmarks_db_add_item (bookmarks, item);
1133 }
1134 g_list_free (list);
1135 }
1136
1137 /**
1138- * midori_array_query_recursive:
1139+ * midori_bookmarks_db_array_from_statement:
1140+ * @stmt: the sqlite returned statement
1141+ * @bookmarks: the database controller
1142+ *
1143+ * Internal function that populate a #KatzeArray by processing the @stmt
1144+ * rows identifying:
1145+ * a- if the item is already in memory
1146+ * in this case the item data is updated with retreived database content
1147+ * and the already existing item is populated in the returned #KatzeArray
1148+ * b- if the data is a folder
1149+ * a new #KatzeArray item is populated in the returned #KatzeArray and
1150+ * memorized for future use.
1151+ * c- if the data is a bookmark
1152+ * a new #KatzeItem item is populated in the returned #KatzeArray and
1153+ * memorized for furure use.
1154+ *
1155+ * Return value: the populated #KatzeArray
1156+ **/
1157+static KatzeArray*
1158+midori_bookmarks_db_array_from_statement (sqlite3_stmt* stmt,
1159+ MidoriBookmarksDb* bookmarks)
1160+{
1161+ KatzeArray *array;
1162+ gint result;
1163+ gint cols;
1164+
1165+ array = katze_array_new (KATZE_TYPE_ITEM);
1166+ cols = sqlite3_column_count (stmt);
1167+
1168+ while ((result = sqlite3_step (stmt)) == SQLITE_ROW)
1169+ {
1170+ gint i;
1171+ KatzeItem* item;
1172+ KatzeItem* found;
1173+
1174+ item = katze_item_new ();
1175+ for (i = 0; i < cols; i++)
1176+ katze_item_set_value_from_column (stmt, i, item);
1177+
1178+ if (NULL != (found = g_hash_table_lookup (bookmarks->all_items, item)))
1179+ {
1180+ for (i = 0; i < cols; i++)
1181+ katze_item_set_value_from_column (stmt, i, found);
1182+
1183+ g_object_unref (item);
1184+
1185+ item = found;
1186+ }
1187+ else if (KATZE_ITEM_IS_FOLDER (item))
1188+ {
1189+ g_object_unref (item);
1190+
1191+ item = KATZE_ITEM (katze_array_new (KATZE_TYPE_ITEM));
1192+
1193+ for (i = 0; i < cols; i++)
1194+ katze_item_set_value_from_column (stmt, i, item);
1195+
1196+ g_object_ref (item);
1197+ g_hash_table_insert (bookmarks->all_items, item, item);
1198+ }
1199+ else
1200+ {
1201+ g_object_ref (item);
1202+ g_hash_table_insert (bookmarks->all_items, item, item);
1203+ }
1204+
1205+ katze_array_add_item (array, item);
1206+ }
1207+
1208+ sqlite3_clear_bindings (stmt);
1209+ sqlite3_reset (stmt);
1210+ return array;
1211+}
1212+
1213+/**
1214+ * midori_bookmarks_db_array_from_sqlite:
1215+ * @array: the main bookmark array
1216+ * @sqlcmd: the sqlcmd to execute
1217+ *
1218+ * Internal function that process the requested @sqlcmd.
1219+ *
1220+ * Return value: a #KatzeArray on success, %NULL otherwise
1221+ **/
1222+static KatzeArray*
1223+midori_bookmarks_db_array_from_sqlite (MidoriBookmarksDb* bookmarks,
1224+ const gchar* sqlcmd)
1225+{
1226+ sqlite3_stmt* stmt;
1227+ gint result;
1228+
1229+ g_return_val_if_fail (bookmarks->db != NULL, NULL);
1230+
1231+ result = sqlite3_prepare_v2 (bookmarks->db, sqlcmd, -1, &stmt, NULL);
1232+ if (result != SQLITE_OK)
1233+ return NULL;
1234+
1235+ return midori_bookmarks_db_array_from_statement (stmt, bookmarks);
1236+}
1237+
1238+/**
1239+ * midori_bookmarks_db_query_recursive:
1240 * @array: the main bookmark array
1241 * @fields: comma separated list of fields
1242 * @condition: condition, like "folder = '%q'"
1243@@ -514,38 +1102,35 @@
1244 *
1245 * Return value: a #KatzeArray on success, %NULL otherwise
1246 *
1247- * Since: 0.4.4
1248+ * Since: 0.5.2
1249 **/
1250 KatzeArray*
1251-midori_array_query_recursive (KatzeArray* bookmarks,
1252- const gchar* fields,
1253- const gchar* condition,
1254- const gchar* value,
1255- gboolean recursive)
1256+midori_bookmarks_db_query_recursive (MidoriBookmarksDb* bookmarks,
1257+ const gchar* fields,
1258+ const gchar* condition,
1259+ const gchar* value,
1260+ gboolean recursive)
1261 {
1262- sqlite3* db;
1263 gchar* sqlcmd;
1264 char* sqlcmd_value;
1265 KatzeArray* array;
1266 KatzeItem* item;
1267 GList* list;
1268
1269- g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), NULL);
1270+ g_return_val_if_fail (IS_MIDORI_BOOKMARKS_DB (bookmarks), NULL);
1271 g_return_val_if_fail (fields, NULL);
1272 g_return_val_if_fail (condition, NULL);
1273- db = g_object_get_data (G_OBJECT (bookmarks), "db");
1274- g_return_val_if_fail (db != NULL, NULL);
1275
1276 sqlcmd = g_strdup_printf ("SELECT %s FROM bookmarks WHERE %s "
1277 "ORDER BY (uri='') ASC, title DESC", fields, condition);
1278 if (strstr (condition, "%q"))
1279 {
1280 sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
1281- array = katze_array_from_sqlite (db, sqlcmd_value);
1282+ array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd_value);
1283 sqlite3_free (sqlcmd_value);
1284 }
1285 else
1286- array = katze_array_from_sqlite (db, sqlcmd);
1287+ array = midori_bookmarks_db_array_from_sqlite (bookmarks, sqlcmd);
1288 g_free (sqlcmd);
1289
1290 if (!recursive)
1291@@ -556,9 +1141,9 @@
1292 if (KATZE_ITEM_IS_FOLDER (item))
1293 {
1294 gchar* parentid = g_strdup_printf ("%" G_GINT64_FORMAT,
1295- katze_item_get_meta_integer (item, "id"));
1296- KatzeArray* subarray = midori_array_query_recursive (bookmarks,
1297- fields, "parentid=%q", parentid, TRUE);
1298+ katze_item_get_meta_integer (item, "id"));
1299+ KatzeArray* subarray = midori_bookmarks_db_query_recursive (bookmarks,
1300+ fields, "parentid=%q", parentid, TRUE);
1301 KatzeItem* subitem;
1302 GList* sublist;
1303
1304@@ -576,21 +1161,21 @@
1305 }
1306
1307 static gint64
1308-count_from_sqlite (sqlite3* db,
1309- const gchar* sqlcmd)
1310+midori_bookmarks_db_count_from_sqlite (sqlite3* db,
1311+ const gchar* sqlcmd)
1312 {
1313 gint64 count = -1;
1314 sqlite3_stmt* stmt;
1315 gint result;
1316-
1317+
1318 result = sqlite3_prepare_v2 (db, sqlcmd, -1, &stmt, NULL);
1319 if (result != SQLITE_OK)
1320 return -1;
1321
1322 g_assert (sqlite3_column_count (stmt) == 1);
1323-
1324+
1325 if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
1326- count = sqlite3_column_int64(stmt, 0);
1327+ count = sqlite3_column_int64(stmt, 0);
1328
1329 sqlite3_clear_bindings (stmt);
1330 sqlite3_reset (stmt);
1331@@ -599,14 +1184,13 @@
1332 }
1333
1334 static gint64
1335-midori_array_count_recursive_by_id (KatzeArray* bookmarks,
1336- const gchar* condition,
1337- const gchar* value,
1338- gint64 id,
1339- gboolean recursive)
1340+midori_bookmarks_db_count_recursive_by_id (MidoriBookmarksDb* bookmarks,
1341+ const gchar* condition,
1342+ const gchar* value,
1343+ gint64 id,
1344+ gboolean recursive)
1345 {
1346 gint64 count = -1;
1347- sqlite3* db;
1348 gchar* sqlcmd;
1349 char* sqlcmd_value;
1350 sqlite3_stmt* stmt;
1351@@ -615,30 +1199,29 @@
1352 GList* iter_ids;
1353
1354 g_return_val_if_fail (condition, -1);
1355- g_return_val_if_fail (KATZE_IS_ARRAY (bookmarks), -1);
1356- db = g_object_get_data (G_OBJECT (bookmarks), "db");
1357- g_return_val_if_fail (db != NULL, -1);
1358+ g_return_val_if_fail (MIDORI_BOOKMARKS_DB (bookmarks), -1);
1359+ g_return_val_if_fail (bookmarks->db != NULL, -1);
1360
1361 g_assert(!strstr("parentid", condition));
1362
1363 if (id > 0)
1364- sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
1365- "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
1366- id,
1367- condition);
1368+ sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
1369+ "WHERE parentid = %" G_GINT64_FORMAT " AND %s",
1370+ id,
1371+ condition);
1372 else
1373- sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
1374- "WHERE parentid IS NULL AND %s ",
1375- condition);
1376+ sqlcmd = g_strdup_printf ("SELECT COUNT(*) FROM bookmarks "
1377+ "WHERE parentid IS NULL AND %s ",
1378+ condition);
1379
1380 if (strstr (condition, "%q"))
1381 {
1382 sqlcmd_value = sqlite3_mprintf (sqlcmd, value ? value : "");
1383- count = count_from_sqlite (db, sqlcmd_value);
1384+ count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd_value);
1385 sqlite3_free (sqlcmd_value);
1386 }
1387 else
1388- count = count_from_sqlite (db, sqlcmd);
1389+ count = midori_bookmarks_db_count_from_sqlite (bookmarks->db, sqlcmd);
1390
1391 g_free (sqlcmd);
1392
1393@@ -648,28 +1231,28 @@
1394 ids = NULL;
1395
1396 if (id > 0)
1397- sqlcmd_value = sqlite3_mprintf (
1398- "SELECT id FROM bookmarks "
1399- "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
1400+ sqlcmd_value = sqlite3_mprintf (
1401+ "SELECT id FROM bookmarks "
1402+ "WHERE parentid = %" G_GINT64_FORMAT " AND uri = ''", id);
1403 else
1404- sqlcmd_value = sqlite3_mprintf (
1405- "SELECT id FROM bookmarks "
1406- "WHERE parentid IS NULL AND uri = ''");
1407+ sqlcmd_value = sqlite3_mprintf (
1408+ "SELECT id FROM bookmarks "
1409+ "WHERE parentid IS NULL AND uri = ''");
1410
1411- if (sqlite3_prepare_v2 (db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
1412+ if (sqlite3_prepare_v2 (bookmarks->db, sqlcmd_value, -1, &stmt, NULL) == SQLITE_OK)
1413 {
1414- g_assert (sqlite3_column_count (stmt) == 1);
1415-
1416- if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
1417- {
1418- gint64* pid = g_new (gint64, 1);
1419-
1420- *pid = sqlite3_column_int64(stmt, 0);
1421- ids = g_list_append (ids, pid);
1422- }
1423-
1424- sqlite3_clear_bindings (stmt);
1425- sqlite3_reset (stmt);
1426+ g_assert (sqlite3_column_count (stmt) == 1);
1427+
1428+ if ((result = sqlite3_step (stmt)) == SQLITE_ROW)
1429+ {
1430+ gint64* pid = g_new (gint64, 1);
1431+
1432+ *pid = sqlite3_column_int64(stmt, 0);
1433+ ids = g_list_append (ids, pid);
1434+ }
1435+
1436+ sqlite3_clear_bindings (stmt);
1437+ sqlite3_reset (stmt);
1438 }
1439
1440 sqlite3_free (sqlcmd_value);
1441@@ -677,29 +1260,29 @@
1442 iter_ids = ids;
1443 while (iter_ids)
1444 {
1445- gint64 sub_count = midori_array_count_recursive_by_id (bookmarks,
1446- condition,
1447- value,
1448- *(gint64*)(iter_ids->data),
1449- recursive);
1450-
1451- if (sub_count < 0)
1452- {
1453- g_list_free_full (ids, g_free);
1454- return -1;
1455- }
1456-
1457- count += sub_count;
1458- iter_ids = g_list_next (iter_ids);
1459+ gint64 sub_count = midori_bookmarks_db_count_recursive_by_id (bookmarks,
1460+ condition,
1461+ value,
1462+ *(gint64*)(iter_ids->data),
1463+ recursive);
1464+
1465+ if (sub_count < 0)
1466+ {
1467+ g_list_free_full (ids, g_free);
1468+ return -1;
1469+ }
1470+
1471+ count += sub_count;
1472+ iter_ids = g_list_next (iter_ids);
1473 }
1474-
1475+
1476 g_list_free_full (ids, g_free);
1477 return count;
1478 }
1479
1480 /**
1481- * midori_array_count_recursive:
1482- * @array: the main bookmark array
1483+ * midori_bookmarks_db_count_recursive:
1484+ * @bookmarks: the main bookmark array
1485 * @condition: condition, like "folder = '%q'"
1486 * @value: a value to be inserted if @condition contains %q
1487 * @recursive: if %TRUE include children
1488@@ -709,19 +1292,19 @@
1489 * Since: 0.5.2
1490 **/
1491 gint64
1492-midori_array_count_recursive (KatzeArray* bookmarks,
1493- const gchar* condition,
1494- const gchar* value,
1495- KatzeItem* folder,
1496- gboolean recursive)
1497+midori_bookmarks_db_count_recursive (MidoriBookmarksDb* bookmarks,
1498+ const gchar* condition,
1499+ const gchar* value,
1500+ KatzeItem* folder,
1501+ gboolean recursive)
1502 {
1503 gint64 id = -1;
1504
1505 g_return_val_if_fail (!folder || KATZE_ITEM_IS_FOLDER (folder), -1);
1506-
1507+
1508 id = folder ? katze_item_get_meta_integer (folder, "id") : 0;
1509
1510- return midori_array_count_recursive_by_id (bookmarks, condition,
1511- value, id,
1512- recursive);
1513+ return midori_bookmarks_db_count_recursive_by_id (bookmarks, condition,
1514+ value, id,
1515+ recursive);
1516 }
1517
1518=== modified file 'midori/midori-bookmarks-db.h'
1519--- midori/midori-bookmarks-db.h 2013-09-08 10:53:32 +0000
1520+++ midori/midori-bookmarks-db.h 2013-09-17 21:28:04 +0000
1521@@ -16,33 +16,60 @@
1522 #include <sqlite3.h>
1523 #include <katze/katze.h>
1524
1525-KatzeArray*
1526-midori_bookmarks_new (char** errmsg);
1527-
1528-void
1529-midori_bookmarks_on_quit (KatzeArray* array);
1530-
1531-void
1532-midori_array_update_item (KatzeArray* bookmarks, KatzeItem* item);
1533-
1534-void
1535-midori_bookmarks_import_array (KatzeArray* bookmarks,
1536- KatzeArray* array,
1537- gint64 parentid);
1538-
1539-KatzeArray*
1540-midori_array_query_recursive (KatzeArray* bookmarks,
1541- const gchar* fields,
1542- const gchar* condition,
1543- const gchar* value,
1544- gboolean recursive);
1545+G_BEGIN_DECLS
1546+
1547+#define TYPE_MIDORI_BOOKMARKS_DB \
1548+ (midori_bookmarks_db_get_type ())
1549+#define MIDORI_BOOKMARKS_DB(obj) \
1550+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDb))
1551+#define MIDORI_BOOKMARKS_DB_CLASS(klass) \
1552+ (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDbClass))
1553+#define IS_MIDORI_BOOKMARKS_DB(obj) \
1554+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MIDORI_BOOKMARKS_DB))
1555+#define IS_MIDORI_BOOKMARKS_DB_CLASS(klass) \
1556+ (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MIDORI_BOOKMARKS_DB))
1557+#define MIDORI_BOOKMARKS_DB_GET_CLASS(obj) \
1558+ (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MIDORI_BOOKMARKS_DB, MidoriBookmarksDbClass))
1559+
1560+typedef struct _MidoriBookmarksDb MidoriBookmarksDb;
1561+typedef struct _MidoriBookmarksDbClass MidoriBookmarksDbClass;
1562+
1563+GType
1564+midori_bookmarks_db_get_type (void) G_GNUC_CONST;
1565+
1566+MidoriBookmarksDb*
1567+midori_bookmarks_db_new (char** errmsg);
1568+
1569+void
1570+midori_bookmarks_db_on_quit (MidoriBookmarksDb* array);
1571+
1572+void
1573+midori_bookmarks_db_add_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
1574+
1575+void
1576+midori_bookmarks_db_update_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
1577+
1578+void
1579+midori_bookmarks_db_remove_item (MidoriBookmarksDb* bookmarks, KatzeItem* item);
1580+
1581+void
1582+midori_bookmarks_db_import_array (MidoriBookmarksDb* bookmarks,
1583+ KatzeArray* array,
1584+ gint64 parentid);
1585+
1586+KatzeArray*
1587+midori_bookmarks_db_query_recursive (MidoriBookmarksDb* bookmarks,
1588+ const gchar* fields,
1589+ const gchar* condition,
1590+ const gchar* value,
1591+ gboolean recursive);
1592
1593 gint64
1594-midori_array_count_recursive (KatzeArray* bookmarks,
1595- const gchar* condition,
1596- const gchar* value,
1597- KatzeItem* folder,
1598- gboolean recursive);
1599+midori_bookmarks_db_count_recursive (MidoriBookmarksDb* bookmarks,
1600+ const gchar* condition,
1601+ const gchar* value,
1602+ KatzeItem* folder,
1603+ gboolean recursive);
1604
1605 gint64
1606 midori_bookmarks_insert_item_db (sqlite3* db,
1607
1608=== modified file 'midori/midori-browser.c'
1609--- midori/midori-browser.c 2013-09-16 22:00:41 +0000
1610+++ midori/midori-browser.c 2013-09-17 21:28:04 +0000
1611@@ -87,7 +87,7 @@
1612
1613 MidoriWebSettings* settings;
1614 KatzeArray* proxy_array;
1615- KatzeArray* bookmarks;
1616+ MidoriBookmarksDb* bookmarks;
1617 KatzeArray* trash;
1618 KatzeArray* search_engines;
1619 KatzeArray* history;
1620@@ -195,8 +195,8 @@
1621 GtkToolbarStyle style);
1622
1623 static void
1624-midori_browser_set_bookmarks (MidoriBrowser* browser,
1625- KatzeArray* bookmarks);
1626+midori_browser_set_bookmarks (MidoriBrowser* browser,
1627+ MidoriBookmarksDb* bookmarks);
1628
1629 static void
1630 midori_browser_add_speed_dial (MidoriBrowser* browser);
1631@@ -863,7 +863,7 @@
1632 }
1633
1634 static GtkWidget*
1635-midori_bookmark_folder_button_new (KatzeArray* array,
1636+midori_bookmark_folder_button_new (MidoriBookmarksDb* array,
1637 gint64 selected_parentid)
1638 {
1639 GtkTreeStore* model;
1640@@ -1231,18 +1231,9 @@
1641 katze_item_set_meta_integer (bookmark, "parentid", selected);
1642
1643 if (new_bookmark)
1644- katze_array_add_item (browser->bookmarks, bookmark);
1645+ midori_bookmarks_db_add_item (browser->bookmarks, bookmark);
1646 else
1647- {
1648- midori_array_update_item (browser->bookmarks, bookmark);
1649- midori_browser_update_history (bookmark, "bookmark", "modify");
1650-
1651- if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_toolbar)))
1652- if (!gtk_widget_get_visible (browser->bookmarkbar))
1653- _action_set_active (browser, "Bookmarkbar", TRUE);
1654- if (gtk_widget_get_visible (browser->bookmarkbar))
1655- midori_bookmarkbar_populate (browser);
1656- }
1657+ midori_bookmarks_db_update_item (browser->bookmarks, bookmark);
1658
1659 return_status = TRUE;
1660 }
1661@@ -2545,7 +2536,7 @@
1662 "bookmarks",
1663 "Bookmarks",
1664 "The bookmarks folder, containing all bookmarks",
1665- KATZE_TYPE_ARRAY,
1666+ TYPE_MIDORI_BOOKMARKS_DB,
1667 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
1668
1669 /**
1670@@ -3273,8 +3264,8 @@
1671 else
1672 condition = "parentid = %q";
1673
1674- bookmarks = midori_array_query_recursive (browser->bookmarks,
1675- "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
1676+ bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
1677+ "id, title, parentid, uri, app, pos_panel, pos_bar", condition, id, FALSE);
1678 if (!bookmarks)
1679 return FALSE;
1680
1681@@ -4308,7 +4299,7 @@
1682 KatzeItem* item;
1683
1684 item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
1685- katze_array_remove_item (browser->bookmarks, item);
1686+ midori_bookmarks_db_remove_item (browser->bookmarks, item);
1687 }
1688
1689 static void
1690@@ -4320,7 +4311,7 @@
1691 MidoriContextAction* menu = midori_context_action_new ("BookmarkContextMenu", NULL, NULL, NULL);
1692 if (KATZE_ITEM_IS_FOLDER (item))
1693 {
1694- gint child_bookmarks_count = midori_array_count_recursive (browser->bookmarks,
1695+ gint child_bookmarks_count = midori_bookmarks_db_count_recursive (browser->bookmarks,
1696 "uri <> ''", NULL, item, FALSE);
1697
1698 GtkAction* action = gtk_action_new ("BookmarkOpenAllTabs", _("Open all in _Tabs"), NULL, STOCK_TAB_NEW);
1699@@ -4590,8 +4581,7 @@
1700 if (error)
1701 g_error_free (error);
1702 }
1703- midori_bookmarks_import_array (browser->bookmarks, bookmarks, selected);
1704-
1705+ midori_bookmarks_db_import_array (browser->bookmarks, bookmarks, selected);
1706 g_object_unref (bookmarks);
1707 g_free (path);
1708 }
1709@@ -4645,7 +4635,7 @@
1710 return;
1711
1712 error = NULL;
1713- bookmarks = midori_array_query_recursive (browser->bookmarks,
1714+ bookmarks = midori_bookmarks_db_query_recursive (browser->bookmarks,
1715 "*", "parentid IS NULL", NULL, TRUE);
1716 if (!midori_array_to_file (bookmarks, path, format, &error))
1717 {
1718@@ -7060,6 +7050,16 @@
1719 }
1720
1721 static void
1722+midori_bookmarkbar_update_item_cb (KatzeArray* bookmarks,
1723+ KatzeItem* item,
1724+ MidoriBrowser* browser)
1725+{
1726+ if (gtk_widget_get_visible (browser->bookmarkbar))
1727+ midori_bookmarkbar_populate (browser);
1728+ midori_browser_update_history (item, "bookmark", "modify");
1729+}
1730+
1731+static void
1732 midori_bookmarkbar_remove_item_cb (KatzeArray* bookmarks,
1733 KatzeItem* item,
1734 MidoriBrowser* browser)
1735@@ -7091,8 +7091,8 @@
1736 gtk_toolbar_insert (GTK_TOOLBAR (browser->bookmarkbar),
1737 gtk_separator_tool_item_new (), -1);
1738
1739- array = midori_array_query_recursive (browser->bookmarks,
1740- "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
1741+ array = midori_bookmarks_db_query_recursive (browser->bookmarks,
1742+ "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "toolbar = 1", NULL, FALSE);
1743 if (!array)
1744 {
1745 _action_set_sensitive (browser, "BookmarkAdd", FALSE);
1746@@ -7132,7 +7132,7 @@
1747
1748 static void
1749 midori_browser_set_bookmarks (MidoriBrowser* browser,
1750- KatzeArray* bookmarks)
1751+ MidoriBookmarksDb* bookmarks)
1752 {
1753 MidoriWebSettings* settings;
1754
1755@@ -7141,6 +7141,8 @@
1756 g_signal_handlers_disconnect_by_func (browser->bookmarks,
1757 midori_bookmarkbar_add_item_cb, browser);
1758 g_signal_handlers_disconnect_by_func (browser->bookmarks,
1759+ midori_bookmarkbar_update_item_cb, browser);
1760+ g_signal_handlers_disconnect_by_func (browser->bookmarks,
1761 midori_bookmarkbar_remove_item_cb, browser);
1762 }
1763
1764@@ -7174,6 +7176,8 @@
1765 g_object_notify (G_OBJECT (settings), "show-bookmarkbar");
1766 g_signal_connect_after (bookmarks, "add-item",
1767 G_CALLBACK (midori_bookmarkbar_add_item_cb), browser);
1768+ g_signal_connect_after (bookmarks, "update-item",
1769+ G_CALLBACK (midori_bookmarkbar_update_item_cb), browser);
1770 g_signal_connect_after (bookmarks, "remove-item",
1771 G_CALLBACK (midori_bookmarkbar_remove_item_cb), browser);
1772 }
1773
1774=== modified file 'midori/midori-frontend.c'
1775--- midori/midori-frontend.c 2013-09-08 11:09:40 +0000
1776+++ midori/midori-frontend.c 2013-09-17 21:28:04 +0000
1777@@ -487,9 +487,9 @@
1778 }
1779 g_free (uri);
1780
1781- KatzeArray* bookmarks;
1782+ MidoriBookmarksDb* bookmarks;
1783 gchar* errmsg = NULL;
1784- if (!(bookmarks = midori_bookmarks_new (&errmsg)))
1785+ if (!(bookmarks = midori_bookmarks_db_new (&errmsg)))
1786 {
1787 g_string_append_printf (error_messages,
1788 _("Bookmarks couldn't be loaded: %s\n"), errmsg);
1789@@ -596,11 +596,11 @@
1790 midori_normal_app_on_quit (MidoriApp* app)
1791 {
1792 MidoriWebSettings* settings = katze_object_get_object (app, "settings");
1793- KatzeArray* bookmarks = katze_object_get_object (app, "bookmarks");
1794+ MidoriBookmarksDb* bookmarks = katze_object_get_object (app, "bookmarks");
1795 KatzeArray* history = katze_object_get_object (app, "history");
1796
1797 g_object_notify (G_OBJECT (settings), "load-on-startup");
1798- midori_bookmarks_on_quit (bookmarks);
1799+ midori_bookmarks_db_on_quit (bookmarks);
1800 midori_history_on_quit (history, settings);
1801 midori_private_data_on_quit (settings);
1802
1803
1804=== modified file 'panels/midori-bookmarks.c'
1805--- panels/midori-bookmarks.c 2013-09-08 11:09:40 +0000
1806+++ panels/midori-bookmarks.c 2013-09-17 21:28:04 +0000
1807@@ -45,7 +45,7 @@
1808 GtkWidget* delete;
1809 GtkWidget* treeview;
1810 MidoriApp* app;
1811- KatzeArray* array;
1812+ MidoriBookmarksDb* bookmarks_db;
1813
1814 gint filter_timeout;
1815 gchar* filter;
1816@@ -125,6 +125,7 @@
1817 return STOCK_BOOKMARKS;
1818 }
1819
1820+#if 0 /* Make sure the following function is never used */
1821 /* TODO: Function never used */
1822 void
1823 midori_bookmarks_export_array_db (sqlite3* db,
1824@@ -138,7 +139,7 @@
1825 gchar* parent_id;
1826
1827 parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
1828- if (!(root_array = midori_array_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
1829+ if (!(root_array = midori_bookmarks_db_query_recursive (array, "*", "parentid = %q", parent_id, FALSE)))
1830 {
1831 g_free (parent_id);
1832 return;
1833@@ -160,6 +161,7 @@
1834 g_free (parent_id);
1835 g_list_free (list);
1836 }
1837+#endif /* 0 */
1838
1839 static KatzeArray*
1840 midori_bookmarks_read_from_db (MidoriBookmarks* bookmarks,
1841@@ -169,21 +171,21 @@
1842 KatzeArray* array;
1843
1844 if (keyword && *keyword)
1845- array = midori_array_query_recursive (bookmarks->array,
1846- "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
1847+ array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
1848+ "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "title LIKE '%%%q%%'", keyword, FALSE);
1849 else
1850 {
1851 if (parentid > 0)
1852 {
1853 gchar* parent_id = g_strdup_printf ("%" G_GINT64_FORMAT, parentid);
1854- array = midori_array_query_recursive (bookmarks->array,
1855- "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
1856+ array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
1857+ "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid = %q", parent_id, FALSE);
1858
1859 g_free (parent_id);
1860 }
1861 else
1862- array = midori_array_query_recursive (bookmarks->array,
1863- "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
1864+ array = midori_bookmarks_db_query_recursive (bookmarks->bookmarks_db,
1865+ "id, parentid, title, uri, desc, app, toolbar, pos_panel, pos_bar", "parentid IS NULL", NULL, FALSE);
1866 }
1867 return array ? array : katze_array_new (KATZE_TYPE_ITEM);
1868 }
1869@@ -274,9 +276,9 @@
1870 else
1871 parentid = 0;
1872
1873- katze_array_remove_item (bookmarks->array, item);
1874 katze_item_set_meta_integer (item, "parentid", parentid);
1875- katze_array_add_item (bookmarks->array, item);
1876+
1877+ midori_bookmarks_db_update_item (bookmarks->bookmarks_db, item);
1878
1879 g_object_unref (item);
1880 if (new_parent)
1881@@ -416,9 +418,9 @@
1882
1883 if (KATZE_ITEM_IS_FOLDER (item))
1884 {
1885- gint child_folders_count = midori_array_count_recursive (bookmarks->array,
1886+ gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
1887 "uri = ''", NULL, item, FALSE);
1888- gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
1889+ gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
1890 "uri <> ''", NULL, item, FALSE);
1891 gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
1892 gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
1893@@ -451,9 +453,9 @@
1894 }
1895 else
1896 {
1897- gint child_folders_count = midori_array_count_recursive (bookmarks->array,
1898+ gint child_folders_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
1899 "uri = ''", NULL, NULL, FALSE);
1900- gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
1901+ gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
1902 "uri <> ''", NULL, NULL, FALSE);
1903 gchar* child_folders_str = midori_bookmarks_statusbar_subfolders_str (child_folders_count);
1904 gchar* child_bookmarks_str = midori_bookmarks_statusbar_bookmarks_str (child_bookmarks_count);
1905@@ -499,10 +501,10 @@
1906
1907 /* Manually remove the iter and block clearing the treeview */
1908 gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
1909- g_signal_handlers_block_by_func (bookmarks->array,
1910+ g_signal_handlers_block_by_func (bookmarks->bookmarks_db,
1911 midori_bookmarks_remove_item_cb, bookmarks);
1912- katze_array_remove_item (bookmarks->array, item);
1913- g_signal_handlers_unblock_by_func (bookmarks->array,
1914+ midori_bookmarks_db_remove_item (bookmarks->bookmarks_db, item);
1915+ g_signal_handlers_unblock_by_func (bookmarks->bookmarks_db,
1916 midori_bookmarks_remove_item_cb, bookmarks);
1917 g_object_unref (item);
1918 }
1919@@ -585,9 +587,9 @@
1920 GtkTreeModel* model;
1921
1922 model = gtk_tree_view_get_model (GTK_TREE_VIEW (bookmarks->treeview));
1923- if (bookmarks->array)
1924+ if (bookmarks->bookmarks_db)
1925 {
1926- g_object_unref (bookmarks->array);
1927+ g_object_unref (bookmarks->bookmarks_db);
1928 gtk_tree_store_clear (GTK_TREE_STORE (model));
1929 }
1930 katze_assign (bookmarks->app, app);
1931@@ -595,13 +597,13 @@
1932 return;
1933
1934 g_object_ref (app);
1935- bookmarks->array = katze_object_get_object (app, "bookmarks");
1936+ bookmarks->bookmarks_db = katze_object_get_object (app, "bookmarks");
1937 midori_bookmarks_read_from_db_to_model (bookmarks, GTK_TREE_STORE (model), NULL, 0, NULL);
1938- g_signal_connect_after (bookmarks->array, "add-item",
1939- G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
1940- g_signal_connect (bookmarks->array, "remove-item",
1941+ g_signal_connect_after (bookmarks->bookmarks_db, "add-item",
1942+ G_CALLBACK (midori_bookmarks_add_item_cb), bookmarks);
1943+ g_signal_connect (bookmarks->bookmarks_db, "remove-item",
1944 G_CALLBACK (midori_bookmarks_remove_item_cb), bookmarks);
1945- g_signal_connect (bookmarks->array, "update",
1946+ g_signal_connect (bookmarks->bookmarks_db, "update",
1947 G_CALLBACK (midori_bookmarks_update_cb), bookmarks);
1948 g_signal_connect_after (model, "row-changed",
1949 G_CALLBACK (midori_bookmarks_row_changed_cb),
1950@@ -835,7 +837,7 @@
1951 menu = gtk_menu_new ();
1952 if (KATZE_ITEM_IS_FOLDER (item))
1953 {
1954- gint child_bookmarks_count = midori_array_count_recursive (bookmarks->array,
1955+ gint child_bookmarks_count = midori_bookmarks_db_count_recursive (bookmarks->bookmarks_db,
1956 "uri <> ''", NULL, item, FALSE);
1957
1958 midori_bookmarks_popup_item (menu,
1959
1960=== modified file 'tests/bookmarks.c'
1961--- tests/bookmarks.c 2012-11-25 15:37:41 +0000
1962+++ tests/bookmarks.c 2013-09-17 21:28:04 +0000
1963@@ -10,11 +10,11 @@
1964 */
1965
1966 #include "midori.h"
1967-#include "panels/midori-bookmarks.h"
1968+#include "midori-bookmarks-db.h"
1969
1970 typedef struct
1971 {
1972- KatzeArray* db_bookmarks;
1973+ MidoriBookmarksDb* db_bookmarks;
1974 KatzeArray* test_bookmarks;
1975 } BookmarksFixture;
1976
1977@@ -37,7 +37,7 @@
1978 KatzeArray* folder;
1979 gchar *errmsg = NULL;
1980
1981- if (!(fixture->db_bookmarks = midori_bookmarks_new (&errmsg)))
1982+ if (!(fixture->db_bookmarks = midori_bookmarks_db_new (&errmsg)))
1983 g_error ("Bookmarks couldn't be loaded: %s\n", errmsg);
1984 g_assert (errmsg == NULL);
1985 g_assert (g_object_get_data (G_OBJECT (fixture->db_bookmarks), "db"));
1986@@ -84,8 +84,8 @@
1987 fixture_teardown (BookmarksFixture* fixture,
1988 const TestParameters *params)
1989 {
1990- midori_bookmarks_on_quit (fixture->db_bookmarks);
1991- g_object_unref (fixture->db_bookmarks);
1992+ midori_bookmarks_db_on_quit (fixture->db_bookmarks);
1993+ /* g_object_unref (fixture->db_bookmarks); */
1994 g_object_unref (fixture->test_bookmarks);
1995 }
1996
1997@@ -112,7 +112,7 @@
1998 /* NB: assumes "title" is unique in a set */
1999 static void
2000 compare_test_and_db (KatzeArray* test_bookmarks,
2001- KatzeArray* db_bookmarks,
2002+ MidoriBookmarksDb* db_bookmarks,
2003 gboolean verbose)
2004 {
2005 KatzeArray* db_items;
2006@@ -127,7 +127,7 @@
2007 g_print ("----------\n");
2008 }
2009
2010- db_items = midori_array_query_recursive (db_bookmarks,
2011+ db_items = midori_bookmarks_db_query_recursive (db_bookmarks,
2012 "*", "title='%q'", katze_item_get_name (test_item), FALSE);
2013
2014 /* FIXME g_assert_cmpint (katze_array_get_length (db_items), ==, 1); */
2015@@ -142,28 +142,33 @@
2016 }
2017
2018 static void
2019+print_bookmarks (KatzeArray* test_bookmarks)
2020+{
2021+ KatzeItem* item;
2022+ GList* list;
2023+ KATZE_ARRAY_FOREACH_ITEM_L (item, test_bookmarks, list)
2024+ {
2025+ print_bookmark (item);
2026+ g_print ("----------\n");
2027+
2028+ if (KATZE_ITEM_IS_FOLDER(item))
2029+ print_bookmarks (KATZE_ARRAY (item));
2030+ }
2031+ g_list_free (list);
2032+}
2033+
2034+static void
2035 insert_bookmarks (KatzeArray* test_bookmarks,
2036- KatzeArray* db_bookmarks,
2037+ MidoriBookmarksDb* db_bookmarks,
2038 gboolean verbose)
2039 {
2040- KatzeItem* item;
2041- GList* list;
2042- sqlite3 *db = g_object_get_data (G_OBJECT (db_bookmarks), "db");
2043
2044- KATZE_ARRAY_FOREACH_ITEM_L (item, test_bookmarks, list)
2045+ if (verbose)
2046 {
2047- if (verbose)
2048- {
2049- print_bookmark (item);
2050- g_print ("----------\n");
2051- }
2052-
2053- midori_bookmarks_insert_item_db (db, item, 0);
2054-
2055- if (KATZE_ITEM_IS_FOLDER(item))
2056- insert_bookmarks (KATZE_ARRAY (item), db_bookmarks, verbose);
2057+ print_bookmarks (test_bookmarks);
2058 }
2059- g_list_free (list);
2060+
2061+ midori_bookmarks_db_import_array (db_bookmarks, test_bookmarks, 0);
2062 }
2063
2064 static void

Subscribers

People subscribed via source and target branches

to all changes: