← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ekiga/vivid-proposed

« back to all changes in this revision

Viewing changes to lib/engine/gui/gtk-core/form-dialog-gtk.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kilian Krause
  • Date: 2011-07-17 00:24:50 UTC
  • mfrom: (5.1.5 upstream) (7.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20110717002450-ytg3wsrc1ptd3153
Tags: 3.3.1-1
* New upstream release.
 - Required libpt-dev 2.10 and libopal-dev 3.10
* Fix debian/watch to catch new version
* Remove libnotify0.7.patch - included upstream
* Add libboost-dev and libboost-signals-dev to Build-Depends
* debian/rules: Don't install *.la files for new internal shared libs
* Fix Vcs URIs to point to correct desktop/experimental/ekiga tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/engine/gui/gtk-core/form-dialog-gtk.cpp
1
1
 
2
2
/*
3
3
 * Ekiga -- A VoIP and Video-Conferencing application
4
 
 * Copyright (C) 2000-2007 Damien Sandras
5
 
 
 
4
 * Copyright (C) 2000-2009 Damien Sandras <dsandras@seconix.com>
 
5
 *
6
6
 * This program is free software; you can  redistribute it and/or modify
7
7
 * it under the terms of the GNU General Public License as published by
8
8
 * the Free Software Foundation; either version 2 of the License, or (at
28
28
 *                         form-dialog.cpp  -  description
29
29
 *                         ------------------------------------------
30
30
 *   begin                : written in 2007 by Julien Puydt
31
 
 *   copyright            : (c) 2007 by Julien Puydt
 
31
 *   copyright            : (c) 2007-2008 by Julien Puydt
32
32
 *   description          : implementation of a gtk+ representation of forms
33
33
 *
34
34
 */
35
35
 
 
36
 
36
37
#include <algorithm>
37
38
#include <cstring>
38
39
#include <iostream>
 
40
#include <glib/gi18n.h>
39
41
 
40
42
#include "toolbox.h"
41
43
#include "form-dialog-gtk.h"
103
105
/** Called when a link in a Form is clicked.
104
106
 * Open the URI.
105
107
 *
106
 
 * @param: The URI to open. 
 
108
 * @param: The URI to open.
107
109
 */
108
 
static void 
 
110
static void
109
111
link_clicked_cb (GtkWidget *widget,
110
112
                 gpointer data);
111
113
 
186
188
 
187
189
  BooleanSubmitter (const std::string _name,
188
190
                    const std::string _description,
 
191
                    bool _advanced,
189
192
                    GtkWidget *_widget): name(_name),
190
193
                                         description(_description),
 
194
                                         advanced(_advanced),
191
195
                                         widget(_widget)
192
196
  { }
193
197
 
197
201
  void submit (Ekiga::FormBuilder &builder)
198
202
  {
199
203
    builder.boolean (name, description,
200
 
                     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
 
204
                     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
 
205
                     advanced);
201
206
  }
202
207
 
203
208
private:
204
209
 
205
210
  const std::string name;
206
211
  const std::string description;
 
212
  bool advanced;
207
213
  GtkWidget *widget;
208
214
};
209
215
 
214
220
 
215
221
  TextSubmitter (const std::string _name,
216
222
                 const std::string _description,
 
223
                 const std::string _tooltip,
 
224
                 bool _advanced,
217
225
                 GtkWidget *_widget): name(_name),
218
226
                                      description(_description),
 
227
                                      tooltip(_tooltip),
 
228
                                      advanced(_advanced),
219
229
                                      widget(_widget)
220
230
  { }
221
231
 
225
235
  void submit (Ekiga::FormBuilder &builder)
226
236
  {
227
237
    builder.text (name, description,
228
 
                  gtk_entry_get_text (GTK_ENTRY (widget)));
 
238
          gtk_entry_get_text (GTK_ENTRY (widget)), tooltip,
 
239
                  advanced);
229
240
  }
230
241
 
231
242
private:
232
243
 
233
244
  const std::string name;
234
245
  const std::string description;
 
246
  const std::string tooltip;
 
247
  bool advanced;
235
248
  GtkWidget *widget;
