← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gq-tab-browse.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-tab-browse.c
2
2
    GQ -- a GTK-based LDAP client
3
3
    Copyright (C) 1998-2003 Bert Vermeulen
4
4
    Copyright (C) 2002-2003 Peter Stamfest
 
5
    Copyright (C) 2006,2007 Sven Herzberg
5
6
 
6
7
    This program is released under the Gnu General Public License with
7
8
    the additional exemption that compiling, linking, and/or using
27
28
#include <glib.h>
28
29
#include <glib/gi18n.h>
29
30
#include <gtk/gtk.h>
30
 
#include <gdk/gdkkeysyms.h>
31
31
 
32
32
#include <errno.h>
33
33
#include <string.h>
38
38
 
39
39
#include "common.h"
40
40
#include "configfile.h"
41
 
 
 
41
#include "debug.h"
 
42
#include "encode.h"
 
43
#include "errorchain.h"
 
44
#ifdef USE_TREE_VIEW
 
45
#include "gq-browser-model.h"
 
46
#endif
42
47
#include "gq-browser-node-dn.h"
43
48
#include "gq-browser-node-server.h"
44
49
#include "gq-browser-node-reference.h"
 
50
#include "gq-diff-tab.h"
 
51
#include "gq-input-form.h"
45
52
#include "gq-server-list.h"
46
 
 
47
 
#include "mainwin.h"
48
 
#include "template.h"
49
 
#include "util.h"
50
 
#include "tinput.h"
51
 
#include "errorchain.h"
 
53
#include "gq-tree-view.h"
 
54
#include "gq-utilities.h"
 
55
#include "gq-window.h"
 
56
#include "ldapops.h"
52
57
#include "ldif.h"
53
 
#include "formfill.h"
54
 
#include "encode.h"
55
 
#include "input.h"
56
 
#include "debug.h"
57
 
#include "ldapops.h"
 
58
#include "prefs.h"
 
59
#include "progress.h"
58
60
#include "search.h"
59
61
#include "state.h"
60
 
#include "progress.h"
61
 
#include "prefs.h"
 
62
#include "template.h"
62
63
 
63
64
#ifdef BROWSER_DND
64
65
#include "browse-dnd.h"
65
66
#endif
66
67
 
67
 
static gboolean button_press_on_tree_item(GtkWidget *tree,
68
 
                                          GdkEventButton *event,
69
 
                                          GqTab *tab);
70
 
 
71
 
 
72
 
static void tree_row_refresh(GtkMenuItem *menuitem, GqTab *tab);
73
 
 
74
 
void record_path(GqTab *tab, GqBrowserNode *entry,
75
 
                 GQTreeWidget *ctreeroot, GQTreeWidgetNode *node)
76
 
{
77
 
     GQTreeWidgetRow *row;
 
68
struct GqTabBrowsePrivate {
 
69
        GqInputForm* input_form;
 
70
#warning "FIXME: get rid of this scrolled window"
 
71
        GtkWidget  * pane2_scrwin;
 
72
        GtkWidget  * content;
 
73
};
 
74
#define P(i) (G_TYPE_INSTANCE_GET_PRIVATE((i), GQ_TYPE_TAB_BROWSE, struct GqTabBrowsePrivate))
 
75
 
 
76
static void tree_row_refresh(GqTab *tab);
 
77
 
 
78
void
 
79
gq_tab_browse_set_content(GqTabBrowse* self,
 
80
                          GtkWidget  * content)
 
81
{
 
82
        g_return_if_fail(GQ_IS_TAB_BROWSE(self));
 
83
        g_return_if_fail(!content || GTK_IS_WIDGET(content));
 
84
 
 
85
        if(GTK_IS_WIDGET(P(self)->pane2_scrwin) && GTK_BIN(P(self)->pane2_scrwin)->child) {
 
86
                gtk_container_remove(GTK_CONTAINER(P(self)->pane2_scrwin),
 
87
                                     GTK_BIN(P(self)->pane2_scrwin)->child);
 
88
        }
 
89
 
 
90
        if(GTK_IS_WIDGET(content)) {
 
91
                gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(P(self)->pane2_scrwin),
 
92
                                                      content);
 
93
        }
 
94
}
 
95
 
 
96
void
 
97
gq_tab_browse_set_input_form(GqTabBrowse* self,
 
98
                             GqInputForm* input_form)
 
99
{
 
100
        g_return_if_fail(GQ_IS_TAB_BROWSE(self));
 
101
        g_return_if_fail(!input_form || GQ_IS_INPUT_FORM(input_form));
 
102
 
 
103
        if(P(self)->input_form) {
 
104
                /* but first get current hide status */
 
105
#warning "FIXME: if this is a HACK, remove it"
 
106
                /* HACK: store hide status it in the browse-tab data-structure */
 
107
                self->hidden = gq_input_form_get_hide(P(self)->input_form);
 
108
                g_object_unref(P(self)->input_form);
 
109
                P(self)->input_form = NULL;
 
110
        }
 
111
 
 
112
        if(input_form) {
 
113
                P(self)->input_form = g_object_ref(input_form);
 
114
                gq_tab_browse_set_content(self, GTK_WIDGET(input_form));
 
115
        }
 
116
 
 
117
        g_object_notify(G_OBJECT(self), "input-form");
 
118
}
 
119
 
 
120
#ifndef USE_TREE_VIEW
 
121
#define gq_tree_node_parent(model, node_p) (node_p = row->parent)
 
122
#define gq_browser_model_get_node(model, node) (GQ_BROWSER_NODE(gq_tree_get_node_data(model, iter)))
 
123
#else
 
124
#define gq_tree_node_parent(model, iter) gtk_tree_model_iter_parent(model, &parent, iter)
 
125
#endif
 
126
 
 
127
#warning "hide this one"
 
128
void
 
129
record_path(GqTab *tab,
 
130
#ifndef USE_TREE_VIEW
 
131
            GQTreeWidget *model,
 
132
            GQTreeWidgetNode *iter
 
133
#else
 
134
            GtkTreeModel* model,
 
135
            GtkTreeIter * iter
 
136
#endif
 
137
            )
 
138
{
 
139
#ifdef USE_TREE_VIEW
 
140
        GtkTreeIter  parent = *iter;
 
141
#endif
78
142
     GqBrowserNode *e;
79
143
     GType type = -1;
80
144
 
85
149
 
86
150
     GQ_TAB_BROWSE(tab)->cur_path = NULL;
87
151
 
88
 
     for ( ; node ; node = row->parent ) {
89
 
          row = GQ_TREE_WIDGET_ROW(node);
90
 
          e = GQ_BROWSER_NODE(gq_tree_get_node_data (ctreeroot, node));
 
152
#ifdef USE_TREE_VIEW
 
153
        g_return_if_fail(gq_browser_model_validate(model, iter));
 
154
#endif
 
155
 
 
156
        do {
 
157
#ifdef USE_TREE_VIEW
 
158
                *iter = parent;
 
159
#else
 
160
          row = GQ_TREE_WIDGET_ROW(iter);
 
161
#endif
 
162
          e = gq_browser_model_get_node(model, iter);
91
163
 
92
164
          /* currently it is sufficient to keep changes in entry types only */
93
165
          if (e && G_OBJECT_TYPE(e) != type) {
102
174
 
103
175
               type = G_OBJECT_TYPE(e);
104
176
          }
105
 
     }
 
177
        } while(gq_tree_node_parent(model, iter));
106
178
}
107
179
 
108
 
GQTreeWidgetNode *dn_browse_single_add(const char *dn,
109
 
                                   GQTreeWidget *ctree,
110
 
                                   GQTreeWidgetNode *node)
 
