« back to all changes in this revision
Viewing changes to src/prefs.c
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- 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
* 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.
+ 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.
- files added:
- debian/README.source
- help
- help/gq-manual
- help/gq-manual/C
- help/gq-manual/de
- files removed:
- README.langpack
- files modified:
- ChangeLog
added
removed
src/prefs.c
22
22
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23
23
*/
24
24
25
/* $Id: prefs.c 994 2006-09-16 14:12:20Z herzi $ */
26
27
25
#ifdef HAVE_CONFIG_H
28
26
# include <config.h>
29
27
#endif /* HAVE_CONFIG_H */
41
39
#include "common.h"
42
40
#include "configfile.h"
43
41
#include "gq-keyring.h"
42
#include "gq-input-form.h"
43
#include "gq-server-dialog.h"
44
44
#include "gq-server-list.h"
45
#include "gq-server-model.h"
45
46
#include "gq-tab-browse.h"
46
#include "ldif.h"
47
#include "mainwin.h"
47
#include "gq-utilities.h"
48
#include "gq-window.h"
48
49
#include "prefs.h"
49
50
#include "state.h"
50
#include "util.h"
51
51
#include "template.h"
52
52
#include "errorchain.h"
53
53
#include "debug.h"
54
#include "input.h"
55
54
56
55
/* for now: only allow a single preferences window */
57
56
static GtkWidget *prefswindow;
58
57
59
/* for now: only allow a single server window */
60
static GtkWidget *current_edit_server_window = NULL;
61
62
static GtkWidget *current_serverstab_serverclist = NULL;
63
GtkWidget *current_template_clist = NULL; /* FIXME: used in
64
template.c as well */
65
66
58
GtkWidget *current_template_clist = NULL;
59
#warning "FIXME: used in template.c as well"
67
60
68
61
struct prefs_windata {
69
GtkWidget *search_st[4];
70
GtkWidget *ldif_format[2];
71
72
62
GtkWidget *prefswindow;
73
63
74
64
GtkWidget *templatelist;
89
79
GtkWidget *schemaserver;
90
80
91
81
/* servers tab */
92
GtkWidget *serverstab_server_clist;
82
GtkWidget *serverstab_server_view;
93
83
94
84
/* security */
95
85
GtkWidget *never_leak_credentials;
110
100
GtkWidget *show_pw_toggle;
111
101
GtkWidget *clear_pw;
112
102
GtkWidget *searchattr;
113
GtkWidget *maxentries;
114
103
GtkWidget *localcachetimeout;
115
104
GtkWidget *ask_pw;
116
105
GtkWidget *hide_internal;
125
114
struct prefs_windata *pw);
126
115
static void create_search_optionstab(GtkWidget *target,
127
116
struct prefs_windata *pw);
128
static void create_ldiftab(GtkWidget *target, struct prefs_windata *pw);
129
130
static void destroy_edit_server_window(GtkWidget *this,
131
struct server_windata *sw);
132
117
static void create_guitab(GtkWidget *target, struct prefs_windata *);
133
118
static void create_security_tab(GtkWidget *target, struct prefs_windata *);
134
119
135
static void template_new_callback(GtkWidget *widget, struct prefs_windata *);
136
static void template_edit_callback(GtkWidget *widget, struct prefs_windata *);
120
static void template_new_callback (struct prefs_windata *);
121
static void template_edit_callback(struct prefs_windata *);
137
122
static void template_selected_callback(GtkWidget *clist, gint row, gint column,
138
GdkEventButton *event,
123
GdkEventButton *event,
139
124
struct prefs_windata *data);
140
125
static void template_delete_callback(GtkWidget *widget,
141
126
struct prefs_windata *pw);
152
137
gboolean transient;
153
138
} prefs_callback_data;
154
139
155
156
157
158
static prefs_callback_data *new_prefs_callback_data(struct server_windata *sw)
159
{
160
prefs_callback_data *d = g_malloc(sizeof(prefs_callback_data));
161
d->server = NULL;
162
d->edit_new_server = 0;
163
d->sw = sw;
164
return d;
165
}
166
167
static void destroy_prefs_callback_data(prefs_callback_data *cb_data) {
168
if (cb_data) {
169
if (cb_data->edit_new_server) {
170
if (cb_data->server) {
171
gq_server_list_remove(gq_server_list_get(), cb_data->server);
172
}
173
}
174
if(cb_data->server) {
175
g_object_unref(cb_data->server);
176
cb_data->server = NULL;
177
}
178
g_free(cb_data);
179
}
180
}
181
182
static void
183
check_unique_name(GQServerList* list, GqServer* server, gpointer user_data) {
184
gpointer* unique_and_server = user_data;
185
gboolean* unique = unique_and_server[0];
186
GqServer* newserver = unique_and_server[1];
187
188
if(server != newserver && !strcmp(server->name, newserver->name)) {
189
*unique = FALSE;
190
}
191
}
192
193
static void server_edit_callback(GtkWidget *this, prefs_callback_data *cb_data)
194
{
195
GtkWidget *window, *field;
196
GqServer *server, *servers;
197
int server_name_changed;
198
const char *text, *passwdtext;
199
char *ep = NULL;
200
#if HAVE_LDAP_CLIENT_CACHE
201
int tmp;
202
#endif
203
GList *I;
204
struct server_windata *sw = cb_data->sw;
205
gboolean save_ok;
206
GqServer *save = gq_server_new();
207
gboolean unique = TRUE;
208
gpointer unique_and_server[2] = {
209
&unique,
210
cb_data->server
211
};
212
213
server = cb_data->server;
214
copy_ldapserver(save, server);
215
216
window = sw->editwindow;
217
218
/* Name */
219
field = sw->servername;
220
text = gtk_entry_get_text(GTK_ENTRY(field));
221
if(strcmp(text, server->name))
222
server_name_changed = 1;
223
else
224
server_name_changed = 0;
225
226
g_free_and_dup(server->name, text);
227
228
/* make sure server name is unique */
229
gq_server_list_foreach(gq_server_list_get(), check_unique_name, unique_and_server);
230
231
if(!unique) {
232
/* already exists */
233
error_popup(_("Error adding new server"),
234
_("A server by that name already exists\n\n"
235
"Please choose another name"),
236
this);
237
goto done;
238
}
239
240
/* LDAP host */
241
field = sw->ldaphost;
242
text = gtk_entry_get_text(GTK_ENTRY(field));
243
g_free_and_dup(server->ldaphost, text);
244
245
/* LDAP port */
246
field = sw->ldapport;
247
text = gtk_entry_get_text(GTK_ENTRY(field));
248
ep = NULL;
249
server->ldapport = strtol(text, &ep, 10);
250
if (ep && *ep) {
251
if (*text) {
252
single_warning_popup(_("Port must be numeric or empty"));
253
goto done;
254
} else {
255
/* empty, might have LDAP URI */
256
server->ldapport = -1;
257
}
258
}
259
260
/* Base DN */
261
field = sw->basedn;
262
text = gtk_entry_get_text(GTK_ENTRY(field));
263
g_free_and_dup(server->basedn, text);
264
265
/* Bind DN */
266
field = sw->binddn;
267
text = gtk_entry_get_text(GTK_ENTRY(field));
268
g_free_and_dup(server->binddn, text);
269
270
/* Ask password */
271
field = sw->ask_pw;
272
server->ask_pw = GTK_TOGGLE_BUTTON(field)->active ? 1 : 0;
273
274
/* Bind Password */
275
passwdtext = gtk_entry_get_text(GTK_ENTRY(sw->bindpw));
276
g_free(server->bindpw);
277
if(!server->ask_pw && passwdtext) {
278
server->bindpw = g_strdup(passwdtext);
279
gq_keyring_save_server_password(server);
280
} else {
281
server->bindpw = g_strdup("");
282
}
283
284
/* Search attribute */
285
field = sw->searchattr;
286
text = gtk_entry_get_text(GTK_ENTRY(field));
287
g_free_and_dup(server->searchattr, text);
288
289
/* Maximum entries */
290
field = sw->maxentries;
291
text = gtk_entry_get_text(GTK_ENTRY(field));
292
ep = NULL;
293
server->maxentries = strtol(text, &ep, 10);
294
if (ep && *ep) {
295
if (*text) {
296
single_warning_popup(_("Maximum number of entries must be numeric or empty"));
297
} else {
298
/* empty, might have LDAP URI */
299
server->maxentries = 0;
300
}
301
}
302
303
/* Hide internal */
304
field = sw->hide_internal;
305
server->hide_internal = GTK_TOGGLE_BUTTON(field)->active ? 1 : 0;
306
307
/* Cache connection */
308
field = sw->cacheconn;
309
server->cacheconn = GTK_TOGGLE_BUTTON(field)->active ? 1 : 0;
310
311
/* Enable TLS */
312
field = sw->enabletls;
313
server->enabletls = GTK_TOGGLE_BUTTON(field)->active ? 1 : 0;
314
315
#if HAVE_LDAP_CLIENT_CACHE
316
/* Local Cache Timeout */
317
field = sw->localcachetimeout;
318
text = gtk_entry_get_text(GTK_ENTRY(field));
319
tmp = (int) strtol(text, &ep, 0);
320
if (!ep || !*ep) server->local_cache_timeout = tmp;
321
#endif
322
323
field = GTK_COMBO(sw->bindtype)->entry;
324
text = gtk_entry_get_text(GTK_ENTRY(field));
325
server->bindtype = tokenize(token_bindtype, text);
326
327
/* connection info might have changed for this server -- close
328
cached connection */
329
close_connection(server, TRUE);
330
canonicalize_ldapserver(server);
331
332
if(server_name_changed) {
333
/* refresh clist in serverstab */
334
fill_serverlist_serverstab();
335
}
336
337
save_ok = TRUE;
338
/* I do not really like this ad-hoc solution to check if a server
339
is a transient server or a configured one, but ... */
340
if (!is_transient_server(server)) {
341
/* so the cancel button doesn't really cancel :-) */
342
save_ok = save_config(window);
343
}
344
345
/* if (cb_data->edit_new_server) { */
346
/* /\* everything ok, take the server out of the cb_data (in case it */
347
/* was created anew, this will avoid that the cb_data destroy */
348
/* function deletes the ldapserver) *\/ */
349
/* cb_data->server = NULL; */
350
/* } */
351
352
if (save_ok) {
353
update_serverlist(&mainwin);
354
gtk_widget_destroy(window);
355
} else {
356
copy_ldapserver(server, save);
357
}
358
359
done:
360
if (save) g_object_unref(save);
361
}
362
363
static void host_changed_callback(GtkEditable *host, GtkWidget *port)
364
{
365
gchar *s = gtk_editable_get_chars(host, 0, -1);
366
367
if (s) {
368
gtk_widget_set_sensitive(GTK_WIDGET(port),
369
(g_utf8_strchr(s, -1, ':') == NULL));
370
g_free(s);
371
}
372
}
373
374
static void destroy_edit_server_window(GtkWidget *this,
375
struct server_windata *sw)
376
{
377
if (this == current_edit_server_window) {
378
current_edit_server_window = NULL;
379
}
380
if (sw) g_free(sw);
381
}
382
383
static gboolean destroy_edit_server_window_on_esc(GtkWidget *widget,
384
GdkEventKey *event,
385
gpointer data)
386
{
387
if(event && event->type == GDK_KEY_PRESS && event->keyval == GDK_Escape) {
388
gtk_widget_destroy(widget);
389
return(TRUE);
390
}
391
392
return(FALSE);
393
}
394
395
static void
396
toggle_pw_visibility(GtkToggleButton* toggle, GtkEntry* entry) {
397
gboolean visible = gtk_toggle_button_get_active(toggle);
398
399
if(!visible || question_popup(_("Cleartext Password"),
400
_("The password that you entered will be displayed in\n"
401
"the entry. This can be dangerous if someone is watching\n"
402
"at the screen you're currently working on (that includes\n"
403
"both people behind you and people that may watch your\n"
404
"desktop via VNC).\n\n"
405
"Do you still want to see the password?")))
406
{
407
// FIXME: let the user set a "don't display again" switch
408
gtk_entry_set_visibility(entry, visible);
409
} else if(visible) {
410
// un-toggle the button if the user was not sure about
411
// displaying the password
412
gtk_toggle_button_set_active(toggle, FALSE);
413
}
414
}
415
416
static void
417
ask_pw_toggled(GtkToggleButton *button, struct server_windata *sw) {
418
gboolean sensitive = !gtk_toggle_button_get_active(button);
419
gtk_widget_set_sensitive(sw->bindpw, sensitive);
420
gtk_widget_set_sensitive(sw->show_pw_toggle, sensitive);
421
gtk_widget_set_sensitive(sw->clear_pw, sensitive);
422
}
423
424
static void
425
clear_pw(GtkButton* button, prefs_callback_data *cb_data) {
426
gtk_entry_set_text(GTK_ENTRY(cb_data->sw->bindpw), "");
427
gq_keyring_forget_password(cb_data->server);
428
}
429
430
void
431
create_edit_server_window(GqServer *server,
432
GtkWidget *modalFor)
433
{
434
GtkWidget *editwindow, *notebook;
435
GtkWidget *main_vbox, *vbox1, *vbox2, *hbox;
436
GtkWidget *table1, *table2, *table3;
437
GtkWidget *label, *entry, *button;
438
GtkWidget *okbutton, *cancelbutton;
439
GtkWidget *bindpw, *host, *box;
440
int y, z;
441
int i;
442
GString *title;
443
char tmp[16]; /* fixed buffer: OK - used for printf("%d") only */
444
GtkWidget *bindtype;
445
GList *bindtypes = NULL;
446
GtkTooltips *tips;
447
prefs_callback_data *cb_data;
448
struct server_windata *sw = NULL;
449
gchar* password = NULL;
450
451
if(current_edit_server_window) {
452
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sw->show_pw_toggle), FALSE);
453
gtk_window_present(GTK_WINDOW(current_edit_server_window));
454
return;
455
}
456
457
tips = gtk_tooltips_new();
458
459
sw = g_malloc0(sizeof(struct server_windata));
460
461
cb_data = new_prefs_callback_data(sw);
462
cb_data->edit_new_server = (server == NULL);
463
cb_data->transient = is_transient_server(server);
464
465
if(!server) {
466
gint i;
467
server = gq_server_new();
468
for(i = 1; i < G_MAXINT; i++) {
469
gchar* name = g_strdup_printf(_("Untitled Server %d"), i);
470
if(G_LIKELY(!gq_server_list_get_by_name(gq_server_list_get(),
471
name))) {
472
gq_server_set_name(server, name);
473
g_free(name);
474
break;
475
}
476
g_free(name);
477
}
478
gq_server_list_add(gq_server_list_get(), server);
479
}
480
481
cb_data->server = g_object_ref(server);
482
483
editwindow = stateful_gtk_window_new(GTK_WINDOW_TOPLEVEL,
484
"serveredit", -1, -1);
485
sw->editwindow = editwindow;
486
current_edit_server_window = editwindow;
487
488
if (modalFor) {
489
g_assert(GTK_IS_WINDOW(modalFor));
490
gtk_window_set_modal(GTK_WINDOW(editwindow), TRUE);
491
gtk_window_set_transient_for(GTK_WINDOW(editwindow),
492
GTK_WINDOW(modalFor));
493
}
494
495
gtk_object_set_data_full(GTK_OBJECT(editwindow),
496
"cb_data",
497
cb_data,
498
(GtkDestroyNotify) destroy_prefs_callback_data);
499
500
title = g_string_sized_new(64);
501
502
if(cb_data->edit_new_server) {
503
g_string_sprintf(title, _("New server"));
504
} else {
505
g_string_sprintf(title, _("Server %s"), server->name);
506
}
507
if (cb_data->transient) {
508
g_string_sprintf(title, _("Transient server %s"), server->name);
509
}
510
511
gtk_window_set_title(GTK_WINDOW(editwindow), title->str);
512
g_string_free(title, TRUE);
513
514
gtk_window_set_policy(GTK_WINDOW(editwindow), TRUE, TRUE, FALSE);
515
516
main_vbox = gtk_vbox_new(FALSE, 0);
517
gtk_container_border_width(GTK_CONTAINER(main_vbox),
518
CONTAINER_BORDER_WIDTH);
519
gtk_widget_show(main_vbox);
520
gtk_container_add(GTK_CONTAINER(editwindow), main_vbox);
521
522
notebook = gtk_notebook_new();
523
gtk_widget_show(notebook);
524
#ifdef OLD_FOCUS_HANDLING
525
GTK_WIDGET_UNSET_FLAGS(GTK_NOTEBOOK(notebook), GTK_CAN_FOCUS);
526
#endif
527
gtk_box_pack_start(GTK_BOX(main_vbox), notebook, TRUE, TRUE, 0);
528
529
/* "General" tab */
530
531
vbox1 = gtk_vbox_new(FALSE, 20);
532
gtk_widget_show(vbox1);
533
gtk_container_border_width(GTK_CONTAINER(vbox1),
534
CONTAINER_BORDER_WIDTH);
535
label = gq_label_new(_("_General"));
536
gtk_widget_show(label);
537
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox1, label);
538
539
table1 = gtk_table_new(4, 2, FALSE);
540
gtk_widget_show(table1);
541
gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, FALSE, 0);
542
gtk_container_border_width(GTK_CONTAINER(table1),
543
CONTAINER_BORDER_WIDTH);
544
gtk_table_set_row_spacings(GTK_TABLE(table1), 5);
545
gtk_table_set_col_spacings(GTK_TABLE(table1), 13);
546
547
/* Name */
548
label = gq_label_new(_("_Name"));
549
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
550
gtk_widget_show(label);
551
gtk_table_attach(GTK_TABLE(table1), label, 0, 1, 0, 1,
552
GTK_FILL, GTK_FILL, 0, 0);
553
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT);
554
555
entry = gtk_entry_new();
556
557
sw->servername = entry;
558
559
gtk_entry_set_text(GTK_ENTRY(entry), server->name);
560
gtk_widget_show(entry);
561
g_signal_connect(entry, "activate",
562
G_CALLBACK(server_edit_callback), cb_data);
563
gtk_table_attach(GTK_TABLE(table1), entry, 1, 2, 0, 1,
564
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
565
gtk_widget_grab_focus(entry);
566
567
gtk_tooltips_set_tip(tips, entry,
568
_("The nickname of the server definition"),
569
Q_("tooltip|The nickname is used to refer to this "
570
"server "
571
"definition throughout this application")
572
);
573
574
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
575
576
/* LDAP host */
577
label = gq_label_new(_("LDAP _Host/URI"));
578
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
579
gtk_widget_show(label);
580
gtk_table_attach(GTK_TABLE(table1), label, 0, 1, 1, 2,
581
GTK_FILL, GTK_FILL, 0, 0);
582
583
host = entry = gtk_entry_new();
584
sw->ldaphost = entry;
585
gtk_entry_set_text(GTK_ENTRY(entry), server->ldaphost);
586
587
gtk_widget_show(entry);
588
g_signal_connect(entry, "activate",
589
G_CALLBACK(server_edit_callback), cb_data);
590
gtk_table_attach(GTK_TABLE(table1), entry, 1, 2, 1, 2,
591
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
592
593
gtk_tooltips_set_tip(tips, entry,
594
_("The host name or LDAP URI of the LDAP server"),
595
Q_("tooltip|Either use the name or IP address of "
596
"the server "
597
"or an LDAP URI (either ldap or ldaps). An URI "
598
"is recognized through the existance of a colon "
599
"in this field")
600
);
601
602
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
603
604
/* Port */
605
label = gq_label_new(_("LDAP _Port"));
606
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
607
gtk_widget_show(label);
608
gtk_table_attach(GTK_TABLE(table1), label, 0, 1, 2, 3,
609
GTK_FILL, GTK_FILL, 0, 0);
610
611
entry = gtk_entry_new();
612
sw->ldapport = entry;
613
if (server->ldapport != 0) {
614
g_snprintf(tmp, sizeof(tmp), "%d", server->ldapport);
615
} else {
616
*tmp = 0;
617
}
618
gtk_entry_set_text(GTK_ENTRY(entry), tmp);
619
gtk_widget_show(entry);
620
g_signal_connect(entry, "activate",
621
G_CALLBACK(server_edit_callback), cb_data);
622
gtk_table_attach(GTK_TABLE(table1), entry, 1, 2, 2, 3,
623
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
624
625
gtk_tooltips_set_tip(tips, entry,
626
_("The port the LDAP server listens on"),
627
Q_("tooltip|If empty, the well-known LDAP port (389) "
628
"is assumed. This field is not available if an "
629
"LDAP URI is used.")
630
);
631
632
/* Callback on HOST to enable/disable PORT if user enters a colon... */
633
634
g_signal_connect(host, "changed",
635
G_CALLBACK(host_changed_callback), entry);
636
637
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
638
639
g_signal_emit_by_name(host, "changed", NULL, NULL);
640
641
/* Base DN */
642
label = gq_label_new(_("_Base DN"));
643
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
644
gtk_widget_show(label);
645
gtk_table_attach(GTK_TABLE(table1), label, 0, 1, 3, 4,
646
GTK_FILL, GTK_FILL, 0, 0);
647
648
entry = gtk_entry_new();
649
sw->basedn = entry;
650
gtk_entry_set_text(GTK_ENTRY(entry), server->basedn);
651
gtk_widget_show(entry);
652
g_signal_connect(entry, "activate",
653
G_CALLBACK(server_edit_callback), cb_data);
654
gtk_table_attach(GTK_TABLE(table1), entry, 1, 2, 3, 4,
655
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
656
657
gtk_tooltips_set_tip(tips, entry,
658
_("The base DN of the server"),
659
Q_("tooltip|This base DN gets used in search mode, "
660
"usually "
661
"though, this application queries the server "
662
"for its 'namingContexts'")
663
);
664
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
665
666
667
668
/* Add not if the server is transient */
669
670
671
if (cb_data->transient) {
672
label = gtk_label_new(_("NOTE: This is a transient server definition. It has been added dynamically and it will not be saved to the permanent configuration."));
673
674
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
675
gtk_box_pack_start(GTK_BOX(vbox1), label, FALSE, FALSE, 0);
676
gtk_widget_show(label);
677
}
678
679
/* "Details" tab */
680
681
vbox2 = gtk_vbox_new(FALSE, 0);
682
gtk_widget_show(vbox2);
683
gtk_container_border_width(GTK_CONTAINER(vbox2),
684
CONTAINER_BORDER_WIDTH);
685
label = gq_label_new(_("_Details"));
686
gtk_widget_show(label);
687
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox2, label);
688
689
table2 = gtk_table_new(8, 2, FALSE);
690
gtk_widget_show(table2);
691
gtk_box_pack_start(GTK_BOX(vbox2), table2, TRUE, TRUE, 0);
692
gtk_container_border_width(GTK_CONTAINER(table2),
693
CONTAINER_BORDER_WIDTH);
694
gtk_table_set_row_spacings(GTK_TABLE(table2), 5);
695
gtk_table_set_col_spacings(GTK_TABLE(table2), 13);
696
y = 0;
697
698
table3 = gtk_table_new(3, 2, FALSE);
699
gtk_widget_show(table3);
700
gtk_box_pack_start(GTK_BOX(vbox2), table3, TRUE, TRUE, 0);
701
gtk_container_border_width(GTK_CONTAINER(table3),
702
CONTAINER_BORDER_WIDTH);
703
gtk_table_set_row_spacings(GTK_TABLE(table3), 5);
704
gtk_table_set_col_spacings(GTK_TABLE(table3), 13);
705
z = 0;
706
707
/* Bind DN */
708
label = gq_label_new(_("_Bind DN"));
709
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
710
gtk_widget_show(label);
711
gtk_table_attach(GTK_TABLE(table2), label, 0, 1, y, y + 1,
712
GTK_FILL, GTK_FILL, 0, 0);
713
714
entry = gtk_entry_new();
715
sw->binddn = entry;
716
gtk_entry_set_text(GTK_ENTRY(entry), server->binddn);
717
gtk_widget_show(entry);
718
g_signal_connect(entry, "activate",
719
G_CALLBACK(server_edit_callback), cb_data);
720
gtk_table_attach(GTK_TABLE(table2), entry, 1, 2, y, y + 1,
721
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
722
y++;
723
724
gtk_tooltips_set_tip(tips, entry,
725
_("The DN to bind with to the LDAP server"),
726
Q_("tooltip|This is equivalent to a 'username'. "
727
"Ask the "
728
"LDAP administrator for the DN to use.")
729
);
730
731
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
732
733
/* Bind Password */
734
label = gq_label_new(_("Bind _Password"));
735
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
736
gtk_widget_show(label);
737
gtk_table_attach(GTK_TABLE(table2), label, 0, 1, y, y + 1,
738
GTK_FILL, GTK_FILL, 0, 0);
739
740
box = gtk_hbox_new(FALSE, 3);
741
gtk_table_attach(GTK_TABLE(table2), box, 1, 2, y, y + 1,
742
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
743
y++;
744
745
sw->bindpw = bindpw = entry = gtk_entry_new();
746
gtk_box_pack_start_defaults(GTK_BOX(box), sw->bindpw);
747
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
748
749
password = gq_keyring_get_password(server);
750
if(password) {
751
gtk_entry_set_text(GTK_ENTRY(sw->bindpw), password ? password : "");
752
g_signal_connect(sw->bindpw, "activate",
753
G_CALLBACK(server_edit_callback), cb_data);
754
gnome_keyring_free_password(password);
755
password = NULL;
756
}
757
758
gtk_tooltips_set_tip(tips, sw->bindpw,
759
_("The password to bind with to the LDAP server"),
760
Q_("tooltip|This is related to the bind DN. Note that the "
761
"password gets stored in a configuration file. "
762
"Recent versions of this application actually "
763
"scramble the password, but this scrambling can "
764
"easily be reverted. Do not use a valuable "
765
"password here.")
766
);
767
768
769
gtk_label_set_mnemonic_widget(GTK_LABEL(label), sw->bindpw);
770
gtk_widget_show_all(box);
771
772
/* the show password button */
773
sw->show_pw_toggle = gtk_toggle_button_new();
774
gtk_container_add(GTK_CONTAINER(sw->show_pw_toggle),
775
gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_MENU));
776
gtk_box_pack_start(GTK_BOX(box), sw->show_pw_toggle, FALSE, FALSE, 0);
777
gtk_tooltips_set_tip(tips, sw->show_pw_toggle,
778
_("Show the password"),
779
Q_("tooltip|Clicking this button asks the user whether "
780
"he really wants to see the password and if that's "
781
"the case, displays the password. Clicking this button "
782
"once more will hide the password."));
783
g_signal_connect(sw->show_pw_toggle, "toggled",
784
G_CALLBACK(toggle_pw_visibility), sw->bindpw);
785
gtk_widget_show_all(sw->show_pw_toggle);
786
787
/* the delete password button */
788
sw->clear_pw = gtk_button_new();
789
gtk_container_add(GTK_CONTAINER(sw->clear_pw),
790
gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU));
791
gtk_box_pack_start(GTK_BOX(box), sw->clear_pw, FALSE, FALSE, 0);
792
gtk_tooltips_set_tip(tips, sw->clear_pw,
793
_("Clear the Password"),
794
Q_("tooltip|Clicking this button asks the user whether "
795
"he really wants to clear the password and if that's "
796
"the case, clears the password entry and deletes the "
797
"password from the keyring."));
798
g_signal_connect(sw->clear_pw, "clicked",
799
G_CALLBACK(clear_pw), cb_data);
800
gtk_widget_show_all(sw->clear_pw);
801
802
/* Bind type */
803
label = gq_label_new(_("Bind t_ype"));
804
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
805
gtk_widget_show(label);
806
gtk_table_attach(GTK_TABLE(table2), label, 0, 1, y, y + 1,
807
GTK_FILL, GTK_FILL, 0, 0);
808
809
bindtype = gtk_combo_new();
810
sw->bindtype = bindtype;
811
812
for (i = 0;
813
token_bindtype[i].keyword && strlen(token_bindtype[i].keyword);
814
i++) {
815
bindtypes = g_list_append(bindtypes,
816
GINT_TO_POINTER(token_bindtype[i].keyword));
817
}
818
819
gtk_combo_set_popdown_strings(GTK_COMBO(bindtype), bindtypes);
820
g_list_free(bindtypes);
821
822
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(bindtype)->entry), FALSE);
823
gtk_widget_show(bindtype);
824
825
gtk_list_select_item(GTK_LIST(GTK_COMBO(bindtype)->list),
826
server->bindtype);
827
gtk_table_attach(GTK_TABLE(table2), bindtype, 1, 2, y, y + 1,
828
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
829
y++;
830
831
gtk_tooltips_set_tip(tips, GTK_WIDGET(GTK_COMBO(bindtype)->entry),
832
_("How to bind to the LDAP server"),
833
Q_("tooltip|gq supports several different bind "
834
"types, like Simple, Kerberos or SASL binds.")
835
);
836
837
gtk_label_set_mnemonic_widget(GTK_LABEL(label),
838
GTK_COMBO(bindtype)->entry);
839
840
/* Search attribute */
841
label = gq_label_new(_("_Search Attribute"));
842
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
843
gtk_widget_show(label);
844
gtk_table_attach(GTK_TABLE(table2), label, 0, 1, y, y + 1,
845
GTK_FILL, GTK_FILL, 0, 0);
846
847
entry = gtk_entry_new();
848
sw->searchattr = entry;
849
gtk_entry_set_text(GTK_ENTRY(entry), server->searchattr);
850
gtk_widget_show(entry);
851
g_signal_connect(entry, "activate",
852
G_CALLBACK(server_edit_callback), cb_data);
853
gtk_table_attach(GTK_TABLE(table2), entry, 1, 2, y, y + 1,
854
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
855
y++;
856
857
gtk_tooltips_set_tip(tips, entry,
858
_("The attribute to 'search' in a search tab."),
859
Q_("tooltip|Search mode in the search tab searches "
860
"this attribute. This alleviates the user to "
861
"always use a proper LDAP filter.")
862
);
863
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
864
865
/* Maximum entries */
866
label = gq_label_new(_("_Maximum entries"));
867
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
868
gtk_widget_show(label);
869
gtk_table_attach(GTK_TABLE(table2), label, 0, 1, y, y + 1,
870
GTK_FILL, GTK_FILL, 0, 0);
871
872
entry = gtk_entry_new();
873
sw->maxentries = entry;
874
g_snprintf(tmp, sizeof(tmp), "%d", server->maxentries);
875
gtk_entry_set_text(GTK_ENTRY(entry), tmp);
876
gtk_widget_show(entry);
877
g_signal_connect(entry, "activate",
878
G_CALLBACK(server_edit_callback), cb_data);
879
gtk_table_attach(GTK_TABLE(table2), entry, 1, 2, y, y + 1,
880
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
881
y++;
882
883
gtk_tooltips_set_tip(tips, entry,
884
_("The maximum number of entries to return in "
885
"search mode."),
886
Q_("tooltip|NOTE: A server might impose stricter "
887
"limits")
888
);
889
890
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
891
892
#if HAVE_LDAP_CLIENT_CACHE
140
#warning "FIXME: enable the client cache timeout setting in the server dialog"
141
#if 0 ||HAVE_LDAP_CLIENT_CACHE
893
142
/* Use local cache */
894
143
label = gq_label_new(_("LDAP cache timeo_ut"));
895
144
gtk_misc_set_alignment(GTK_MISC(label), 0.0, .5);
920
169
921
170
#endif
922
171
923
/* Ask password on first connect */
924
button = gq_check_button_new_with_label(_("_Ask password on first connect"));
925
sw->ask_pw = button;
926
g_signal_connect(button, "toggled",
927
G_CALLBACK(ask_pw_toggled), sw);
928
929
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), server->ask_pw);
930
931
#ifdef OLD_FOCUS_HANDLING
932
GTK_WIDGET_UNSET_FLAGS(GTK_CHECK_BUTTON(button), GTK_CAN_FOCUS);
933
#endif
934
gtk_widget_show(button);
935
gtk_table_attach(GTK_TABLE(table3), button, 0, 1, z, z + 1,
936
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
937
938
gtk_tooltips_set_tip(tips, button,
939
_("Should the application ask for a bind password?"),
940
Q_("tooltip|This disables the password entered via "
941
"the preferences dialog. ")
942
);
943
944
/* Hide internal attributes */
945
button = gq_check_button_new_with_label(_("_Hide internal attributes"));
946
sw->hide_internal = button;
947
if(server->hide_internal)
948
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
949
#ifdef OLD_FOCUS_HANDLING
950
GTK_WIDGET_UNSET_FLAGS(GTK_CHECK_BUTTON(button), GTK_CAN_FOCUS);
951
#endif
952
gtk_widget_show(button);
953
gtk_table_attach(GTK_TABLE(table3), button, 1, 2, z, z + 1,
954
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
955
z++;
956
gtk_tooltips_set_tip(tips, button,
957
_("Do not show attributes internal to the LDAP "
958
"server"),
959
Q_("tooltip|At least OpenLDAP allows to view "
960
"several "
961
"interesting attributes. Setting this option "
962
"turns them off.")
963
);
964
965
/* Cache connections */
966
button = gq_check_button_new_with_label(_("Cach_e connection"));
967
sw->cacheconn = button;
968
if(server->cacheconn)
969
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
970
#ifdef OLD_FOCUS_HANDLING
971
GTK_WIDGET_UNSET_FLAGS(GTK_CHECK_BUTTON(button), GTK_CAN_FOCUS);
972
#endif
973
gtk_widget_show(button);
974
gtk_table_attach(GTK_TABLE(table3), button, 0, 1, z, z + 1,
975
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
976
977
gtk_tooltips_set_tip(tips, button,
978
_("If set: Do not close the connection between "
979
"LDAP operations"),
980
Q_("tooltip|Setting this may speed up LDAP "
981
"operations, as it does not require the overhead "
982
"to open a new "
983
"connection to the server for every operation. "
984
"OTOH it might put additional stress on the "
985
"server (depends on what you call 'stress')")
986
);
987
988
z++;
989
990
/* Enable TLS */
991
button = gq_check_button_new_with_label(_("Enable _TLS"));
992
sw->enabletls = button;
993
if(server->enabletls)
994
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
995
#ifdef OLD_FOCUS_HANDLING
996
GTK_WIDGET_UNSET_FLAGS(GTK_CHECK_BUTTON(button), GTK_CAN_FOCUS);
997
#endif
998
gtk_widget_show(button);
999
gtk_table_attach(GTK_TABLE(table3), button, 0, 1, z, z + 1,
1000
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
1001
z++;
1002
1003
gtk_tooltips_set_tip(tips, button,
1004
_("Should we use Transport Layer Security?"),
1005
Q_("tooltip|Almost but not quite entirely SSL.")
1006
);
1007
1008
/* OK and Cancel buttons */
1009
hbox = gtk_hbutton_box_new(); /* FALSE, 13); */
1010
/* gtk_container_border_width(GTK_CONTAINER(hbox), 10); */
1011
gtk_widget_show(hbox);
1012
gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 10);
1013
1014
1015
okbutton = gtk_button_new_from_stock(GTK_STOCK_OK);
1016
1017
gtk_widget_show(okbutton);
1018
g_signal_connect(okbutton, "clicked",
1019
G_CALLBACK(server_edit_callback),
1020
cb_data);
1021
gtk_box_pack_start(GTK_BOX(hbox), okbutton, FALSE, TRUE, 10);
1022
GTK_WIDGET_SET_FLAGS(okbutton, GTK_CAN_DEFAULT);
1023
gtk_widget_grab_default(okbutton);
1024
1025
cancelbutton = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
1026
1027
gtk_widget_show(cancelbutton);
1028
g_signal_connect_swapped(cancelbutton, "clicked",
1029
G_CALLBACK(gtk_widget_destroy),
1030
editwindow);
1031
g_signal_connect(editwindow, "key_press_event",
1032
G_CALLBACK(destroy_edit_server_window_on_esc),
1033
sw);
1034
g_signal_connect(editwindow, "destroy",
1035
G_CALLBACK(destroy_edit_server_window),
1036
sw);
1037
1038
1039
gtk_box_pack_end(GTK_BOX(hbox), cancelbutton, FALSE, TRUE, 10);
1040
1041
gtk_widget_show(editwindow);
1042
1043
statusbar_msg(_("Server properties window opened for server '%s'"),
1044
server->name);
1045
}
1046
1047
1048
172
static void
1049
173
serverstab_deletebutton_callback(GtkWidget* widget,
1050
174
struct prefs_windata* pw)
1051
175
{
1052
GtkWidget *clist = pw->serverstab_server_clist;
1053
gint row = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(clist), "selected-row"));
1054
GqServer *server = gtk_clist_get_row_data(GTK_CLIST(clist), row);
1055
1056
if (server) {
176
GtkTreeModel* model;
177
GtkTreeIter iter;
178
GqServer * server;
179
180
#warning "FIXME: this check should be unnecessary if the button is disabled without selection"
181
if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(pw->serverstab_server_view)),
182
&model, &iter))
183
{
184
return;
185
}
186
187
server = gq_server_model_get_server(GQ_SERVER_MODEL(model), &iter);
188
if(server) {
1057
189
GQServerList* list = gq_server_list_get();
1058
190
1059
191
g_object_ref(server);
1060
192
gq_server_list_remove(list, server);
1061
193
1062
194
if (save_config(widget)) {
1063
/* unref server due to removal of the server from
1064
the list of servers */
1065
g_object_unref(server);
1066
1067
gtk_object_remove_data(GTK_OBJECT(clist),
1068
"selected-row");
1069
1070
fill_serverlist_serverstab();
1071
195
update_serverlist(&mainwin);
1072
196
} else {
1073
197
/* undo changes */
1077
201
}
1078
202
}
1079
203
1080
static void serverstab_newbutton_callback(GtkWidget *widget,
1081
struct prefs_windata *pw)
1082
{
1083
create_edit_server_window(NULL, pw->prefswindow);
1084
}
1085
1086
1087
static void serverstab_editbutton_callback(GtkWidget *widget,
1088
struct prefs_windata *pw)
1089
{
1090
GtkWidget *clist = pw->serverstab_server_clist;
1091
void *data = gtk_object_get_data(GTK_OBJECT(clist),
1092
"selected-row");
1093
1094
gint row = GPOINTER_TO_INT(data);
1095
GqServer *server = gtk_clist_get_row_data(GTK_CLIST(clist),
1096
row);
1097
/* quietly ignore editbutton if no server selected */
1098
if(server) create_edit_server_window(server, pw->prefswindow);
1099
}
1100
1101
1102
static void
1103
server_selected_callback(GtkWidget* clist,
1104
gint row,
1105
gint column,
1106
GdkEventButton* event,
1107
struct prefs_windata* pw)
1108
{
1109
gtk_object_set_data(GTK_OBJECT(clist),
1110
"selected-row", GINT_TO_POINTER(row));
1111
1112
if(event && event->type == GDK_2BUTTON_PRESS) {
1113
GqServer *server = GQ_SERVER(gtk_clist_get_row_data(GTK_CLIST(clist), row));
1114
create_edit_server_window(server, pw->prefswindow);
1115
}
1116
}
1117
1118
1119
static void server_unselected_callback(GtkWidget *clist, gint row, gint column,
1120
GdkEventButton *event, gpointer data)
1121
{
1122
gtk_object_remove_data(GTK_OBJECT(clist), "selected-row");
1123
}
1124
1125
static void
1126
add_single_server(GQServerList* list,
1127
GqServer* server,
1128
gpointer user_data)
1129
{
1130
gpointer * clist_and_row = user_data;
1131
GtkWidget* clist = clist_and_row[0];
1132
gint * row = clist_and_row[1];
1133
gint rrow;
1134
1135
rrow = gtk_clist_append(GTK_CLIST(clist), &server->name);
1136
gtk_clist_set_row_data_full(GTK_CLIST(clist), *row,
1137
g_object_ref(server), g_object_unref);
1138
(*row)++;
1139
}
1140
1141
void fill_serverlist_serverstab(void)
1142
{
1143
GtkWidget *clist = current_serverstab_serverclist;
1144
gint row = 0;
1145
gpointer clist_and_row[2] = {
1146
clist,
1147
&row
1148
};
1149
1150
if(!GTK_IS_CLIST(clist))
1151
return;
1152
1153
gtk_clist_freeze(GTK_CLIST(clist));
1154
gtk_clist_clear(GTK_CLIST(clist));
1155
1156
gq_server_list_foreach(gq_server_list_get(), add_single_server, clist_and_row);
1157
1158
gtk_clist_thaw(GTK_CLIST(clist));
1159
}
1160
1161
1162
static void prefs_okbutton_callback(GtkWidget *button,
1163
struct prefs_windata *pw)
1164
{
1165
unsigned int type;
204
static void
205
serverstab_newbutton_callback(struct prefs_windata* pw)
206
{
207
GqServer * server = gq_server_new(NULL);
208
GtkWidget* dialog = gq_server_dialog_new(server, GTK_WINDOW(pw->prefswindow));
209
210
switch(gtk_dialog_run(GTK_DIALOG(dialog))) {
211
case GTK_RESPONSE_CLOSE:
212
gq_server_list_add(gq_server_list_get(), server);
213
break;
214
default:
215
// revert or deleted
216
break;
217
}
218
219
gtk_widget_destroy(dialog);
220
g_object_unref(server);
221
}
222
223
224
static void
225
serverstab_editbutton_callback(struct prefs_windata* pw)
226
{
227
GtkTreeModel* model;
228
GtkTreeIter iter;
229
GtkWidget * server_dialog;
230
GqServer * server;
231
232
#warning "FIXME: don't allow the edit button and the delete button if no server is selected"
233
if(!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(pw->serverstab_server_view)), &model, &iter))
234
{
235
return;
236
}
237
238
server = gq_server_model_get_server(GQ_SERVER_MODEL(model), &iter);
239
g_return_if_fail(server);
240
241
server_dialog = gq_server_dialog_new(server, GTK_WINDOW(pw->prefswindow));
242
gtk_dialog_run(GTK_DIALOG(server_dialog));
243
gtk_widget_destroy(server_dialog);
244
}
245
246
247
static gboolean
248
server_clicked_callback(struct prefs_windata* pw,
249
GdkEventButton* event,
250
GtkWidget* treeview)
251
{
252
GtkTreeModel* model;
253
GtkTreeIter iter;
254
255
if(event &&
256
event->type == GDK_2BUTTON_PRESS &&
257
gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
258
&model, &iter))
259
{
260
GqServer *server = gq_server_model_get_server(GQ_SERVER_MODEL(model), &iter);
261
GtkWidget* dialog = gq_server_dialog_new(server, GTK_WINDOW(pw->prefswindow));
262
gtk_dialog_run(GTK_DIALOG(dialog));
263
gtk_widget_destroy(dialog);
264
}
265
266
return FALSE;
267
}
268
269
270
static void
271
prefs_okbutton_callback(struct prefs_windata* pw)
272
{
1166
273
/* use a dummy configuration to store current/old preferences for
1167
274
rollback */
1168
275
struct gq_config *save = new_config();
1169
276
1170
/* Search type */
1171
for(type = 0; type < sizeof(pw->search_st)/sizeof(pw->search_st[0]);
1172
type++) {
1173
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pw->search_st[type])))
1174
break;
1175
}
1176
config->search_argument = type;
1177
1178
277
/* saves a lot of typing */
1179
278
#define CONFIG_TOGGLE_BUTTON(c,p,s,n) { \
1180
279
(s)->n = (c)->n; \
1218
317
CONFIG_TOGGLE_BUTTON(config, pw, save, do_not_use_ldap_conf);
1219
318
1220
319
/* WHEN ADDING STUFF: DO NOT FORGET TO CODE ROLLBACK AS WELL */
1221
/* Search type */
1222
for(type = 0; type < sizeof(pw->search_st)/sizeof(pw->search_st[0]);
1223
type++) {
1224
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pw->search_st[type])))
1225
break;
1226
}
1227
save->search_argument = config->search_argument;
1228
config->search_argument = type;
1229
1230
320
/* do_not_use_ldap_conf */
1231
321
CONFIG_TOGGLE_BUTTON(config, pw, save, do_not_use_ldap_conf);
1232
322
1233
/* LDIF: format */
1234
for(type = 0; type < sizeof(pw->ldif_format)/sizeof(pw->ldif_format[0]);
1235
type++) {
1236
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pw->ldif_format[type])))
1237
break;
1238
}
1239
save->ldifformat = config->ldifformat;
1240
config->ldifformat = type;
1241
1242
323
g_free_and_dup(save->schemaserver, config->schemaserver);
1243
324
if(pw->schemaserver) {
1244
g_free_and_dup(config->schemaserver,
1245
gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(pw->schemaserver)->entry)));
325
GtkTreeIter iter;
326
GqServer* server;
327
if(gtk_combo_box_get_active_iter(GTK_COMBO_BOX(pw->schemaserver), &iter)) {
328
g_free(config->schemaserver);
329
server = gq_server_model_get_server(GQ_SERVER_MODEL(gtk_combo_box_get_model(GTK_COMBO_BOX(pw->schemaserver))),
330
&iter);
331
config->schemaserver = g_strdup(gq_server_get_name(server));
332
}
1246
333
}
1247
334
1248
335
if (save_config(pw->prefswindow)) {
1263
350
CONFIG_ROLLBACK(config, save, never_leak_credentials);
1264
351
CONFIG_ROLLBACK(config, save, do_not_use_ldap_conf);
1265
352
1266
CONFIG_ROLLBACK(config, save, search_argument);
1267
CONFIG_ROLLBACK(config, save, ldifformat);
1268
353
g_free_and_dup(config->schemaserver, save->schemaserver);
1269
354
}
1270
355
1271
356
free_config(save);
1272
357
}
1273
358
1274
static void destroy_prefswindow(GtkWidget *window,
359
static void destroy_prefswindow(GtkWidget *window,
1275
360
struct prefs_windata *pw) {
1276
361
g_assert(pw);
1277
362
g_assert(window == prefswindow);
1281
366
}
1282
367
1283
368
1284
void create_prefs_window(struct mainwin_data *win)
369
void create_prefs_window(GqWindow *win)
1285
370
{
1286
371
GtkWidget *label, *vbox2;
1287
372
GtkWidget *notebook;
1288
373
GtkWidget *vbox_search_options, *vbox_browse_options;
1289
GtkWidget *vbox_servers, *vbox_templates, *vbox_ldif, *vbox_gui;
374
GtkWidget *vbox_servers, *vbox_templates, *vbox_gui;
1290
375
GtkWidget *vbox_sec;
1291
376
GtkWidget *hbox_buttons, *okbutton, *cancelbutton;
1292
377
1378
463
vbox_templates = NULL;
1379
464
#endif
1380
465
1381
/* LDIF tab */
1382
vbox_ldif = gtk_vbox_new(FALSE, 0);
1383
gtk_container_border_width(GTK_CONTAINER(vbox_ldif),
1384
CONTAINER_BORDER_WIDTH);
1385
create_ldiftab(vbox_ldif, pw);
1386
gtk_widget_show(vbox_ldif);
1387
label = gq_label_new(_("_LDIF"));
1388
gtk_widget_show(label);
1389
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_ldif, label);
1390
1391
1392
466
/* GUI tab */
1393
467
vbox_gui = gtk_vbox_new(FALSE, 0);
1394
468
gtk_container_border_width(GTK_CONTAINER(vbox_gui),
1410
484
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_sec, label);
1411
485
1412
486
/* OK and Cancel buttons outside notebook */
1413
hbox_buttons = gtk_hbutton_box_new(); /* FALSE, 0); */
487
hbox_buttons = gtk_hbutton_box_new();
488
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox_buttons), GTK_BUTTONBOX_END);
1414
489
gtk_widget_show(hbox_buttons);
1415
490
gtk_box_pack_start(GTK_BOX(vbox2), hbox_buttons, FALSE, TRUE, 10);
1416
491
/* gtk_container_border_width(GTK_CONTAINER(hbox_buttons), 10); */
1417
492
1418
okbutton = gtk_button_new_from_stock(GTK_STOCK_OK);
493
cancelbutton = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
494
gtk_widget_show(cancelbutton);
495
gtk_box_pack_end(GTK_BOX(hbox_buttons), cancelbutton, FALSE, TRUE, 0);
496
g_signal_connect_swapped(cancelbutton, "clicked",
497
G_CALLBACK(gtk_widget_destroy),
498
GTK_OBJECT(prefswindow));
499
500
okbutton = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
1419
501
gtk_widget_show(okbutton);
1420
g_signal_connect(okbutton, "clicked",
502
g_signal_connect_swapped(okbutton, "clicked",
1421
503
G_CALLBACK(prefs_okbutton_callback),
1422
504
pw);
1423
gtk_box_pack_start(GTK_BOX(hbox_buttons), okbutton, FALSE, TRUE, 0);
505
gtk_box_pack_end(GTK_BOX(hbox_buttons), okbutton, FALSE, TRUE, 0);
1424
506
GTK_WIDGET_SET_FLAGS(okbutton, GTK_CAN_DEFAULT);
1425
507
gtk_widget_grab_focus(okbutton);
1426
508
gtk_widget_grab_default(okbutton);
1427
509
1428
cancelbutton = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
1429
gtk_widget_show(cancelbutton);
1430
gtk_box_pack_end(GTK_BOX(hbox_buttons), cancelbutton, FALSE, TRUE, 0);
1431
g_signal_connect_swapped(cancelbutton, "clicked",
1432
G_CALLBACK(gtk_widget_destroy),
1433
GTK_OBJECT(prefswindow));
1434
1435
510
gtk_widget_show(prefswindow);
1436
511
1437
512
statusbar_msg(_("Preferences window opened"));
1438
513
}
1439
514
1440
515
1441
void create_serverstab(GtkWidget *target, struct prefs_windata *pw)
516
void
517
create_serverstab(GtkWidget * target,
518
struct prefs_windata* pw)
1442
519
{
1443
520
GtkWidget *vbox0, *vbox1, *vbox2, *hbox1, *hbox2, *scrwin;
1444
521
GtkWidget *button_new, *button_edit, *button_delete;
1445
GtkWidget *server_clist;
1446
522
1447
523
vbox1 = gtk_vbox_new(FALSE, 0);
1448
524
gtk_widget_show(vbox1);
1460
536
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwin),
1461
537
GTK_POLICY_AUTOMATIC,
1462
538
GTK_POLICY_AUTOMATIC);
539
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrwin), GTK_SHADOW_IN);
1463
540
gtk_box_pack_start(GTK_BOX(hbox2), scrwin, TRUE, TRUE, 0);
1464
541
1465
server_clist = gtk_clist_new(1);
1466
pw->serverstab_server_clist = server_clist;
1467
1468
#ifdef OLD_FOCUS_HANDLING
1469
GTK_WIDGET_UNSET_FLAGS(server_clist, GTK_CAN_FOCUS);
1470
#endif
1471
current_serverstab_serverclist = server_clist;
1472
gtk_widget_set_usize(scrwin, 200, 300);
1473
gtk_clist_set_selection_mode(GTK_CLIST(server_clist),
1474
GTK_SELECTION_SINGLE);
1475
gtk_clist_set_shadow_type(GTK_CLIST(server_clist), GTK_SHADOW_ETCHED_IN);
1476
gtk_widget_show(server_clist);
1477
1478
g_signal_connect(server_clist, "select_row",
1479
G_CALLBACK(server_selected_callback), pw);
1480
g_signal_connect(server_clist, "unselect_row",
1481
G_CALLBACK(server_unselected_callback), NULL);
1482
1483
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrwin),
1484
server_clist);
1485
fill_serverlist_serverstab();
542
pw->serverstab_server_view = gtk_tree_view_new();
543
{
544
GtkTreeViewColumn* column;
545
GtkCellRenderer * renderer;
546
GtkTreeModel * model = gq_server_model_new(gq_server_list_get());
547
gtk_tree_view_set_model(GTK_TREE_VIEW(pw->serverstab_server_view),
548
model);
549
g_object_unref(model);
550
551
column = gtk_tree_view_column_new();
552
renderer = gtk_cell_renderer_pixbuf_new();
553
gtk_tree_view_column_pack_start(column, renderer, FALSE);
554
gtk_tree_view_column_add_attribute(column, renderer,
555
"icon-name", GQ_SERVER_MODEL_COL_STATUS);
556
renderer = gtk_cell_renderer_text_new();
557
gtk_tree_view_column_pack_start(column, renderer, TRUE);
558
gtk_tree_view_column_add_attribute(column, renderer,
559
"text", GQ_SERVER_MODEL_COL_NAME);
560
gtk_tree_view_append_column(GTK_TREE_VIEW(pw->serverstab_server_view), column);
561
}
562
563
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(pw->serverstab_server_view)),
564
GTK_SELECTION_SINGLE);
565
g_signal_connect_swapped(pw->serverstab_server_view, "button-press-event",
566
G_CALLBACK(server_clicked_callback), pw);
567
gtk_widget_show(pw->serverstab_server_view);
568
569
gtk_container_add(GTK_CONTAINER(scrwin), pw->serverstab_server_view);
1486
570
1487
571
vbox0 = gtk_vbox_new(FALSE, 10);
1488
572
gtk_widget_show(vbox0);
1500
584
GTK_WIDGET_UNSET_FLAGS(button_new, GTK_CAN_FOCUS);
1501
585
#endif
1502
586
gtk_widget_show(button_new);
1503
g_signal_connect(button_new, "clicked",
587
g_signal_connect_swapped(button_new, "clicked",
1504
588
G_CALLBACK(serverstab_newbutton_callback),
1505
589
pw);
1506
590
gtk_box_pack_start(GTK_BOX(vbox2), button_new, FALSE, TRUE, 0);
1511
595
GTK_WIDGET_UNSET_FLAGS(button_edit, GTK_CAN_FOCUS);
1512
596
#endif
1513
597
gtk_widget_show(button_edit);
1514
g_signal_connect(button_edit, "clicked",
598
g_signal_connect_swapped(button_edit, "clicked",
1515
599
G_CALLBACK(serverstab_editbutton_callback),
1516
600
pw);
1517
601
gtk_box_pack_start(GTK_BOX(vbox2), button_edit, FALSE, TRUE, 0);
1540
624
{
1541
625
GtkWidget *vbox0, *vbox1, *vbox2, *hbox1, *hbox2, *scrwin;
1542
626
GtkWidget *button_new, *button_edit, *button_delete;
1543
GtkWidget *template_clist, *label, *combo;
627
GtkWidget *template_clist, *label;
1544
628
1545
629
vbox1 = gtk_vbox_new(FALSE, 0);
1546
630
gtk_widget_show(vbox1);
1558
642
gtk_widget_show(label);
1559
643
gtk_box_pack_start(GTK_BOX(hbox1), label, FALSE, FALSE, 0);
1560
644
1561
combo = gtk_combo_new();
1562
pw->schemaserver = combo;
1563
#ifdef OLD_FOCUS_HANDLING
1564
GTK_WIDGET_UNSET_FLAGS(GTK_COMBO(combo)->entry, GTK_CAN_FOCUS);
1565
#endif
1566
fill_serverlist_combo(combo);
1567
if(strlen(config->schemaserver))
1568
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry),
1569
config->schemaserver);
1570
gtk_widget_show(combo);
1571
gtk_box_pack_start(GTK_BOX(hbox1), combo, FALSE, FALSE, 0);
645
pw->schemaserver = gtk_combo_box_new();
646
{
647
GtkCellRenderer* renderer;
648
GtkTreeModel* model = gq_server_model_new(gq_server_list_get());
649
650
gtk_combo_box_set_model(GTK_COMBO_BOX(pw->schemaserver),
651
model);
652
g_object_unref(model);
653
654
renderer = gtk_cell_renderer_text_new();
655
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(pw->schemaserver),
656
renderer, TRUE);
657
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(pw->schemaserver),
658
renderer,
659
"text", GQ_SERVER_MODEL_COL_NAME,
660
NULL);
661
}
662
663
if(config->schemaserver && *config->schemaserver) {
664
GtkTreeModel* model;
665
GtkTreeIter iter;
666
GqServer * server = gq_server_list_get_by_name(gq_server_list_get(), config->schemaserver);
667
model = gtk_combo_box_get_model(GTK_COMBO_BOX(pw->schemaserver));
668
if(server && gq_server_model_get_iter(GQ_SERVER_MODEL(model), &iter, server)) {
669
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(pw->schemaserver), &iter);
670
}
671
}
672
gtk_widget_show(pw->schemaserver);
673
gtk_box_pack_start(GTK_BOX(hbox1), pw->schemaserver, FALSE, FALSE, 0);
1572
674
1573
675
hbox2 = gtk_hbox_new(FALSE, 25);
1574
676
gtk_widget_show(hbox2);
1617
719
GTK_WIDGET_UNSET_FLAGS(button_new, GTK_CAN_FOCUS);
1618
720
#endif
1619
721
gtk_widget_show(button_new);
1620
g_signal_connect(button_new, "clicked",
722
g_signal_connect_swapped(button_new, "clicked",
1621
723
G_CALLBACK(template_new_callback),
1622
724
pw);
1623
725
gtk_box_pack_start(GTK_BOX(vbox2), button_new, FALSE, TRUE, 0);
1628
730
GTK_WIDGET_UNSET_FLAGS(button_edit, GTK_CAN_FOCUS);
1629
731
#endif
1630
732
gtk_widget_show(button_edit);
1631
g_signal_connect(button_edit, "clicked",
733
g_signal_connect_swapped(button_edit, "clicked",
1632
734
G_CALLBACK(template_edit_callback),
1633
735
pw);
1634
736
gtk_box_pack_start(GTK_BOX(vbox2), button_edit, FALSE, TRUE, 0);
1649
751
1650
752
void create_search_optionstab(GtkWidget *target, struct prefs_windata *pw)
1651
753
{
1652
GtkWidget *stframe, *vbox_st, *viewframe, *vbox_view;
1653
GtkWidget *stradiobutton, *dnbutton; /* , *ocbutton; */
754
GtkWidget *viewframe, *vbox_view;
755
GtkWidget *dnbutton;
1654
756
GtkWidget *hbox_options;
1655
/* , *sort_search_button; */
1656
GSList *stgroup;
1657
757
1658
758
hbox_options = gtk_hbox_new(TRUE, 10);
1659
759
gtk_widget_show(hbox_options);
1660
760
gtk_box_pack_start(GTK_BOX(target), hbox_options, FALSE, TRUE, 5);
1661
761
1662
/* Search type frame in Options tab */
1663
stframe = gtk_frame_new(_("Search type"));
1664
gtk_widget_show(stframe);
1665
gtk_box_pack_start(GTK_BOX(hbox_options), stframe, FALSE, TRUE, 0);
1666
vbox_st = gtk_vbox_new(TRUE, 0);
1667
gtk_container_border_width(GTK_CONTAINER(vbox_st),
1668
CONTAINER_BORDER_WIDTH);
1669
gtk_widget_show(vbox_st);
1670
gtk_container_add(GTK_CONTAINER(stframe), vbox_st);
1671
1672
stradiobutton = gq_radio_button_new_with_label(NULL, _("_Begins with"));
1673
if(config->search_argument == SEARCHARG_BEGINS_WITH)
1674
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stradiobutton), TRUE);
1675
#ifdef OLD_FOCUS_HANDLING
1676
GTK_WIDGET_UNSET_FLAGS(GTK_RADIO_BUTTON(stradiobutton), GTK_CAN_FOCUS);
1677
#endif
1678
pw->search_st[0] = stradiobutton;
1679
gtk_box_pack_start(GTK_BOX(vbox_st), stradiobutton, TRUE, TRUE, 3);
1680
gtk_widget_show(stradiobutton);
1681
1682
stgroup = gtk_radio_button_group(GTK_RADIO_BUTTON(stradiobutton));
1683
stradiobutton = gq_radio_button_new_with_label(stgroup, _("_Ends with"));
1684
if(config->search_argument == SEARCHARG_ENDS_WITH)
1685
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stradiobutton), TRUE);
1686
#ifdef OLD_FOCUS_HANDLING
1687
GTK_WIDGET_UNSET_FLAGS(GTK_RADIO_BUTTON(stradiobutton), GTK_CAN_FOCUS);
1688
#endif
1689
pw->search_st[1] = stradiobutton;
1690
gtk_box_pack_start(GTK_BOX(vbox_st), stradiobutton, TRUE, TRUE, 3);
1691
gtk_widget_show(stradiobutton);
1692
1693
stgroup = gtk_radio_button_group(GTK_RADIO_BUTTON(stradiobutton));
1694
stradiobutton = gq_radio_button_new_with_label(stgroup, _("_Contains"));
1695
if(config->search_argument == SEARCHARG_CONTAINS)
1696
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stradiobutton), TRUE);
1697
#ifdef OLD_FOCUS_HANDLING
1698
GTK_WIDGET_UNSET_FLAGS(GTK_RADIO_BUTTON(stradiobutton), GTK_CAN_FOCUS);
1699
#endif
1700
pw->search_st[2] = stradiobutton;
1701
gtk_box_pack_start(GTK_BOX(vbox_st), stradiobutton, TRUE, TRUE, 3);
1702
gtk_widget_show(stradiobutton);
1703
1704
stgroup = gtk_radio_button_group(GTK_RADIO_BUTTON(stradiobutton));
1705
stradiobutton = gq_radio_button_new_with_label(stgroup, _("E_quals"));
1706
if(config->search_argument == SEARCHARG_EQUALS)
1707
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stradiobutton), TRUE);
1708
#ifdef OLD_FOCUS_HANDLING
1709
GTK_WIDGET_UNSET_FLAGS(GTK_RADIO_BUTTON(stradiobutton), GTK_CAN_FOCUS);
1710
#endif
1711
pw->search_st[3] = stradiobutton;
1712
gtk_box_pack_start(GTK_BOX(vbox_st), stradiobutton, TRUE, TRUE, 3);
1713
gtk_widget_show(stradiobutton);
1714
1715
762
/* View frame in Options tab */
1716
763
viewframe = gtk_frame_new(_("View"));
1717
764
gtk_widget_show(viewframe);
1811
858
1812
859
}
1813
860
1814
1815
void create_ldiftab(GtkWidget *target, struct prefs_windata *pw)
1816
{
1817
GtkWidget *formatframe;
1818
GtkWidget *formatradio;
1819
GSList *formatgroup;
1820
GtkWidget *vbox1;
1821
1822
/* Format frame */
1823
formatframe = gtk_frame_new(_("Format"));
1824
gtk_widget_show(formatframe);
1825
gtk_box_pack_start(GTK_BOX(target), formatframe, FALSE, TRUE, 5);
1826
1827
vbox1 = gtk_vbox_new(FALSE, 0);
1828
gtk_container_border_width(GTK_CONTAINER(vbox1),
1829
CONTAINER_BORDER_WIDTH);
1830
gtk_container_add(GTK_CONTAINER(formatframe), vbox1);
1831
gtk_widget_show(vbox1);
1832
1833
formatradio = gq_radio_button_new_with_label(NULL, _("_UMich/OpenLDAP style (no comments/version)"));
1834
if(config->ldifformat == LDIF_UMICH)
1835
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(formatradio), TRUE);
1836
#ifdef OLD_FOCUS_HANDLING
1837
GTK_WIDGET_UNSET_FLAGS(GTK_RADIO_BUTTON(formatradio), GTK_CAN_FOCUS);
1838
#endif
1839
pw->ldif_format[0] = formatradio;
1840
gtk_box_pack_start(GTK_BOX(vbox1), formatradio, TRUE, TRUE, 3);
1841
gtk_widget_show(formatradio);
1842
1843
formatgroup = gtk_radio_button_group(GTK_RADIO_BUTTON(formatradio));
1844
formatradio = gq_radio_button_new_with_label(formatgroup, _("LDIF Version _1 (RFC2849)"));
1845
if(config->ldifformat == LDIF_V1)
1846
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(formatradio), TRUE);
1847
#ifdef OLD_FOCUS_HANDLING
1848
GTK_WIDGET_UNSET_FLAGS(GTK_RADIO_BUTTON(formatradio), GTK_CAN_FOCUS);
1849
#endif
1850
pw->ldif_format[1] = formatradio;
1851
gtk_box_pack_start(GTK_BOX(vbox1), formatradio, TRUE, TRUE, 3);
1852
gtk_widget_show(formatradio);
1853
1854
}
1855
1856
1857
861
static void create_guitab(GtkWidget *target, struct prefs_windata *pw)
1858
862
{
1859
863
GtkWidget *persistframe;
2005
1009
2006
1010
2007
1011
#ifdef HAVE_LDAP_STR2OBJECTCLASS
2008
void template_new_callback(GtkWidget *widget, struct prefs_windata *pw)
1012
void template_new_callback(struct prefs_windata *pw)
2009
1013
{
2010
1014
GqServer *server;
2011
1015
const char *servername;
2022
1026
}
2023
1027
2024
1028
2025
void template_edit_callback(GtkWidget *widget, struct prefs_windata *pw)
1029
void template_edit_callback(struct prefs_windata *pw)
2026
1030
{
2027
1031
GqServer *server;
2028
1032
const char *servername, *templatename;
2046
1050
2047
1051
}
2048
1052
2049
2050
void template_selected_callback(GtkWidget *clist, gint row, gint column,
2051
GdkEventButton *event, struct prefs_windata *data)
1053
void
1054
template_selected_callback(GtkWidget * clist G_GNUC_UNUSED,
1055
gint row G_GNUC_UNUSED,
1056
gint column G_GNUC_UNUSED,
1057
GdkEventButton * event,
1058
struct prefs_windata* data)
2052
1059
{
2053
1060
if (event) {
2054
1061
if(event->type == GDK_2BUTTON_PRESS) {
2055
template_edit_callback(NULL, data);
1062
template_edit_callback(data);
2056
1063
}
2057
1064
}
2058
1065
}
2059
1066
2060
2061
1067
void template_delete_callback(GtkWidget *widget, struct prefs_windata *pw)
2062
1068
{
2063
1069
GList *list;
2086
1092
}
2087
1093
#endif
2088
1094
2089
2090
/*
2091
Local Variables:
2092
c-basic-offset: 5
2093
End:
2094
*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.1