236
249
};
237
250
 
242
255
 
243
256
  PrivateTextSubmitter (const std::string _name,
244
257
                        const std::string _description,
 
258
                        bool _advanced,
245
259
                        GtkWidget *_widget): name(_name),
246
260
                                             description(_description),
 
261
                                             advanced(_advanced),
247
262
                                             widget(_widget)
248
263
  { }
249
264
 
253
268
  void submit (Ekiga::FormBuilder &builder)
254
269
  {
255
270
    builder.private_text (name, description,
256
 
                          gtk_entry_get_text (GTK_ENTRY (widget)));
 
271
                          gtk_entry_get_text (GTK_ENTRY (widget)),
 
272
                          tooltip, advanced);
257
273
  }
258
274
 
259
275
private:
260
276
 
261
277
  const std::string name;
262
278
  const std::string description;
 
279
  const std::string tooltip;
 
280
  bool advanced;
263
281
  GtkWidget *widget;
264
282
};
265
283
 
270
288
 
271
289
  MultiTextSubmitter (const std::string _name,
272
290
                      const std::string _description,
 
291
                      bool _advanced,
273
292
                      GtkTextBuffer *_buffer): name(_name),
274
293
                                               description(_description),
 
294
                                               advanced(_advanced),
275
295
                                               buffer(_buffer)
276
296
  { }
277
297
 
287
307
    gtk_text_buffer_get_end_iter (buffer, &end);
288
308
    builder.multi_text (name, description,
289
309
                        gtk_text_buffer_get_text (buffer,
290
 
                                                  &start, &end, FALSE));
 
310
                                                  &start, &end, FALSE),
 
311
                        advanced);
291
312
  }
292
313
 
293
314
private:
294
315
 
295
316
  const std::string name;
296
317
  const std::string description;
 
318
  bool advanced;
297
319
  GtkTextBuffer *buffer;
298
320
};
299
321
 
305
327
  SingleChoiceSubmitter (const std::string _name,
306
328
                         const std::string _description,
307
329
                         const std::map<std::string, std::string> _choices,
 
330
                         bool _advanced,
308
331
                         GtkWidget *_combo): name(_name),
309
332
                                             description(_description),
310
333
                                             choices(_choices),
 
334
                                             advanced(_advanced),
311
335
                                             combo(_combo)
312
336
  { }
313
337
 
332
356
    gtk_tree_model_get (model, &iter, COLUMN_VALUE, &cvalue, -1);
333
357
 
334
358
    builder.single_choice (name, description,
335
 
                           std::string (cvalue), choices);
 
359
                           std::string (cvalue), choices,
 
360
                           advanced);
336
361
 
337
362
    g_free (cvalue);
338
363
  }
342
367
  const std::string name;
343
368
  const std::string description;
344
369
  const std::map<std::string, std::string> choices;
 
370
  bool advanced;
345
371
  GtkWidget *combo;
346
372
};
347
373
 
353
379
  MultipleChoiceSubmitter (const std::string _name,
354
380
                           const std::string _description,
355
381
                           const std::map<std::string, std::string> _choices,
 
382
                           bool _advanced,
356
383
                           GtkWidget *_tree_view):
357
384
    name(_name), description(_description),
358
 
    choices(_choices), tree_view (_tree_view)
 
385
    choices(_choices), advanced(_advanced), tree_view (_tree_view)
359
386
  { }
360
387
 
361
388
  ~MultipleChoiceSubmitter ()
403
430
      } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
404
431
    }
405
432
 
406
 
    builder.multiple_choice (name, description, values, choices);
 
433
    builder.multiple_choice (name, description, values, choices, advanced);
407
434
  }
408
435
 
409
436
private:
411
438
  const std::string name;
412
439
  const std::string description;
413
440
  std::map<std::string, std::string> choices;
 
441
  bool advanced;
414
442
  GtkWidget *tree_view;
415
443
};
416
444
 
421
449
 
422
450
  EditableSetSubmitter (const std::string _name,
423
451
                        const std::string _description,
 
452
                        bool _advanced,
424
453
                        GtkWidget *_tree_view):
