← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gq/trusty

« back to all changes in this revision

Viewing changes to src/gq-browser-node-server.c

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese
  • Date: 2009-10-25 23:34:56 UTC
  • mfrom: (1.1.4 upstream) (3.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20091025233456-i794n3yg2cff930j
Tags: 1.3.4-1
http://bugs.debian.org/534705
http://bugs.debian.org/444312
http://bugs.debian.org/449749
* QA upload.
  + Set maintainer to Debian QA Group <packages@qa.debian.org>.
* New upstream release. (Closes: #534705).
  + Does not segfault on amd64. (Closes: #444312).
  + Remove all existing patches and change patch system to quilt.
  + Replace dpatch build-dep with quilt.
* 01_desktop_file.diff - Remove encoding and bogus categories 
  from desktop file.
* Copy in config.{sub,guess} on configure, rm them on clean.
  + Add build-dep on autotools-dev.
* Make clean not ignore errors.
* Add copyright holders and version path to GPL (GPL-2).
* Update watch file to use SF redirector. (Closes: #449749).
* Bump debhelper build-dep and compat to 5.
* Bump Standards Version to 3.8.3.
  + Menu policy transition.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gq-browser-node-server.c
35
35
# include <config.h>
36
36
#endif /* HAVE_CONFIG_H */
37
37
 
 
38
#include "errorchain.h"
 
39
#include "gq-browser-model.h"
38
40
#include "gq-browser-node-dn.h"
 
41
#include "gq-export-dialog.h"
 
42
#include "gq-server-dn.h"
 
43
#include "gq-server-dialog.h"
39
44
#include "gq-tab-browse.h"
 
45
#include "gq-utilities.h"               /* get_suffixes */
40
46
#include "prefs.h"                      /* create_edit_server_window */
41
 
#include "util.h"                       /* get_suffixes */
42
 
 
43
 
#include "browse-export.h"
44
 
#include "errorchain.h"
45
47
 
46
48
#ifdef BROWSER_DND
47
49
#include "browse-dnd.h"
50
52
/*
51
53
 *  Really add a single suffix to the tree
52
54
 */
53
 
static void add_suffix(GqBrowserNodeServer *entry,
54
 
                       GQTreeWidget *ctreeroot, GQTreeWidgetNode *node,
55
 
                       char *suffix)
56
 
{
57
 
     GQTreeWidgetNode *new_item;
58
 
     GqBrowserNode *new_entry = gq_browser_node_dn_new(suffix);
59
 
 
60
 
     new_item = gq_tree_insert_node (ctreeroot,
61
 
                                     node, NULL,
62
 
                                     suffix,
63
 
                                     new_entry,
64
 
                                     g_object_unref);
65
 
 
66
 
     gq_tree_insert_dummy_node (ctreeroot,
67
 
                                new_item);
68
 
}
69
 
 
70
55
static void
71
 
server_browse_entry_destroy(GqBrowserNode *entry)
 
56
add_suffix(GqBrowserNodeServer* entry,
 
57
           GtkTreeModel       * model,
 
58
           GtkTreeIter        * iter,
 
59
           char               * suffix)
72
60
{
73
 
        GqBrowserNodeServer* self;
74
 
        g_return_if_fail(GQ_IS_BROWSER_NODE_SERVER(entry));
75
 
 
76
 
        self = GQ_BROWSER_NODE_SERVER(entry);
77
 
        g_object_unref(self->server);
78
 
        self->server = NULL;
79
 
 
80
 
        g_free(entry);
 
61
        GqServerDn      * server_entry = gq_server_dn_new(suffix, entry->server);
 
62
        GqBrowserNode   * new_entry = gq_browser_node_dn_new(server_entry);
 
63
        g_object_unref(server_entry);
 
64
        gq_browser_model_add_node(GQ_BROWSER_MODEL(model), iter, new_entry);
81
65
}
82
66
 
83
67
static void server_browse_entry_expand(GqBrowserNode *e,
84
68
                                       int error_context,
85
 
                                       GQTreeWidget *ctree, GQTreeWidgetNode *node,
86
 
                                       GqTab *tab)
 
69
#ifndef USE_TREE_VIEW
 
70
                                       GQTreeWidget *ctree,
 
71
                                       GQTreeWidgetNode *node,
 
72
                                       GqTab *tab
 
73
#else
 
74
                                       GtkTreeModel* model,
 
75
                                       GtkTreeIter* iter,
 
76
                                       gpointer dummy G_GNUC_UNUSED
 
77
#endif
 
78
                                       )
87
79
{
88
80
     GList *suffixes = NULL, *next;
89
81
     GqBrowserNodeServer *entry;
90
82
 
91
 
     g_assert(GQ_IS_BROWSER_NODE_SERVER(e));
 
83
     g_return_if_fail(GQ_IS_BROWSER_NODE_SERVER(e));
92
84
     entry = GQ_BROWSER_NODE_SERVER(e);
93
85
 
94
86
     if (!entry->once_expanded) {
95
87
/*        printf("expanding %s\n", entry->server->name); */
96
 
 
 
88
#ifndef USE_TREE_VIEW
97
89
          gq_tree_remove_children (ctree, node);
 
90
#endif
98
91
          entry->once_expanded = 1;
99
92
 
100
93
          suffixes = get_suffixes(error_context, entry->server);
101
 
 
 
94
#ifndef USE_TREE_VIEW
102
95
          gtk_clist_freeze(GTK_CLIST(ctree));
103
 
 
 
96
#endif
104
97
          for (next = suffixes ; next ; next = g_list_next(next) ) {
105
 
               add_suffix(entry, ctree, node, next->data);
 
98
               add_suffix(entry,
 
99
#ifndef USE_TREE_VIEW
 
100
                          ctree, node,
 
101
#else
 
102
                          model, iter,
 
103
#endif
 
104
                          next->data);
106
105
               g_free(next->data);
107
106
               next->data = NULL;
108
107
          }
109
 
 
 
108
#ifndef USE_TREE_VIEW
110
109
          gtk_clist_thaw(GTK_CLIST(ctree));
111
 
 
 
110
#endif
112
111
          g_list_free(suffixes);
113
112
     }
114
113
}
120
119
 */
121
120
static void server_browse_entry_selected(GqBrowserNode *be,
122
121
                                         int error_context,
 
122
#ifndef USE_TREE_VIEW
123
123
                                         GQTreeWidget *ctree,
124
124
                                         GQTreeWidgetNode *node,
 
125
#else
 
126
                                         GtkTreeModel* model,
 
127
                                         GtkTreeIter* iter,
 
128
#endif
125
129
                                         GqTab *tab)
126
130
{
127
 
     GtkWidget *pane2_scrwin, *pane2_vbox, *label, *e;
 
131
        GtkWidget *pane2_vbox, *label, *e;
128
132
     GtkWidget *table;
129
 
     char *server_name;
 
133
     gchar const*server_name;
130
134
     int row = 0;
131
135
     char buf[128];
132
136
     LDAP *ld;
138
142
     ld = open_connection(error_context, entry->server);
139
143
     if (!ld) return;
140
144
 
141
 
     server_name = entry->server->name; /* dn_by_node(node); */
142
 
     record_path(tab, GQ_BROWSER_NODE(entry), ctree, node);
143
 
 
144
 
     pane2_scrwin = GQ_TAB_BROWSE(tab)->pane2_scrwin;
145
 
     pane2_vbox = GQ_TAB_BROWSE(tab)->pane2_vbox;
146
 
 
147
 
     /*           gtk_widget_destroy(pane2_vbox); */
148
 
     /* remove the viewport of the scrolled window. This should
149
 
        _really_ destroy the widgets below it. The pane2_scrwin
150
 
        is a GtkBin Object and thus has only one child, use this
151
 
        to obtain the viewport */
152
 
 
153
 
     gtk_container_remove(GTK_CONTAINER(pane2_scrwin),
154
 
                          GTK_BIN(pane2_scrwin)->child);
 
145
     server_name = gq_server_get_name(entry->server); /* dn_by_node(node); */
 
146
     record_path(tab,
 
147
#ifndef USE_TREE_VIEW
 
148
                 ctree, node
 
149
#else
 
150
                 model, iter
 
151
#endif
 
152
                 );
155
153
 
156
154
     pane2_vbox = gtk_vbox_new(FALSE, 2);
157
 
     GQ_TAB_BROWSE(tab)->pane2_vbox = pane2_vbox;
158
155
 
159
156
     gtk_widget_show(pane2_vbox);
160
 
     gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pane2_scrwin),
161
 
                                           pane2_vbox);
 
157
        gq_tab_browse_set_content(GQ_TAB_BROWSE(tab), pane2_vbox);
162
158
 
163
159
     table = gtk_table_new(5, 2, FALSE);
164
160
     gtk_container_border_width(GTK_CONTAINER(table), 5);
198
194
                      0, 0);
199
195
 
200
196
     e = gtk_entry_new();
201
 
     gtk_entry_set_text(GTK_ENTRY(e), entry->server->ldaphost);
 
197
     gtk_entry_set_text(GTK_ENTRY(e), gq_server_get_host(entry->server));
202
198
     gtk_widget_set_sensitive(e, FALSE);
203
199
     gtk_widget_show(e);
204
200
     gtk_table_attach(GTK_TABLE(table),
219
215
                      GTK_EXPAND | GTK_SHRINK | GTK_FILL,
220
216
                      0, 0);
221
217
 
222
 
     g_snprintf(buf, sizeof(buf), "%d", entry->server->ldapport);
 
218
     g_snprintf(buf, sizeof(buf), "%d", gq_server_get_port(entry->server));
223
219
     e = gtk_entry_new();
224
220
     gtk_entry_set_text(GTK_ENTRY(e), buf);
225
221
     gtk_widget_set_sensitive(e, FALSE);
243
239
                      0, 0);
