← Back to branch summary

~maxolasersquad/ubuntu/precise/epiphany-browser/add_quicklist

« back to all changes in this revision

Viewing changes to .pc/81_ubuntu_force_update_bookmarks_menu.patch/src/bookmarks/ephy-bookmarks-ui.c

  • Committer: Bazaar Package Importer
  • Author(s): Artur Rona
  • Date: 2010-10-14 12:45:29 UTC
  • mfrom: (98.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20101014124529-57hi6lecoo68e3sq
Tags: 2.30.6-1ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Update the search URL:
    + add debian/patches/80_ubuntu_search_url.patch
    + update debian/epiphany-browser-data.gconf-defaults
  - Set branding to Ubuntu.
  - debian/patches/81_ubuntu_force_update_bookmarks_menu.patch:
    + Update the bookmarks menu every time the internal structure
      is changed (needed for the UNE application menu to work correctly).
  - Support appindicator.
  - debian/control.in:
    + Temporary bump for gir dependencies to ensure we rebuild against
      the correct version.
  - debian/patches/13_clearing_temp.patch:
    + Fix crashing epiphany-browser while clearing temp files.
      This patch can be dropped with new upstream 2.32 release.
* debian/control.in:
  - Bump Build-Depends on network-manager-dev to avoid FTBFS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/81_ubuntu_force_update_bookmarks_menu.patch/src/bookmarks/ephy-bookmarks-ui.c
 
1
/*
 
2
 *  Copyright © 2005 Peter Harvey
 
3
 *  Copyright © 2006 Christian Persch
 
4
 *
 
5
 *  This program is free software; you can redistribute it and/or modify
 
6
 *  it under the terms of the GNU General Public License as published by
 
7
 *  the Free Software Foundation; either version 2, or (at your option)
 
8
 *  any later version.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
18
 *
 
19
 */
 
20
 
 
21
#include "config.h"
 
22
 
 
23
#include "eel-gconf-extensions.h"
 
24
#include "ephy-bookmarks.h"
 
25
#include "ephy-bookmarks-ui.h"
 
26
#include "ephy-bookmarks-menu.h"
 
27
#include "ephy-bookmark-action.h"
 
28
#include "ephy-topic-action.h"
 
29
#include "ephy-bookmark-action-group.h"
 
30
#include "ephy-topic-action-group.h"
 
31
#include "ephy-related-action.h"
 
32
#include "ephy-open-tabs-action.h"
 
33
#include "ephy-topic-factory-action.h"
 
34
#include "ephy-bookmark-factory-action.h"
 
35
#include "ephy-bookmark-properties.h"
 
36
#include "ephy-node-common.h"
 
37
#include "ephy-link.h"
 
38
#include "ephy-dnd.h"
 
39
#include "ephy-history.h"
 
40
#include "ephy-shell.h"
 
41
#include "ephy-string.h"
 
42
#include "ephy-debug.h"
 
43
#include "ephy-file-helpers.h"
 
44
#include "ephy-gui.h"
 
45
#include "ephy-stock-icons.h"
 
46
#include "ephy-prefs.h"
 
47
#include "egg-editable-toolbar.h"
 
48
 
 
49
#include <string.h>
 
50
#include <glib/gi18n.h>
 
51
#include <gtk/gtk.h>
 
52
 
 
53
#define BM_WINDOW_DATA_KEY "bookmarks-window-data"
 
54
 
 
55
typedef struct
 
56
{
 
57
        guint bookmarks_menu;
 
58
        guint toolbar_menu;
 
59
} BookmarksWindowData;
 
60
 
 
61
enum
 
62
{
 
63
        RESPONSE_SHOW_PROPERTIES = 1,
 
64
        RESPONSE_NEW_BOOKMARK = 2
 
65
};
 
66
 
 
67
static GString * bookmarks_menu_string = 0;
 
68
static GHashTable *properties_dialogs = 0;
 
69
 
 
70
static GtkAction *
 
71
find_action (GtkUIManager *manager, const char *name)
 
72
{
 
73
        GList *l = gtk_ui_manager_get_action_groups (manager);
 
74
        GtkAction *action;
 
75
        
 
76
        while (l != NULL)
 
77
        {
 
78
                action = gtk_action_group_get_action (GTK_ACTION_GROUP (l->data), name);
 
79
                if (action) return action;
 
80
                l = l->next;
 
81
        }
 
82
 
 
83
        return NULL;
 
84
}
 
85
 
 
86
static void
 
87
activate_bookmarks_menu (GtkAction *action, EphyWindow *window)
 
88
{
 
89
        BookmarksWindowData *data = g_object_get_data (G_OBJECT (window), BM_WINDOW_DATA_KEY);
 
90
        if (data && !data->bookmarks_menu)
 
91
        {
 
92
                GtkUIManager *manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
 
93
                gtk_ui_manager_ensure_update (manager);
 
94
 
 
95
                if (!bookmarks_menu_string->len)
 
96
                {
 
97
                        g_string_append (bookmarks_menu_string,
 
98
                                         "<ui><menubar><menu name=\"BookmarksMenu\" action=\"Bookmarks\">");
 
99
                        ephy_bookmarks_menu_build (bookmarks_menu_string, 0);
 
100
                        g_string_append (bookmarks_menu_string, "</menu></menubar></ui>");
 
101
                }
 
102
 
 
103
                data->bookmarks_menu = gtk_ui_manager_add_ui_from_string
 
104
                  (manager, bookmarks_menu_string->str, bookmarks_menu_string->len, 0);
 
105
                
 
106
                gtk_ui_manager_ensure_update (manager);
 
107
        }
 
108
}
 
109
 
 
110
static void
 
111
activate_bookmark_properties (GtkAction *action,
 
112
                              EggEditableToolbar *etoolbar)
 
113
{
 
114
        GtkAction *baction;
 
115
        GtkWidget *widget;
 
116
 
 
117
        widget = gtk_widget_get_ancestor (egg_editable_toolbar_get_selected (etoolbar),
 
118
                                          GTK_TYPE_TOOL_ITEM);
 
119
        baction = widget ? gtk_activatable_get_related_action (GTK_ACTIVATABLE (widget)) : NULL;
 
120
        g_return_if_fail (EPHY_IS_BOOKMARK_ACTION (baction));
 
121
 
 
122
        ephy_bookmarks_ui_show_bookmark (ephy_bookmark_action_get_bookmark
 
123
                                                 (EPHY_BOOKMARK_ACTION (baction)));
 
124
}
 
125
 
 
126
static void
 
127
activate_bookmark_open_tab (GtkAction *action,
 
128
                            EggEditableToolbar *etoolbar)
 
129
{
 
130
        GtkAction *baction;
 
131
        GtkWidget *widget;
 
132
 
 
133
        widget = gtk_widget_get_ancestor (egg_editable_toolbar_get_selected (etoolbar),
 
134
                                          GTK_TYPE_TOOL_ITEM);
 
135
        baction = widget ? gtk_activatable_get_related_action (GTK_ACTIVATABLE (widget)) : NULL;
 
136
        g_return_if_fail (EPHY_IS_BOOKMARK_ACTION (baction));
 
137
 
 
138
        ephy_bookmark_action_activate (EPHY_BOOKMARK_ACTION (baction), widget,
 
139
                                       EPHY_LINK_NEW_TAB);
 
140
}
 
141
 
 
142
static void
 
143
activate_bookmark_open_window (GtkAction *action,
 
144
                               EggEditableToolbar *etoolbar)
 
145
{
 
146
        GtkAction *baction;
 
147
        GtkWidget *widget;
 
148
 
 
149
        widget = gtk_widget_get_ancestor (egg_editable_toolbar_get_selected (etoolbar),
 
150
                                          GTK_TYPE_TOOL_ITEM);
 
151
        baction = widget ? gtk_activatable_get_related_action (GTK_ACTIVATABLE (widget)) : NULL;
 
152
        g_return_if_fail (EPHY_IS_BOOKMARK_ACTION (baction));
 
153
 
 
154
        ephy_bookmark_action_activate (EPHY_BOOKMARK_ACTION (baction), widget,
 
155
                                       EPHY_LINK_NEW_WINDOW);
 
156
}
 
157
 
 
158
static void
 
159
selected_bookmark_action (EggEditableToolbar *etoolbar,
 
160
                          GParamSpec *pspec,
 
161
                          GtkAction *action)
 
162
{
 
163
        GtkAction *baction;
 
164
        GtkWidget *widget;
 
165
        gboolean visible;
 
166
        
 
167
        visible = FALSE;
 
168
        
 
169
        if (!egg_editable_toolbar_get_edit_mode (etoolbar))
 
170
        {
 
171
                widget = egg_editable_toolbar_get_selected (etoolbar);
 
172
                widget = widget ? gtk_widget_get_ancestor (widget, GTK_TYPE_TOOL_ITEM) : NULL;
 
173
                baction = widget ? gtk_activatable_get_related_action (GTK_ACTIVATABLE (widget)) : NULL;
 
174
                visible = EPHY_IS_BOOKMARK_ACTION (baction);
 
175
        }
 
176
          
 
177
        gtk_action_set_visible (action, visible);
 
178
}
 
179
 
 
180
static void
 
181
erase_bookmarks_menu (EphyWindow *window)
 
182
{
 
183
        BookmarksWindowData *data;
 
184
        GtkUIManager *manager;
 
185
 
 
186
        manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
 
187
        data = g_object_get_data (G_OBJECT (window), BM_WINDOW_DATA_KEY);
 
188
 
 
189
        if (data != NULL && data->bookmarks_menu != 0)
 
190
        {
 
191
                gtk_ui_manager_remove_ui (manager, data->bookmarks_menu);
 
192
                data->bookmarks_menu = 0;
 
193
        }
 
194
 
 
195
        g_string_truncate (bookmarks_menu_string, 0);
 
196
}
 
197
 
 
198
static void
 
199
tree_changed_cb (EphyBookmarks *bookmarks,
 
200
                 EphyWindow *window)
 
201
{
 
202
        erase_bookmarks_menu (window);
 
203
}
 
204
 
 
205
static void
 
206
node_added_cb (EphyNode *parent,
 
207
               EphyNode *child,
 
208
               EphyWindow *window)
 
209
{
 
210
        erase_bookmarks_menu (window);
 
211
}
 
212
 
 
213
static void
 
214
node_changed_cb (EphyNode *parent,
 
215
                 EphyNode *child,
 
216
                 guint property_id,
 
217
                 EphyWindow *window)
 
218
{
 
219
        if (property_id == EPHY_NODE_KEYWORD_PROP_NAME ||
 
220
            property_id == EPHY_NODE_BMK_PROP_TITLE)
 
221
        {
 
222
                erase_bookmarks_menu (window);
 
223
        }
 
224
}
 
225
 
 
226
static void
 
227
node_removed_cb (EphyNode *parent,
 
228
                 EphyNode *child,
 
229
                 guint index,
 
230
                 EphyWindow *window)
 
231
{
 
232
        erase_bookmarks_menu (window);
 
233
}
 
234
 
 
235
void
 
236
ephy_bookmarks_ui_attach_window (EphyWindow *window)
 
237
{
 
238
        EphyBookmarks *eb;
 
239
        EphyNode *bookmarks;
 
240
        EphyNode *topics;
 
241
        BookmarksWindowData *data;
 
242
        GtkUIManager *manager;
 
243
        EggEditableToolbar *etoolbar;
 
244
        GtkActionGroup *actions;
 
245
        GtkAction *action;
 
246
 
 
247
        eb = ephy_shell_get_bookmarks (ephy_shell);
 
248
        bookmarks = ephy_bookmarks_get_bookmarks (eb);
 
249
        topics = ephy_bookmarks_get_keywords (eb);
 
250
        data = g_object_get_data (G_OBJECT (window), BM_WINDOW_DATA_KEY);
 
251
        g_return_if_fail (data == NULL);
 
252
 
 
253
        manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
 
254
        etoolbar = EGG_EDITABLE_TOOLBAR (ephy_window_get_toolbar (window));
 
255
 
 
256
        data = g_new0 (BookmarksWindowData, 1);
 
257
        g_object_set_data_full (G_OBJECT (window), BM_WINDOW_DATA_KEY, data, g_free);
 
258
 
 
259
        /* Create the self-maintaining action groups for bookmarks and topics */
 
260
        actions = ephy_bookmark_group_new (bookmarks);
 
261
        gtk_ui_manager_insert_action_group (manager, actions, -1);
 
262
        g_signal_connect_object (actions, "open-link",
 
263
                                 G_CALLBACK (ephy_link_open), G_OBJECT (window),
 
264
                                 G_CONNECT_SWAPPED | G_CONNECT_AFTER);
 
265
        g_object_unref (actions);
 
266
        
 
267
        actions = ephy_topic_action_group_new (topics, manager);
 
268
        gtk_ui_manager_insert_action_group (manager, actions, -1);
 
269
        g_object_unref (actions);
 
270
 
 
271
        actions = ephy_open_tabs_group_new (topics);
 
272
        gtk_ui_manager_insert_action_group (manager, actions, -1);
 
273
        g_signal_connect_object (actions, "open-link",
 
274
                                 G_CALLBACK (ephy_link_open), G_OBJECT (window),
 
275
                                 G_CONNECT_SWAPPED | G_CONNECT_AFTER);
 
276
        g_object_unref (actions);
 
277
        
 
278
        /* Create and add an action group specifically foor bookmarks on the toolbar */
 
279
        actions = gtk_action_group_new ("BookmarkToolbarActions");
 
280
        gtk_ui_manager_insert_action_group (manager, actions, 0);       
 
281
        g_object_unref (actions);
 
282
 
 
283
        /* Add factory actions */
 
284
        action = ephy_topic_factory_action_new ("AddTopicToToolbar");
 
285
        gtk_action_group_add_action (actions, action);
 
286
        g_object_unref (action);
 
287
        
 
288
        action = ephy_bookmark_factory_action_new ("AddBookmarkToToolbar");
 
289
        gtk_action_group_add_action (actions, action);
 
290
        g_object_unref (action);
 
291
 
 
292
        /* Add the dynamic 'related topic' action */
 
293
        action = ephy_related_action_new (EPHY_LINK (window), manager, "RelatedTopic");
 
294
        gtk_action_group_add_action (actions, action);
 
295
        g_object_unref (action);
 
296
 
 
297
        /* Add popup menu actions that are specific to the bookmark widgets */
 
298
        action = gtk_action_new ("ToolbarBookmarkProperties", _("_Properties"), 
 
299
                                 _("Show properties for this bookmark"), GTK_STOCK_PROPERTIES);
 
300
        g_signal_connect_object (action, "activate",
 
301
                                 G_CALLBACK (activate_bookmark_properties), 
 
302
                                 G_OBJECT (etoolbar), 0);
 
303
        g_signal_connect_object (etoolbar, "notify::selected",
 
304
                                 G_CALLBACK (selected_bookmark_action),
 
305
                                 G_OBJECT (action), 0);
 
306
        gtk_action_group_add_action (actions, action);
 
307
        g_object_unref (action);
 
308
 
 
309
        /* FIXME ngettext */
 
310
        action = gtk_action_new ("ToolbarBookmarkOpenInTab", _("Open in New _Tab"),
 
311
                                 _("Open this bookmark in a new tab"), STOCK_NEW_TAB);
 
312
        g_signal_connect_object (action, "activate",
 
313
                                 G_CALLBACK (activate_bookmark_open_tab), 
 
314
                                 G_OBJECT (etoolbar), 0);
 
315
        g_signal_connect_object (etoolbar, "notify::selected",
 
316
                                 G_CALLBACK (selected_bookmark_action),
 
317
                                 G_OBJECT (action), 0);
 
318
        gtk_action_group_add_action (actions, action);
 
319
        g_object_unref (action);
 
320
 
 
321
        /* FIXME ngettext */
 
322
        action = gtk_action_new ("ToolbarBookmarkOpenInWindow", _("Open in New _Window"), 
 
323
                                 _("Open this bookmark in a new window"), GTK_STOCK_NEW);
 
324
        g_signal_connect_object (action, "activate",
 
325
                                 G_CALLBACK (activate_bookmark_open_window),
 
326
                                 G_OBJECT (etoolbar), 0);
 
327
        g_signal_connect_object (etoolbar, "notify::selected",
 
328
                                 G_CALLBACK (selected_bookmark_action),
 
329
                                 G_OBJECT (action), 0);
 
330
        gtk_action_group_add_action (actions, action);
 
331
        g_object_unref (action);
 
332
 
 
333
        data->toolbar_menu = gtk_ui_manager_add_ui_from_string (manager,
 
334
           "<popup name=\"ToolbarPopup\">"
 
335
           "<placeholder name=\"SpecificItemsGroup\">"
 
336
           "<menuitem action=\"ToolbarBookmarkOpenInTab\"/>"
 
337
           "<menuitem action=\"ToolbarBookmarkOpenInWindow\"/>"
 
338
           "<menuitem action=\"ToolbarBookmarkProperties\"/>"
 
339
           "</placeholder>"
 
340
           "</popup>", -1, NULL);  
 
341
 
 
342
        /* Add signal handlers for the bookmark database */
 
343
        ephy_node_signal_connect_object (bookmarks, EPHY_NODE_CHILD_ADDED,
 
344
                                         (EphyNodeCallback)node_added_cb,
 
345
                                         G_OBJECT (window));
 
346
        ephy_node_signal_connect_object (topics, EPHY_NODE_CHILD_ADDED,
 
347
                                         (EphyNodeCallback)node_added_cb,
 
348
                                         G_OBJECT (window));
 
349
 
 
350
        ephy_node_signal_connect_object (bookmarks, EPHY_NODE_CHILD_REMOVED,
 
351
                                         (EphyNodeCallback)node_removed_cb,
 
352
                                         G_OBJECT (window));
 
353
        ephy_node_signal_connect_object (topics, EPHY_NODE_CHILD_REMOVED,
 
354
                                         (EphyNodeCallback)node_removed_cb,
 
355
                                         G_OBJECT (window));
 
356
 
 
357
        ephy_node_signal_connect_object (bookmarks, EPHY_NODE_CHILD_CHANGED,
 
358
                                         (EphyNodeCallback)node_changed_cb,
 
359
                                         G_OBJECT (window));        
 
360
        ephy_node_signal_connect_object (topics, EPHY_NODE_CHILD_CHANGED,
 
361
                                         (EphyNodeCallback)node_changed_cb,
 
362
                                         G_OBJECT (window));
 
363
 
 
364
        g_signal_connect_object (eb, "tree_changed",
 
365
                                 G_CALLBACK (tree_changed_cb),
 
366
                                 G_OBJECT (window), 0);
 
367
 
 
368
        /* Setup empty menu strings and add signal handlers to build the menus on demand */
 
369
        if (!bookmarks_menu_string) bookmarks_menu_string = g_string_new ("");
 
370
        action = find_action (manager, "Bookmarks");
 
371
        g_signal_connect_object (action, "activate",
 
372
                                 G_CALLBACK (activate_bookmarks_menu),
 
373
                                 G_OBJECT (window), 0);
 
374
}
 
375
 
 
376
void
 
377
ephy_bookmarks_ui_detach_window (EphyWindow *window)
 
378
{
 
379
        EphyBookmarks *eb = ephy_shell_get_bookmarks (ephy_shell);
 
380
        EphyNode *bookmarks = ephy_bookmarks_get_bookmarks (eb);
 
381
        EphyNode *topics = ephy_bookmarks_get_keywords (eb);
 
382
 
 
383
        BookmarksWindowData *data = g_object_get_data (G_OBJECT (window), BM_WINDOW_DATA_KEY);
 
384
        GtkUIManager *manager = GTK_UI_MANAGER (ephy_window_get_ui_manager (window));
 
385
        GtkAction *action;
 
386
 
 
387
        g_return_if_fail (data != 0);
 
388
        if (data->bookmarks_menu) gtk_ui_manager_remove_ui (manager, data->bookmarks_menu);
 
389
        if (data->toolbar_menu) gtk_ui_manager_remove_ui (manager, data->toolbar_menu);
 
390
        g_object_set_data (G_OBJECT (window), BM_WINDOW_DATA_KEY, 0);
 
391
        
 
392
        ephy_node_signal_disconnect_object (bookmarks, EPHY_NODE_CHILD_ADDED,
 
393
                                            (EphyNodeCallback)node_added_cb,
 
394
                                            G_OBJECT (window));
 
395
        ephy_node_signal_disconnect_object (topics, EPHY_NODE_CHILD_ADDED,
 
396
                                            (EphyNodeCallback)node_added_cb,
 
397
                                            G_OBJECT (window));
 
398
        
 
399
        ephy_node_signal_disconnect_object (bookmarks, EPHY_NODE_CHILD_REMOVED,
 
400
                                            (EphyNodeCallback)node_removed_cb,
 
401
                                            G_OBJECT (window));
 
402
        ephy_node_signal_disconnect_object (topics, EPHY_NODE_CHILD_REMOVED,
 
403
                                            (EphyNodeCallback)node_removed_cb,
 
404
                                            G_OBJECT (window));
 
405
        
 
406
        ephy_node_signal_disconnect_object (bookmarks, EPHY_NODE_CHILD_CHANGED,
 
407
                                            (EphyNodeCallback)node_changed_cb,
 
408
                                            G_OBJECT (window));        
 
409
        ephy_node_signal_disconnect_object (topics, EPHY_NODE_CHILD_CHANGED,
 
410
                                            (EphyNodeCallback)node_changed_cb,
 
411
                                            G_OBJECT (window));
 
412
        
 
413
        g_signal_handlers_disconnect_by_func
 
414
          (G_OBJECT (eb), G_CALLBACK (tree_changed_cb), G_OBJECT (window));
 
415
        
 
416
        action = find_action (manager, "Bookmarks");
 
417
        g_signal_handlers_disconnect_by_func
 
418
          (G_OBJECT (action), G_CALLBACK (activate_bookmarks_menu), G_OBJECT (window));
 
419
}
 
420
 
 
421
static void
 
422
properties_dialog_destroy_cb (EphyBookmarkProperties *dialog,
 
423
                              EphyNode *bookmark)
 
424
{
 
425
        g_hash_table_remove (properties_dialogs, bookmark);
 
426
}
 
427
 
 
428
void
 
429
ephy_bookmarks_ui_add_bookmark (GtkWindow *parent,
 
430
                                const char *location, 
 
431
                                const char *title)
 
432
{
 
433
        EphyBookmarks *bookmarks;
 
434
        EphyNode *bookmark;
 
435
        GtkWidget *dialog;
 
436
 
 
437
        if (eel_gconf_get_boolean (CONF_LOCKDOWN_DISABLE_BOOKMARK_EDITING)) return;
 
438
        
 
439
        bookmarks = ephy_shell_get_bookmarks (ephy_shell_get_default ());
 
440
        bookmark = ephy_bookmarks_add (bookmarks, title, location);
 
441
        
 
442
        if (properties_dialogs == 0)
 
443
        {
 
444
                properties_dialogs = g_hash_table_new (g_direct_hash, g_direct_equal);
 
445
        }
 
446
        
 
447
        dialog = ephy_bookmark_properties_new (bookmarks, bookmark, TRUE);
 
448
 
 
449
        g_assert (parent != NULL);
 
450
 
 
451
        gtk_window_group_add_window (ephy_gui_ensure_window_group (parent),
 
452
                                     GTK_WINDOW (dialog));
 
453
        gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
 
454
 
 
455
        g_signal_connect (dialog, "destroy",
 
456
                          G_CALLBACK (properties_dialog_destroy_cb), bookmark);
 
457
        g_hash_table_insert (properties_dialogs,
 
458
                             bookmark, dialog);
 
459
        
 
460
        gtk_window_present_with_time (GTK_WINDOW (dialog),
 
461
                                      gtk_get_current_event_time ());
 
462
}
 
463
 
 
464
void
 
465
ephy_bookmarks_ui_show_bookmark (EphyNode *bookmark)
 
466
{
 
467
        EphyBookmarks *bookmarks;
 
468
        GtkWidget *dialog;
 
469
 
 
470
        bookmarks = ephy_shell_get_bookmarks (ephy_shell_get_default ());
 
471
 
 
472
        g_return_if_fail (EPHY_IS_BOOKMARKS (bookmarks));
 
473
        g_return_if_fail (EPHY_IS_NODE (bookmark));
 
474
 
 
475
        if (properties_dialogs == 0)
 
476
        {
 
477
                properties_dialogs = g_hash_table_new (g_direct_hash, g_direct_equal);
 
478
        }
 
479
        
 
480
        dialog = g_hash_table_lookup (properties_dialogs, bookmark);
 
481
 
 
482
        if (dialog == NULL)
 
483
        {
 
484
                dialog = ephy_bookmark_properties_new (bookmarks, bookmark, FALSE);
 
485
                
 
486
                g_signal_connect (dialog, "destroy",
 
487
                                  G_CALLBACK (properties_dialog_destroy_cb), bookmark);
 
488
                g_hash_table_insert (properties_dialogs,
 
489
                                     bookmark, dialog);
 
490
        }
 
491
 
 
492
        gtk_window_present_with_time (GTK_WINDOW (dialog),
 
493
                                      gtk_get_current_event_time ());
 
494
}
 
495
 
 
496
/* Below this line we have functions relating to toolbar code */
 
497
 
 
498
static EggToolbarsItemType bookmark_type;
 
499
static EggToolbarsItemType topic_type;
 
500
static EphyBookmarks *eb;
 
501
 
 
502
static gboolean
 
503
topic_has_data (EggToolbarsItemType *type,
 
504
                const char *name)
 
505
{
 
506
        EphyNode *node, *topics;
 
507
        guint node_id;
 
508
        
 
509
        if (sscanf (name, EPHY_TOPIC_ACTION_NAME_FORMAT, &node_id) != 1) return FALSE;
 
510
 
 
511
        node = ephy_bookmarks_get_from_id (eb, node_id);
 
512
        if (node == NULL) return FALSE;
 
513
 
 
514
        topics = ephy_bookmarks_get_keywords (eb);
 
515
 
 
516
        return ephy_node_has_child (topics, node);
 
517
}
 
518
 
 
519
static char *
 
520
topic_get_data (EggToolbarsItemType *type,
 
521
                const char *name)
 
522
{
 
523
        EphyNode *node;
 
524
        guint node_id;
 
525
        
 
526
        if (sscanf (name, EPHY_TOPIC_ACTION_NAME_FORMAT, &node_id) != 1) return NULL;
 
527
 
 
528
        node = ephy_bookmarks_get_from_id (eb, node_id);
 
529
        g_return_val_if_fail (node != NULL, NULL);
 
530
 
 
531
        return ephy_bookmarks_get_topic_uri (eb, node);
 
532
}
 
533
 
 
534
static char *
 
535
topic_get_name (EggToolbarsItemType *type,
 
536
                const char *data)
 
537
{
 
538
        EphyNode *topic;
 
539
 
 
540
        topic = ephy_bookmarks_find_keyword (eb, data, FALSE);
 
541
        if (topic == NULL) return NULL;
 
542
 
 
543
        return EPHY_TOPIC_ACTION_NAME_STRDUP_PRINTF (topic);
 
544
}
 
545
 
 
546
static gboolean
 
547
bookmark_has_data (EggToolbarsItemType *type,
 
548
                   const char *name)
 
549
{
 
550
        EphyNode *node;
 
551
        guint node_id;
 
552
 
 
553
        if (sscanf (name, EPHY_BOOKMARK_ACTION_NAME_FORMAT, &node_id) != 1) return FALSE;
 
554
 
 
555
        node = ephy_bookmarks_get_from_id (eb, node_id);
 
556
        if (node == NULL) return FALSE;
 
557
 
 
558
        return (ephy_node_get_property_string (node, EPHY_NODE_BMK_PROP_LOCATION) != NULL);
 
559
}
 
560
 
 
561
static char *
 
562
bookmark_get_data (EggToolbarsItemType *type,
 
563
                   const char *name)
 
564
{
 
565
        EphyNode *node;
 
566
        guint node_id;
 
567
 
 
568
        if (sscanf (name, EPHY_BOOKMARK_ACTION_NAME_FORMAT, &node_id) != 1) return NULL;
 
569
 
 
570
        node = ephy_bookmarks_get_from_id (eb, node_id);
 
571
        g_return_val_if_fail (node != NULL, NULL);
 
572
 
 
573
        return g_strdup (ephy_node_get_property_string (node, EPHY_NODE_BMK_PROP_LOCATION));
 
574
}
 
575
 
 
576
static char *
 
577
bookmark_get_name (EggToolbarsItemType *type,
 
578
                   const char *data)
 
579
{
 
580
        EphyNode *node;
 
581
        gchar **netscape_url;
 
582
 
 
583
        netscape_url = g_strsplit (data, "\n", 2);
 
584
        if (netscape_url == NULL || netscape_url[0] == '\0')
 
585
        {
 
586
                g_strfreev (netscape_url);
 
587
 
 
588
                return NULL;
 
589
        }
 
590
 
 
591
        node = ephy_bookmarks_find_bookmark (eb, netscape_url[0]);
 
592
        g_strfreev (netscape_url);
 
593
 
 
594
        if (node == NULL) return NULL;
 
595
 
 
596
        return EPHY_BOOKMARK_ACTION_NAME_STRDUP_PRINTF (node);
 
597
}
 
598
 
 
599
static char *
 
600
bookmark_new_name (EggToolbarsItemType *type,
 
601
                   const char *data)
 
602
{
 
603
        EphyNode *node;
 
604
        gchar **netscape_url;
 
605
 
 
606
        netscape_url = g_strsplit (data, "\n", 2);
 
607
        if (netscape_url == NULL || netscape_url[0] == '\0' || g_strv_length (netscape_url) < 2)
 
608
        {
 
609
                g_strfreev (netscape_url);
 
610
 
 
611
                return NULL;
 
612
        }
 
613
 
 
614
        node = ephy_bookmarks_add (eb, netscape_url[1], netscape_url[0]);
 
615
        g_strfreev (netscape_url);
 
616
 
 
617
        return EPHY_BOOKMARK_ACTION_NAME_STRDUP_PRINTF (node);
 
618
}
 
619
 
 
620
static void
 
621
toolbar_node_removed_cb (EphyNode *parent,
 
622
                         EphyNode *child,
 
623
                         guint index,
 
624
                         EggToolbarsModel *model)
 
625
{
 
626
        char name[EPHY_BOOKMARKS_UI_ACTION_NAME_BUFFER_SIZE];
 
627
        
 
628
        switch (ephy_node_get_id (parent))
 
629
        {
 
630
                case BOOKMARKS_NODE_ID:
 
631
                        EPHY_BOOKMARK_ACTION_NAME_PRINTF (name, child);
 
632
                        break;
 
633
                case KEYWORDS_NODE_ID:
 
634
                        EPHY_TOPIC_ACTION_NAME_PRINTF (name, child);
 
635
                        break;
 
636
                default:
 
637
                        return;
 
638
        }
 
639
 
 
640
        egg_toolbars_model_delete_item (model, name);
 
641
}
 
642
 
 
643
void
 
644
ephy_bookmarks_ui_attach_toolbar_model (EggToolbarsModel *model)
 
645
{
 
646
        EphyNode *bookmarks;
 
647
        EphyNode *topics;
 
648
        GList *types;
 
649
 
 
650
        eb = ephy_shell_get_bookmarks (ephy_shell);        
 
651
        bookmarks = ephy_bookmarks_get_bookmarks (eb);
 
652
        topics = ephy_bookmarks_get_keywords (eb);
 
653
        types = egg_toolbars_model_get_types (model);
 
654
 
 
655
        topic_type.type = gdk_atom_intern (EPHY_DND_TOPIC_TYPE, TRUE);
 
656
        topic_type.has_data = topic_has_data;
 
657
        topic_type.get_data = topic_get_data;
 
658
        topic_type.new_name = NULL;
 
659
        topic_type.get_name = topic_get_name;
 
660
 
 
661
        bookmark_type.type = gdk_atom_intern (EPHY_DND_URL_TYPE, TRUE);
 
662
        bookmark_type.has_data = bookmark_has_data;
 
663
        bookmark_type.get_data = bookmark_get_data;
 
664
        bookmark_type.new_name = bookmark_new_name;
 
665
        bookmark_type.get_name = bookmark_get_name;
 
666
 
 
667
        types = g_list_prepend (types, &bookmark_type);
 
668
        types = g_list_prepend (types, &topic_type);
 
669
        egg_toolbars_model_set_types (model, types);
 
670
 
 
671
        ephy_node_signal_connect_object (bookmarks, EPHY_NODE_CHILD_REMOVED,
 
672
                                         (EphyNodeCallback)toolbar_node_removed_cb,
 
673
                                         G_OBJECT (model));
 
674
        ephy_node_signal_connect_object (topics, EPHY_NODE_CHILD_REMOVED,
 
675
                                         (EphyNodeCallback)toolbar_node_removed_cb,
 
676
                                         G_OBJECT (model));
 
677
 
 
678
        egg_toolbars_model_set_name_flags (model, "AddTopicToToolbar", 
 
679
                                           EGG_TB_MODEL_NAME_KNOWN |
 
680
                                           EGG_TB_MODEL_NAME_INFINITE);
 
681
        egg_toolbars_model_set_name_flags (model, "AddBookmarkToToolbar", 
 
682
                                           EGG_TB_MODEL_NAME_KNOWN |
 
683
                                           EGG_TB_MODEL_NAME_INFINITE);
 
684
        egg_toolbars_model_set_name_flags (model, "RelatedTopic", 
 
685
                                           EGG_TB_MODEL_NAME_KNOWN);
 
686
}
 
687
 
 
688
 
 
689
void
 
690
ephy_bookmarks_ui_detach_toolbar_model (EggToolbarsModel *model)
 
691
{
 
692
        EphyBookmarks *eb = ephy_shell_get_bookmarks (ephy_shell);        
 
693
        EphyNode *bookmarks = ephy_bookmarks_get_bookmarks (eb);
 
694
        EphyNode *topics = ephy_bookmarks_get_keywords (eb);
 
695
        
 
696
        ephy_node_signal_disconnect_object (bookmarks, EPHY_NODE_CHILD_REMOVED,
 
697
                                            (EphyNodeCallback)toolbar_node_removed_cb,
 
698
                                            G_OBJECT (model));
 
699
        ephy_node_signal_disconnect_object (topics, EPHY_NODE_CHILD_REMOVED,
 
700
                                            (EphyNodeCallback)toolbar_node_removed_cb,
 
701
                                            G_OBJECT (model));
 
702
}