425
 
    name(_name), description(_description), tree_view(_tree_view)
 
454
    name(_name), description(_description), advanced(_advanced), tree_view(_tree_view)
426
455
  { }
427
456
 
428
457
  ~EditableSetSubmitter ()
466
495
      } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
467
496
    }
468
497
 
469
 
    builder.editable_set (name, description, values, proposed_values);
 
498
    builder.editable_set (name, description, values, proposed_values, advanced);
470
499
  }
471
500
 
472
501
private:
473
502
 
474
503
  const std::string name;
475
504
  const std::string description;
 
505
  bool advanced;
476
506
  GtkWidget *tree_view;
477
507
};
478
508
 
587
617
}
588
618
 
589
619
 
590
 
static void 
 
620
static void
591
621
link_clicked_cb (GtkWidget * /*widget*/,
592
622
                 gpointer data)
593
623
{
595
625
}
596
626
 
597
627
 
598
 
FormDialog::FormDialog (Ekiga::FormRequest &_request,
 
628
FormDialog::FormDialog (Ekiga::FormRequestPtr _request,
599
629
                        GtkWidget *parent): request(_request)
600
630
{
601
631
  GtkWidget *vbox = NULL;
602
632
 
603
633
  rows = 0;
 
634
  advanced_rows = 0;
604
635
 
605
636
  window = gtk_dialog_new_with_buttons (NULL, GTK_WINDOW (NULL),
606
637
                                        GTK_DIALOG_MODAL,
617
648
  vbox = gtk_vbox_new (FALSE, 0);
618
649
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
619
650
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, FALSE, FALSE, 0);
 
651
  gtk_widget_show (vbox);
620
652
 
621
653
  preamble = gtk_vbox_new (FALSE, 0);
622
654
  gtk_box_pack_start (GTK_BOX (vbox), preamble, FALSE, FALSE, 0);
626
658
  gtk_table_set_col_spacings (GTK_TABLE (fields), 2);
627
659
  gtk_box_pack_start (GTK_BOX (vbox), fields, FALSE, FALSE, 3);
628
660
 
 
661
  advanced_fields = gtk_table_new (0, 2, FALSE);
 
662
  gtk_table_set_row_spacings (GTK_TABLE (advanced_fields), 2);
 
663
  gtk_table_set_col_spacings (GTK_TABLE (advanced_fields), 2);
 
664
  expander = gtk_expander_new (_("Advanced"));
 
665
  gtk_container_add (GTK_CONTAINER (expander), advanced_fields);
 
666
  gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 3);
 
667
 
629
668
  labels_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
630
669
  options_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
631
670
 
632
 
  request.visit (*this);
 
671
  request->visit (*this);
633
672
}
634
673
 
635
674
 
647
686
void
648
687
FormDialog::run ()
649
688
{
650
 
  gtk_widget_show_all (window);
 
689
  gtk_widget_show_all (preamble);
 
690
  gtk_widget_show_all (fields);
 
691
  if (advanced_rows > 0)
 
692
    gtk_widget_show_all (expander);
 
693
  gtk_widget_show (window);
651
694
  switch (gtk_dialog_run (GTK_DIALOG (window))) {
652
695
 
653
696
  case GTK_RESPONSE_ACCEPT:
715
758
  gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
716
759
  gtk_box_pack_start (GTK_BOX (preamble), widget, FALSE, FALSE, 0);
717
760
 
718
 
  g_signal_connect_data (G_OBJECT (widget), "clicked",
 
761
  g_signal_connect_data (widget, "clicked",
719
762
                         G_CALLBACK (link_clicked_cb), (gpointer) g_strdup (_uri.c_str ()),
720
763
                         (GClosureNotify) g_free, (GConnectFlags) 0);
721
764
}
751
794
void
752
795
FormDialog::boolean (const std::string name,
753
796
                     const std::string description,
754
 
                     bool value)
 
797
                     bool value,
 
798
                     bool advanced)
755
799
{
756
800
  GtkWidget *widget = NULL;
757
801
  BooleanSubmitter *submitter = NULL;
758
802
 
759
 
  rows++;
760
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
803
  grow_fields (advanced);
761
804
 
762
805
  widget = gtk_check_button_new_with_label (description.c_str ());
763
806
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
764
 
  gtk_table_attach_defaults (GTK_TABLE (fields), widget,
765
 
                             0, 2, rows -1, rows);
766
 
 
767
 
  submitter = new BooleanSubmitter (name, description, widget);
 
807
  if (advanced) {
 
808
 
 
809
    gtk_table_attach_defaults (GTK_TABLE (advanced_fields), widget,
 
810
                               0, 2, advanced_rows -1, advanced_rows);
 
811
  } else {
 
812
 
 
813
    gtk_table_attach_defaults (GTK_TABLE (fields), widget,
 
814
                               0, 2, rows -1, rows);
 
815
  }
 
816
 
 
817
  submitter = new BooleanSubmitter (name, description, advanced, widget);
768
818
  submitters.push_back (submitter);
769
819
}
770
820
 
771
821
void
772
822
FormDialog::text (const std::string name,
773
823
                  const std::string description,
774
 
                  const std::string value)
 
824
                  const std::string value,
 
825
                  const std::string tooltip,
 
826
                  bool advanced)