244
240
 
245
241
     g_snprintf(buf, sizeof(buf), "%s", 
246
 
              entry->server->cacheconn ? _("on") : _("off"));
 
242
              gq_server_get_cache_connection(entry->server) ? _("on") : _("off"));
247
243
     e = gtk_entry_new();
248
244
     gtk_entry_set_text(GTK_ENTRY(e), buf);
249
245
     gtk_widget_set_sensitive(e, FALSE);
268
264
                      0, 0);
269
265
 
270
266
     g_snprintf(buf, sizeof(buf), "%s", 
271
 
              entry->server->enabletls ? _("on") : _("off"));
 
267
                gq_server_get_use_tls(entry->server) ? _("on") : _("off"));
272
268
     e = gtk_entry_new();
273
269
     gtk_entry_set_text(GTK_ENTRY(e), buf);
274
270
     gtk_widget_set_sensitive(e, FALSE);
472
468
 
473
469
 
474
470
 
475
 
static void server_browse_entry_refresh(GqBrowserNode *e,
476
 
                                        int error_context,
477
 
                                        GQTreeWidget *ctree,
478
 
                                        GQTreeWidgetNode *node,
479
 
                                        GqTab *tab)
 
471
static void
 
472
server_browse_entry_refresh(GqBrowserNode   * e,
 
473
                            int               error_context,
 
474
                            GtkTreeModel    * model,
 
475
                            GtkTreeIter     * iter,
 
476
                            GqTab           * tab)