180
void
 
181
dn_browse_single_add(GqServer    * server,
 
182
                     gchar const * dn,
 
183
                     GtkTreeModel* model,
 
184
                     GtkTreeIter * iter,
 
185
                     GtkTreeIter * created)
111
186
{
112
187
     char **exploded_dn = NULL;
113
188
     gchar const* label;
114
189
     GqBrowserNode *new_entry;
115
 
     GQTreeWidgetNode *new_item, *added = NULL;
 
190
        GqServerDn* entry;
116
191
     int ctx;
117
 
 
118
 
     ctx = error_new_context(_("Exploding DN"), GTK_WIDGET(ctree));
 
192
#warning "FIXME: add a widget"
 
193
        ctx = error_new_context(_("Exploding DN"), NULL);
119
194
 
120
195
     if (config->show_rdn_only) {
121
196
          /* explode DN */
133
208
          label = dn;
134
209
     }
135
210
 
136
 
     new_entry = gq_browser_node_dn_new(dn);
137
 
 
138
 
     added = gq_tree_insert_node (ctree,
139
 
                                  node,
140
 
                                  NULL,
141
 
                                  label,
142
 
                                  new_entry,
143
 
                                  g_object_unref);
144
 
 
145
 
     /* add dummy node */
146
 
     gq_tree_insert_dummy_node (ctree,
147
 
                                added);
 
211
        entry = gq_server_dn_new(dn, server);
 
212
        new_entry = gq_browser_node_dn_new(entry);
 
213
        g_object_unref(entry);
 
214
        gq_browser_model_add_node(model, iter, new_entry);
148
215
 
149
216
 fail:
150
217
     if (exploded_dn) gq_exploded_free(exploded_dn);
151
218
 
152
219
     error_flush(ctx);
153
 
 
154
 
     return added;
155
220
}
156
221
 
157
222
/*
169
234
          new_item = gq_tree_insert_node (ctree,
170
235
                                          NULL,
171
236
                                          NULL,
172
 
                                          server->name,
 
237
                                          gq_server_get_name(server),
173
238
                                          entry,
174
239
                                          g_object_unref);
175
240
          gq_tree_insert_dummy_node (ctree,
178
243
}
179
244
 
180
245
static void
181
 
add_single_server_count(GQServerList* list, GqServer* server, gpointer user_data) {
 
246
add_single_server_count(GQServerList* list      G_GNUC_UNUSED,
 
247
                        GqServer    * server,
 
248
                        gpointer      user_data) {
182
249
        gpointer**count_and_tree = user_data;
183
250
        gint    * server_cnt = (gint*)count_and_tree[0];
184
251
        GQTreeWidget* ctree = GQ_TREE_WIDGET(count_and_tree[1]);
192
259
 */
193
260
static void add_all_servers(GQTreeWidget *ctree)
194
261
{
195
 
     GqServer *server;
196
262
     int server_cnt = 0;
197
263
     gpointer count_and_ctree[2] = {
198
264
             &server_cnt,
206
272
                   server_cnt);
207
273
}
208
274
 
209
 
 
 
275
#ifndef USE_TREE_VIEW
210
276
/* GTK callbacks translating to the correct entry object method calls */
211
277
static void tree_row_expanded(GQTreeWidget *ctree,
212
278
                              GQTreeWidgetNode *ctree_node,
223
289
                                      GTK_WIDGET(ctree));
224
290
 
225
291
          GQ_BROWSER_NODE_GET_CLASS(entry)->expand(entry, ctx, ctree, ctree_node, tab);
226
 
          record_path(tab, entry, ctree, ctree_node);
 
292
          record_path(tab, ctree, ctree_node);
227
293
 
228
294
          error_flush(ctx);
229
295
     }
230
296
}
231
 
 
232
 
 
233
 
static void tree_row_selected(GQTreeWidget *ctree, GQTreeWidgetNode *node,
234
 
                              int column, GqTab *tab)
 
297
#endif
 
298
 
 
299
static void
 
300
#ifndef USE_TREE_VIEW
 
301
tree_row_selected(GQTreeWidget    * ctree,
 
302
                  GQTreeWidgetNode* node,
 
303
                  int               column G_GNUC_UNUSED,
 
304
                  GqTab           * tab)
 
305
#else
 
306
browser_tree_selection_changed(GtkTreeSelection* selection,
 
307
                               GqTab           * tab)
 
308
#endif
235
309
{
 
310
#ifndef USE_TREE_VIEW
236
311
     GqBrowserNode *entry;
237
 
     struct inputform *iform;
238
312
 
239
313
     /* avoid recursive calls to this handler - this causes crashes!!! */
240
314
     /* This is a legitimate use of
250
324
 
251
325
     entry = GQ_BROWSER_NODE(gq_tree_get_node_data (ctree, node));
252
326
 
253
 
     /* delete old struct inputform (if any) */
254
 
     iform = GQ_TAB_BROWSE(tab)->inputform;
255
 
     if(iform) {
256
 
          /* but first get current hide status */
257
 
          /* HACK: store hide status it in the browse-tab data-structure */
258
 
          GQ_TAB_BROWSE(tab)->hidden = iform->hide_status;
259
 
 
260
 
          inputform_free(iform);
261
 
          GQ_TAB_BROWSE(tab)->inputform = NULL;
262
 
     }
 
327
     /* delete old GqInputForm (if any) */
 
328
        gq_tab_browse_set_input_form(GQ_TAB_BROWSE(tab), NULL);
263
329
 
264
330
     if (entry) {
265
331
          if (GQ_BROWSER_NODE_GET_CLASS(entry)->select) {
276
342
     }
277
343
 
278
344
     g_object_set_data(G_OBJECT(ctree), "in-tree_row_selected", GINT_TO_POINTER(0));
 
345
#else
 
346
        GtkTreeModel * model;
 
347
        GtkTreeIter    iter;
 
348
 
 
349
        switch(gtk_tree_selection_count_selected_rows(selection)) {
 
350
                GList* selected;
 
351
        case 0:
 
352
                gq_tab_browse_set_content(GQ_TAB_BROWSE(tab), NULL);
 
353
                break;
 
354
        case 1:
 
355
                selected = gtk_tree_selection_get_selected_rows(selection, &model);
 
356
                if(gtk_tree_model_get_iter(model, &iter, selected->data)) {
 
357
                        GqBrowserNode* node = gq_browser_model_get_node(GQ_BROWSER_MODEL(model), &iter);
 
358
                        int ctx = error_new_context(_("Selecting entry"),
 
359
                                                    GTK_WIDGET(gtk_tree_selection_get_tree_view(selection)));
 
360
                        gq_browser_node_select(node, ctx, model, &iter, tab);
 
361
                        error_flush(ctx);
 
362
                }
 
363
                else
 
364
                {
 
365
                        g_warning("Got invalid selection.");
 
366
                }
 
367
                break;
 
368
        case 2:
 
369
                break;
 
370
        default:
 
371
                break;
 
372
        }
 
373
#endif
279
374
}
280
375
 
281
376
 
282
 
static void tree_row_refresh(GtkMenuItem *menuitem, GqTab *tab)
 
377
static void
 
378
tree_row_refresh(GqTab *tab)
283
379
{
284
380
     GQTreeWidget *ctree;
285
 
     GQTreeWidgetNode *node;
286
381
     GqBrowserNode *entry;
287
382
 
288
383
     ctree = GQ_TAB_BROWSE(tab)->ctreeroot;
289
 
     node = GQ_TAB_BROWSE(tab)->tree_row_popped_up;
290
 
     entry = GQ_BROWSER_NODE(gq_tree_get_node_data (ctree, node));
 
384
        entry = gq_browser_model_get_node(gtk_tree_view_get_model(ctree),
 
385
                                          &GQ_TAB_BROWSE(tab)->tree_row_popped_up);
291
386
 
292
387
     if (!entry) return;
293
388
 
295
390
          int ctx = error_new_context(_("Refreshing entry"),
296
391
                                      GTK_WIDGET(ctree));
297
392
 
298
 
          /* delete old struct inputform (if any) */
299
 
          struct inputform *iform = GQ_TAB_BROWSE(tab)->inputform;
300
 
          if(iform) {
301
 
               /* but first get current hide status */
302
 
               /* HACK: store hide status it in the browse-tab
303
 
                  data-structure */
304
 
               GQ_TAB_BROWSE(tab)->hidden = iform->hide_status;
305
 
 
306
 
               inputform_free(iform);
307
 
               GQ_TAB_BROWSE(tab)->inputform = NULL;
308
 
          }
309
 
 
310
 
          GQ_BROWSER_NODE_GET_CLASS(entry)->refresh(entry, ctx, ctree, node, tab);
 
393
                /* delete old GqInputForm (if any) */
 
394
                gq_tab_browse_set_input_form(GQ_TAB_BROWSE(tab), NULL);
 
395
 
 
396
          GQ_BROWSER_NODE_GET_CLASS(entry)->refresh(entry, ctx, ctree, &GQ_TAB_BROWSE(tab)->tree_row_popped_up, tab);
311
397
          error_flush(ctx);
312
398
     }
313
399
}
314
400
 