775
827
{
776
828
  GtkWidget *label = NULL;
777
829
  GtkWidget *widget = NULL;
779
831
 
780
832
  gchar *label_text = NULL;
781
833
 
782
 
  rows++;
783
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
834
  grow_fields (advanced);
784
835
 
785
836
  label = gtk_label_new (NULL);
786
837
  gtk_size_group_add_widget (labels_group, label);
790
841
  g_free (label_text);
791
842
 
792
843
  widget = gtk_entry_new ();
 
844
  gtk_widget_set_tooltip_text (widget, tooltip.c_str ());
793
845
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
794
846
  gtk_entry_set_activates_default (GTK_ENTRY (widget), true);
795
847
  gtk_size_group_add_widget (options_group, widget);
796
848
  gtk_entry_set_text (GTK_ENTRY (widget), value.c_str ());
797
849
 
798
 
  gtk_table_attach (GTK_TABLE (fields), label,
799
 
                    0, 1, rows - 1, rows,
800
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
801
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
802
 
                    0, 0);
803
 
  gtk_table_attach (GTK_TABLE (fields), widget,
804
 
                    1, 2, rows - 1, rows,
805
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
806
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
807
 
                    0, 0);
808
 
 
809
 
  submitter = new TextSubmitter (name, description, widget);
 
850
  if (advanced) {
 
851
 
 
852
    gtk_table_attach (GTK_TABLE (advanced_fields), label,
 
853
                      0, 1, advanced_rows - 1, advanced_rows,
 
854
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
855
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
856
                      0, 0);
 
857
    gtk_table_attach (GTK_TABLE (advanced_fields), widget,
 
858
                      1, 2, advanced_rows - 1, advanced_rows,
 
859
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
860
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
861
                      0, 0);
 
862
  } else {
 
863
 
 
864
    gtk_table_attach (GTK_TABLE (fields), label,
 
865
                      0, 1, rows - 1, rows,
 
866
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
867
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
868
                      0, 0);
 
869
    gtk_table_attach (GTK_TABLE (fields), widget,
 
870
                      1, 2, rows - 1, rows,
 
871
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
872
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
873
                      0, 0);
 
874
  }
 
875
 
 
876
  submitter = new TextSubmitter (name, description, tooltip, advanced, widget);
810
877
  submitters.push_back (submitter);
811
878
}
812
879
 
814
881
void
815
882
FormDialog::private_text (const std::string name,
816
883
                          const std::string description,
817
 
                          const std::string value)
 
884
                          const std::string value,
 
885
                          const std::string tooltip,
 
886
                          bool advanced)