480
477
{
481
 
     GqBrowserNodeServer *entry;
 
478
        GqBrowserNodeServer *entry;
482
479
 
483
 
     g_assert(GQ_IS_BROWSER_NODE_SERVER(e));
484
 
     entry = GQ_BROWSER_NODE_SERVER(e);
 
480
        g_return_if_fail(GQ_IS_BROWSER_NODE_SERVER(e));
 
481
        entry = GQ_BROWSER_NODE_SERVER(e);
485
482
 
486
483
     entry->once_expanded = 0;
487
484
 
488
 
     gtk_clist_freeze(GTK_CLIST(ctree));
489
 
 
490
 
     server_browse_entry_selected(e, error_context, ctree, node, tab);
491
 
 
492
 
     gq_tree_fire_expand_callback (ctree, node);
493
 
 
 
485
        server_browse_entry_selected(e, error_context, model, iter, tab);
 
486
 
 
487
#warning "FIXME: enable the next line"
 
488
        //gq_tree_fire_expand_callback (ctree, node);
494
489
/*       server_browse_entry_expand(entry, ctree, node, tab); */
495
 
 
496
 
     gtk_clist_thaw(GTK_CLIST(ctree));
497
 
 
498
490
}
499
491
 
500
492
 
501
 
static char* server_browse_entry_get_name(GqBrowserNode *entry,
502
 
                                          gboolean long_form)
 
493
static char*
 
494
server_browse_entry_get_name(GqBrowserNode const* entry,
 
495
                             gboolean             long_form G_GNUC_UNUSED)
503
496
{
504
 
     g_assert(GQ_IS_BROWSER_NODE_SERVER(entry));
 
497
        g_return_val_if_fail(GQ_IS_BROWSER_NODE_SERVER(entry), NULL);
505
498
 
506
 
     return g_strdup(GQ_BROWSER_NODE_SERVER(entry)->server->name);
 
499
        return g_strdup(gq_server_get_name(GQ_BROWSER_NODE_SERVER(entry)->server));
507
500
}
508
501
 
509
502
struct edit_server_cb_data {
518
511
        g_free(cbd);
519
512
}
520
513
 
521
 
static void edit_server_activated(struct edit_server_cb_data *cbd)
 
514
static void
 