315
401
/* server & ref */
316
 
void tree_row_close_connection(GtkMenuItem *menuitem, GqTab *tab)
 
402
void
 
403
tree_row_close_connection(GqTab *tab)
317
404
{
318
 
     GQTreeWidget *ctree;
319
 
     GQTreeWidgetNode *node;
320
 
     GqServer *server;
321
 
 
322
 
     ctree = GQ_TAB_BROWSE(tab)->ctreeroot;
323
 
     node = GQ_TAB_BROWSE(tab)->tree_row_popped_up;
324
 
     server = server_from_node(ctree, node);
325
 
     close_connection(server, TRUE);
326
 
 
327
 
     statusbar_msg(_("Closed connection to server %s"), server->name);
 
405
        GtkTreeView* tview;
 
406
        GqServer *server;
 
407
 
 
408
        tview = GTK_TREE_VIEW(GQ_TAB_BROWSE(tab)->ctreeroot);
 
409
        server = gq_browser_node_get_server(gq_browser_model_get_node(gtk_tree_view_get_model(tview),
 
410
                                                                      &GQ_TAB_BROWSE(tab)->tree_row_popped_up));
 
411
        close_connection(server, TRUE);
 
412
 
 
413
        statusbar_msg(_("Closed connection to server %s"), gq_server_get_name(server));
328
414
}
329
415
 
330
416
 
345
431
     strcpy(tmp, state_name);
346
432
     strcat(tmp, ".input");
347
433
     
348
 
     if (GQ_TAB_BROWSE(tab)->inputform) {
349
 
          save_input_snapshot(error_context, GQ_TAB_BROWSE(tab)->inputform, tmp);
 
434
     if(P(tab)->input_form) {
 
435
          save_input_snapshot(error_context, P(tab)->input_form, tmp);
350
436
     } else {
351
437
          rm_value(tmp);
352
438
     }
376
462
     char *tmp;
377
463
 
378
464
     GqServer *server = NULL;
379
 
 
 
465
#ifndef USE_TREE_VIEW
380
466
     GQTreeWidgetNode *node = gq_tree_get_root_node (ctree);
 
467
#else
 
468
        GtkTreeIter node;
 
469
#endif
381
470
 
382
471
     if (path) {
383
472
          const GList *I;
394
483
               }
395
484
 
396
485
               if (c == ep) {
 
486
#warning "FIXME: solve this the OO way"
397
487
                    if(type == GQ_TYPE_BROWSER_NODE_DN) {
 
488
#ifndef USE_TREE_VIEW
398
489
                         node = show_dn(context, ctree, node, c + 1, FALSE);
 
490
#else
 
491
                         GtkTreeIter found;
 
492
                         show_dn(context,
 
493
                                 gtk_tree_view_get_model(GTK_TREE_VIEW(ctree)),
 
494
                                 (I == path) ? NULL : &node,
 
495
                                 &found,
 
496
                                 c + 1,
 
497
                                 FALSE);
 
498
                         node = found;
 
499
#endif
399
500
                    }
400
501
                    else if(type == GQ_TYPE_BROWSER_NODE_REFERENCE) {
 
502
#ifndef USE_TREE_VIEW
401
503
                         gq_tree_expand_node (ctree, node);
402
504
                         node =
403
505
                              gq_tree_widget_find_by_row_data_custom(GQ_TREE_WIDGET(ctree),
404
506
                                                                node,
405
507
                                                                (gpointer)(c + 1),
406
508
                                                                (GCompareFunc) cmp_name);
 
509
#endif
407
510
                    }
408
511
                    else if(type == GQ_TYPE_BROWSER_NODE_SERVER) {
409
512
                         server = gq_server_list_get_by_name(gq_server_list_get(), c + 1);
410
513
                         if (server != NULL) {
 
514
#ifndef USE_TREE_VIEW
411
515
                              node = tree_node_from_server_dn(ctree, server,
412
516
                                                              "");
 
517
#endif
413
518
                         } else {
414
519
                              /* FIXME - popup error? */
 
520
#ifndef USE_TREE_VIEW
415
521
                              node = NULL;
 
522
#endif
416
523
                         }
417
524
                    }
418
525
               }
 
526
#ifndef USE_TREE_VIEW
419
527
               if (node == NULL) break;
 
528
#endif
420
529
          }
 
530
#ifndef USE_TREE_VIEW
421
531
          if (node) gq_tree_select_node(ctree, node);
 
532
#else
 
533
          g_warning("FIXME: port this");
 
534
#endif
422
535
     }
423
536
 
424
537
     if (!progress->cancelled) {
431
544
          strcpy(tmp, state_name);
432
545
          strcat(tmp, ".input");
433
546
 
434
 
          if (GQ_TAB_BROWSE(tab)->inputform) {
435
 
               restore_input_snapshot(context, GQ_TAB_BROWSE(tab)->inputform, tmp);
436
 
          }
 
547
                if(P(tab)->input_form) {
 
548
                        restore_input_snapshot(context, P(tab)->input_form, tmp);
 
549
                }
437
550
 
438
551
          g_free(tmp);
439
552
     }
451
564
     GQ_TAB_BROWSE(tab)->update_lock--;
452
565
}
453
566
 
454
 
GqTab *new_browsemode()
455
 