818
887
{
819
888
  GtkWidget *label = NULL;
820
889
  GtkWidget *widget = NULL;
822
891
 
823
892
  gchar *label_text = NULL;
824
893
 
825
 
  rows++;
826
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
894
  grow_fields (advanced);
827
895
 
828
896
  label = gtk_label_new (NULL);
829
897
  gtk_size_group_add_widget (labels_group, label);
833
901
  g_free (label_text);
834
902
 
835
903
  widget = gtk_entry_new ();
 
904
  gtk_widget_set_tooltip_text (widget, tooltip.c_str ());
836
905
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
837
906
  gtk_entry_set_activates_default (GTK_ENTRY (widget), true);
838
907
  gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
839
908
  gtk_size_group_add_widget (options_group, widget);
840
909
  gtk_entry_set_text (GTK_ENTRY (widget), value.c_str ());
841
910
 
842
 
  gtk_table_attach (GTK_TABLE (fields), label,
843
 
                    0, 1, rows - 1, rows,
844
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
845
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
846
 
                    0, 0);
847
 
  gtk_table_attach (GTK_TABLE (fields), widget,
848
 
                    1, 2, rows - 1, rows,
849
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
850
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
851
 
                    0, 0);
852
 
 
853
 
  submitter = new PrivateTextSubmitter (name, description, widget);
 
911
  if (advanced) {
 
912
 
 
913
    gtk_table_attach (GTK_TABLE (advanced_fields), label,
 
914
                      0, 1, advanced_rows - 1, advanced_rows,
 
915
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
916
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
917
                      0, 0);
 
918
    gtk_table_attach (GTK_TABLE (advanced_fields), widget,
 
919
                      1, 2, advanced_rows - 1, advanced_rows,
 
920
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
921
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
922
                      0, 0);
 
923
  } else {
 
924
 
 
925
    gtk_table_attach (GTK_TABLE (fields), label,
 
926
                      0, 1, rows - 1, rows,
 
927
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
928
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
929
                      0, 0);
 
930
    gtk_table_attach (GTK_TABLE (fields), widget,
 
931
                      1, 2, rows - 1, rows,
 
932
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
933
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
934
                      0, 0);
 
935
  }
 
936
 
 
937
  submitter = new PrivateTextSubmitter (name, description, advanced, widget);
854
938
  submitters.push_back (submitter);
855
939
}
856
940
 
858
942
void
859
943
FormDialog::multi_text (const std::string name,
860
944
                        const std::string description,
861
 
                        const std::string value)
 
945
                        const std::string value,
 
946
                        bool advanced)
862
947
{
863
948
  GtkWidget *label = NULL;
864
949
  GtkWidget *scroller = NULL;
866
951
  GtkTextBuffer *buffer = NULL;
867
952
  MultiTextSubmitter *submitter = NULL;
868
953
 
869
 
  rows++;
870
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
954
  grow_fields (advanced);
871
955
 
872
956
  label = gtk_label_new_with_mnemonic (description.c_str ());
873
957
  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
874
958
  gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD);
875
 
  gtk_table_attach_defaults (GTK_TABLE (fields), label,
876
 
                             0, 2, rows -1, rows);
877
 
  rows++;
878
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
959
  if (advanced) {
 
960
 
 
961
    gtk_table_attach_defaults (GTK_TABLE (advanced_fields), label,
 
962
                               0, 2, advanced_rows -1, advanced_rows);
 
963
  } else {
 
964
 
 
965
    gtk_table_attach_defaults (GTK_TABLE (fields), label,
 
966
                               0, 2, rows -1, rows);
 
967
  }
 
968
 
 
969
  grow_fields (advanced);
879
970
 
880
971
  widget = gtk_text_view_new ();
881
972
  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));
885
976
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
886
977
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
887
978
  gtk_container_add (GTK_CONTAINER (scroller), widget);
888
 
  gtk_table_attach_defaults (GTK_TABLE (fields), scroller,
889
 
                             0, 2, rows -1, rows);
890
 
 
891
 
  submitter = new MultiTextSubmitter (name, description, buffer);
 
979
 
 
980
  if (advanced) {
 
981
 
 
982
    gtk_table_attach_defaults (GTK_TABLE (advanced_fields), scroller,
 
983
                               0, 2, advanced_rows -1, advanced_rows);
 
984
  } else {
 
985
 
 
986
    gtk_table_attach_defaults (GTK_TABLE (fields), scroller,
 
987
                               0, 2, rows -1, rows);
 
988
  }
 
