?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merged pidgin/main into default
[pidgin-git.git] / pidgin / gtkrequest.c
blobe6ec26ad3e84b2d9003ce6c5f82dc5fea31bd79e
1 /* pidgin
2 *
3 * Pidgin is the legal property of its developers, whose names are too numerous
4 * to list here. Please refer to the COPYRIGHT file distributed with this
5 * source distribution.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
20 */
21 #include "internal.h"
22 #include "pidgin.h"
23
24 #include "debug.h"
25 #include "prefs.h"
26 #include "tls-certificate-info.h"
27 #include "util.h"
28
29 #include "gtkwebview.h"
30 #include "gtkrequest.h"
31 #include "gtkutils.h"
32 #include "pidginstock.h"
33 #include "gtkblist.h"
34 #include "gtkinternal.h"
35
36 #include <gdk/gdkkeysyms.h>
37
38 #ifdef ENABLE_GCR
39 #define GCR_API_SUBJECT_TO_CHANGE
40 #include <gcr/gcr.h>
41 #endif
42
43 #include "gtk3compat.h"
44
45 typedef struct
46 {
47 PurpleRequestType type;
48
49 void *user_data;
50 GtkWidget *dialog;
51
52 GtkWidget *ok_button;
53
54 size_t cb_count;
55 GCallback *cbs;
56
57 union
58 {
59 struct
60 {
61 GtkProgressBar *progress_bar;
62 } wait;
63
64 struct
65 {
66 GtkWidget *entry;
67
68 gboolean multiline;
69 gchar *hint;
70
71 } input;
72
73 struct
74 {
75 PurpleRequestFields *fields;
76
77 } multifield;
78
79 struct
80 {
81 gboolean savedialog;
82 gchar *name;
83
84 } file;
85
86 } u;
87
88 } PidginRequestData;
89
90 static GHashTable *datasheet_stock = NULL;
91
92 static GtkWidget * create_account_field(PurpleRequestField *field);
93
94 static void
95 pidgin_widget_decorate_account(GtkWidget *cont, PurpleAccount *account)
96 {
97 GtkWidget *image;
98 GdkPixbuf *pixbuf;
99
100 if (!account)
101 return;
102
103 pixbuf = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_SMALL);
104 image = gtk_image_new_from_pixbuf(pixbuf);
105 g_object_unref(G_OBJECT(pixbuf));
106
107 gtk_widget_set_tooltip_text(image, purple_account_get_username(account));
108
109 if (GTK_IS_DIALOG(cont)) {
110 gtk_box_pack_start(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(cont))),
111 image, FALSE, TRUE, 0);
112 gtk_box_reorder_child(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(cont))),
113 image, 0);
114 } else if (GTK_IS_BOX(cont)) {
115 gtk_widget_set_halign(image, GTK_ALIGN_START);
116 gtk_widget_set_valign(image, GTK_ALIGN_START);
117 gtk_box_pack_end(GTK_BOX(cont), image, FALSE, TRUE, 0);
118 }
119 gtk_widget_show(image);
120 }
121
122 static void
123 generic_response_start(PidginRequestData *data)
124 {
125 g_return_if_fail(data != NULL);
126
127 /* Tell the user we're doing something. */
128 pidgin_set_cursor(GTK_WIDGET(data->dialog), GDK_WATCH);
129
130 g_object_set_data(G_OBJECT(data->dialog),
131 "pidgin-window-is-closing", GINT_TO_POINTER(TRUE));
132 gtk_widget_set_visible(GTK_WIDGET(data->dialog), FALSE);
133 }
134
135 static void
136 input_response_cb(GtkDialog *dialog, gint id, PidginRequestData *data)
137 {
138 const char *value;
139 char *multiline_value = NULL;
140
141 generic_response_start(data);
142
143 if (data->u.input.multiline) {
144 GtkTextIter start_iter, end_iter;
145 GtkTextBuffer *buffer =
146 gtk_text_view_get_buffer(GTK_TEXT_VIEW(data->u.input.entry));
147
148 gtk_text_buffer_get_start_iter(buffer, &start_iter);
149 gtk_text_buffer_get_end_iter(buffer, &end_iter);
150
151 if ((data->u.input.hint != NULL) && (!strcmp(data->u.input.hint, "html")))
152 multiline_value = pidgin_webview_get_body_html(PIDGIN_WEBVIEW(data->u.input.entry));
153 else
154 multiline_value = gtk_text_buffer_get_text(buffer, &start_iter, &end_iter,
155 FALSE);
156
157 value = multiline_value;
158 }
159 else
160 value = gtk_entry_get_text(GTK_ENTRY(data->u.input.entry));
161
162 if (id >= 0 && (gsize)id < data->cb_count && data->cbs[id] != NULL)
163 ((PurpleRequestInputCb)data->cbs[id])(data->user_data, value);
164 else if (data->cbs[1] != NULL)
165 ((PurpleRequestInputCb)data->cbs[1])(data->user_data, value);
166
167 if (data->u.input.multiline)
168 g_free(multiline_value);
169
170 purple_request_close(PURPLE_REQUEST_INPUT, data);
171 }
172
173 static void
174 action_response_cb(GtkDialog *dialog, gint id, PidginRequestData *data)
175 {
176 generic_response_start(data);
177
178 if (id >= 0 && (gsize)id < data->cb_count && data->cbs[id] != NULL)
179 ((PurpleRequestActionCb)data->cbs[id])(data->user_data, id);
180
181 purple_request_close(PURPLE_REQUEST_INPUT, data);
182 }
183
184
185 static void
186 choice_response_cb(GtkDialog *dialog, gint id, PidginRequestData *data)
187 {
188 GtkWidget *radio = g_object_get_data(G_OBJECT(dialog), "radio");
189 GSList *group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
190
191 generic_response_start(data);
192
193 if (id >= 0 && (gsize)id < data->cb_count && data->cbs[id] != NULL)
194 while (group) {
195 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(group->data))) {
196 ((PurpleRequestChoiceCb)data->cbs[id])(data->user_data, g_object_get_data(G_OBJECT(group->data), "choice_value"));
197 break;
198 }
199 group = group->next;
200 }
201 purple_request_close(PURPLE_REQUEST_INPUT, data);
202 }
203
204 static gboolean
205 field_string_focus_out_cb(GtkWidget *entry, GdkEventFocus *event,
206 PurpleRequestField *field)
207 {
208 const char *value;
209
210 if (purple_request_field_string_is_multiline(field))
211 {
212 GtkTextBuffer *buffer;
213 GtkTextIter start_iter, end_iter;
214
215 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
216
217 gtk_text_buffer_get_start_iter(buffer, &start_iter);
218 gtk_text_buffer_get_end_iter(buffer, &end_iter);
219
220 value = gtk_text_buffer_get_text(buffer, &start_iter, &end_iter, FALSE);
221 }
222 else
223 value = gtk_entry_get_text(GTK_ENTRY(entry));
224
225 purple_request_field_string_set_value(field,
226 (*value == '\0' ? NULL : value));
227
228 return FALSE;
229 }
230
231 static void
232 field_bool_cb(GtkToggleButton *button, PurpleRequestField *field)
233 {
234 purple_request_field_bool_set_value(field,
235 gtk_toggle_button_get_active(button));
236 }
237
238 static void
239 field_choice_menu_cb(GtkComboBox *menu, PurpleRequestField *field)
240 {
241 int active = gtk_combo_box_get_active(menu);
242 gpointer *values = g_object_get_data(G_OBJECT(menu), "values");
243
244 g_return_if_fail(values != NULL);
245 g_return_if_fail(active >= 0);
246
247 purple_request_field_choice_set_value(field, values[active]);
248 }
249
250 static void
251 field_choice_option_cb(GtkRadioButton *button, PurpleRequestField *field)
252 {
253 int active;
254 gpointer *values = g_object_get_data(G_OBJECT(g_object_get_data(
255 G_OBJECT(button), "box")), "values");
256
257 if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)))
258 return;
259
260 active = (g_slist_length(gtk_radio_button_get_group(button)) -
261 g_slist_index(gtk_radio_button_get_group(button), button)) - 1;
262
263 g_return_if_fail(values != NULL);
264 g_return_if_fail(active >= 0);
265
266 purple_request_field_choice_set_value(field, values[active]);
267 }
268
269 static void
270 field_account_cb(GObject *w, PurpleAccount *account, PurpleRequestField *field)
271 {
272 purple_request_field_account_set_value(field, account);
273 }
274
275 static void
276 multifield_ok_cb(GtkWidget *button, PidginRequestData *data)
277 {
278 generic_response_start(data);
279
280 if (!gtk_widget_has_focus(button))
281 gtk_widget_grab_focus(button);
282
283 if (data->cbs[0] != NULL)
284 ((PurpleRequestFieldsCb)data->cbs[0])(data->user_data,
285 data->u.multifield.fields);
286
287 purple_request_close(PURPLE_REQUEST_FIELDS, data);
288 }
289
290 static void
291 multifield_cancel_cb(GtkWidget *button, PidginRequestData *data)
292 {
293 generic_response_start(data);
294
295 if (data->cbs[1] != NULL)
296 ((PurpleRequestFieldsCb)data->cbs[1])(data->user_data,
297 data->u.multifield.fields);
298
299 purple_request_close(PURPLE_REQUEST_FIELDS, data);
300 }
301
302 static void
303 multifield_extra_cb(GtkWidget *button, PidginRequestData *data)
304 {
305 PurpleRequestFieldsCb cb;
306
307 generic_response_start(data);
308
309 cb = g_object_get_data(G_OBJECT(button), "extra-cb");
310
311 if (cb != NULL)
312 cb(data->user_data, data->u.multifield.fields);
313
314 purple_request_close(PURPLE_REQUEST_FIELDS, data);
315 }
316
317 static gboolean
318 destroy_multifield_cb(GtkWidget *dialog, GdkEvent *event,
319 PidginRequestData *data)
320 {
321 multifield_cancel_cb(NULL, data);
322 return FALSE;
323 }
324
325
326 #define STOCK_ITEMIZE(r, l) \
327 if (!strcmp((r), text) || !strcmp(_(r), text)) \
328 return (l);
329
330 static const char *
331 text_to_stock(const char *text)
332 {
333 STOCK_ITEMIZE(N_("Yes"), GTK_STOCK_YES);
334 STOCK_ITEMIZE(N_("_Yes"), GTK_STOCK_YES);
335 STOCK_ITEMIZE(N_("No"), GTK_STOCK_NO);
336 STOCK_ITEMIZE(N_("_No"), GTK_STOCK_NO);
337 STOCK_ITEMIZE(N_("OK"), GTK_STOCK_OK);
338 STOCK_ITEMIZE(N_("_OK"), GTK_STOCK_OK);
339 STOCK_ITEMIZE(N_("Cancel"), GTK_STOCK_CANCEL);
340 STOCK_ITEMIZE(N_("_Cancel"), GTK_STOCK_CANCEL);
341 STOCK_ITEMIZE(N_("Apply"), GTK_STOCK_APPLY);
342 STOCK_ITEMIZE(N_("Close"), GTK_STOCK_CLOSE);
343 STOCK_ITEMIZE(N_("Delete"), GTK_STOCK_DELETE);
344 STOCK_ITEMIZE(N_("Add"), GTK_STOCK_ADD);
345 STOCK_ITEMIZE(N_("Remove"), GTK_STOCK_REMOVE);
346 STOCK_ITEMIZE(N_("Save"), GTK_STOCK_SAVE);
347 STOCK_ITEMIZE(N_("Next"), PIDGIN_STOCK_NEXT);
348 STOCK_ITEMIZE(N_("_Next"), PIDGIN_STOCK_NEXT);
349 STOCK_ITEMIZE(N_("Back"), GTK_STOCK_GO_BACK);
350 STOCK_ITEMIZE(N_("_Back"), GTK_STOCK_GO_BACK);
351 STOCK_ITEMIZE(N_("Alias"), PIDGIN_STOCK_ALIAS);
352
353 return text;
354 }
355
356 #undef STOCK_ITEMIZE
357
358 static gchar *
359 pidgin_request_escape(PurpleRequestCommonParameters *cpar, const gchar *text)
360 {
361 if (text == NULL)
362 return NULL;
363
364 if (purple_request_cpar_is_html(cpar)) {
365 gboolean valid;
366
367 valid = pango_parse_markup(text, -1, 0, NULL, NULL, NULL, NULL);
368
369 if (valid)
370 return g_strdup(text);
371 else {
372 purple_debug_error("pidgin", "Passed label text is not "
373 "a valid markup. Falling back to plain text.");
374 }
375 }
376
377 return g_markup_escape_text(text, -1);
378 }
379
380 static GtkWidget *
381 pidgin_request_dialog_icon(PurpleRequestType dialog_type,
382 PurpleRequestCommonParameters *cpar)
383 {
384 GtkWidget *img = NULL;
385 PurpleRequestIconType icon_type;
386 gconstpointer icon_data;
387 gsize icon_size;
388 const gchar *icon_stock = PIDGIN_STOCK_DIALOG_QUESTION;
389
390 /* Dialog icon. */
391 icon_data = purple_request_cpar_get_custom_icon(cpar, &icon_size);
392 if (icon_data) {
393 GdkPixbuf *pixbuf;
394
395 pixbuf = pidgin_pixbuf_from_data(icon_data, icon_size);
396 if (pixbuf) {
397 /* scale the image if it is too large */
398 int width = gdk_pixbuf_get_width(pixbuf);
399 int height = gdk_pixbuf_get_height(pixbuf);
400 if (width > 128 || height > 128) {
401 int scaled_width = width > height ?
402 128 : (128 * width) / height;
403 int scaled_height = height > width ?
404 128 : (128 * height) / width;
405 GdkPixbuf *scaled;
406
407 purple_debug_info("pidgin", "dialog icon was "
408 "too large, scaling it down");
409
410 scaled = gdk_pixbuf_scale_simple(pixbuf,
411 scaled_width, scaled_height,
412 GDK_INTERP_BILINEAR);
413 if (scaled) {
414 g_object_unref(pixbuf);
415 pixbuf = scaled;
416 }
417 }
418 img = gtk_image_new_from_pixbuf(pixbuf);
419 g_object_unref(pixbuf);
420 } else {
421 purple_debug_info("pidgin",
422 "failed to parse dialog icon");
423 }
424 }
425
426 if (img)
427 return img;
428
429 icon_type = purple_request_cpar_get_icon(cpar);
430 switch (icon_type)
431 {
432 case PURPLE_REQUEST_ICON_DEFAULT:
433 icon_stock = NULL;
434 break;
435 case PURPLE_REQUEST_ICON_REQUEST:
436 icon_stock = PIDGIN_STOCK_DIALOG_QUESTION;
437 break;
438 case PURPLE_REQUEST_ICON_DIALOG:
439 case PURPLE_REQUEST_ICON_INFO:
440 case PURPLE_REQUEST_ICON_WAIT: /* TODO: we need another icon */
441 icon_stock = PIDGIN_STOCK_DIALOG_INFO;
442 break;
443 case PURPLE_REQUEST_ICON_WARNING:
444 icon_stock = PIDGIN_STOCK_DIALOG_WARNING;
445 break;
446 case PURPLE_REQUEST_ICON_ERROR:
447 icon_stock = PIDGIN_STOCK_DIALOG_ERROR;
448 break;
449 /* intentionally no default value */
450 }
451
452 if (icon_stock == NULL) {
453 switch (dialog_type) {
454 case PURPLE_REQUEST_INPUT:
455 case PURPLE_REQUEST_CHOICE:
456 case PURPLE_REQUEST_ACTION:
457 case PURPLE_REQUEST_FIELDS:
458 case PURPLE_REQUEST_FILE:
459 case PURPLE_REQUEST_FOLDER:
460 icon_stock = PIDGIN_STOCK_DIALOG_QUESTION;
461 break;
462 case PURPLE_REQUEST_WAIT:
463 icon_stock = PIDGIN_STOCK_DIALOG_INFO;
464 break;
465 /* intentionally no default value */
466 }
467 }
468
469 img = gtk_image_new_from_stock(icon_stock,
470 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE));
471
472 if (img || icon_type == PURPLE_REQUEST_ICON_REQUEST)
473 return img;
474
475 return gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_QUESTION,
476 gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE));
477 }
478
479 static void
480 pidgin_request_help_clicked(GtkButton *button, gpointer _unused)
481 {
482 PurpleRequestHelpCb cb;
483 gpointer data;
484
485 cb = g_object_get_data(G_OBJECT(button), "pidgin-help-cb");
486 data = g_object_get_data(G_OBJECT(button), "pidgin-help-data");
487
488 g_return_if_fail(cb != NULL);
489 cb(data);
490 }
491
492 static void
493 pidgin_request_add_help(GtkDialog *dialog, PurpleRequestCommonParameters *cpar)
494 {
495 GtkWidget *button;
496 PurpleRequestHelpCb help_cb;
497 gpointer help_data;
498
499 help_cb = purple_request_cpar_get_help_cb(cpar, &help_data);
500 if (help_cb == NULL)
501 return;
502
503 button = gtk_dialog_add_button(dialog, GTK_STOCK_HELP,
504 GTK_RESPONSE_HELP);
505
506 g_object_set_data(G_OBJECT(button), "pidgin-help-cb", help_cb);
507 g_object_set_data(G_OBJECT(button), "pidgin-help-data", help_data);
508
509 g_signal_connect(G_OBJECT(button), "clicked",
510 G_CALLBACK(pidgin_request_help_clicked), NULL);
511 }
512
513 static void *
514 pidgin_request_input(const char *title, const char *primary,
515 const char *secondary, const char *default_value,
516 gboolean multiline, gboolean masked, gchar *hint,
517 const char *ok_text, GCallback ok_cb,
518 const char *cancel_text, GCallback cancel_cb,
519 PurpleRequestCommonParameters *cpar,
520 void *user_data)
521 {
522 PidginRequestData *data;
523 GtkWidget *dialog;
524 GtkWidget *vbox;
525 GtkWidget *hbox;
526 GtkLabel *label;
527 GtkWidget *entry;
528 GtkWidget *img;
529 char *label_text;
530 char *primary_esc, *secondary_esc;
531
532 data = g_new0(PidginRequestData, 1);
533 data->type = PURPLE_REQUEST_INPUT;
534 data->user_data = user_data;
535
536 data->cb_count = 2;
537 data->cbs = g_new0(GCallback, 2);
538
539 data->cbs[0] = ok_cb;
540 data->cbs[1] = cancel_cb;
541
542 /* Create the dialog. */
543 dialog = gtk_dialog_new_with_buttons(title ? title : PIDGIN_ALERT_TITLE,
544 NULL, 0,
545 text_to_stock(cancel_text), 1,
546 text_to_stock(ok_text), 0,
547 NULL);
548 data->dialog = dialog;
549
550 g_signal_connect(G_OBJECT(dialog), "response",
551 G_CALLBACK(input_response_cb), data);
552
553 /* Setup the dialog */
554 gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BORDER/2);
555 gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
556 PIDGIN_HIG_BORDER / 2);
557 if (!multiline)
558 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
559 gtk_dialog_set_default_response(GTK_DIALOG(dialog), 0);
560 gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
561 PIDGIN_HIG_BORDER);
562
563 /* Setup the main horizontal box */
564 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
565 gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
566 hbox);
567
568 /* Dialog icon. */
569 img = pidgin_request_dialog_icon(PURPLE_REQUEST_INPUT, cpar);
570 gtk_widget_set_halign(img, GTK_ALIGN_START);
571 gtk_widget_set_valign(img, GTK_ALIGN_START);
572 gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
573
574 pidgin_request_add_help(GTK_DIALOG(dialog), cpar);
575
576 /* Vertical box */
577 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
578
579 gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
580
581 pidgin_widget_decorate_account(hbox, purple_request_cpar_get_account(cpar));
582
583 /* Descriptive label */
584 primary_esc = pidgin_request_escape(cpar, primary);
585 secondary_esc = pidgin_request_escape(cpar, secondary);
586 label_text = g_strdup_printf((primary ? "<span weight=\"bold\" size=\"larger\">"
587 "%s</span>%s%s" : "%s%s%s"),
588 (primary ? primary_esc : ""),
589 ((primary && secondary) ? "\n\n" : ""),
590 (secondary ? secondary_esc : ""));
591 g_free(primary_esc);
592 g_free(secondary_esc);
593
594 label = GTK_LABEL(gtk_label_new(NULL));
595
596 gtk_label_set_markup(label, label_text);
597 gtk_label_set_line_wrap(label, TRUE);
598 gtk_label_set_xalign(label, 0);
599 gtk_label_set_yalign(label, 0);
600 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(label), FALSE, FALSE, 0);
601
602 g_free(label_text);
603
604 /* Entry field. */
605 data->u.input.multiline = multiline;
606 data->u.input.hint = g_strdup(hint);
607
608 gtk_widget_show_all(hbox);
609
610 if ((data->u.input.hint != NULL) && (!strcmp(data->u.input.hint, "html"))) {
611 GtkWidget *frame;
612
613 /* webview */
614 frame = pidgin_create_webview(TRUE, &entry, NULL);
615 gtk_widget_set_size_request(entry, 320, 130);
616 gtk_widget_set_name(entry, "pidgin_request_webview");
617 if (default_value != NULL)
618 pidgin_webview_append_html(PIDGIN_WEBVIEW(entry), default_value);
619 gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
620 gtk_widget_show(frame);
621 }
622 else {
623 if (multiline) {
624 /* GtkTextView */
625 entry = gtk_text_view_new();
626 gtk_text_view_set_editable(GTK_TEXT_VIEW(entry), TRUE);
627
628 if (default_value != NULL) {
629 GtkTextBuffer *buffer;
630
631 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
632 gtk_text_buffer_set_text(buffer, default_value, -1);
633 }
634
635 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(entry), GTK_WRAP_WORD_CHAR);
636
637 gtk_box_pack_start(GTK_BOX(vbox),
638 pidgin_make_scrollable(entry, GTK_POLICY_NEVER, GTK_POLICY_ALWAYS, GTK_SHADOW_IN, 320, 130),
639 TRUE, TRUE, 0);
640 }
641 else {
642 entry = gtk_entry_new();
643
644 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
645
646 gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
647
648 if (default_value != NULL)
649 gtk_entry_set_text(GTK_ENTRY(entry), default_value);
650
651 if (masked)
652 {
653 gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
654 }
655 }
656 gtk_widget_show_all(vbox);
657 }
658
659 pidgin_set_accessible_label(entry, label);
660 data->u.input.entry = entry;
661
662 pidgin_auto_parent_window(dialog);
663
664 /* Show everything. */
665 gtk_widget_show(dialog);
666
667 return data;
668 }
669
670 static void *
671 pidgin_request_choice(const char *title, const char *primary,
672 const char *secondary, gpointer default_value, const char *ok_text,
673 GCallback ok_cb, const char *cancel_text, GCallback cancel_cb,
674 PurpleRequestCommonParameters *cpar, void *user_data, va_list args)
675 {
676 PidginRequestData *data;
677 GtkWidget *dialog;
678 GtkWidget *vbox, *vbox2;
679 GtkWidget *hbox;
680 GtkWidget *label;
681 GtkWidget *img;
682 GtkWidget *radio = NULL;
683 char *label_text;
684 char *radio_text;
685 char *primary_esc, *secondary_esc;
686
687 data = g_new0(PidginRequestData, 1);
688 data->type = PURPLE_REQUEST_ACTION;
689 data->user_data = user_data;
690
691 data->cb_count = 2;
692 data->cbs = g_new0(GCallback, 2);
693 data->cbs[0] = cancel_cb;
694 data->cbs[1] = ok_cb;
695
696 /* Create the dialog. */
697 data->dialog = dialog = gtk_dialog_new();
698
699 if (title != NULL)
700 gtk_window_set_title(GTK_WINDOW(dialog), title);
701 #ifdef _WIN32
702 gtk_window_set_title(GTK_WINDOW(dialog), PIDGIN_ALERT_TITLE);
703 #endif
704
705 gtk_dialog_add_button(GTK_DIALOG(dialog),
706 text_to_stock(cancel_text), 0);
707
708 gtk_dialog_add_button(GTK_DIALOG(dialog),
709 text_to_stock(ok_text), 1);
710
711 g_signal_connect(G_OBJECT(dialog), "response",
712 G_CALLBACK(choice_response_cb), data);
713
714 /* Setup the dialog */
715 gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BORDER/2);
716 gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
717 PIDGIN_HIG_BORDER / 2);
718 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
719 gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
720 PIDGIN_HIG_BORDER);
721
722 /* Setup the main horizontal box */
723 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
724 gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
725 hbox);
726
727 /* Dialog icon. */
728 img = pidgin_request_dialog_icon(PURPLE_REQUEST_CHOICE, cpar);
729 gtk_widget_set_halign(img, GTK_ALIGN_START);
730 gtk_widget_set_valign(img, GTK_ALIGN_START);
731 gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
732
733 pidgin_widget_decorate_account(hbox, purple_request_cpar_get_account(cpar));
734
735 pidgin_request_add_help(GTK_DIALOG(dialog), cpar);
736
737 /* Vertical box */
738 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
739 gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
740
741 /* Descriptive label */
742 primary_esc = pidgin_request_escape(cpar, primary);
743 secondary_esc = pidgin_request_escape(cpar, secondary);
744 label_text = g_strdup_printf((primary ? "<span weight=\"bold\" size=\"larger\">"
745 "%s</span>%s%s" : "%s%s%s"),
746 (primary ? primary_esc : ""),
747 ((primary && secondary) ? "\n\n" : ""),
748 (secondary ? secondary_esc : ""));
749 g_free(primary_esc);
750 g_free(secondary_esc);
751
752 label = gtk_label_new(NULL);
753
754 gtk_label_set_markup(GTK_LABEL(label), label_text);
755 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
756 gtk_label_set_xalign(GTK_LABEL(label), 0);
757 gtk_label_set_yalign(GTK_LABEL(label), 0);
758 gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
759
760 g_free(label_text);
761
762 vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
763 gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, 0);
764 while ((radio_text = va_arg(args, char*))) {
765 gpointer resp = va_arg(args, gpointer);
766 radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), radio_text);
767 gtk_box_pack_start(GTK_BOX(vbox2), radio, FALSE, FALSE, 0);
768 g_object_set_data(G_OBJECT(radio), "choice_value", resp);
769 if (resp == default_value)
770 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE);
771 }
772
773 g_object_set_data(G_OBJECT(dialog), "radio", radio);
774
775 /* Show everything. */
776 pidgin_auto_parent_window(dialog);
777
778 gtk_widget_show_all(dialog);
779
780 return data;
781 }
782
783 static void *
784 pidgin_request_action(const char *title, const char *primary,
785 const char *secondary, int default_action,
786 PurpleRequestCommonParameters *cpar, void *user_data,
787 size_t action_count, va_list actions)
788 {
789 PidginRequestData *data;
790 GtkWidget *dialog;
791 GtkWidget *vbox;
792 GtkWidget *hbox;
793 GtkWidget *label;
794 GtkWidget *img = NULL;
795 void **buttons;
796 char *label_text;
797 char *primary_esc, *secondary_esc;
798 gsize i;
799
800 data = g_new0(PidginRequestData, 1);
801 data->type = PURPLE_REQUEST_ACTION;
802 data->user_data = user_data;
803
804 data->cb_count = action_count;
805 data->cbs = g_new0(GCallback, action_count);
806
807 /* Reverse the buttons */
808 buttons = g_new0(void *, action_count * 2);
809
810 for (i = 0; i < action_count * 2; i += 2) {
811 buttons[(action_count * 2) - i - 2] = va_arg(actions, char *);
812 buttons[(action_count * 2) - i - 1] = va_arg(actions, GCallback);
813 }
814
815 /* Create the dialog. */
816 data->dialog = dialog = gtk_dialog_new();
817
818 gtk_window_set_deletable(GTK_WINDOW(data->dialog), FALSE);
819
820 if (title != NULL)
821 gtk_window_set_title(GTK_WINDOW(dialog), title);
822 #ifdef _WIN32
823 else
824 gtk_window_set_title(GTK_WINDOW(dialog), PIDGIN_ALERT_TITLE);
825 #endif
826
827 for (i = 0; i < action_count; i++) {
828 gtk_dialog_add_button(GTK_DIALOG(dialog),
829 text_to_stock(buttons[2 * i]), i);
830
831 data->cbs[i] = buttons[2 * i + 1];
832 }
833
834 g_free(buttons);
835
836 g_signal_connect(G_OBJECT(dialog), "response",
837 G_CALLBACK(action_response_cb), data);
838
839 /* Setup the dialog */
840 gtk_container_set_border_width(GTK_CONTAINER(dialog), PIDGIN_HIG_BORDER/2);
841 gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
842 PIDGIN_HIG_BORDER / 2);
843 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
844 gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
845 PIDGIN_HIG_BORDER);
846
847 /* Setup the main horizontal box */
848 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
849 gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
850 hbox);
851
852 img = pidgin_request_dialog_icon(PURPLE_REQUEST_ACTION, cpar);
853 gtk_widget_set_halign(img, GTK_ALIGN_START);
854 gtk_widget_set_valign(img, GTK_ALIGN_START);
855 gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
856
857 /* Vertical box */
858 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
859 gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
860
861 pidgin_widget_decorate_account(hbox,
862 purple_request_cpar_get_account(cpar));
863
864 pidgin_request_add_help(GTK_DIALOG(dialog), cpar);
865
866 /* Descriptive label */
867 primary_esc = pidgin_request_escape(cpar, primary);
868 secondary_esc = pidgin_request_escape(cpar, secondary);
869 label_text = g_strdup_printf((primary ? "<span weight=\"bold\" size=\"larger\">"
870 "%s</span>%s%s" : "%s%s%s"),
871 (primary ? primary_esc : ""),
872 ((primary && secondary) ? "\n\n" : ""),
873 (secondary ? secondary_esc : ""));
874 g_free(primary_esc);
875 g_free(secondary_esc);
876
877 label = gtk_label_new(NULL);
878
879 gtk_label_set_markup(GTK_LABEL(label), label_text);
880 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
881 gtk_label_set_xalign(GTK_LABEL(label), 0);
882 gtk_label_set_yalign(GTK_LABEL(label), 0);
883 gtk_label_set_selectable(GTK_LABEL(label), TRUE);
884 gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
885
886 g_free(label_text);
887
888
889 if (default_action == PURPLE_DEFAULT_ACTION_NONE) {
890 gtk_widget_set_can_default(img, TRUE);
891 gtk_widget_set_can_focus(img, TRUE);
892 gtk_widget_grab_focus(img);
893 gtk_widget_grab_default(img);
894 } else
895 /*
896 * Need to invert the default_action number because the
897 * buttons are added to the dialog in reverse order.
898 */
899 gtk_dialog_set_default_response(GTK_DIALOG(dialog), action_count - 1 - default_action);
900
901 /* Show everything. */
902 pidgin_auto_parent_window(dialog);
903
904 gtk_widget_show_all(dialog);
905
906 return data;
907 }
908
909 static void
910 wait_cancel_cb(GtkWidget *button, PidginRequestData *data)
911 {
912 generic_response_start(data);
913
914 if (data->cbs[0] != NULL)
915 ((PurpleRequestCancelCb)data->cbs[0])(data->user_data);
916
917 purple_request_close(PURPLE_REQUEST_FIELDS, data);
918 }
919
920 static void *
921 pidgin_request_wait(const char *title, const char *primary,
922 const char *secondary, gboolean with_progress,
923 PurpleRequestCancelCb cancel_cb, PurpleRequestCommonParameters *cpar,
924 void *user_data)
925 {
926 PidginRequestData *data;
927 GtkWidget *dialog;
928 GtkWidget *hbox, *vbox, *img, *label, *button;
929 gchar *primary_esc, *secondary_esc, *label_text;
930
931 data = g_new0(PidginRequestData, 1);
932 data->type = PURPLE_REQUEST_WAIT;
933 data->user_data = user_data;
934
935 data->cb_count = 1;
936 data->cbs = g_new0(GCallback, 1);
937 data->cbs[0] = (GCallback)cancel_cb;
938
939 data->dialog = dialog = gtk_dialog_new();
940
941 gtk_window_set_deletable(GTK_WINDOW(data->dialog), cancel_cb != NULL);
942
943 if (title != NULL)
944 gtk_window_set_title(GTK_WINDOW(dialog), title);
945 else
946 gtk_window_set_title(GTK_WINDOW(dialog), _("Please wait"));
947
948 /* Setup the dialog */
949 gtk_container_set_border_width(GTK_CONTAINER(dialog),
950 PIDGIN_HIG_BORDER / 2);
951 gtk_container_set_border_width(GTK_CONTAINER(
952 gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
953 PIDGIN_HIG_BORDER / 2);
954 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
955 gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(
956 GTK_DIALOG(dialog))), PIDGIN_HIG_BORDER);
957
958 /* Setup the main horizontal box */
959 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
960 gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(
961 GTK_DIALOG(dialog))), hbox);
962
963 img = pidgin_request_dialog_icon(PURPLE_REQUEST_WAIT, cpar);
964 gtk_widget_set_halign(img, GTK_ALIGN_START);
965 gtk_widget_set_valign(img, GTK_ALIGN_START);
966 gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
967
968 /* Cancel button */
969 button = pidgin_dialog_add_button(GTK_DIALOG(dialog),
970 text_to_stock(_("Cancel")), G_CALLBACK(wait_cancel_cb), data);
971 gtk_widget_set_can_default(button, FALSE);
972
973 /* Vertical box */
974 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
975 gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
976
977 pidgin_widget_decorate_account(hbox,
978 purple_request_cpar_get_account(cpar));
979
980 pidgin_request_add_help(GTK_DIALOG(dialog), cpar);
981
982 /* Descriptive label */
983 primary_esc = pidgin_request_escape(cpar, primary);
984 secondary_esc = pidgin_request_escape(cpar, secondary);
985 label_text = g_strdup_printf((primary ? "<span weight=\"bold\" "
986 "size=\"larger\">%s</span>%s%s" : "%s%s%s"),
987 (primary ? primary_esc : ""),
988 ((primary && secondary) ? "\n\n" : ""),
989 (secondary ? secondary_esc : ""));
990 g_free(primary_esc);
991 g_free(secondary_esc);
992
993 label = gtk_label_new(NULL);
994
995 gtk_label_set_markup(GTK_LABEL(label), label_text);
996 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
997 gtk_label_set_xalign(GTK_LABEL(label), 0);
998 gtk_label_set_yalign(GTK_LABEL(label), 0);
999 gtk_label_set_selectable(GTK_LABEL(label), FALSE);
1000 gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
1001
1002 g_free(label_text);
1003
1004 if (with_progress) {
1005 GtkProgressBar *bar;
1006
1007 bar = data->u.wait.progress_bar =
1008 GTK_PROGRESS_BAR(gtk_progress_bar_new());
1009 gtk_progress_bar_set_fraction(bar, 0);
1010 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(bar),
1011 FALSE, FALSE, 0);
1012 }
1013
1014 /* Move focus out of cancel button. */
1015 gtk_widget_set_can_default(img, TRUE);
1016 gtk_widget_set_can_focus(img, TRUE);
1017 gtk_widget_grab_focus(img);
1018 gtk_widget_grab_default(img);
1019
1020 /* Show everything. */
1021 pidgin_auto_parent_window(dialog);
1022
1023 gtk_widget_show_all(dialog);
1024
1025 return data;
1026 }
1027
1028 static void
1029 pidgin_request_wait_update(void *ui_handle, gboolean pulse, gfloat fraction)
1030 {
1031 GtkProgressBar *bar;
1032 PidginRequestData *data = ui_handle;
1033
1034 g_return_if_fail(data->type == PURPLE_REQUEST_WAIT);
1035
1036 bar = data->u.wait.progress_bar;
1037 if (pulse)
1038 gtk_progress_bar_pulse(bar);
1039 else
1040 gtk_progress_bar_set_fraction(bar, fraction);
1041 }
1042
1043 static void
1044 req_entry_field_changed_cb(GtkWidget *entry, PurpleRequestField *field)
1045 {
1046 if (purple_request_field_get_field_type(field) == PURPLE_REQUEST_FIELD_INTEGER) {
1047 int value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(entry));
1048 purple_request_field_int_set_value(field, value);
1049 return;
1050 }
1051
1052 if (purple_request_field_string_is_multiline(field))
1053 {
1054 char *text;
1055 GtkTextIter start_iter, end_iter;
1056
1057 gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(entry), &start_iter);
1058 gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(entry), &end_iter);
1059
1060 text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(entry), &start_iter, &end_iter, FALSE);
1061 purple_request_field_string_set_value(field, (!text || !*text) ? NULL : text);
1062 g_free(text);
1063 }
1064 else
1065 {
1066 const char *text = NULL;
1067 text = gtk_entry_get_text(GTK_ENTRY(entry));
1068 purple_request_field_string_set_value(field, (*text == '\0') ? NULL : text);
1069 }
1070 }
1071
1072 static void
1073 req_field_changed_cb(GtkWidget *widget, PurpleRequestField *field)
1074 {
1075 PurpleRequestFieldGroup *group;
1076 PurpleRequestFields *fields;
1077 PidginRequestData *req_data;
1078 const GList *it;
1079
1080 group = purple_request_field_get_group(field);
1081 fields = purple_request_field_group_get_fields_list(group);
1082 req_data = purple_request_fields_get_ui_data(fields);
1083
1084 gtk_widget_set_sensitive(req_data->ok_button,
1085 purple_request_fields_all_required_filled(fields) &&
1086 purple_request_fields_all_valid(fields));
1087
1088 it = purple_request_fields_get_autosensitive(fields);
1089 for (; it != NULL; it = g_list_next(it)) {
1090 PurpleRequestField *field = it->data;
1091 GtkWidget *widget = purple_request_field_get_ui_data(field);
1092 gboolean sensitive;
1093
1094 sensitive = purple_request_field_is_sensitive(field);
1095 gtk_widget_set_sensitive(widget, sensitive);
1096
1097 /* XXX: and what about multiline? */
1098 if (GTK_IS_EDITABLE(widget))
1099 gtk_editable_set_editable(GTK_EDITABLE(widget), sensitive);
1100 }
1101 }
1102
1103 static void
1104 setup_entry_field(GtkWidget *entry, PurpleRequestField *field)
1105 {
1106 const char *type_hint;
1107
1108 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
1109
1110 g_signal_connect(G_OBJECT(entry), "changed",
1111 G_CALLBACK(req_entry_field_changed_cb), field);
1112 g_signal_connect(G_OBJECT(entry), "changed",
1113 G_CALLBACK(req_field_changed_cb), field);
1114
1115 if ((type_hint = purple_request_field_get_field_type_hint(field)) != NULL)
1116 {
1117 if (purple_str_has_prefix(type_hint, "screenname"))
1118 {
1119 GtkWidget *optmenu = NULL;
1120 PurpleRequestFieldGroup *group = purple_request_field_get_group(field);
1121 GList *fields = purple_request_field_group_get_fields(group);
1122
1123 /* Ensure the account option menu is created (if the widget hasn't
1124 * been initialized already) for username auto-completion. */
1125 while (fields)
1126 {
1127 PurpleRequestField *fld = fields->data;
1128 fields = fields->next;
1129
1130 if (purple_request_field_get_field_type(fld) == PURPLE_REQUEST_FIELD_ACCOUNT &&
1131 purple_request_field_is_visible(fld))
1132 {
1133 const char *type_hint = purple_request_field_get_field_type_hint(fld);
1134 if (type_hint != NULL && strcmp(type_hint, "account") == 0)
1135 {
1136 optmenu = GTK_WIDGET(purple_request_field_get_ui_data(fld));
1137 if (optmenu == NULL) {
1138 optmenu = GTK_WIDGET(create_account_field(fld));
1139 purple_request_field_set_ui_data(fld, optmenu);
1140 }
1141 break;
1142 }
1143 }
1144 }
1145 pidgin_setup_screenname_autocomplete(entry, optmenu, pidgin_screenname_autocomplete_default_filter, GINT_TO_POINTER(!strcmp(type_hint, "screenname-all")));
1146 }
1147 }
1148 }
1149
1150 static GtkWidget *
1151 create_string_field(PurpleRequestField *field)
1152 {
1153 const char *value;
1154 GtkWidget *widget;
1155 gboolean is_editable;
1156
1157 value = purple_request_field_string_get_default_value(field);
1158 is_editable = purple_request_field_is_sensitive(field);
1159
1160 if (purple_request_field_string_is_multiline(field))
1161 {
1162 GtkWidget *textview;
1163
1164 textview = gtk_text_view_new();
1165 gtk_text_view_set_editable(GTK_TEXT_VIEW(textview),
1166 TRUE);
1167 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview),
1168 GTK_WRAP_WORD_CHAR);
1169
1170 gtk_widget_show(textview);
1171
1172 if (value != NULL)
1173 {
1174 GtkTextBuffer *buffer;
1175
1176 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
1177
1178 gtk_text_buffer_set_text(buffer, value, -1);
1179 }
1180
1181 gtk_widget_set_tooltip_text(textview, purple_request_field_get_tooltip(field));
1182
1183 gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), is_editable);
1184
1185 g_signal_connect(G_OBJECT(textview), "focus-out-event",
1186 G_CALLBACK(field_string_focus_out_cb), field);
1187
1188 if (purple_request_field_is_required(field))
1189 {
1190 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
1191 g_signal_connect(G_OBJECT(buffer), "changed",
1192 G_CALLBACK(req_entry_field_changed_cb), field);
1193 }
1194
1195 widget = pidgin_make_scrollable(textview, GTK_POLICY_NEVER, GTK_POLICY_ALWAYS, GTK_SHADOW_IN, -1, 75);
1196 }
1197 else
1198 {
1199 widget = gtk_entry_new();
1200
1201 setup_entry_field(widget, field);
1202
1203 if (value != NULL)
1204 gtk_entry_set_text(GTK_ENTRY(widget), value);
1205
1206 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1207
1208 if (purple_request_field_string_is_masked(field))
1209 {
1210 gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE);
1211 }
1212
1213 gtk_editable_set_editable(GTK_EDITABLE(widget), is_editable);
1214
1215 g_signal_connect(G_OBJECT(widget), "focus-out-event",
1216 G_CALLBACK(field_string_focus_out_cb), field);
1217 }
1218
1219 return widget;
1220 }
1221
1222 static GtkWidget *
1223 create_int_field(PurpleRequestField *field)
1224 {
1225 int value;
1226 GtkWidget *widget;
1227
1228 widget = gtk_spin_button_new_with_range(
1229 purple_request_field_int_get_lower_bound(field),
1230 purple_request_field_int_get_upper_bound(field), 1);
1231
1232 setup_entry_field(widget, field);
1233
1234 value = purple_request_field_int_get_default_value(field);
1235 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), value);
1236
1237 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1238
1239 return widget;
1240 }
1241
1242 static GtkWidget *
1243 create_bool_field(PurpleRequestField *field,
1244 PurpleRequestCommonParameters *cpar)
1245 {
1246 GtkWidget *widget;
1247 gchar *label;
1248
1249 label = pidgin_request_escape(cpar,
1250 purple_request_field_get_label(field));
1251 widget = gtk_check_button_new_with_label(label);
1252 g_free(label);
1253
1254 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1255
1256 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
1257 purple_request_field_bool_get_default_value(field));
1258
1259 g_signal_connect(G_OBJECT(widget), "toggled",
1260 G_CALLBACK(field_bool_cb), field);
1261 g_signal_connect(widget, "toggled",
1262 G_CALLBACK(req_field_changed_cb), field);
1263
1264 return widget;
1265 }
1266
1267 static GtkWidget *
1268 create_choice_field(PurpleRequestField *field,
1269 PurpleRequestCommonParameters *cpar)
1270 {
1271 GtkWidget *widget;
1272 GList *elements = purple_request_field_choice_get_elements(field);
1273 int num_labels = g_list_length(elements) / 2;
1274 GList *l;
1275 gpointer *values = g_new(gpointer, num_labels);
1276 gpointer default_value;
1277 gboolean default_found = FALSE;
1278 int i;
1279
1280 default_value = purple_request_field_choice_get_value(field);
1281 if (num_labels > 5 || purple_request_cpar_is_compact(cpar))
1282 {
1283 int default_index = 0;
1284 widget = gtk_combo_box_text_new();
1285
1286 i = 0;
1287 l = elements;
1288 while (l != NULL)
1289 {
1290 const char *text;
1291 gpointer *value;
1292
1293 text = l->data;
1294 l = g_list_next(l);
1295 value = l->data;
1296 l = g_list_next(l);
1297
1298 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), text);
1299 if (value == default_value) {
1300 default_index = i;
1301 default_found = TRUE;
1302 }
1303 values[i++] = value;
1304 }
1305
1306 gtk_combo_box_set_active(GTK_COMBO_BOX(widget), default_index);
1307
1308 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1309
1310 g_signal_connect(G_OBJECT(widget), "changed",
1311 G_CALLBACK(field_choice_menu_cb), field);
1312 }
1313 else
1314 {
1315 GtkWidget *box;
1316 GtkWidget *first_radio = NULL;
1317 GtkWidget *radio;
1318
1319 if (num_labels == 2)
1320 box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
1321 else
1322 box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1323
1324 widget = box;
1325
1326 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1327
1328 i = 0;
1329 l = elements;
1330 while (l != NULL)
1331 {
1332 const char *text;
1333 gpointer *value;
1334
1335 text = l->data;
1336 l = g_list_next(l);
1337 value = l->data;
1338 l = g_list_next(l);
1339
1340 radio = gtk_radio_button_new_with_label_from_widget(
1341 GTK_RADIO_BUTTON(first_radio), text);
1342 g_object_set_data(G_OBJECT(radio), "box", box);
1343
1344 if (first_radio == NULL)
1345 first_radio = radio;
1346
1347 if (value == default_value) {
1348 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE);
1349 default_found = TRUE;
1350 }
1351 values[i++] = value;
1352
1353 gtk_box_pack_start(GTK_BOX(box), radio, TRUE, TRUE, 0);
1354 gtk_widget_show(radio);
1355
1356 g_signal_connect(G_OBJECT(radio), "toggled",
1357 G_CALLBACK(field_choice_option_cb), field);
1358 }
1359 }
1360
1361 if (!default_found && i > 0)
1362 purple_request_field_choice_set_value(field, values[0]);
1363
1364 g_object_set_data_full(G_OBJECT(widget), "values", values, g_free);
1365
1366 return widget;
1367 }
1368
1369 static GtkWidget *
1370 create_image_field(PurpleRequestField *field)
1371 {
1372 GtkWidget *widget;
1373 GdkPixbuf *buf, *scale;
1374
1375 buf = pidgin_pixbuf_from_data(
1376 (const guchar *)purple_request_field_image_get_buffer(field),
1377 purple_request_field_image_get_size(field));
1378
1379 scale = gdk_pixbuf_scale_simple(buf,
1380 purple_request_field_image_get_scale_x(field) * gdk_pixbuf_get_width(buf),
1381 purple_request_field_image_get_scale_y(field) * gdk_pixbuf_get_height(buf),
1382 GDK_INTERP_BILINEAR);
1383 widget = gtk_image_new_from_pixbuf(scale);
1384 g_object_unref(G_OBJECT(buf));
1385 g_object_unref(G_OBJECT(scale));
1386
1387 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1388
1389 return widget;
1390 }
1391
1392 static GtkWidget *
1393 create_account_field(PurpleRequestField *field)
1394 {
1395 GtkWidget *widget;
1396
1397 widget = pidgin_account_option_menu_new(
1398 purple_request_field_account_get_default_value(field),
1399 purple_request_field_account_get_show_all(field),
1400 G_CALLBACK(field_account_cb),
1401 purple_request_field_account_get_filter(field),
1402 field);
1403
1404 gtk_widget_set_tooltip_text(widget, purple_request_field_get_tooltip(field));
1405 g_signal_connect(widget, "changed",
1406 G_CALLBACK(req_field_changed_cb), field);
1407
1408 return widget;
1409 }
1410
1411 static void
1412 select_field_list_item(GtkTreeModel *model, GtkTreePath *path,
1413 GtkTreeIter *iter, gpointer data)
1414 {
1415 PurpleRequestField *field = (PurpleRequestField *)data;
1416 char *text;
1417
1418 gtk_tree_model_get(model, iter, 1, &text, -1);
1419
1420 purple_request_field_list_add_selected(field, text);
1421 g_free(text);
1422 }
1423
1424 static void
1425 list_field_select_changed_cb(GtkTreeSelection *sel, PurpleRequestField *field)
1426 {
1427 purple_request_field_list_clear_selected(field);
1428
1429 gtk_tree_selection_selected_foreach(sel, select_field_list_item, field);
1430 }
1431
1432 static GtkWidget *
1433 create_list_field(PurpleRequestField *field)
1434 {
1435 GtkWidget *treeview;
1436 GtkListStore *store;
1437 GtkCellRenderer *renderer;
1438 GtkTreeSelection *sel;
1439 GtkTreeViewColumn *column;
1440 GtkTreeIter iter;
1441 GList *l;
1442 GList *icons = NULL;
1443
1444 icons = purple_request_field_list_get_icons(field);
1445
1446
1447 /* Create the list store */
1448 if (icons)
1449 store = gtk_list_store_new(3, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF);
1450 else
1451 store = gtk_list_store_new(2, G_TYPE_POINTER, G_TYPE_STRING);
1452
1453 /* Create the tree view */
1454 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1455 g_object_unref(G_OBJECT(store));
1456 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
1457
1458 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
1459
1460 if (purple_request_field_list_get_multi_select(field))
1461 gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
1462
1463 column = gtk_tree_view_column_new();
1464 gtk_tree_view_insert_column(GTK_TREE_VIEW(treeview), column, -1);
1465
1466 renderer = gtk_cell_renderer_text_new();
1467 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1468 gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
1469
1470 if (icons)
1471 {
1472 renderer = gtk_cell_renderer_pixbuf_new();
1473 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1474 gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
1475
1476 gtk_widget_set_size_request(treeview, 200, 400);
1477 }
1478
1479 for (l = purple_request_field_list_get_items(field); l != NULL; l = l->next)
1480 {
1481 const char *text = (const char *)l->data;
1482
1483 gtk_list_store_append(store, &iter);
1484
1485 if (icons)
1486 {
1487 const char *icon_path = (const char *)icons->data;
1488 GdkPixbuf* pixbuf = NULL;
1489
1490 if (icon_path)
1491 pixbuf = pidgin_pixbuf_new_from_file(icon_path);
1492
1493 gtk_list_store_set(store, &iter,
1494 0, purple_request_field_list_get_data(field, text),
1495 1, text,
1496 2, pixbuf,
1497 -1);
1498 icons = icons->next;
1499 }
1500 else
1501 gtk_list_store_set(store, &iter,
1502 0, purple_request_field_list_get_data(field, text),
1503 1, text,
1504 -1);
1505
1506 if (purple_request_field_list_is_selected(field, text))
1507 gtk_tree_selection_select_iter(sel, &iter);
1508 }
1509
1510 /*
1511 * We only want to catch changes made by the user, so it's important
1512 * that we wait until after the list is created to connect this
1513 * handler. If we connect the handler before the loop above and
1514 * there are multiple items selected, then selecting the first iter
1515 * in the tree causes list_field_select_changed_cb to be triggered
1516 * which clears out the rest of the list of selected items.
1517 */
1518 g_signal_connect(G_OBJECT(sel), "changed",
1519 G_CALLBACK(list_field_select_changed_cb), field);
1520
1521 gtk_widget_show(treeview);
1522
1523 return pidgin_make_scrollable(treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, -1);
1524 }
1525
1526 static GtkWidget *
1527 create_certificate_field(PurpleRequestField *field)
1528 {
1529 GTlsCertificate *cert;
1530 #ifdef ENABLE_GCR
1531 GByteArray *der = NULL;
1532 GcrCertificateBasicsWidget *cert_widget;
1533 GcrCertificate *gcrt;
1534 #else
1535 PurpleTlsCertificateInfo *info;
1536 GtkWidget *cert_label;
1537 char *str;
1538 char *escaped;
1539 #endif
1540
1541 cert = purple_request_field_certificate_get_value(field);
1542
1543 #ifdef ENABLE_GCR
1544 g_object_get(cert, "certificate", &der, NULL);
1545 g_return_val_if_fail(der, NULL);
1546
1547 gcrt = gcr_simple_certificate_new(der->data, der->len);
1548 g_return_val_if_fail(gcrt, NULL);
1549
1550 cert_widget = gcr_certificate_basics_widget_new(gcrt);
1551
1552 g_byte_array_free(der, TRUE);
1553 g_object_unref(G_OBJECT(gcrt));
1554
1555 return GTK_WIDGET(cert_widget);
1556 #else
1557 info = purple_tls_certificate_get_info(cert);
1558 str = purple_tls_certificate_info_get_display_string(info);
1559 purple_tls_certificate_info_free(info);
1560
1561 escaped = g_markup_escape_text(str, -1);
1562
1563 cert_label = gtk_label_new(NULL);
1564 gtk_label_set_markup(GTK_LABEL(cert_label), escaped);
1565 gtk_label_set_line_wrap(GTK_LABEL(cert_label), TRUE);
1566 gtk_label_set_xalign(GTK_LABEL(cert_label), 0);
1567 gtk_label_set_yalign(GTK_LABEL(cert_label), 0);
1568
1569 g_free(str);
1570 g_free(escaped);
1571
1572 return cert_label;
1573 #endif
1574 }
1575
1576 static GdkPixbuf*
1577 _pidgin_datasheet_stock_icon_get(const gchar *stock_name)
1578 {
1579 GdkPixbuf *image = NULL;
1580 gchar *domain, *id;
1581
1582 if (stock_name == NULL)
1583 return NULL;
1584
1585 /* core is quitting */
1586 if (datasheet_stock == NULL)
1587 return NULL;
1588
1589 if (g_hash_table_lookup_extended(datasheet_stock, stock_name,
1590 NULL, (gpointer*)&image))
1591 {
1592 return image;
1593 }
1594
1595 domain = g_strdup(stock_name);
1596 id = strchr(domain, '/');
1597 if (!id) {
1598 g_free(domain);
1599 return NULL;
1600 }
1601 id[0] = '\0';
1602 id++;
1603
1604 if (g_strcmp0(domain, "protocol") == 0) {
1605 PurpleAccount *account;
1606 gchar *protocol_id, *accountname;
1607
1608 protocol_id = id;
1609 accountname = strchr(id, ':');
1610
1611 if (!accountname) {
1612 g_free(domain);
1613 return NULL;
1614 }
1615
1616 accountname[0] = '\0';
1617 accountname++;
1618
1619 account = purple_accounts_find(accountname, protocol_id);
1620 if (account) {
1621 image = pidgin_create_protocol_icon(account,
1622 PIDGIN_PROTOCOL_ICON_SMALL);
1623 }
1624 } else if (g_strcmp0(domain, "e2ee") == 0) {
1625 image = pidgin_pixbuf_from_image(
1626 _pidgin_e2ee_stock_icon_get(id));
1627 } else {
1628 purple_debug_error("gtkrequest", "Unknown domain: %s", domain);
1629 g_free(domain);
1630 return NULL;
1631 }
1632
1633 g_hash_table_insert(datasheet_stock, g_strdup(stock_name), image);
1634 return image;
1635 }
1636
1637 static PurpleRequestDatasheetRecord*
1638 datasheet_get_selected_row(GtkWidget *sheet_widget)
1639 {
1640 PurpleRequestDatasheet *sheet;
1641 GtkTreeView *view;
1642 GtkTreeSelection *selection;
1643 GtkTreeModel *model;
1644 GtkTreeIter iter;
1645 GList *sel_list;
1646 gpointer key;
1647
1648 g_return_val_if_fail(sheet_widget != NULL, NULL);
1649
1650 view = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(sheet_widget), "view"));
1651 sheet = g_object_get_data(G_OBJECT(sheet_widget), "sheet");
1652
1653 g_return_val_if_fail(view != NULL, NULL);
1654 g_return_val_if_fail(sheet != NULL, NULL);
1655
1656 selection = gtk_tree_view_get_selection(view);
1657 if (gtk_tree_selection_count_selected_rows(selection) != 1)
1658 return NULL;
1659
1660 sel_list = gtk_tree_selection_get_selected_rows(selection, &model);
1661 gtk_tree_model_get_iter(model, &iter, sel_list->data);
1662 g_list_foreach(sel_list, (GFunc)gtk_tree_path_free, NULL);
1663 g_list_free(sel_list);
1664
1665 gtk_tree_model_get(model, &iter, 0, &key, -1);
1666
1667 return purple_request_datasheet_record_find(sheet, key);
1668 }
1669
1670 static void
1671 datasheet_button_check_sens(GtkWidget *button, gpointer _sheet_widget)
1672 {
1673 PurpleRequestDatasheetAction *act;
1674 GtkWidget *sheet_widget = GTK_WIDGET(_sheet_widget);
1675
1676 g_return_if_fail(sheet_widget != NULL);
1677
1678 act = g_object_get_data(G_OBJECT(button), "action");
1679
1680 g_return_if_fail(act != NULL);
1681
1682 gtk_widget_set_sensitive(button,
1683 purple_request_datasheet_action_is_sensitive(act,
1684 datasheet_get_selected_row(sheet_widget)));
1685 }
1686
1687 static void
1688 datasheet_selection_changed(GtkWidget *sheet_widget)
1689 {
1690 gpointer buttons_box;
1691
1692 g_return_if_fail(sheet_widget != NULL);
1693
1694 buttons_box = g_object_get_data(G_OBJECT(sheet_widget), "buttons");
1695 gtk_container_foreach(GTK_CONTAINER(buttons_box),
1696 datasheet_button_check_sens, sheet_widget);
1697 }
1698
1699 static void
1700 datasheet_update_rec(PurpleRequestDatasheetRecord *rec, GtkListStore *model,
1701 GtkTreeIter *iter)
1702 {
1703 guint i, col_count;
1704 PurpleRequestDatasheet *sheet;
1705
1706 g_return_if_fail(rec != NULL);
1707 g_return_if_fail(model != NULL);
1708 g_return_if_fail(iter != NULL);
1709
1710 sheet = purple_request_datasheet_record_get_datasheet(rec);
1711
1712 g_return_if_fail(sheet != NULL);
1713
1714 col_count = purple_request_datasheet_get_column_count(sheet);
1715
1716 for (i = 0; i < col_count; i++) {
1717 PurpleRequestDatasheetColumnType type;
1718
1719 type = purple_request_datasheet_get_column_type(
1720 sheet, i);
1721 if (type == PURPLE_REQUEST_DATASHEET_COLUMN_STRING) {
1722 GValue val;
1723
1724 val.g_type = 0;
1725 g_value_init(&val, G_TYPE_STRING);
1726 g_value_set_string(&val,
1727 purple_request_datasheet_record_get_string_data(
1728 rec, i));
1729 gtk_list_store_set_value(model, iter,
1730 i + 1, &val);
1731 } else if (type ==
1732 PURPLE_REQUEST_DATASHEET_COLUMN_IMAGE)
1733 {
1734 GdkPixbuf *pixbuf;
1735
1736 pixbuf = _pidgin_datasheet_stock_icon_get(
1737 purple_request_datasheet_record_get_image_data(
1738 rec, i));
1739 gtk_list_store_set(model, iter, i + 1,
1740 pixbuf, -1);
1741 } else
1742 g_warn_if_reached();
1743 }
1744 }
1745
1746 static void
1747 datasheet_fill(PurpleRequestDatasheet *sheet, GtkListStore *model)
1748 {
1749 const GList *it;
1750
1751 gtk_list_store_clear(model);
1752
1753 it = purple_request_datasheet_get_records(sheet);
1754 for (; it != NULL; it = g_list_next(it)) {
1755 PurpleRequestDatasheetRecord *rec = it->data;
1756 GtkTreeIter iter;
1757
1758 gtk_list_store_append(model, &iter);
1759 gtk_list_store_set(model, &iter, 0,
1760 purple_request_datasheet_record_get_key(rec), -1);
1761
1762 datasheet_update_rec(rec, model, &iter);
1763 }
1764
1765 datasheet_selection_changed(GTK_WIDGET(g_object_get_data(
1766 G_OBJECT(model), "sheet-widget")));
1767 }
1768
1769 static void
1770 datasheet_update(PurpleRequestDatasheet *sheet, gpointer key,
1771 GtkListStore *model)
1772 {
1773 PurpleRequestDatasheetRecord *rec;
1774 GtkTreeIter iter;
1775 GtkTreeModel *tmodel = GTK_TREE_MODEL(model);
1776 gboolean found = FALSE;
1777
1778 g_return_if_fail(tmodel != NULL);
1779
1780 if (key == NULL) {
1781 datasheet_fill(sheet, model);
1782 return;
1783 }
1784
1785 rec = purple_request_datasheet_record_find(sheet, key);
1786
1787 if (gtk_tree_model_get_iter_first(tmodel, &iter)) {
1788 do {
1789 gpointer ikey;
1790
1791 gtk_tree_model_get(tmodel, &iter, 0, &ikey, -1);
1792
1793 if (key == ikey) {
1794 found = TRUE;
1795 break;
1796 }
1797 } while (gtk_tree_model_iter_next(tmodel, &iter));
1798 }
1799
1800 if (rec == NULL && !found)
1801 return;
1802
1803 if (rec == NULL) {
1804 gtk_list_store_remove(model, &iter);
1805 return;
1806 }
1807
1808 if (!found) {
1809 gtk_list_store_append(model, &iter);
1810 gtk_list_store_set(model, &iter, 0, key, -1);
1811 }
1812
1813 datasheet_update_rec(rec, model, &iter);
1814
1815 datasheet_selection_changed(GTK_WIDGET(g_object_get_data(
1816 G_OBJECT(model), "sheet-widget")));
1817 }
1818
1819
1820 static void
1821 datasheet_selection_changed_cb(GtkTreeSelection *sel, gpointer sheet_widget)
1822 {
1823 datasheet_selection_changed(GTK_WIDGET(sheet_widget));
1824 }
1825
1826 static void
1827 datasheet_action_clicked(GtkButton *btn, PurpleRequestDatasheetAction *act)
1828 {
1829 GtkWidget *sheet_widget;
1830
1831 sheet_widget = g_object_get_data(G_OBJECT(btn), "sheet-widget");
1832
1833 g_return_if_fail(sheet_widget != NULL);
1834
1835 purple_request_datasheet_action_call(act, datasheet_get_selected_row(
1836 sheet_widget));
1837 }
1838
1839 static GtkWidget *
1840 create_datasheet_field(PurpleRequestField *field, GtkSizeGroup *buttons_sg)
1841 {
1842 PurpleRequestDatasheet *sheet;
1843 guint i, col_count;
1844 GType *col_types;
1845 GtkListStore *model;
1846 GtkTreeView *view;
1847 GtkTreeSelection *sel;
1848 GtkWidget *scrollable;
1849 GtkCellRenderer *renderer_image = NULL, *renderer_text = NULL;
1850 GtkTreeViewColumn *id_column;
1851 GtkWidget *main_box;
1852 GtkWidget *buttons_box;
1853 const GList *it;
1854
1855 sheet = purple_request_field_datasheet_get_sheet(field);
1856 main_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
1857
1858 col_count = purple_request_datasheet_get_column_count(sheet);
1859
1860 col_types = g_new0(GType, col_count + 1);
1861 col_types[0] = G_TYPE_POINTER;
1862 for (i = 0; i < col_count; i++) {
1863 PurpleRequestDatasheetColumnType type;
1864 type = purple_request_datasheet_get_column_type(sheet, i);
1865 if (type == PURPLE_REQUEST_DATASHEET_COLUMN_STRING)
1866 col_types[i + 1] = G_TYPE_STRING;
1867 else if (type == PURPLE_REQUEST_DATASHEET_COLUMN_IMAGE)
1868 col_types[i + 1] = GDK_TYPE_PIXBUF;
1869 else
1870 g_warn_if_reached();
1871 }
1872 model = gtk_list_store_newv(col_count + 1, col_types);
1873 g_free(col_types);
1874
1875 view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
1876 GTK_TREE_MODEL(model)));
1877 g_object_set_data(G_OBJECT(model), "sheet-widget", main_box);
1878 g_object_unref(G_OBJECT(model));
1879
1880 id_column = gtk_tree_view_column_new();
1881 gtk_tree_view_column_set_visible(id_column, FALSE);
1882 gtk_tree_view_append_column(view, id_column);
1883
1884 for (i = 0; i < col_count; i++) {
1885 PurpleRequestDatasheetColumnType type;
1886 const gchar *title;
1887 GtkCellRenderer *renderer = NULL;
1888 const gchar *type_str = "";
1889
1890 type = purple_request_datasheet_get_column_type(sheet, i);
1891 title = purple_request_datasheet_get_column_title(sheet, i);
1892
1893 if (type == PURPLE_REQUEST_DATASHEET_COLUMN_STRING) {
1894 type_str = "text";
1895 if (!renderer_text)
1896 renderer_text = gtk_cell_renderer_text_new();
1897 renderer = renderer_text;
1898 }
1899 else if (type == PURPLE_REQUEST_DATASHEET_COLUMN_IMAGE) {
1900 type_str = "pixbuf";
1901 if (!renderer_image)
1902 renderer_image = gtk_cell_renderer_pixbuf_new();
1903 renderer = renderer_image;
1904 } else
1905 g_warn_if_reached();
1906
1907 if (title == NULL)
1908 title = "";
1909 gtk_tree_view_insert_column_with_attributes(
1910 view, -1, title, renderer, type_str,
1911 i + 1, NULL);
1912 }
1913
1914 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
1915
1916 gtk_widget_set_size_request(GTK_WIDGET(view), 400, 250);
1917
1918 scrollable = pidgin_make_scrollable(GTK_WIDGET(view),
1919 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS, GTK_SHADOW_IN, -1, -1);
1920 gtk_widget_show(GTK_WIDGET(view));
1921
1922 buttons_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
1923 gtk_size_group_add_widget(buttons_sg, buttons_box);
1924
1925 gtk_box_pack_start(GTK_BOX(main_box), scrollable, TRUE, TRUE, 0);
1926 gtk_box_pack_start(GTK_BOX(main_box), buttons_box,
1927 FALSE, FALSE, 0);
1928 gtk_widget_show(scrollable);
1929 gtk_widget_show(buttons_box);
1930
1931 it = purple_request_datasheet_get_actions(sheet);
1932 for (; it != NULL; it = g_list_next(it)) {
1933 PurpleRequestDatasheetAction *act = it->data;
1934 GtkButton *btn;
1935 const gchar *label;
1936
1937 label = purple_request_datasheet_action_get_label(act);
1938
1939 btn = GTK_BUTTON(gtk_button_new_with_label(label ? label : ""));
1940
1941 g_object_set_data(G_OBJECT(btn), "action", act);
1942 g_object_set_data(G_OBJECT(btn), "sheet-widget", main_box);
1943 g_signal_connect(G_OBJECT(btn), "clicked",
1944 G_CALLBACK(datasheet_action_clicked), act);
1945
1946 gtk_box_pack_start(GTK_BOX(buttons_box), GTK_WIDGET(btn),
1947 FALSE, FALSE, 0);
1948 gtk_widget_show(GTK_WIDGET(btn));
1949 }
1950
1951 g_object_set_data(G_OBJECT(main_box), "view", view);
1952 g_object_set_data(G_OBJECT(main_box), "buttons", buttons_box);
1953 g_object_set_data(G_OBJECT(main_box), "sheet", sheet);
1954
1955 datasheet_fill(sheet, model);
1956 purple_signal_connect(sheet, "record-changed",
1957 pidgin_request_get_handle(),
1958 PURPLE_CALLBACK(datasheet_update), model);
1959
1960 sel = gtk_tree_view_get_selection(view);
1961 g_signal_connect(G_OBJECT(sel), "changed",
1962 G_CALLBACK(datasheet_selection_changed_cb), main_box);
1963
1964 return main_box;
1965 }
1966
1967 static void *
1968 pidgin_request_fields(const char *title, const char *primary,
1969 const char *secondary, PurpleRequestFields *fields, const char *ok_text,
1970 GCallback ok_cb, const char *cancel_text, GCallback cancel_cb,
1971 PurpleRequestCommonParameters *cpar, void *user_data)
1972 {
1973 PidginRequestData *data;
1974 GtkWidget *win;
1975 GtkNotebook *notebook;
1976 GtkWidget **pages;
1977 GtkWidget *hbox, *vbox;
1978 GtkWidget *frame;
1979 GtkWidget *label;
1980 GtkWidget *grid;
1981 GtkWidget *button;
1982 GtkWidget *img;
1983 GtkSizeGroup *sg, *datasheet_buttons_sg;
1984 GList *gl, *fl;
1985 PurpleRequestFieldGroup *group;
1986 PurpleRequestField *field;
1987 char *label_text;
1988 char *primary_esc, *secondary_esc;
1989 const gboolean compact = purple_request_cpar_is_compact(cpar);
1990 GSList *extra_actions, *it;
1991 size_t extra_actions_count, i;
1992 const gchar **tab_names;
1993 guint tab_count;
1994 gboolean ok_btn = (ok_text != NULL);
1995
1996 data = g_new0(PidginRequestData, 1);
1997 data->type = PURPLE_REQUEST_FIELDS;
1998 data->user_data = user_data;
1999 data->u.multifield.fields = fields;
2000
2001 purple_request_fields_set_ui_data(fields, data);
2002
2003 extra_actions = purple_request_cpar_get_extra_actions(cpar);
2004 extra_actions_count = g_slist_length(extra_actions) / 2;
2005
2006 data->cb_count = 2;
2007 data->cbs = g_new0(GCallback, 2);
2008
2009 data->cbs[0] = ok_cb;
2010 data->cbs[1] = cancel_cb;
2011
2012 #ifdef _WIN32
2013 data->dialog = win = pidgin_create_dialog(PIDGIN_ALERT_TITLE, PIDGIN_HIG_BORDER, "multifield", TRUE) ;
2014 #else /* !_WIN32 */
2015 data->dialog = win = pidgin_create_dialog(title, PIDGIN_HIG_BORDER, "multifield", TRUE) ;
2016 #endif /* _WIN32 */
2017
2018 g_signal_connect(G_OBJECT(win), "delete_event",
2019 G_CALLBACK(destroy_multifield_cb), data);
2020
2021 /* Setup the main horizontal box */
2022 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
2023 gtk_container_add(GTK_CONTAINER(pidgin_dialog_get_vbox(GTK_DIALOG(win))), hbox);
2024 gtk_widget_show(hbox);
2025
2026 /* Dialog icon. */
2027 img = pidgin_request_dialog_icon(PURPLE_REQUEST_FIELDS, cpar);
2028 gtk_widget_set_halign(img, GTK_ALIGN_START);
2029 gtk_widget_set_valign(img, GTK_ALIGN_START);
2030 gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
2031 gtk_widget_show(img);
2032
2033 pidgin_request_add_help(GTK_DIALOG(win), cpar);
2034
2035 it = extra_actions;
2036 for (i = 0; i < extra_actions_count; i++, it = it->next->next) {
2037 const gchar *label = it->data;
2038 PurpleRequestFieldsCb *cb = it->next->data;
2039
2040 button = pidgin_dialog_add_button(GTK_DIALOG(win),
2041 text_to_stock(label), G_CALLBACK(multifield_extra_cb),
2042 data);
2043 g_object_set_data(G_OBJECT(button), "extra-cb", cb);
2044 }
2045
2046 /* Cancel button */
2047 button = pidgin_dialog_add_button(GTK_DIALOG(win), text_to_stock(cancel_text), G_CALLBACK(multifield_cancel_cb), data);
2048 gtk_widget_set_can_default(button, TRUE);
2049
2050 /* OK button */
2051 if (!ok_btn) {
2052 gtk_window_set_default(GTK_WINDOW(win), button);
2053 } else {
2054 button = pidgin_dialog_add_button(GTK_DIALOG(win), text_to_stock(ok_text), G_CALLBACK(multifield_ok_cb), data);
2055 data->ok_button = button;
2056 gtk_widget_set_can_default(button, TRUE);
2057 gtk_window_set_default(GTK_WINDOW(win), button);
2058 }
2059
2060 pidgin_widget_decorate_account(hbox,
2061 purple_request_cpar_get_account(cpar));
2062
2063 /* Setup the vbox */
2064 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
2065 gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
2066 gtk_widget_show(vbox);
2067
2068 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2069 datasheet_buttons_sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2070
2071 if(primary) {
2072 primary_esc = pidgin_request_escape(cpar, primary);
2073 label_text = g_strdup_printf(
2074 "<span weight=\"bold\" size=\"larger\">%s</span>", primary_esc);
2075 g_free(primary_esc);
2076 label = gtk_label_new(NULL);
2077
2078 gtk_label_set_markup(GTK_LABEL(label), label_text);
2079 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
2080 gtk_label_set_xalign(GTK_LABEL(label), 0);
2081 gtk_label_set_yalign(GTK_LABEL(label), 0);
2082 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
2083 gtk_widget_show(label);
2084 g_free(label_text);
2085 }
2086
2087 /* Setup tabs */
2088 tab_names = purple_request_fields_get_tab_names(fields);
2089 if (tab_names == NULL) {
2090 notebook = NULL;
2091 tab_count = 1;
2092
2093 pages = g_new0(GtkWidget*, 1);
2094 pages[0] = vbox;
2095 } else {
2096 tab_count = g_strv_length((gchar **)tab_names);
2097 notebook = GTK_NOTEBOOK(gtk_notebook_new());
2098
2099 pages = g_new0(GtkWidget*, tab_count);
2100
2101 for (i = 0; i < tab_count; i++) {
2102 pages[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
2103 gtk_container_set_border_width(GTK_CONTAINER(pages[i]), PIDGIN_HIG_BORDER);
2104 gtk_notebook_append_page(notebook, pages[i], NULL);
2105 gtk_notebook_set_tab_label_text(notebook, pages[i], tab_names[i]);
2106 gtk_widget_show(pages[i]);
2107 }
2108 }
2109
2110 for (i = 0; i < tab_count; i++) {
2111 guint total_fields = 0;
2112 GList *it;
2113
2114 it = purple_request_fields_get_groups(fields);
2115 for (; it != NULL; it = g_list_next(it)) {
2116 group = it->data;
2117 if (purple_request_field_group_get_tab(group) != i)
2118 continue;
2119 total_fields += g_list_length(
2120 purple_request_field_group_get_fields(group));
2121 }
2122
2123 if(total_fields > 9) {
2124 GtkWidget *hbox_for_spacing, *vbox_for_spacing;
2125
2126 gtk_container_set_border_width(
2127 GTK_CONTAINER(pages[i]), 0);
2128
2129 hbox_for_spacing =
2130 gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BORDER);
2131 gtk_box_pack_start(GTK_BOX(pages[i]),
2132 pidgin_make_scrollable(hbox_for_spacing,
2133 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC,
2134 GTK_SHADOW_NONE, -1, 200),
2135 TRUE, TRUE, 0);
2136 gtk_widget_show(hbox_for_spacing);
2137
2138 vbox_for_spacing =
2139 gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
2140 gtk_box_pack_start(GTK_BOX(hbox_for_spacing),
2141 vbox_for_spacing, TRUE, TRUE,
2142 PIDGIN_HIG_BOX_SPACE);
2143 gtk_widget_show(vbox_for_spacing);
2144
2145 pages[i] = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
2146 gtk_box_pack_start(GTK_BOX(vbox_for_spacing),
2147 pages[i], TRUE, TRUE, PIDGIN_HIG_BOX_SPACE);
2148 gtk_widget_show(pages[i]);
2149 }
2150
2151 if (notebook == NULL)
2152 vbox = pages[0];
2153 }
2154
2155 if (secondary) {
2156 secondary_esc = pidgin_request_escape(cpar, secondary);
2157 label = gtk_label_new(NULL);
2158
2159 gtk_label_set_markup(GTK_LABEL(label), secondary_esc);
2160 g_free(secondary_esc);
2161 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
2162 gtk_label_set_xalign(GTK_LABEL(label), 0);
2163 gtk_label_set_yalign(GTK_LABEL(label), 0);
2164 gtk_box_pack_start(GTK_BOX(vbox), label, (notebook == NULL),
2165 (notebook == NULL), 0);
2166 gtk_widget_show(label);
2167 }
2168
2169 if (notebook != NULL) {
2170 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(notebook), TRUE, TRUE, 0);
2171 gtk_widget_show(GTK_WIDGET(notebook));
2172 }
2173
2174 for (gl = purple_request_fields_get_groups(fields);
2175 gl != NULL;
2176 gl = gl->next)
2177 {
2178 GList *field_list;
2179 size_t field_count = 0;
2180 size_t cols = 1;
2181 size_t rows;
2182 #if 0
2183 size_t col_num;
2184 #endif
2185 size_t row_num = 0;
2186 guint tab_no;
2187 gboolean contains_resizable = FALSE, frame_fill;
2188
2189 group = gl->data;
2190 field_list = purple_request_field_group_get_fields(group);
2191 tab_no = purple_request_field_group_get_tab(group);
2192 if (tab_no >= tab_count) {
2193 purple_debug_warning("gtkrequest",
2194 "Invalid tab number: %d", tab_no);
2195 tab_no = 0;
2196 }
2197
2198 if (purple_request_field_group_get_title(group) != NULL)
2199 {
2200 frame = pidgin_make_frame(pages[tab_no],
2201 purple_request_field_group_get_title(group));
2202 }
2203 else
2204 frame = pages[tab_no];
2205
2206 field_count = g_list_length(field_list);
2207 #if 0
2208 if (field_count > 9)
2209 {
2210 rows = field_count / 2;
2211 cols++;
2212 }
2213 else
2214 #endif
2215 rows = field_count;
2216
2217 #if 0
2218 col_num = 0;
2219 #endif
2220
2221 for (fl = field_list; fl != NULL; fl = fl->next)
2222 {
2223 PurpleRequestFieldType type;
2224
2225 field = (PurpleRequestField *)fl->data;
2226
2227 type = purple_request_field_get_field_type(field);
2228
2229 if (type == PURPLE_REQUEST_FIELD_DATASHEET)
2230 contains_resizable = TRUE;
2231
2232 if (type == PURPLE_REQUEST_FIELD_LABEL)
2233 {
2234 #if 0
2235 if (col_num > 0)
2236 rows++;
2237 #endif
2238
2239 rows++;
2240 }
2241 else if ((type == PURPLE_REQUEST_FIELD_LIST) ||
2242 (type == PURPLE_REQUEST_FIELD_STRING &&
2243 purple_request_field_string_is_multiline(field)))
2244 {
2245 #if 0
2246 if (col_num > 0)
2247 rows++;
2248 #endif
2249
2250 rows += 2;
2251 } else if (compact && type != PURPLE_REQUEST_FIELD_BOOLEAN)
2252 rows++;
2253
2254 #if 0
2255 col_num++;
2256
2257 if (col_num >= cols)
2258 col_num = 0;
2259 #endif
2260 }
2261
2262 grid = gtk_grid_new();
2263 gtk_grid_set_row_spacing(GTK_GRID(grid), PIDGIN_HIG_BOX_SPACE);
2264 gtk_grid_set_column_spacing(GTK_GRID(grid), PIDGIN_HIG_BOX_SPACE);
2265
2266 frame_fill = (notebook == NULL || contains_resizable);
2267 gtk_box_pack_start(GTK_BOX(frame), grid, frame_fill, frame_fill, 0);
2268 gtk_widget_show(grid);
2269
2270 for (row_num = 0, fl = field_list;
2271 row_num < rows && fl != NULL;
2272 row_num++)
2273 {
2274 #if 0
2275 for (col_num = 0;
2276 col_num < cols && fl != NULL;
2277 col_num++, fl = fl->next)
2278 #else
2279 gboolean dummy_counter = TRUE;
2280 /* it's the same as loop above */
2281 for (; dummy_counter && fl != NULL; dummy_counter = FALSE, fl = fl->next)
2282 #endif
2283 {
2284 #if 0
2285 size_t col_offset = col_num * 2;
2286 #else
2287 size_t col_offset = 0;
2288 #endif
2289 PurpleRequestFieldType type;
2290 GtkWidget *widget = NULL;
2291 gchar *field_label;
2292
2293 label = NULL;
2294 field = fl->data;
2295
2296 if (!purple_request_field_is_visible(field)) {
2297 #if 0
2298 col_num--;
2299 #endif
2300 continue;
2301 }
2302
2303 type = purple_request_field_get_field_type(field);
2304 field_label = pidgin_request_escape(cpar,
2305 purple_request_field_get_label(field));
2306
2307 if (type != PURPLE_REQUEST_FIELD_BOOLEAN && field_label)
2308 {
2309 char *text = NULL;
2310
2311 if (field_label[strlen(field_label) - 1] != ':' &&
2312 field_label[strlen(field_label) - 1] != '?' &&
2313 type != PURPLE_REQUEST_FIELD_LABEL)
2314 {
2315 text = g_strdup_printf("%s:", field_label);
2316 }
2317
2318 label = gtk_label_new(NULL);
2319 gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), text ? text : field_label);
2320 g_free(text);
2321
2322 gtk_widget_set_hexpand(label, TRUE);
2323 gtk_widget_set_vexpand(label, TRUE);
2324 gtk_label_set_xalign(GTK_LABEL(label), 0);
2325
2326 gtk_size_group_add_widget(sg, label);
2327
2328 if (type == PURPLE_REQUEST_FIELD_LABEL ||
2329 type == PURPLE_REQUEST_FIELD_LIST ||
2330 (type == PURPLE_REQUEST_FIELD_STRING &&
2331 purple_request_field_string_is_multiline(field)))
2332 {
2333 #if 0
2334 if(col_num > 0)
2335 row_num++;
2336 #endif
2337
2338 gtk_grid_attach(GTK_GRID(grid), label,
2339 0, row_num, 2 * cols, 1);
2340
2341 row_num++;
2342 #if 0
2343 col_num=cols;
2344 #endif
2345 }
2346 else
2347 {
2348 gtk_grid_attach(GTK_GRID(grid), label,
2349 col_offset, row_num, 1, 1);
2350 }
2351
2352 gtk_widget_show(label);
2353 g_free(field_label);
2354 }
2355
2356 widget = GTK_WIDGET(purple_request_field_get_ui_data(field));
2357 if (widget == NULL)
2358 {
2359 if (type == PURPLE_REQUEST_FIELD_STRING)
2360 widget = create_string_field(field);
2361 else if (type == PURPLE_REQUEST_FIELD_INTEGER)
2362 widget = create_int_field(field);
2363 else if (type == PURPLE_REQUEST_FIELD_BOOLEAN)
2364 widget = create_bool_field(field, cpar);
2365 else if (type == PURPLE_REQUEST_FIELD_CHOICE)
2366 widget = create_choice_field(field, cpar);
2367 else if (type == PURPLE_REQUEST_FIELD_LIST)
2368 widget = create_list_field(field);
2369 else if (type == PURPLE_REQUEST_FIELD_IMAGE)
2370 widget = create_image_field(field);
2371 else if (type == PURPLE_REQUEST_FIELD_ACCOUNT)
2372 widget = create_account_field(field);
2373 else if (type == PURPLE_REQUEST_FIELD_CERTIFICATE)
2374 widget = create_certificate_field(field);
2375 else if (type == PURPLE_REQUEST_FIELD_DATASHEET)
2376 widget = create_datasheet_field(field, datasheet_buttons_sg);
2377 else
2378 continue;
2379 }
2380
2381 gtk_widget_set_sensitive(widget,
2382 purple_request_field_is_sensitive(field));
2383
2384 if (label)
2385 gtk_label_set_mnemonic_widget(GTK_LABEL(label), widget);
2386
2387 gtk_widget_set_hexpand(widget, TRUE);
2388 gtk_widget_set_vexpand(widget, TRUE);
2389 #if GTK_CHECK_VERSION(3,12,0)
2390 gtk_widget_set_margin_start(widget, 5);
2391 gtk_widget_set_margin_end(widget, 5);
2392 #else
2393 gtk_widget_set_margin_left(widget, 5);
2394 gtk_widget_set_margin_right(widget, 5);
2395 #endif
2396
2397 if (type == PURPLE_REQUEST_FIELD_STRING &&
2398 purple_request_field_string_is_multiline(field))
2399 {
2400 gtk_grid_attach(GTK_GRID(grid), widget,
2401 0, row_num, 2 * cols, 1);
2402 }
2403 else if (type == PURPLE_REQUEST_FIELD_LIST)
2404 {
2405 gtk_grid_attach(GTK_GRID(grid), widget,
2406 0, row_num, 2 * cols, 1);
2407 }
2408 else if (type == PURPLE_REQUEST_FIELD_BOOLEAN)
2409 {
2410 gtk_grid_attach(GTK_GRID(grid), widget,
2411 col_offset, row_num, 1, 1);
2412 }
2413 else if (compact) {
2414 row_num++;
2415 gtk_grid_attach(GTK_GRID(grid), widget,
2416 0, row_num, 2 * cols, 1);
2417 } else {
2418 gtk_grid_attach(GTK_GRID(grid), widget,
2419 1, row_num, 2 * cols - 1, 1);
2420 }
2421
2422 gtk_widget_show(widget);
2423
2424 purple_request_field_set_ui_data(field, widget);
2425 }
2426 }
2427 }
2428
2429 g_object_unref(sg);
2430 g_object_unref(datasheet_buttons_sg);
2431
2432 if (!purple_request_fields_all_required_filled(fields))
2433 gtk_widget_set_sensitive(data->ok_button, FALSE);
2434
2435 if (!purple_request_fields_all_valid(fields))
2436 gtk_widget_set_sensitive(data->ok_button, FALSE);
2437
2438 g_free(pages);
2439
2440 pidgin_auto_parent_window(win);
2441
2442 gtk_widget_show(win);
2443
2444 return data;
2445 }
2446
2447 static void
2448 file_yes_no_cb(PidginRequestData *data, gint id)
2449 {
2450 /* Only call the callback if yes was selected, otherwise the request
2451 * (eg. file transfer) will be cancelled, then when a new filename is chosen
2452 * things go BOOM */
2453 if (id == 1) {
2454 if (data->cbs[1] != NULL)
2455 ((PurpleRequestFileCb)data->cbs[1])(data->user_data, data->u.file.name);
2456 purple_request_close(data->type, data);
2457 } else {
2458 pidgin_clear_cursor(GTK_WIDGET(data->dialog));
2459 }
2460 }
2461
2462 static void
2463 file_ok_check_if_exists_cb(GtkWidget *widget, gint response, PidginRequestData *data)
2464 {
2465 gchar *current_folder;
2466
2467 generic_response_start(data);
2468
2469 if (response != GTK_RESPONSE_ACCEPT) {
2470 if (data->cbs[0] != NULL)
2471 ((PurpleRequestFileCb)data->cbs[0])(data->user_data, NULL);
2472 purple_request_close(data->type, data);
2473 return;
2474 }
2475
2476 data->u.file.name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(data->dialog));
2477 current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(data->dialog));
2478 if (current_folder != NULL) {
2479 if (data->u.file.savedialog) {
2480 purple_prefs_set_path(PIDGIN_PREFS_ROOT "/filelocations/last_save_folder", current_folder);
2481 } else {
2482 purple_prefs_set_path(PIDGIN_PREFS_ROOT "/filelocations/last_open_folder", current_folder);
2483 }
2484 g_free(current_folder);
2485 }
2486 if ((data->u.file.savedialog == TRUE) &&
2487 (g_file_test(data->u.file.name, G_FILE_TEST_EXISTS))) {
2488 purple_request_action(data, NULL, _("That file already exists"),
2489 _("Would you like to overwrite it?"), 0,
2490 NULL,
2491 data, 2,
2492 _("Overwrite"), G_CALLBACK(file_yes_no_cb),
2493 _("Choose New Name"), G_CALLBACK(file_yes_no_cb));
2494 } else
2495 file_yes_no_cb(data, 1);
2496 }
2497
2498 static void *
2499 pidgin_request_file(const char *title, const char *filename,
2500 gboolean savedialog, GCallback ok_cb, GCallback cancel_cb,
2501 PurpleRequestCommonParameters *cpar, void *user_data)
2502 {
2503 PidginRequestData *data;
2504 GtkWidget *filesel;
2505 #ifdef _WIN32
2506 const gchar *current_folder;
2507 gboolean folder_set = FALSE;
2508 #endif
2509
2510 data = g_new0(PidginRequestData, 1);
2511 data->type = PURPLE_REQUEST_FILE;
2512 data->user_data = user_data;
2513 data->cb_count = 2;
2514 data->cbs = g_new0(GCallback, 2);
2515 data->cbs[0] = cancel_cb;
2516 data->cbs[1] = ok_cb;
2517 data->u.file.savedialog = savedialog;
2518
2519 filesel = gtk_file_chooser_dialog_new(
2520 title ? title : (savedialog ? _("Save File...")
2521 : _("Open File...")),
2522 NULL,
2523 savedialog ? GTK_FILE_CHOOSER_ACTION_SAVE
2524 : GTK_FILE_CHOOSER_ACTION_OPEN,
2525 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2526 savedialog ? GTK_STOCK_SAVE
2527 : GTK_STOCK_OPEN,
2528 GTK_RESPONSE_ACCEPT,
2529 NULL);
2530 gtk_dialog_set_default_response(GTK_DIALOG(filesel), GTK_RESPONSE_ACCEPT);
2531
2532 pidgin_request_add_help(GTK_DIALOG(filesel), cpar);
2533
2534 if ((filename != NULL) && (*filename != '\0')) {
2535 if (savedialog)
2536 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(filesel), filename);
2537 else if (g_file_test(filename, G_FILE_TEST_EXISTS))
2538 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(filesel), filename);
2539 }
2540
2541 #ifdef _WIN32
2542 if (savedialog) {
2543 current_folder = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/filelocations/last_save_folder");
2544 } else {
2545 current_folder = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/filelocations/last_open_folder");
2546 }
2547
2548 if ((filename == NULL || *filename == '\0' || !g_file_test(filename, G_FILE_TEST_EXISTS)) &&
2549 (current_folder != NULL) && (*current_folder != '\0')) {
2550 folder_set = gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filesel), current_folder);
2551 }
2552
2553 if (!folder_set && (filename == NULL || *filename == '\0' || !g_file_test(filename, G_FILE_TEST_EXISTS))) {
2554 char *my_documents = wpurple_get_special_folder(CSIDL_PERSONAL);
2555
2556 if (my_documents != NULL) {
2557 gtk_file_chooser_set_current_folder(
2558 GTK_FILE_CHOOSER(filesel), my_documents);
2559
2560 g_free(my_documents);
2561 }
2562 }
2563 #endif
2564
2565 g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(filesel)), "response",
2566 G_CALLBACK(file_ok_check_if_exists_cb), data);
2567
2568 pidgin_auto_parent_window(filesel);
2569
2570 data->dialog = filesel;
2571 gtk_widget_show(filesel);
2572
2573 return (void *)data;
2574 }
2575
2576 static void *
2577 pidgin_request_folder(const char *title, const char *dirname, GCallback ok_cb,
2578 GCallback cancel_cb, PurpleRequestCommonParameters *cpar,
2579 void *user_data)
2580 {
2581 PidginRequestData *data;
2582 GtkWidget *dirsel;
2583
2584 data = g_new0(PidginRequestData, 1);
2585 data->type = PURPLE_REQUEST_FOLDER;
2586 data->user_data = user_data;
2587 data->cb_count = 2;
2588 data->cbs = g_new0(GCallback, 2);
2589 data->cbs[0] = cancel_cb;
2590 data->cbs[1] = ok_cb;
2591 data->u.file.savedialog = FALSE;
2592
2593 dirsel = gtk_file_chooser_dialog_new(
2594 title ? title : _("Select Folder..."),
2595 NULL,
2596 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
2597 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2598 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
2599 NULL);
2600 gtk_dialog_set_default_response(GTK_DIALOG(dirsel), GTK_RESPONSE_ACCEPT);
2601
2602 pidgin_request_add_help(GTK_DIALOG(dirsel), cpar);
2603
2604 if ((dirname != NULL) && (*dirname != '\0'))
2605 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dirsel), dirname);
2606
2607 g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(dirsel)), "response",
2608 G_CALLBACK(file_ok_check_if_exists_cb), data);
2609
2610 data->dialog = dirsel;
2611 pidgin_auto_parent_window(dirsel);
2612
2613 gtk_widget_show(dirsel);
2614
2615 return (void *)data;
2616 }
2617
2618 /* if request callback issues another request, it should be attached to the
2619 * primary request parent */
2620 static void
2621 pidgin_window_detach_children(GtkWindow* win)
2622 {
2623 GList *it;
2624 GtkWindow *par;
2625
2626 g_return_if_fail(win != NULL);
2627
2628 par = gtk_window_get_transient_for(win);
2629 it = gtk_window_list_toplevels();
2630 for (it = g_list_first(it); it != NULL; it = g_list_next(it)) {
2631 GtkWindow *child = GTK_WINDOW(it->data);
2632 if (gtk_window_get_transient_for(child) != win)
2633 continue;
2634 if (gtk_window_get_destroy_with_parent(child)) {
2635 #ifdef _WIN32
2636 /* XXX test/verify it: Win32 gtk ignores
2637 * gtk_window_set_destroy_with_parent(..., FALSE). */
2638 gtk_window_set_transient_for(child, NULL);
2639 #endif
2640 continue;
2641 }
2642 gtk_window_set_transient_for(child, par);
2643 }
2644 }
2645
2646 static void
2647 pidgin_close_request(PurpleRequestType type, void *ui_handle)
2648 {
2649 PidginRequestData *data = (PidginRequestData *)ui_handle;
2650
2651 g_free(data->cbs);
2652
2653 pidgin_window_detach_children(GTK_WINDOW(data->dialog));
2654
2655 gtk_widget_destroy(data->dialog);
2656
2657 if (type == PURPLE_REQUEST_FIELDS)
2658 purple_request_fields_destroy(data->u.multifield.fields);
2659 else if (type == PURPLE_REQUEST_FILE)
2660 g_free(data->u.file.name);
2661
2662 g_free(data);
2663 }
2664
2665 GtkWindow *
2666 pidgin_request_get_dialog_window(void *ui_handle)
2667 {
2668 PidginRequestData *data = ui_handle;
2669
2670 g_return_val_if_fail(
2671 purple_request_is_valid_ui_handle(data, NULL), NULL);
2672
2673 return GTK_WINDOW(data->dialog);
2674 }
2675
2676 static PurpleRequestUiOps ops =
2677 {
2678 PURPLE_REQUEST_FEATURE_HTML,
2679 pidgin_request_input,
2680 pidgin_request_choice,
2681 pidgin_request_action,
2682 pidgin_request_wait,
2683 pidgin_request_wait_update,
2684 pidgin_request_fields,
2685 pidgin_request_file,
2686 pidgin_request_folder,
2687 pidgin_close_request,
2688 NULL,
2689 NULL,
2690 NULL,
2691 NULL
2692 };
2693
2694 PurpleRequestUiOps *
2695 pidgin_request_get_ui_ops(void)
2696 {
2697 return &ops;
2698 }
2699
2700 void *
2701 pidgin_request_get_handle(void)
2702 {
2703 static int handle;
2704
2705 return &handle;
2706 }
2707
2708 static void
2709 pidgin_request_datasheet_stock_remove(gpointer obj)
2710 {
2711 if (obj == NULL)
2712 return;
2713 g_object_unref(obj);
2714 }
2715
2716 void
2717 pidgin_request_init(void)
2718 {
2719 datasheet_stock = g_hash_table_new_full(g_str_hash, g_str_equal,
2720 g_free, pidgin_request_datasheet_stock_remove);
2721 }
2722
2723 void
2724 pidgin_request_uninit(void)
2725 {
2726 purple_signals_disconnect_by_handle(pidgin_request_get_handle());
2727 g_hash_table_destroy(datasheet_stock);
2728 datasheet_stock = NULL;
2729 }
Git mirror of Pidgin's Mercurial repository