{
456
 
     GQTreeWidget *ctreeroot;
457
 
     GtkWidget *browsemode_vbox, *spacer;
458
 
     GtkWidget *mainpane, *pane2_vbox, *pane1_scrwin, *pane2_scrwin;
459
 
     GqTabBrowse *modeinfo;
460
 
     GqTab *tab = g_object_new(GQ_TYPE_TAB_BROWSE, NULL);
461
 
     tab->type = BROWSE_MODE;
462
 
 
463
 
     modeinfo = GQ_TAB_BROWSE(tab);
464
 
 
465
 
     browsemode_vbox = gtk_vbox_new(FALSE, 0);
466
 
 
467
 
     spacer = gtk_hbox_new(FALSE, 0);
468
 
     gtk_widget_show(spacer);
469
 
     gtk_box_pack_start(GTK_BOX(browsemode_vbox), spacer, FALSE, FALSE, 3);
470
 
 
471
 
     mainpane = gtk_hpaned_new();
472
 
     gtk_container_border_width(GTK_CONTAINER(mainpane), 2);
473
 
     gtk_widget_show(mainpane);
474
 
     gtk_box_pack_start(GTK_BOX(browsemode_vbox), mainpane, TRUE, TRUE, 0);
475
 
     GQ_TAB_BROWSE(tab)->mainpane = mainpane;
476
 
 
477
 
     ctreeroot = gq_tree_widget_new ();
478
 
     modeinfo->ctreeroot = ctreeroot;
479
 
 
480
 
     gq_tree_widget_set_selection_mode(GQ_TREE_WIDGET(ctreeroot), GTK_SELECTION_BROWSE);
481
 
     gq_tree_widget_set_column_auto_resize(GQ_TREE_WIDGET(ctreeroot), 0, TRUE);
482
 
     if (config->sort_browse) {
483
 
          gtk_clist_set_auto_sort(GTK_CLIST(ctreeroot), TRUE);
484
 
     }
485
 
 
486
 
     gq_tree_widget_set_select_callback(GQ_TREE_WIDGET(ctreeroot),
487
 
                                        G_CALLBACK(tree_row_selected),
488
 
                                        tab);
489
 
     gq_tree_widget_set_expand_callback(GQ_TREE_WIDGET(ctreeroot),
490
 
                                        G_CALLBACK(tree_row_expanded),
491
 
                                        tab);
492
 
     g_signal_connect(ctreeroot, "button_press_event",
493
 
                        G_CALLBACK(button_press_on_tree_item), tab);
494
 
 
495
 
#ifdef BROWSER_DND
496
 
     browse_dnd_setup(GTK_WIDGET(ctreeroot), tab);
497
 
#endif /* BROWSER_DND */
498
 
 
499
 
     add_all_servers(GQ_TREE_WIDGET(ctreeroot));
500
 
     gtk_widget_show(GTK_WIDGET (ctreeroot));
501
 
 
502
 
     pane1_scrwin = gtk_scrolled_window_new(NULL, NULL);
503
 
     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pane1_scrwin),
504
 
                                    GTK_POLICY_AUTOMATIC,
505
 
                                    GTK_POLICY_AUTOMATIC);
506
 
     gtk_widget_show(pane1_scrwin);
507
 
 
508
 
     gtk_paned_set_position(GTK_PANED(mainpane), 300);
509
 
     gtk_paned_pack1(GTK_PANED(mainpane), pane1_scrwin, FALSE, FALSE);
510
 
     gtk_container_add(GTK_CONTAINER(pane1_scrwin), GTK_WIDGET(ctreeroot));
511
 
 
512
 
     // FIXME: remove this scrolled window, we only keep it for API compatibility
513
 
     pane2_scrwin = gtk_scrolled_window_new(NULL, NULL);
514
 
     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pane2_scrwin),
515
 
                                    GTK_POLICY_NEVER,
516
 
                                    GTK_POLICY_NEVER);
517
 
     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(pane2_scrwin),
518
 
                                         GTK_SHADOW_NONE);
519
 
     gtk_widget_show(pane2_scrwin);
520
 
     modeinfo->pane2_scrwin = pane2_scrwin;
521
 
 
522
 
     pane2_vbox = gtk_vbox_new(FALSE, 5);
523
 
     gtk_widget_show(pane2_vbox);
524
 
     modeinfo->pane2_vbox = pane2_vbox;
525
 
 
526
 
     gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pane2_scrwin), pane2_vbox);
527
 
 
528
 
     gtk_paned_pack2(GTK_PANED(mainpane), pane2_scrwin, TRUE, FALSE);
529
 
 
530
 
     gtk_widget_show(browsemode_vbox);
531
 
 
532
 
     /* prepare for proper cleanup */
533
 
     g_signal_connect_swapped(browsemode_vbox, "destroy",
534
 
                              G_CALLBACK(g_object_unref), tab);
535
 
 
536
 
     tab->content = browsemode_vbox;
537
 
     gtk_object_set_data(GTK_OBJECT(tab->content), "tab", tab);
538
 
     return tab;
539
 
}
540
 
 
541
 
GqServer *server_from_node(GQTreeWidget *ctreeroot,
542
 
                                    GQTreeWidgetNode *node)
543
 
{
544
 
     GQTreeWidgetRow *row = NULL;
545
 
     GqBrowserNode *entry;
546
 
 
547
 
     for ( ; node ; node = row->parent ) {
548
 
          row = GQ_TREE_WIDGET_ROW(node);
549
 
          entry = GQ_BROWSER_NODE(gq_tree_get_node_data (ctreeroot,
550
 
                                                               node));
551
 
          if (GQ_IS_BROWSER_NODE_SERVER(entry)) {
552
 
               return GQ_BROWSER_NODE_SERVER(entry)->server;
553
 
          }
554
 
          if (GQ_IS_BROWSER_NODE_REFERENCE(entry)) {
555
 
               return GQ_BROWSER_NODE_REFERENCE(entry)->server;
556
 
          }
557
 
     }
558
 
     return NULL;
559
 
}
 
567
GqTab*
 
568
gq_tab_browse_new(void)
 
569
{
 
570
        return g_object_new(GQ_TYPE_TAB_BROWSE, NULL);
 
571
}
 
572
 
 
573
#ifndef USE_TREE_VIEW
 
574
GqServer*
 
575
server_from_node(GQTreeWidget    * ctreeroot,
 
576
                 GQTreeWidgetNode* node)
 
577
{
 
578
#warning "FIXME: remove this function"
 
579
        return gq_browser_node_get_server(GQ_BROWSER_NODE(gq_tree_get_node_data(ctreeroot, node)));
 
580
}
 
581
#else
 
582
GqServer*
 
583
server_from_node(GtkTreeModel* model,
 
584
                 GtkTreeIter * iter)
 
585
{
 
586
#warning "FIXME: remove this function"
 
587
        GqBrowserNode* node = NULL;
 
588
        g_return_val_if_fail(GQ_IS_BROWSER_MODEL(model), NULL);
 
589
        g_return_val_if_fail(gq_browser_model_validate(model, iter), NULL);
 
590
 
 
591
        node = gq_browser_model_get_node(GQ_BROWSER_MODEL(model), iter);
 
592
        g_return_val_if_fail(GQ_IS_BROWSER_NODE(node), NULL);
 
593
 
 
594
        return gq_browser_node_get_server(node);
 
595
}
 
596
#endif
560
597
 
561
598
static int dn_row_compare_func(GqBrowserNodeDn *row_data, char *dn)
562
599
{
563
600
     if (row_data == NULL || !GQ_IS_BROWSER_NODE_DN(row_data)) return 1;
564
601
 
565
 
     return strcasecmp(dn, row_data->dn);
 
602
     return strcasecmp(dn, gq_browser_node_dn_get_dn(row_data));
566
603
}
567
604
 
568
605
/*
569
606
 * returns this DN's GQTreeWidgetNode
570
607
 */
571
 
 
 
608
#ifndef USE_TREE_VIEW
572
609
GQTreeWidgetNode *node_from_dn(GQTreeWidget *ctreeroot,
573
610
                           GQTreeWidgetNode *top,
574
611
                           char *dn)
577
614
                                              top, dn,
578
615
                                              (GCompareFunc) dn_row_compare_func);
579
616
}
 
