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