515
edit_server_activated(struct edit_server_cb_data *cbd)
522
516
{
523
 
     create_edit_server_window(cbd->server, cbd->tab->win->mainwin);
 
517
        GtkWidget* dialog = gq_server_dialog_new(cbd->server, GTK_WINDOW(cbd->tab->win->mainwin));
 
518
        gtk_dialog_run(GTK_DIALOG(dialog));
 
519
        gtk_widget_destroy(dialog);
524
520
}
525
521
 
526
 
static void dump_server(GtkWidget *widget, GqTab *tab)
 
522
static void
 
523
dump_server(GqTab* tab)
527
524
{
528
 
     GQTreeWidget *ctree;
529
 
     GQTreeWidgetNode *node;
 
525
        GtkTreeView* ctree;
530
526
     GqBrowserNode *e;
531
527
     GqServer *server;
532
528
     GList *bases = NULL;
533
529
     GList *to_export = NULL, *I;
534
 
     struct dn_on_server *dos;
 
530
     GqServerDn *dos;
535
531
     int error_context;
536
532
 
537
 
     ctree = GQ_TAB_BROWSE(tab)->ctreeroot;
538
 
     node = GQ_TAB_BROWSE(tab)->tree_row_popped_up;
539
 
     e = GQ_BROWSER_NODE(gq_tree_get_node_data (ctree, node));
 
533
        ctree = GTK_TREE_VIEW(GQ_TAB_BROWSE(tab)->ctreeroot);
 
534
        e = gq_browser_model_get_node(GQ_BROWSER_MODEL(gtk_tree_view_get_model(ctree)),
 
535
                                      &GQ_TAB_BROWSE(tab)->tree_row_popped_up);
540
536
 
541
537
     g_assert(GQ_IS_BROWSER_NODE_SERVER(e));
542
538
 
543
 
     server = server_from_node(ctree, node);
 
539
        server = gq_browser_node_get_server(e);
544
540
 
545
541
     if (e == NULL || server == NULL)
546
542
          return;
550
546
 
551
547
     bases = get_suffixes(error_context, GQ_BROWSER_NODE_SERVER(e)->server);
552
548
 
553
 
     /* turn suffixes list into a list of dn_on_server objects
 
549
     /* turn suffixes list into a list of GqServerDn objects
554
550
        (impedance match) */
555
551
     for (I = g_list_first(bases) ; I ; I = g_list_next(I) ) {
556
 
          dos = new_dn_on_server(I->data, server);
 
552
          dos = gq_server_dn_new(I->data, server);
557
553
          dos->flags = LDAP_SCOPE_SUBTREE; /* default is LDAP_SCOPE_BASE */
558
554
          to_export = g_list_append(to_export, dos);
559
555
          g_free(I->data);
561
557
     }
562
558
     g_list_free(bases);
563
559
 
564
 
     export_many(error_context, tab->win->mainwin, to_export);
 
560
     gq_export_server_dns(error_context, GTK_WINDOW(tab->win->mainwin), to_export);
565
561
 
566
562
     error_flush(error_context);
567
563
}
568
564
 
569
 
static void server_browse_entry_popup(GqBrowserNode *e,
570
 
                                      GtkWidget *menu,
571
 
                                      GQTreeWidget *ctreeroot,
572
 
                                      GQTreeWidgetNode *ctree_node,
573
 
                                      GqTab *tab)
 
565
static void
 
566
server_browse_entry_popup(GqBrowserNode * e,
 
567
                          GtkWidget     * menu,
 
568
                          GtkTreeView   * ctreeroot,
 
569
                          GtkTreeIter   * ctree_node,
 
570
                          GqTab         * tab)
574
571
{
 
572
        GtkTreeModel* model;
575
573
     GtkWidget *menu_item;
576
574
     GqServer *server;
577
575
     struct edit_server_cb_data *cbd;
580
578
     g_assert(GQ_IS_BROWSER_NODE_SERVER(e));
581
579
     entry = GQ_BROWSER_NODE_SERVER(e);
582
580
 
583
 
     server = server_from_node(ctreeroot, ctree_node);
 
581
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(ctreeroot));
 
582
        server = server_from_node(model, ctree_node);
584
583
 
585
584
     /* Edit Server settings */
586
585
     menu_item = gtk_menu_item_new_with_label(_("Edit Server"));
606
605
          gtk_widget_set_sensitive(menu_item, FALSE);
607
606
     }
608
607
 
609
 
     /* Export to LDIF */
610
 
     menu_item = gtk_menu_item_new_with_label(_("Export to LDIF"));
 
608
        /* Export to LDIF */
 
609
        menu_item = gtk_image_menu_item_new_with_label(_("Export to LDIF"));
 