617
#else
 
618
gboolean
 
619
node_from_dn(GtkTreeModel* model,
 
620
             GtkTreeIter * parent,
 
621
             GtkTreeIter * found,
 
622
             gchar const * dn)
 
623
{
 
624
        g_warning("FIXME: port");
 
625
        return FALSE;
 
626
}
 
627
#endif
580
628
 
581
629
struct server_dn {
582
630
     const GqServer *server;
602
650
          return;
603
651
     }
604
652
     if (GQ_IS_BROWSER_NODE_DN(e)) {
605
 
          if (strcasecmp(sd->dn, GQ_BROWSER_NODE_DN(e)->dn) == 0 &&
 
653
          if (strcasecmp(sd->dn, gq_browser_node_dn_get_dn(GQ_BROWSER_NODE_DN(e))) == 0 &&
606
654
              sd->currserver && sd->currserver == sd->server) {
607
655
               sd->found = node;
608
656
          }
668
716
          is_expanded = gq_tree_is_node_expanded (ctree, node);
669
717
 
670
718
          if (newdn) {
 
719
                GqServerDn* entry = gq_server_dn_new(newdn, server_from_node(ctree, node));
671
720
               parent = GQ_TREE_WIDGET_ROW(node)->parent;
672
721
               sibling = GQ_TREE_WIDGET_ROW(node)->sibling;
673
722
 
674
723
               /* disconnecting entry from row doesn't work without calling
675
724
                  the destroy notify function - thus copy the entry */
676
 
               e = GQ_BROWSER_NODE_DN(gq_browser_node_dn_new(newdn ? newdn : e->dn));
 
725
               e = GQ_BROWSER_NODE_DN(gq_browser_node_dn_new(entry));
 
726
               g_object_unref(entry);
677
727
 
678
728
               gq_tree_widget_unselect(ctree, node);
679
729
 
680
 
               exploded_dn = gq_ldap_explode_dn(e->dn, FALSE);
 
730
               exploded_dn = gq_ldap_explode_dn(gq_browser_node_dn_get_dn(e), FALSE);
681
731
               if (exploded_dn == NULL) {
682
732
                    /* parsing problem */
683
733
               }
733
783
          }
734
784
 
735
785
          show_server_dn(error_context, 
736
 
                         ctree, server_from_node(ctree, node), e->dn, TRUE);
 
786
                         ctree, server_from_node(ctree, node),
 
787
                         gq_browser_node_dn_get_dn(e), TRUE);
737
788
 
738
789
 
739
790
          gtk_clist_thaw(GTK_CLIST(ctree));
755
806
     refresh_subtree_new_dn(error_context, ctree, node, NULL, options);
756
807
}
757
808
 
 
809
#ifndef USE_TREE_VIEW
758
810
GQTreeWidgetNode *show_server_dn(int context, 
759
811
                             GQTreeWidget *tree, 
760
812
                             GqServer *server, const char *dn,
767
819
     }
768
820
     return NULL;
769
821
}
 
822
#else
 
823
void
 
824
show_server_dn(int           context,
 
825
               GtkTreeModel* model,
 
826
               GqServer    * server,
 
827
               gchar const * dn,
 
828
               gboolean      select_node)
 
829
{
 
830
        g_warning("FIXME: implement show_server_dn()");
 
831
}
 
832
#endif
770
833
 
771
 
GQTreeWidgetNode *show_dn(int error_context,
772
 
                      GQTreeWidget *tree, GQTreeWidgetNode *node, const char *dn, 
773
 
                      gboolean select_node)
 
834
#ifndef USE_TREE_VIEW
 
835
GQTreeWidgetNode*
 
836
#else
 
837
void
 
838
#endif
 
839
show_dn(int               error_context,
 
840
#ifndef USE_TREE_VIEW
 
841
        GQTreeWidget    * tree,
 
842
        GQTreeWidgetNode* node,
 
843
#else
 
844
        GtkTreeModel    * model,
 
845
        GtkTreeIter     * iter,
 
846
        GtkTreeIter     * found,
 
847
#endif
 
848
        gchar const     * dn, 
 
849
        gboolean          select_node)