989
 
 
990
  submitter = new MultiTextSubmitter (name, description, advanced, buffer);
892
991
  submitters.push_back (submitter);
893
992
}
894
993
 
897
996
FormDialog::single_choice (const std::string name,
898
997
                           const std::string description,
899
998
                           const std::string value,
900
 
                           const std::map<std::string, std::string> choices)
 
999
                           const std::map<std::string, std::string> choices,
 
1000
                           bool advanced)
901
1001
{
902
1002
  GtkWidget *label = NULL;
903
1003
  gchar* label_text = NULL;
907
1007
  GtkTreeIter iter;
908
1008
  SingleChoiceSubmitter *submitter = NULL;
909
1009
 
910
 
  rows++;
911
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
1010
  grow_fields (advanced);
912
1011
 
913
1012
  label = gtk_label_new (NULL);
914
1013
  gtk_size_group_add_widget (labels_group, label);
941
1040
      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
942
1041
  }
943
1042
 
944
 
  gtk_table_attach (GTK_TABLE (fields), label,
945
 
                    0, 1, rows -1, rows,
946
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
947
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
948
 
                    0,0);
949
 
  gtk_table_attach (GTK_TABLE (fields), widget,
950
 
                    1, 2, rows -1, rows,
951
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
952
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
953
 
                    0,0);
954
 
 
955
 
  submitter = new SingleChoiceSubmitter (name, description, choices, widget);
 
1043
  if (advanced) {
 
1044
 
 
1045
    gtk_table_attach (GTK_TABLE (advanced_fields), label,
 
1046
                      0, 1, advanced_rows -1, advanced_rows,
 
1047
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1048
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1049
                      0,0);
 
1050
    gtk_table_attach (GTK_TABLE (advanced_fields), widget,
 
1051
                      1, 2, advanced_rows -1, advanced_rows,
 
1052
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1053
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1054
                      0,0);
 
1055
  } else {
 
1056
 
 
1057
    gtk_table_attach (GTK_TABLE (fields), label,
 
1058
                      0, 1, rows -1, rows,
 
1059
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1060
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1061
                      0,0);
 
1062
    gtk_table_attach (GTK_TABLE (fields), widget,
 
1063
                      1, 2, rows -1, rows,
 
1064
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1065
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1066
                      0,0);
 
1067
  }
 
1068
 
 
1069
  submitter = new SingleChoiceSubmitter (name, description, choices,
 
1070
                                         advanced, widget);
956
1071
  submitters.push_back (submitter);
957
1072
}
958
1073
 
961
1076
FormDialog::multiple_choice (const std::string name,
962
1077
                             const std::string description,
963
1078
                             const std::set<std::string> values,
964
 
                             const std::map<std::string, std::string> choices)
 
1079
                             const std::map<std::string, std::string> choices,
 
1080
                             bool advanced)
965
1081
{
966
1082
  GtkWidget *label = NULL;
967
1083
  GtkWidget *scroll = NULL;
977
1093
 
978
1094
  MultipleChoiceSubmitter *submitter = NULL;
979
1095
 
980
 
  rows++;
981
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
1096
  grow_fields (advanced);
982
1097
 
983
1098
  /* The label */
984
1099
  label = gtk_label_new (NULL);
987
1102
  gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
988
1103
  g_free (label_text);
989
1104
 
990
 
  gtk_table_attach (GTK_TABLE (fields), label,
991
 
                    0, 2, rows - 1, rows,
992
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
993
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
994
 
                    0, 0);
995
 
 
996
1105
  /* The GtkListStore containing the choices */
997
1106
  tree_view = gtk_tree_view_new ();
998
1107
  list_store = gtk_list_store_new (MultipleChoiceSubmitter::COLUMN_NUMBER,
1017
1126
                                              "active", MultipleChoiceSubmitter::COLUMN_ACTIVE,
1018
1127
                                              NULL);
1019
1128
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
1020
 
  g_signal_connect (G_OBJECT (renderer), "toggled",
 
1129
  g_signal_connect (renderer, "toggled",
1021
1130
                    G_CALLBACK (multiple_choice_choice_toggled_cb), list_store);
1022
1131
 
1023
1132
  renderer = gtk_cell_renderer_text_new ();
1042
1151
                        -1);
1043
1152
  }