610
        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),
 
611
                                      gtk_image_new_from_stock(GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU));
611
612
     gtk_menu_append(GTK_MENU(menu), menu_item);
612
 
     g_signal_connect(menu_item, "activate",
613
 
                        G_CALLBACK(dump_server),
614
 
                        tab);
 
613
        g_signal_connect_swapped(menu_item, "activate",
 
614
                                 G_CALLBACK(dump_server), tab);
615
615
     gtk_widget_show(menu_item);
616
616
 
617
617
     /* Close connection */
618
 
     menu_item = gtk_menu_item_new_with_label(_("Close Connection"));
 
618
     menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_DISCONNECT, NULL);
619
619
     gtk_menu_append(GTK_MENU(menu), menu_item);
620
 
     g_signal_connect(menu_item, "activate",
 
620
     g_signal_connect_swapped(menu_item, "activate",
621
621
                        G_CALLBACK(tree_row_close_connection),
622
622
                        tab);
623
623
     gtk_widget_show(menu_item);
624
624
 
625
 
     if (server == NULL) {
626
 
          gtk_widget_set_sensitive(menu_item, FALSE);
627
 
     }
 
625
        if(server == NULL || !gq_server_is_connected(server)) {
 
626
                gtk_widget_set_sensitive(menu_item, FALSE);
 
627
        }
628
628
}
629
629
 
630
630
GqBrowserNode*
642
642
};
643
643
 
644
644
static void
645
 
gq_browser_node_server_init(GqBrowserNodeServer* self) {}
 
645
gq_browser_node_server_init(GqBrowserNodeServer* self G_GNUC_UNUSED) {}
 
646
 
 
647
static void
 
648
browser_node_server_dispose(GObject* object)
 
649
{
 
650
        GqBrowserNodeServer* self = GQ_BROWSER_NODE_SERVER(object);
 
651
 
 
652
        if(self->server) {
 
653
                g_object_unref(self->server);
 
654
                self->server = NULL;
 
655
        }
 
656
 
 
657
        G_OBJECT_CLASS(gq_browser_node_server_parent_class)->finalize(object);
 
658
}
646
659
 
647
660
static void
648
661
server_node_get_property(GObject* object, guint pid, GValue* value, GParamSpec* pspec)
657
670
}
658
671
 
659
672
static void
 
673
browser_node_server_notify_connected(GqBrowserNodeServer* self)
 
674
{
 
675
        gq_browser_node_set_status(GQ_BROWSER_NODE(self),
 
676
                                   gq_server_is_connected(self->server) ? GTK_STOCK_CONNECT : GTK_STOCK_DISCONNECT);
 
677
}
 
678
 
 
679
static void
660
680
server_node_set_property(GObject* object, guint pid, GValue const* value, GParamSpec* pspec)
661
681
{
662
682
        GqBrowserNodeServer* self = GQ_BROWSER_NODE_SERVER(object);
664
684
        case PROP_SERVER:
665
685
                if(self->server != g_value_get_object(value)) {
666
686
                        if(self->server) {
 
687
                                g_signal_handlers_disconnect_by_func(self->server,
 
688
                                                                     browser_node_server_notify_connected,
 
689
                                                                     self);
667
690
                                g_object_unref(self->server);
668
691
                                self->server = NULL;
669
692
                        }
670
693
 
671
694
                        if(g_value_get_object(value)) {
672
695
                                self->server = g_object_ref(g_value_get_object(value));
 
696
                                g_signal_connect_swapped(self->server, "notify::connected",
 
697
                                                         G_CALLBACK(browser_node_server_notify_connected), self);
 
698
                                browser_node_server_notify_connected(self);
673
699
                        }
674
700
 
675
701
                        g_object_notify(object, "server");
692
718
        GObjectClass*     object_class = G_OBJECT_CLASS(self_class);
693
719
        GqBrowserNodeClass* node_class = GQ_BROWSER_NODE_CLASS(self_class);
694
720
 
 
721
        object_class->dispose      = browser_node_server_dispose;
695
722
        object_class->get_property = server_node_get_property;
696
723
        object_class->set_property = server_node_set_property;
697
724
        g_object_class_install_property(object_class,
702
729
                                                            GQ_TYPE_SERVER,
703
730
                                                            G_PARAM_READWRITE));
704
731
 
705
 
        node_class->destroy    = server_browse_entry_destroy;
706
732
        node_class->expand     = server_browse_entry_expand;
707
733
        node_class->select     = server_browse_entry_selected;
708
734
        node_class->refresh    = server_browse_entry_refresh;