774
850
{
775
851
     char **dnparts;
776
852
     int i;
777
853
     GString *s;
 
854
#ifndef USE_TREE_VIEW
778
855
     GQTreeWidgetNode *found = NULL;
 
856
#endif
779
857
     char *attrs[] = { LDAP_NO_ATTRS, NULL };
780
858
 
 
859
#ifndef USE_TREE_VIEW
781
860
     if (!dn) return NULL;
782
861
     if (!tree) return NULL;
 
862
#else
 
863
        g_return_if_fail(GQ_IS_BROWSER_MODEL(model));
 
864
        if(!dn) {
 
865
                return;
 
866
        }
 
867
#endif
783
868
     
784
869
     s = g_string_new("");
785
870
     dnparts = gq_ldap_explode_dn(dn, 0);
792
877
          g_string_insert(s, 0, dnparts[i]);
793
878
 
794
879
/*        printf("try %s at %08lx\n", s->str, node); */
 
880
#ifndef USE_TREE_VIEW
795
881
          if (node) gq_tree_expand_node(tree, node);
796
 
 
797
 
          found = node_from_dn(tree, node, s->str);
798
 
 
799
 
          if (found) {
 
882
#else
 
883
          g_warning("FIXME: port this");
 
884
#endif
 
885
 
 
886
#ifndef USE_TREE_VIEW
 
887
          found = node_from_dn(model, iter, s->str);
 
888
 
 
889
          if (gq_browser_model_validate(model, &found)) {
800
890
               node = found;
801
891
          } else if (node) {
 
892
#else
 
893
                if(!node_from_dn(model, iter, found, s->str) && iter) {
 
894
#endif
802
895
               /* check if the object with this dn actually exists. If
803
896
                  it does, we add it to the tree by hand, as we
804
897
                  probably cannot see it due to a size limit */
805
 
 
 
898
#ifndef USE_TREE_VIEW
806
899
               GqServer *server = server_from_node(tree, node);
 
900
#else
 
901
               GqServer* server = server_from_node(model, iter);
 
902
#endif
807
903
               LDAP *ld;
808
904
 
809
905
               if ((ld = open_connection(error_context, server)) != NULL) {
841
937
                         if (e) {
842
938
                              /* have it!! */
843
939
                              char *dn2 = ldap_get_dn(ld, e);
844
 
                              found = dn_browse_single_add(dn2, tree, node);
 
940
#ifndef USE_TREE_VIEW
 
941
                              found = dn_browse_single_add(server, dn2, tree, node);
 
942
 
 
943
                              node = found;
 
944
#else
 
945
                              dn_browse_single_add(server, dn2, model, iter, found);
 
946
#endif
845
947
                              if (dn2) ldap_memfree(dn2);
846
 
 
847
 
                              node = found;
848
948
                         }
849
949
                    } else {
850
950
                         /* FIXME report error */
873
973
     gq_exploded_free(dnparts);
874
974
     g_string_free(s, TRUE);
875
975
 
876
 
     if (found && select_node) {
 
976
#ifndef USE_TREE_VIEW
 
977
     if (gq_browser_model_validate(gtk_tree_view_get_model(self->ctreeroot), &found) && select_node) {
877
978
          gq_tree_select_node(tree, found);
878
979
          gq_tree_widget_scroll_to(tree, node,
879
980
                                0,
880
981
                                0.5, 0);
881
982
     }
882
 
 
 
983
#else
 
984
                g_warning("FIXME: implement this passage");
 
985
#endif
 
986
#ifndef USE_TREE_VIEW
883
987
     if (found) return found;
884
988
     return NULL;
 
989
#endif
 
990
}
 
991
 
 
992
static void
 
993
browse_tab_open_diff(GqTabBrowse* self)
 
994
{
 
995
        GtkTreeModel* model;
 
996
        GqTab* tab = new_modetab(&mainwin, GQ_TYPE_DIFF_TAB, TRUE);
 
997
        GList* selected = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(self->ctreeroot), &model);
 
998
        GList* it;
 
999
        gint i;
 
1000
        for(i = 0, it = selected; it; i++, it = g_list_next(it)) {
 
1001
                GtkTreeIter  iter;
 
1002
                if(!gtk_tree_model_get_iter(model, &iter, it->data)) {
 
1003
                        g_warning("Got an invalid selection");
 
1004
                        continue;
 
1005
                }
 
1006
                gq_diff_tab_set_entry(GQ_DIFF_TAB(tab), i,
 
1007
                                      gq_browser_node_dn_get_entry(gq_browser_model_get_node(GQ_BROWSER_MODEL(model),
 
1008
                                                                                             &iter)));
 
1009
        }
 
1010
        g_list_foreach(selected, gtk_tree_path_free, NULL);
 
1011
        g_list_free(selected);
 
1012
}
 
1013
 
 
1014
static void
 
1015
browse_tab_check_dn_node(GtkTreeModel* model,
 
1016
                         GtkTreePath * path,
 
1017
                         GtkTreeIter * iter,
 
1018
                         gpointer      data)
 
1019
{
 
1020
        gboolean* is_dn = data;
 
1021
 
 
1022
        if(!GQ_IS_BROWSER_NODE_DN(gq_browser_model_get_node(GQ_BROWSER_MODEL(model), iter))) {
 
1023
                *is_dn = FALSE;
 
1024
        }
885
1025
}
886
1026
 
887
1027
/*
890
1030
 *
891
1031
 * the return values here are related to handling of button events only.
892
1032
 */
893
 
static gboolean button_press_on_tree_item(GtkWidget *tree,
894
 
                                          GdkEventButton *event,
895
 
                                          GqTab *tab)
 
1033
static gboolean
 
1034
button_press_on_tree_item(GtkWidget     * tree,
 
1035
                          GdkEventButton* event,
 
1036
                          GqTab         * tab)
896
1037
{
897
 
     GtkWidget *ctreeroot;
898
 
     GtkWidget *root_menu, *menu, *menu_item, *label;
899
 
     GQTreeWidgetNode *ctree_node;
900
 
     GqBrowserNodeDn *entry;
901
 
 
902
 
     if (event->type == GDK_BUTTON_PRESS && event->button == 3
903
 
         && event->window == GTK_CLIST(tree)->clist_window) {
904
 
          char *name;
905
 
          ctree_node = gq_tree_get_node_at (GQ_TREE_WIDGET(tree), event->x, event->y);
906
 
 
907
 
          if (ctree_node == NULL)
908
 
               return TRUE;
909
 
 
910
 
          ctreeroot = GTK_WIDGET(GQ_TAB_BROWSE(tab)->ctreeroot);
911
 
 
912
 
          entry = GQ_BROWSER_NODE_DN(gq_tree_get_node_data (GQ_TREE_WIDGET(ctreeroot), GQ_TREE_WIDGET_NODE(ctree_node)));
913
 
 
914
 
          if (entry == NULL) return TRUE;
915
 
          if (GQ_BROWSER_NODE_GET_CLASS(entry)->popup) {
916
 
               /* The get_name method already does UTF-8 decoding */
917
 
               name = GQ_BROWSER_NODE_GET_CLASS(entry)->get_name(GQ_BROWSER_NODE(entry), FALSE);
918
 
 
919
 
               GQ_TAB_BROWSE(tab)->tree_row_popped_up = ctree_node;
920
 
 
921
 
               /* hack, hack. Need to pass both the ctree_node and tab... */
922
 
               GQ_TAB_BROWSE(tab)->selected_ctree_node = ctree_node;
923
 
 
924
 
               root_menu = gtk_menu_item_new_with_label("Root");
925
 
               gtk_widget_show(root_menu);
926
 
               menu = gtk_menu_new();
927
 
 
928
 
               gtk_menu_item_set_submenu(GTK_MENU_ITEM(root_menu), menu);
929
 
 
930
 
               label = gtk_menu_item_new_with_label(name);
931
 
               gtk_widget_set_sensitive(label, FALSE);
932
 
               gtk_widget_show(label);
933
 
 
934
 
               gtk_menu_append(GTK_MENU(menu), label);
935
 
               gtk_menu_set_title(GTK_MENU(menu), name);
936
 
 
937
 
               menu_item = gtk_separator_menu_item_new();
938
 
 
939
 
               gtk_menu_append(GTK_MENU(menu), menu_item);
940
 
               gtk_widget_set_sensitive(menu_item, FALSE);
941
 
               gtk_widget_show(menu_item);
942
 
 
943
 
               if (name) g_free(name);
944
 
 
945
 
               /* The common Refresh item */
946
 
               menu_item = gtk_menu_item_new_with_label(_("Refresh"));
947
 
               gtk_menu_append(GTK_MENU(menu), menu_item);
948
 
               gtk_widget_show(menu_item);
949
 
 
950
 
               g_signal_connect(menu_item, "activate",
951
 
                                  G_CALLBACK(tree_row_refresh),
952
 
                                  tab);
953
 
 
954
 
               GQ_BROWSER_NODE_GET_CLASS(entry)->popup(GQ_BROWSER_NODE(entry), menu,
955
 
                                          GQ_TREE_WIDGET (ctreeroot), ctree_node, tab);
956
 
 
957
 
               gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
958
 
                              event->button, event->time);
959
 
 
960
 
               g_signal_stop_emission_by_name(ctreeroot,
961
 
                                            "button_press_event");
962
 
               return(TRUE);
963
 
          }
964
 
     }
965
 
     return(FALSE);
 
1038
        if(event->type == GDK_BUTTON_PRESS && event->button == 3)
 
1039
        {
 
1040
                GqBrowserNodeDn* entry;
 
1041
                GtkTreeModel* model;
 
1042
                GtkTreePath * path;
 
1043
                GtkWidget   * item;
 
1044
                GtkMenu     * menu;
 
1045
                gchar       * name;
 
1046
 
 
1047
                if(event->window != gtk_tree_view_get_bin_window(GTK_TREE_VIEW(tree)))
 
1048
                {
 
1049
                        return FALSE;
 
1050
                }
 
1051
 
 
1052
                if(!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree), event->x, event->y,
 
1053
                                                 &path, NULL, NULL, NULL))
 
1054
                {
 
1055
                        return FALSE;
 
1056
                }
 
1057
 
 
1058
                model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree));
 
1059
 
 
1060
                if(!gtk_tree_model_get_iter(model, &GQ_TAB_BROWSE(tab)->tree_row_popped_up, path))
 
1061
                {
 
1062
                        gtk_tree_path_free(path);
 
1063
                        return FALSE;
 
1064
                }
 
1065
 
 
1066
                entry = gq_browser_model_get_node(GQ_BROWSER_MODEL(model), &GQ_TAB_BROWSE(tab)->tree_row_popped_up);
 
1067
                
 
1068
                name = gq_browser_node_get_name(GQ_BROWSER_NODE(entry), FALSE);
 
1069
                menu = gtk_menu_new();
 
1070
 
 
1071
                item = gtk_menu_item_new_with_label(name);
 
1072
                gtk_widget_set_sensitive(item, FALSE);
 
1073
                gtk_widget_show(item);
 
1074
                gtk_menu_append(GTK_MENU(menu), item);
 
1075
                gtk_menu_set_title(GTK_MENU(menu), name);
 
1076
 
 
1077
                item = gtk_separator_menu_item_new();
 
1078
                gtk_widget_show(item);
 
1079
                gtk_menu_append(GTK_MENU(menu), item);
 
1080
 
 
1081
                gq_browser_node_popup(entry, menu,
 
1082
                                      GTK_TREE_VIEW(tree), &GQ_TAB_BROWSE(tab)->tree_row_popped_up, tab);
 
1083
 
 
1084
                item = gtk_separator_menu_item_new();
 
1085
                gtk_widget_show(item);
 
1086
                gtk_menu_append(GTK_MENU(menu), item);
 
1087
 
 
1088
                item = gtk_menu_item_new_with_label(_("Compare Items"));
 
1089
                g_signal_connect_swapped(item, "activate",
 
1090
                                         G_CALLBACK(browse_tab_open_diff), tab);
 
1091
                gtk_widget_show(item);
 
1092
                gtk_menu_append(GTK_MENU(menu), item);
 
1093
 
 
1094
                if(gtk_tree_selection_count_selected_rows(gtk_tree_view_get_selection(tree)) == 2) {
 
1095
                        gboolean is_dn = TRUE;
 
1096
                        gtk_tree_selection_selected_foreach(gtk_tree_view_get_selection(tree),
 
1097
                                                            browse_tab_check_dn_node,
 
1098
                                                            &is_dn);
 
1099
 
 
1100
                        gtk_widget_set_sensitive(item, is_dn);
 
1101
                }
 
1102
                else
 
1103
                {
 
1104
                        gtk_widget_set_sensitive(item, FALSE);
 
1105
                }
 
1106
 
 
1107
                /* The common Refresh item */
 
1108
                item = gtk_image_menu_item_new_from_stock(GTK_STOCK_REFRESH, NULL);
 
1109
                gtk_widget_show(item);
 
1110
                gtk_menu_append(GTK_MENU(menu), item);
 
1111
 
 
1112
                g_signal_connect_swapped(item, "activate",
 
1113
                                         G_CALLBACK(tree_row_refresh), tab);
 
1114
 
 
1115
                gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
 
1116
                               event->button, event->time);
 