1044
1153
 
1045
 
  rows++;
1046
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
1047
 
  gtk_table_attach (GTK_TABLE (fields), frame,
1048
 
                    0, 2, rows - 1, rows,
1049
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1050
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1051
 
                    0, 0);
1052
 
 
1053
 
  submitter = new MultipleChoiceSubmitter (name, description, choices, tree_view);
 
1154
  if (advanced) {
 
1155
 
 
1156
    gtk_table_attach (GTK_TABLE (advanced_fields), label,
 
1157
                      0, 2, advanced_rows - 1, advanced_rows,
 
1158
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1159
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1160
                      0, 0);
 
1161
    gtk_table_attach (GTK_TABLE (advanced_fields), frame,
 
1162
                      0, 2, advanced_rows - 1, advanced_rows,
 
1163
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1164
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1165
                      0, 0);
 
1166
  } else {
 
1167
 
 
1168
    gtk_table_attach (GTK_TABLE (fields), label,
 
1169
                      0, 2, rows - 1, rows,
 
1170
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1171
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1172
                      0, 0);
 
1173
    gtk_table_attach (GTK_TABLE (fields), frame,
 
1174
                      0, 2, rows - 1, rows,
 
1175
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1176
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1177
                      0, 0);
 
1178
  }
 
1179
 
 
1180
  submitter = new MultipleChoiceSubmitter (name, description,
 
1181
                                           choices, advanced, tree_view);
1054
1182
  submitters.push_back (submitter);
1055
1183
}
1056
1184
 
1058
1186
FormDialog::editable_set (const std::string name,
1059
1187
                          const std::string description,
1060
1188
                          const std::set<std::string> values,
1061
 
                          const std::set<std::string> proposed_values)
 
1189
                          const std::set<std::string> proposed_values,
 
1190
                          bool advanced)
1062
1191
{
1063
1192
  GtkWidget *label = NULL;
1064
1193
  GtkWidget *scroll = NULL;
1077
1206
 
1078
1207
  EditableSetSubmitter *submitter = NULL;
1079
1208
 
1080
 
  rows++;
1081
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
1209
  grow_fields (advanced);
1082
1210
 
1083
1211
  /* The label */
1084
1212
  label = gtk_label_new (NULL);
1087
1215
  gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
1088
1216
  g_free (label_text);
1089
1217
 
1090
 
  gtk_table_attach (GTK_TABLE (fields), label,
1091
 
                    0, 2, rows - 1, rows,
1092
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1093
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1094
 
                    0, 0);
1095
 
 
1096
1218
  /* The GtkListStore containing the values */
1097
1219
  list_store = gtk_list_store_new (EditableSetSubmitter::COLUMN_NUMBER,
1098
1220
                                   G_TYPE_BOOLEAN, G_TYPE_STRING);
1116
1238
                                              "active", EditableSetSubmitter::COLUMN_ACTIVE,
1117
1239
                                              NULL);
1118
1240
  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
1119
 
  g_signal_connect (G_OBJECT (renderer), "toggled",
 
1241
  g_signal_connect (renderer, "toggled",
1120
1242
                    G_CALLBACK (editable_set_choice_toggled_cb), list_store);
1121
1243
 
1122
1244
  renderer = gtk_cell_renderer_text_new ();
1151
1273
    }
1152
1274
  }
1153
1275
 
1154
 
  rows++;
1155
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
1156
 
  gtk_table_attach (GTK_TABLE (fields), frame,
1157
 
                    0, 2, rows - 1, rows,
1158
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1159
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1160
 
                    0, 0);
 