1117
                gtk_tree_path_free(path);
 
1118
                g_free(name);
 
1119
                return TRUE;
 
1120
        }
 
1121
        return FALSE;
966
1122
}
967
1123
 
968
1124
 
986
1142
}
987
1143
 
988
1144
static void
989
 
add_missing_server(GQServerList* list, GqServer* server, gpointer user_data) {
 
1145
add_missing_server(GQServerList* list G_GNUC_UNUSED,
 
1146
                   GqServer    * server,
 
1147
                   gpointer      user_data)
 
1148
{
990
1149
        GQTreeWidget* tree = GQ_TREE_WIDGET(user_data);
991
1150
 
992
1151
        if(!server_node_from_server(tree, server)) {
994
1153
        }
995
1154
}
996
1155
 
997
 
void update_browse_serverlist(GqTab *tab)
 
1156
void
 
1157
update_browse_serverlist(GqTab *tab G_GNUC_UNUSED)
998
1158
{
 
1159
#ifndef USE_TREE_VIEW
999
1160
     GQTreeWidget *ctree;
1000
 
     GqServer *server;
1001
1161
     cb_server_list csl;
1002
 
     GList *l, *I;
 
1162
     GList *l;
1003
1163
 
1004
1164
     ctree = GQ_TAB_BROWSE(tab)->ctreeroot;
1005
1165
     /* walk the list of ldapservers, add any not yet in the show list */
1025
1185
          } else {
1026
1186
               /* renamed servers ? */
1027
1187
               char *currtext = gq_tree_get_node_text (ctree,node);
1028
 
               if (currtext && strcmp(currtext, thisserver->name) != 0) {
1029
 
                    gq_tree_set_node_text (ctree, node, thisserver->name);
 
1188
               if (currtext && strcmp(currtext, gq_server_get_name(thisserver)) != 0) {
 
1189
                    gq_tree_set_node_text (ctree, node, gq_server_get_name(thisserver));
1030
1190
               }
1031
1191
          }
1032
1192
     }
1035
1195
          g_list_foreach(csl.list, (GFunc)g_object_unref, NULL);
1036
1196
          g_list_free(csl.list);
1037
1197
     }
 
1198
#endif
1038
1199
}
1039
1200
 
1040
1201
/* GType */
1041
1202
G_DEFINE_TYPE(GqTabBrowse, gq_tab_browse, GQ_TYPE_TAB);
1042
1203
 
 
1204
enum {
 
1205
        PROP_0,
 
1206
        PROP_INPUT_FORM
 
1207
};
 
1208
 
1043
1209
static void
1044
 
gq_tab_browse_init(GqTabBrowse* self) {}
 
1210
gq_tab_browse_init(GqTabBrowse* self)
 
1211
{
 
1212
#define modeinfo self
 
1213
        GtkTreeViewColumn* column;
 
1214
        GtkTreeSelection * selection;
 
1215
        GtkCellRenderer  * renderer;
 
1216
        GtkTreeModel     * model;
 
1217
        GtkWidget *mainpane, *pane1_scrwin;
 
1218
     GtkWidget *browsemode_vbox, *spacer;
 
1219
        GqTab            * tab = GQ_TAB(self);
 
1220
 
 
1221
     browsemode_vbox = gtk_vbox_new(FALSE, 0);
 
1222
 
 
1223
     spacer = gtk_hbox_new(FALSE, 0);
 
1224
     gtk_widget_show(spacer);
 
1225
     gtk_box_pack_start(GTK_BOX(browsemode_vbox), spacer, FALSE, FALSE, 3);
 
1226
 
 
1227
     mainpane = gtk_hpaned_new();
 
1228
     gtk_container_border_width(GTK_CONTAINER(mainpane), 2);
 
1229
     gtk_widget_show(mainpane);
 
1230
     gtk_box_pack_start(GTK_BOX(browsemode_vbox), mainpane, TRUE, TRUE, 0);
 
1231
     GQ_TAB_BROWSE(tab)->mainpane = mainpane;
 
1232
#ifndef USE_TREE_VIEW
 
1233
     ctreeroot = gq_tree_widget_new ();
 
1234
     modeinfo->ctreeroot = ctreeroot;
 
1235
 
 
1236
     gq_tree_widget_set_selection_mode(GQ_TREE_WIDGET(ctreeroot), GTK_SELECTION_BROWSE);
 
1237
     gq_tree_widget_set_column_auto_resize(GQ_TREE_WIDGET(ctreeroot), 0, TRUE);
 
1238
     if (config->sort_browse) {
 
1239
          gtk_clist_set_auto_sort(GTK_CLIST(ctreeroot), TRUE);
 
1240
     }
 
1241
 
 
1242
     gq_tree_widget_set_select_callback(GQ_TREE_WIDGET(ctreeroot),
 
1243
                                        G_CALLBACK(tree_row_selected),
 
1244
                                        tab);
 
1245
     gq_tree_widget_set_expand_callback(GQ_TREE_WIDGET(ctreeroot),
 
1246
                                        G_CALLBACK(tree_row_expanded),
 
1247
                                        tab);
 
1248
     g_signal_connect(ctreeroot, "button_press_event",
 
1249
                        G_CALLBACK(button_press_on_tree_item), tab);
 
1250
 
 
1251
#ifdef BROWSER_DND
 
1252
     browse_dnd_setup(GTK_WIDGET(ctreeroot), tab);
 
1253
#endif /* BROWSER_DND */
 
1254
 
 
1255
     add_all_servers(GQ_TREE_WIDGET(ctreeroot));
 
1256
#else
 
1257
        /* set up the tree view */
 
1258
        modeinfo->ctreeroot = GTK_TREE_VIEW(gq_tree_view_new());
 
1259
        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(modeinfo->ctreeroot), FALSE);
 
1260
 
 
1261
        column = gtk_tree_view_column_new();
 
1262
        renderer = gtk_cell_renderer_pixbuf_new();
 
1263
        gtk_tree_view_column_pack_start(column, renderer, FALSE);
 
1264
        gtk_tree_view_column_add_attribute(column, renderer,
 
1265
                                           "icon-name", GQ_BROWSER_MODEL_COL_TYPE);
 
1266
        renderer = gtk_cell_renderer_text_new();
 
1267
        gtk_tree_view_column_pack_start(column, renderer, TRUE);
 
1268
        gtk_tree_view_column_add_attribute(column, renderer,
 
1269
                                           "text", GQ_BROWSER_MODEL_COL_NAME);
 
1270
        gtk_tree_view_append_column(GTK_TREE_VIEW(modeinfo->ctreeroot), column);
 
1271
        g_signal_connect(modeinfo->ctreeroot, "button-press-event",
 
1272
                         G_CALLBACK(button_press_on_tree_item), tab);
 
1273
 
 
1274
        /* set up the selection */
 
1275
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(modeinfo->ctreeroot));
 
1276
        gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
 
1277
        g_signal_connect(selection, "changed",
 
1278
                         G_CALLBACK(browser_tree_selection_changed), tab);
 
1279
 
 
1280
        /* set up the model */
 
1281
#warning "FIXME: add a sort model"
 
1282
        model = gq_browser_model_new();
 
1283
        gtk_tree_view_set_model(GTK_TREE_VIEW(modeinfo->ctreeroot), model);
 
1284
        g_object_unref(model);
 
1285
#endif
 
1286
        gtk_widget_show(GTK_WIDGET(modeinfo->ctreeroot));
 
1287
 
 
1288
     pane1_scrwin = gtk_scrolled_window_new(NULL, NULL);
 
1289
     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pane1_scrwin),
 
1290
                                    GTK_POLICY_AUTOMATIC,
 
1291
                                    GTK_POLICY_ALWAYS);
 
1292
#ifdef USE_TREE_VIEW
 
1293
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(pane1_scrwin),
 
1294
                                            GTK_SHADOW_IN);
 
1295
#endif
 
1296
     gtk_widget_show(pane1_scrwin);
 
1297
 
 
1298
#warning "FIXME: calculate a good default from the window size; load and save to config"
 
1299
     gtk_paned_set_position(GTK_PANED(mainpane), 300);
 
1300
     gtk_paned_pack1(GTK_PANED(mainpane), pane1_scrwin, FALSE, FALSE);
 
1301
        gtk_container_add(GTK_CONTAINER(pane1_scrwin), GTK_WIDGET(modeinfo->ctreeroot));
 
1302
 
 
1303
     // FIXME: remove this scrolled window, we only keep it for API compatibility
 
1304
     P(self)->pane2_scrwin = gtk_scrolled_window_new(NULL, NULL);
 
1305
     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(P(self)->pane2_scrwin),
 
1306
                                    GTK_POLICY_NEVER,
 
1307
                                    GTK_POLICY_NEVER);
 
1308
     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(P(self)->pane2_scrwin),
 
1309
                                         GTK_SHADOW_NONE);
 
1310
 
 
1311
        gtk_widget_show(P(self)->pane2_scrwin);
 
1312
 
 
1313
        gtk_paned_pack2(GTK_PANED(mainpane), P(self)->pane2_scrwin, TRUE, FALSE);
 
1314
 
 
1315
     gtk_widget_show(browsemode_vbox);
 
1316
 
 
1317
     /* prepare for proper cleanup */
 
1318
     g_signal_connect_swapped(browsemode_vbox, "destroy",
 
1319
                              G_CALLBACK(g_object_unref), tab);
 
1320
 
 
1321
     tab->content = browsemode_vbox;
 
1322
     gtk_object_set_data(GTK_OBJECT(tab->content), "tab", tab);
 
1323
#undef modeinfo
 
1324
}
1045
1325
 
1046
1326
static void
1047
1327
tab_dispose(GObject* object)
1048
1328
{
1049
1329
        GqTabBrowse* self = GQ_TAB_BROWSE(object);
1050
1330
 
1051
 
        if(self->inputform) {
1052
 
                inputform_free(self->inputform);
1053
 
                self = NULL;
1054
 
        }
 
1331
        gq_tab_browse_set_input_form(self, NULL);
1055
1332
 
1056
1333
        G_OBJECT_CLASS(gq_tab_browse_parent_class)->dispose(object);
1057
1334
}
1070
1347
}
1071
1348
 
1072
1349
static void
 
1350
tab_get_property(GObject   * object,
 
1351
                 guint       prop_id,
 
1352
                 GValue    * value,
 
1353
                 GParamSpec* pspec)
 
1354
{
 
1355
        switch(prop_id) {
 
1356
        case PROP_INPUT_FORM:
 
1357
                g_value_set_object(value, P(object)->input_form);
 
1358
                break;
 
1359
        default:
 
1360
                G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 
1361
                break;
 
1362
        }
 
1363
}
 
1364
 
 
1365
static void
 
1366
tab_set_property(GObject     * object,
 
1367
                 guint         prop_id,
 
1368
                 GValue const* value,
 
1369
                 GParamSpec  * pspec)
 
1370
{
 
1371
        switch(prop_id) {
 
1372
        case PROP_INPUT_FORM:
 
1373
                gq_tab_browse_set_input_form(GQ_TAB_BROWSE(object), g_value_get_object(value));
 
1374
                break;
 
1375
        default:
 
1376
                G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 
1377
                break;
 
1378
        }
 
1379
}
 
1380
 
 
1381
static void
1073
1382
gq_tab_browse_class_init(GqTabBrowseClass* self_class)
1074
1383
{
1075
1384
        GObjectClass* object_class = G_OBJECT_CLASS(self_class);
1076
1385
        GqTabClass* tab_class = GQ_TAB_CLASS(self_class);
1077
1386
 
1078
 
        object_class->dispose  = tab_dispose;
1079
 
        object_class->finalize = tab_finalize;
 
1387
        /* GObjectClass */
 
1388
        object_class->dispose      = tab_dispose;
 
1389
        object_class->finalize     = tab_finalize;
 
1390
        object_class->get_property = tab_get_property;
 
1391
        object_class->set_property = tab_set_property;
 
1392
 
 
1393
        g_object_class_install_property(object_class,
 
1394
                                        PROP_INPUT_FORM,
 
1395
                                        g_param_spec_object("input-form",
 
1396
                                                            _("Input Form"),
 
1397
                                                            _("The input form to be used for display"),
 
1398
                                                            GQ_TYPE_INPUT_FORM,
 
1399
                                                            G_PARAM_READWRITE));
1080
1400
 
1081
1401
        tab_class->save_snapshot    = browse_save_snapshot;
1082
1402
        tab_class->restore_snapshot = browse_restore_snapshot;
 
1403
 
 
1404
        /* GqTabBrowseClass */
 
1405
        g_type_class_add_private(self_class, sizeof(struct GqTabBrowsePrivate));
1083
1406
}
1084
1407