1276
  if (advanced) {
 
1277
 
 
1278
    gtk_table_attach (GTK_TABLE (advanced_fields), label,
 
1279
                      0, 2, advanced_rows - 1, advanced_rows,
 
1280
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1281
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1282
                      0, 0);
 
1283
    gtk_table_attach (GTK_TABLE (advanced_fields), frame,
 
1284
                      0, 2, advanced_rows - 1, advanced_rows,
 
1285
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1286
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1287
                      0, 0);
 
1288
  } else {
 
1289
 
 
1290
    gtk_table_attach (GTK_TABLE (fields), label,
 
1291
                      0, 2, rows - 1, rows,
 
1292
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1293
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1294
                      0, 0);
 
1295
    gtk_table_attach (GTK_TABLE (fields), frame,
 
1296
                      0, 2, rows - 1, rows,
 
1297
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1298
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1299
                      0, 0);
 
1300
  }
1161
1301
 
1162
1302
  hbox = gtk_hbox_new (FALSE, 2);
1163
1303
  entry = gtk_entry_new ();
1165
1305
  gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 2);
1166
1306
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
1167
1307
 
1168
 
  g_signal_connect (G_OBJECT (entry), "activate",
 
1308
  g_signal_connect (entry, "activate",
1169
1309
                    (GCallback) editable_set_add_value_activated_cb,
1170
1310
                    (gpointer) tree_view);
1171
1311
 
1172
 
  g_signal_connect (G_OBJECT (button), "clicked",
 
1312
  g_signal_connect (button, "clicked",
1173
1313
                    (GCallback) editable_set_add_value_clicked_cb,
1174
1314
                    (gpointer) entry);
1175
1315
 
1176
 
  rows++;
1177
 
  gtk_table_resize (GTK_TABLE (fields), rows, 2);
1178
 
  gtk_table_attach (GTK_TABLE (fields), hbox,
1179
 
                    0, 2, rows - 1, rows,
1180
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1181
 
                    (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
1182
 
                    0, 0);
1183
 
 
1184
 
  submitter = new EditableSetSubmitter (name, description, tree_view);
 
1316
 
 
1317
  grow_fields (advanced);
 
1318
 
 
1319
  if (advanced) {
 
1320
 
 
1321
    gtk_table_attach (GTK_TABLE (advanced_fields), hbox,
 
1322
                      0, 2, advanced_rows - 1, advanced_rows,
 
1323
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1324
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1325
                      0, 0);
 
1326
  } else {
 
1327
 
 
1328
    gtk_table_attach (GTK_TABLE (fields), hbox,
 
1329
                      0, 2, rows - 1, rows,
 
1330
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1331
                      (GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
 
1332
                      0, 0);
 
1333
  }
 
1334
 
 
1335
  submitter = new EditableSetSubmitter (name, description, advanced, tree_view);
1185
1336
  submitters.push_back (submitter);
1186
1337
}
1187
1338
 
1190
1341
{
1191
1342
  Ekiga::FormBuilder builder;
1192
1343
 
1193
 
  gtk_widget_hide_all (GTK_WIDGET (window));
 
1344
  gtk_widget_hide (GTK_WIDGET (window));
1194
1345
 
1195
1346
  for (std::list<Submitter *>::iterator iter = submitters.begin ();
1196
1347
       iter != submitters.end ();
1197
1348
       iter++)
1198
1349
    (*iter)->submit (builder);
1199
1350
 
1200
 
  request.submit (builder);
 
1351
  request->submit (builder);
1201
1352
}
1202
1353
 
1203
1354
void
1204
1355
FormDialog::cancel ()
1205
1356
{
1206
 
  gtk_widget_hide_all (GTK_WIDGET (window));
1207
 
  request.cancel ();
 
1357
  gtk_widget_hide (GTK_WIDGET (window));
 
1358
  request->cancel ();
 
1359
}
 
1360
 
 
1361
void
 
1362
FormDialog::grow_fields (bool advanced)
 
1363
{
 
1364
  if (advanced) {
 
1365
 
 
1366
    advanced_rows++;
 
1367
    gtk_table_resize (GTK_TABLE (advanced_fields), advanced_rows, 2);
 
1368
  } else {
 
1369
 
 
1370
    rows++;
 
1371
    gtk_table_resize (GTK_TABLE (fields), rows, 2);
 
1372
  }
1208
1373
}