sjero.net Git - linphone/blob - gtk/propertybox.c

   1 /*
   2 linphone, gtk-glade interface.
   3 Copyright (C) 2008-2009  Simon MORLAT (simon.morlat@linphone.org)
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19
  20 #include "linphone.h"
  21 #include "linphone_tunnel.h"
  22
  23 typedef enum {
  24         CAP_IGNORE,
  25         CAP_PLAYBACK,
  26         CAP_CAPTURE
  27 }DeviceCap;
  28
  29 static void linphone_gtk_fill_combo_box(GtkWidget *combo, const char **devices, const char *selected, DeviceCap cap){
  30         const char **p=devices;
  31         int i=0,active=0;
  32         /* glade creates a combo box without list model and text renderer,
  33         unless we fill it with a dummy text.
  34         This dummy text needs to be removed first*/
  35         gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
  36         for(;*p!=NULL;++p){
  37                 if ( cap==CAP_IGNORE
  38                         || (cap==CAP_CAPTURE && linphone_core_sound_device_can_capture(linphone_gtk_get_core(),*p))
  39                         || (cap==CAP_PLAYBACK && linphone_core_sound_device_can_playback(linphone_gtk_get_core(),*p)) ){
  40                         gtk_combo_box_append_text(GTK_COMBO_BOX(combo),*p);
  41                         if (strcmp(selected,*p)==0) active=i;
  42                         i++;
  43                 }
  44         }
  45         gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
  46 }
  47
  48 void linphone_gtk_fill_video_sizes(GtkWidget *combo){
  49         const MSVideoSizeDef *def=linphone_core_get_supported_video_sizes(linphone_gtk_get_core());;
  50         int i,active=0;
  51         char vsize_def[256];
  52         MSVideoSize cur=linphone_core_get_preferred_video_size(linphone_gtk_get_core());
  53         /* glade creates a combo box without list model and text renderer,
  54         unless we fill it with a dummy text.
  55         This dummy text needs to be removed first*/
  56         gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
  57         for(i=0;def->name!=NULL;++def,++i){
  58                 snprintf(vsize_def,sizeof(vsize_def),"%s (%ix%i)",def->name,def->vsize.width,def->vsize.height);
  59                 gtk_combo_box_append_text(GTK_COMBO_BOX(combo),vsize_def);
  60                 if (cur.width==def->vsize.width && cur.height==def->vsize.height) active=i;
  61         }
  62         gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
  63 }
  64
  65 void linphone_gtk_parameters_closed(GtkWidget *button){
  66         GtkWidget *pb=gtk_widget_get_toplevel(button);
  67         gtk_widget_destroy(pb);
  68 }
  69
  70 void linphone_gtk_update_my_contact(GtkWidget *w){
  71         GtkWidget *pb=gtk_widget_get_toplevel(w);
  72         const char *username=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"username")));
  73         const char *displayname=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"displayname")));
  74         int port=linphone_core_get_sip_port(linphone_gtk_get_core());
  75         LinphoneAddress *parsed=linphone_core_get_primary_contact_parsed(linphone_gtk_get_core());
  76         char *contact;
  77         g_return_if_fail(parsed!=NULL);
  78         if (username[0]=='\0') return;
  79
  80         linphone_address_set_display_name(parsed,displayname);
  81         linphone_address_set_username(parsed,username);
  82         linphone_address_set_port_int(parsed,port);
  83         contact=linphone_address_as_string(parsed);
  84         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"sip_address")),contact);
  85         linphone_core_set_primary_contact(linphone_gtk_get_core(),contact);
  86         ms_free(contact);
  87         linphone_address_destroy(parsed);
  88         linphone_gtk_load_identities();
  89 }
  90
  91 void linphone_gtk_update_my_port(GtkWidget *w){
  92     GtkWidget *pb=gtk_widget_get_toplevel(GTK_WIDGET(w));
  93         LCSipTransports tr;
  94         LinphoneCore *lc=linphone_gtk_get_core();
  95     GtkComboBox *combo = GTK_COMBO_BOX(linphone_gtk_get_widget(pb, "proto_combo"));
  96
  97         gint port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
  98     if (port == 1) { // We use default port if not specified
  99         if (strcmp(gtk_combo_box_get_active_text(combo), "SIP (UDP)") == 0) {
 100             gtk_spin_button_set_value(GTK_SPIN_BUTTON(w),
 101                                 5060);
 102         }
 103         else if (strcmp(gtk_combo_box_get_active_text(combo), "SIP (TCP)") == 0) {
 104             gtk_spin_button_set_value(GTK_SPIN_BUTTON(w),
 105                                 5060);
 106         }
 107         else if (strcmp(gtk_combo_box_get_active_text(combo), "SIP (TLS)") == 0) {
 108             gtk_spin_button_set_value(GTK_SPIN_BUTTON(w),
 109                                 5061);
 110         }
 111     }
 112
 113         linphone_core_get_sip_transports(lc,&tr);
 114     gchar *selected = gtk_combo_box_get_active_text(combo);
 115         if (strcmp(selected, "SIP (TCP)") == 0) {
 116                 tr.tcp_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
 117                 tr.udp_port = 0;
 118                 tr.tls_port = 0;
 119         }
 120         else if (strcmp(gtk_combo_box_get_active_text(GTK_COMBO_BOX(linphone_gtk_get_widget(pb, "proto_combo"))), "SIP (UDP)") == 0) {
 121                 tr.udp_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
 122         tr.tcp_port = 0;
 123                 tr.tls_port = 0;
 124         }
 125         else if (strcmp(gtk_combo_box_get_active_text(GTK_COMBO_BOX(linphone_gtk_get_widget(pb, "proto_combo"))), "SIP (TLS)") == 0){
 126                 tr.udp_port = 0;
 127         tr.tcp_port = 0;
 128                 tr.tls_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
 129         }
 130
 131         linphone_core_set_sip_transports(lc,&tr);
 132 }
 133
 134 void linphone_gtk_stun_server_changed(GtkWidget *w){
 135         const gchar *addr=gtk_entry_get_text(GTK_ENTRY(w));
 136         linphone_core_set_stun_server(linphone_gtk_get_core(),addr);
 137 }
 138
 139 void linphone_gtk_nat_address_changed(GtkWidget *w){
 140         const gchar *addr=gtk_entry_get_text(GTK_ENTRY(w));
 141         linphone_core_set_nat_address(linphone_gtk_get_core(),addr);
 142 }
 143
 144 void linphone_gtk_ipv6_toggled(GtkWidget *w){
 145         linphone_core_enable_ipv6(linphone_gtk_get_core(),
 146                                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
 147 }
 148
 149 void linphone_gtk_audio_port_changed(GtkWidget *w){
 150         linphone_core_set_audio_port(linphone_gtk_get_core(),
 151                         (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 152 }
 153
 154 void linphone_gtk_video_port_changed(GtkWidget *w){
 155         linphone_core_set_video_port(linphone_gtk_get_core(),
 156                         (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 157 }
 158
 159 void linphone_gtk_no_firewall_toggled(GtkWidget *w){
 160         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 161                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyNoFirewall);
 162 }
 163
 164 void linphone_gtk_use_nat_address_toggled(GtkWidget *w){
 165         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 166                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseNatAddress);
 167 }
 168
 169 void linphone_gtk_use_stun_toggled(GtkWidget *w){
 170         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 171                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseStun);
 172 }
 173
 174 void linphone_gtk_use_ice_toggled(GtkWidget *w){
 175         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 176                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseIce);
 177 }
 178
 179 void linphone_gtk_mtu_changed(GtkWidget *w){
 180         if (GTK_WIDGET_SENSITIVE(w))
 181                 linphone_core_set_mtu(linphone_gtk_get_core(),gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 182 }
 183
 184 void linphone_gtk_use_sip_info_dtmf_toggled(GtkWidget *w){
 185         linphone_core_set_use_info_for_dtmf(linphone_gtk_get_core(),
 186                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
 187 }
 188
 189 void linphone_gtk_mtu_set(GtkWidget *w){
 190         GtkWidget *mtu=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"mtu");
 191         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
 192                 gtk_widget_set_sensitive(mtu,TRUE);
 193                 linphone_gtk_mtu_changed(mtu);
 194         }else{
 195                 gtk_widget_set_sensitive(mtu,FALSE);
 196                 linphone_core_set_mtu(linphone_gtk_get_core(),0);
 197         }
 198 }
 199
 200 void linphone_gtk_playback_device_changed(GtkWidget *w){
 201         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 202         linphone_core_set_playback_device(linphone_gtk_get_core(),sel);
 203         g_free(sel);
 204 }
 205
 206 void linphone_gtk_capture_device_changed(GtkWidget *w){
 207         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 208         linphone_core_set_capture_device(linphone_gtk_get_core(),sel);
 209         g_free(sel);
 210 }
 211
 212 void linphone_gtk_ring_device_changed(GtkWidget *w){
 213         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 214         linphone_core_set_ringer_device(linphone_gtk_get_core(),sel);
 215         g_free(sel);
 216 }
 217
 218 void linphone_gtk_alsa_special_device_changed(GtkWidget *w){
 219         /*
 220         const gchar *dev=gtk_entry_get_text(GTK_ENTRY(w));
 221         ...*/
 222 }
 223
 224 void linphone_gtk_cam_changed(GtkWidget *w){
 225         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 226         linphone_core_set_video_device(linphone_gtk_get_core(),sel);
 227         g_free(sel);
 228 }
 229
 230 void linphone_gtk_video_size_changed(GtkWidget *w){
 231         int sel=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 232         const MSVideoSizeDef *defs=linphone_core_get_supported_video_sizes(linphone_gtk_get_core());
 233         if (sel<0) return;
 234         linphone_core_set_preferred_video_size(linphone_gtk_get_core(),
 235                                         defs[sel].vsize);
 236 }
 237
 238 void linphone_gtk_ring_file_set(GtkWidget *w){
 239         gchar *file=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(w));
 240         linphone_core_set_ring(linphone_gtk_get_core(),file);
 241         g_free(file);
 242 }
 243
 244 static void linphone_gtk_end_of_ring(LinphoneCore *lc, void *user_data){
 245         gtk_widget_set_sensitive((GtkWidget*)user_data,TRUE);
 246 }
 247
 248 void linphone_gtk_play_ring_file(GtkWidget *w){
 249         if (linphone_core_preview_ring(linphone_gtk_get_core(),
 250                                 linphone_core_get_ring(linphone_gtk_get_core()),
 251                                 linphone_gtk_end_of_ring,
 252                                 w)==0){
 253                 gtk_widget_set_sensitive(w,FALSE);
 254         }
 255 }
 256
 257 void linphone_gtk_echo_cancelation_toggled(GtkWidget *w){
 258         linphone_core_enable_echo_cancellation(linphone_gtk_get_core(),
 259                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
 260 }
 261
 262 enum {
 263         CODEC_NAME,
 264         CODEC_RATE,
 265         CODEC_BITRATE,
 266         CODEC_STATUS,
 267         CODEC_PARAMS,
 268         CODEC_PRIVDATA,
 269         CODEC_COLOR,
 270         CODEC_INFO,
 271         CODEC_NCOLUMNS
 272 };
 273
 274 static void fmtp_edited(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer userdata){
 275         GtkListStore *store=(GtkListStore*)userdata;
 276         GtkTreeIter iter;
 277         if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),&iter,path)){
 278                 PayloadType *pt;
 279                 gtk_list_store_set(store,&iter,CODEC_PARAMS,new_text,-1);
 280                 gtk_tree_model_get(GTK_TREE_MODEL(store),&iter,CODEC_PRIVDATA,&pt,-1);
 281                 payload_type_set_recv_fmtp(pt,new_text);
 282         }
 283 }
 284
 285 static void linphone_gtk_init_codec_list(GtkTreeView *listview){
 286         GtkCellRenderer *renderer;
 287         GtkTreeViewColumn *column;
 288         GtkTreeSelection *select;
 289
 290         GtkListStore *store = gtk_list_store_new (CODEC_NCOLUMNS, G_TYPE_STRING,G_TYPE_INT,
 291                                                         G_TYPE_FLOAT,
 292                                                         G_TYPE_STRING,
 293                                                         G_TYPE_STRING,
 294                                                         G_TYPE_POINTER,
 295                                                         G_TYPE_STRING,
 296                                                         G_TYPE_STRING);
 297
 298         gtk_tree_view_set_model(listview,GTK_TREE_MODEL(store));
 299         g_object_unref(G_OBJECT(store));
 300
 301         renderer = gtk_cell_renderer_text_new ();
 302         column = gtk_tree_view_column_new_with_attributes (_("Name"),
 303                                                    renderer,
 304                                                    "text", CODEC_NAME,
 305                                                 "foreground",CODEC_COLOR,
 306                                                    NULL);
 307         gtk_tree_view_append_column (listview, column);
 308         column = gtk_tree_view_column_new_with_attributes (_("Rate (Hz)"),
 309                                                    renderer,
 310                                                    "text", CODEC_RATE,
 311                                                 "foreground",CODEC_COLOR,
 312                                                    NULL);
 313         gtk_tree_view_append_column (listview, column);
 314         column = gtk_tree_view_column_new_with_attributes (_("Status"),
 315                                                    renderer,
 316                                                    "text", CODEC_STATUS,
 317                                                 "foreground",CODEC_COLOR,
 318                                                    NULL);
 319         gtk_tree_view_append_column (listview, column);
 320         column = gtk_tree_view_column_new_with_attributes (_("Min bitrate (kbit/s)"),
 321                                                    renderer,
 322                                                    "text", CODEC_BITRATE,
 323                                                 "foreground",CODEC_COLOR,
 324                                                    NULL);
 325         gtk_tree_view_append_column (listview, column);
 326         renderer = gtk_cell_renderer_text_new ();
 327         column = gtk_tree_view_column_new_with_attributes (_("Parameters"),
 328                                                    renderer,
 329                                                    "text", CODEC_PARAMS,
 330                                                 "foreground",CODEC_COLOR,
 331                                         "editable",TRUE,
 332                                                    NULL);
 333         g_signal_connect(G_OBJECT(renderer),"edited",G_CALLBACK(fmtp_edited),store);
 334         gtk_tree_view_append_column (listview, column);
 335         /* Setup the selection handler */
 336         select = gtk_tree_view_get_selection (listview);
 337         gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
 338 }
 339
 340
 341 const char *get_codec_color(LinphoneCore *lc, PayloadType *pt){
 342         const gchar *color;
 343         if (linphone_core_check_payload_type_usability(lc,pt)) color="blue";
 344                 else color="red";
 345         if (!linphone_core_payload_type_enabled(lc,pt)) {
 346                 color="grey";
 347         }
 348         return color;
 349 }
 350
 351 static void linphone_gtk_show_codecs(GtkTreeView *listview, const MSList *codeclist)
 352 {
 353         const MSList *elem;
 354         GtkTreeIter iter;
 355         GtkListStore *store=GTK_LIST_STORE(gtk_tree_view_get_model(listview));
 356         GtkTreeSelection *selection;
 357
 358         gtk_list_store_clear(store);
 359
 360         for(elem=codeclist; elem!=NULL; elem=elem->next){
 361                 gchar *status;
 362                 gint rate;
 363                 gfloat bitrate;
 364                 const gchar *color;
 365                 const char *params="";
 366
 367                 struct _PayloadType *pt=(struct _PayloadType *)elem->data;
 368
 369                 color=get_codec_color(linphone_gtk_get_core(),pt);
 370                 if (linphone_core_payload_type_enabled(linphone_gtk_get_core(),pt)) status=_("Enabled");
 371                 else {
 372                         status=_("Disabled");
 373                 }
 374                 /* get an iterator */
 375                 gtk_list_store_append(store,&iter);
 376                 bitrate=payload_type_get_bitrate(pt)/1000.0;
 377                 rate=payload_type_get_rate(pt);
 378                 if (pt->recv_fmtp!=NULL) params=pt->recv_fmtp;
 379                 gtk_list_store_set(store,&iter, CODEC_NAME,payload_type_get_mime(pt),
 380                                         CODEC_RATE,rate,
 381                                         CODEC_BITRATE,bitrate,
 382                                         CODEC_STATUS,status,
 383                                         CODEC_PARAMS,params,
 384                                         CODEC_PRIVDATA,(gpointer)pt,
 385                                         CODEC_COLOR,(gpointer)color,
 386                                         CODEC_INFO,(gpointer)linphone_core_get_payload_type_description(linphone_gtk_get_core(),pt),
 387                                         -1);
 388         }
 389
 390
 391
 392         /* Setup the selection handler */
 393         selection = gtk_tree_view_get_selection (listview);
 394         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 395         //gtk_tree_view_columns_autosize(GTK_TREE_VIEW (sec->interfaces));
 396 #if GTK_CHECK_VERSION(2,12,0)
 397         gtk_tree_view_set_tooltip_column(listview,CODEC_INFO);
 398 #endif
 399 }
 400
 401 static void linphone_gtk_check_codec_bandwidth(GtkTreeView *v){
 402         GtkTreeIter iter;
 403         GtkTreeModel *model;
 404         model=gtk_tree_view_get_model(v);
 405         g_return_if_fail(gtk_tree_model_get_iter_first(model,&iter));
 406         do{
 407                 PayloadType *pt=NULL;
 408
 409                 gfloat bitrate;
 410                 gtk_tree_model_get(model,&iter,CODEC_PRIVDATA,&pt,-1);
 411
 412                 bitrate=payload_type_get_bitrate(pt)/1000.0;
 413                 gtk_list_store_set(GTK_LIST_STORE(model),&iter,CODEC_COLOR, (gpointer)get_codec_color(linphone_gtk_get_core(),pt),
 414                                         CODEC_BITRATE, bitrate,-1);
 415         }while(gtk_tree_model_iter_next(model,&iter));
 416 }
 417
 418 static void linphone_gtk_select_codec(GtkTreeView *v, PayloadType *ref){
 419         GtkTreeIter iter;
 420         GtkTreeModel *model;
 421         GtkTreeSelection *selection;
 422         selection=gtk_tree_view_get_selection(v);
 423         model=gtk_tree_view_get_model(v);
 424         g_return_if_fail(gtk_tree_model_get_iter_first(model,&iter));
 425         do{
 426                 PayloadType *pt=NULL;
 427                 gtk_tree_model_get(model,&iter,CODEC_PRIVDATA,&pt,-1);
 428                 if (pt==ref){
 429                         gtk_tree_selection_select_iter(selection,&iter);
 430                 }
 431
 432         }while(gtk_tree_model_iter_next(model,&iter));
 433 }
 434
 435 static void linphone_gtk_draw_codec_list(GtkTreeView *v, int type){ /* 0=audio, 1=video*/
 436         const MSList *list;
 437         if (type==0) list=linphone_core_get_audio_codecs(linphone_gtk_get_core());
 438         else list=linphone_core_get_video_codecs(linphone_gtk_get_core());
 439         linphone_gtk_show_codecs(v,list);
 440 }
 441
 442 void linphone_gtk_codec_view_changed(GtkWidget *w){
 443         GtkWidget *listview=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"codec_list");
 444         int active=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 445         linphone_gtk_draw_codec_list(GTK_TREE_VIEW(listview),active);
 446 }
 447
 448 void linphone_gtk_download_bw_changed(GtkWidget *w){
 449         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"codec_list"));
 450         linphone_core_set_download_bandwidth(linphone_gtk_get_core(),
 451                                 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 452         linphone_gtk_check_codec_bandwidth(v);
 453 }
 454
 455 void linphone_gtk_upload_bw_changed(GtkWidget *w){
 456         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"codec_list"));
 457         linphone_core_set_upload_bandwidth(linphone_gtk_get_core(),
 458                                 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 459         linphone_gtk_check_codec_bandwidth(v);
 460 }
 461
 462 void linphone_gtk_adaptive_rate_control_toggled(GtkToggleButton *button){
 463         gboolean active=gtk_toggle_button_get_active(button);
 464         linphone_core_enable_adaptive_rate_control(linphone_gtk_get_core(),active);
 465 }
 466
 467 static void linphone_gtk_codec_move(GtkWidget *button, int dir){
 468         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"codec_list"));
 469         GtkTreeSelection *sel=gtk_tree_view_get_selection(v);
 470         GtkTreeModel *mod;
 471         GtkTreeIter iter;
 472         PayloadType *pt=NULL;
 473         LinphoneCore *lc=linphone_gtk_get_core();
 474         if (gtk_tree_selection_get_selected(sel,&mod,&iter)){
 475                 MSList *sel_elem,*before;
 476                 MSList *codec_list;
 477                 gtk_tree_model_get(mod,&iter,CODEC_PRIVDATA,&pt,-1);
 478                 if (pt->type==PAYLOAD_VIDEO)
 479                         codec_list=ms_list_copy(linphone_core_get_video_codecs(lc));
 480                 else codec_list=ms_list_copy(linphone_core_get_audio_codecs(lc));
 481                 sel_elem=ms_list_find(codec_list,pt);
 482                 if (dir>0) {
 483                         if (sel_elem->prev) before=sel_elem->prev;
 484                         else before=sel_elem;
 485                         codec_list=ms_list_insert(codec_list,before,pt);
 486                 }
 487                 else{
 488                         if (sel_elem->next) before=sel_elem->next->next;
 489                         else before=sel_elem;
 490                         codec_list=ms_list_insert(codec_list,before,pt);
 491                 }
 492                 codec_list=ms_list_remove_link(codec_list,sel_elem);
 493                 if (pt->type==PAYLOAD_VIDEO)
 494                         linphone_core_set_video_codecs(lc,codec_list);
 495                 else linphone_core_set_audio_codecs(lc,codec_list);
 496                 linphone_gtk_show_codecs(v,codec_list);
 497                 linphone_gtk_select_codec(v,pt);
 498         }
 499 }
 500
 501 static void linphone_gtk_codec_set_enable(GtkWidget *button, gboolean enabled){
 502         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"codec_list"));
 503         GtkTreeSelection *sel=gtk_tree_view_get_selection(v);
 504         GtkTreeModel *mod;
 505         GtkListStore *store;
 506         GtkTreeIter iter;
 507         PayloadType *pt=NULL;
 508
 509         if (gtk_tree_selection_get_selected(sel,&mod,&iter)){
 510                 store=GTK_LIST_STORE(mod);
 511                 gtk_tree_model_get(mod,&iter,CODEC_PRIVDATA,&pt,-1);
 512                 linphone_core_enable_payload_type(linphone_gtk_get_core(),pt,enabled);
 513                 gtk_list_store_set(store,&iter,CODEC_STATUS, enabled ? _("Enabled") : _("Disabled"),
 514                                    CODEC_COLOR,(gpointer)get_codec_color(linphone_gtk_get_core(),pt), -1);
 515         }
 516 }
 517
 518 void linphone_gtk_codec_up(GtkWidget *button){
 519         linphone_gtk_codec_move(button,+1);
 520 }
 521
 522 void linphone_gtk_codec_down(GtkWidget *button){
 523         linphone_gtk_codec_move(button,-1);
 524 }
 525
 526 void linphone_gtk_codec_enable(GtkWidget *button){
 527         linphone_gtk_codec_set_enable(button,TRUE);
 528 }
 529
 530 void linphone_gtk_codec_disable(GtkWidget *button){
 531         linphone_gtk_codec_set_enable(button,FALSE);
 532 }
 533
 534 void linphone_gtk_clear_passwords(GtkWidget *button){
 535         linphone_core_clear_all_auth_info(linphone_gtk_get_core());
 536 }
 537
 538 enum{
 539         PROXY_CONFIG_IDENTITY,
 540         PROXY_CONFIG_REF,
 541         PROXY_CONFIG_NCOL
 542 };
 543
 544 void linphone_gtk_show_sip_accounts(GtkWidget *w){
 545         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"proxy_list"));
 546         GtkTreeModel *model=gtk_tree_view_get_model(v);
 547         GtkListStore *store;
 548         GtkTreeSelection *select;
 549         const MSList *elem;
 550         if (!model){
 551                 GtkCellRenderer *renderer;
 552                 GtkTreeViewColumn *column;
 553                 /* create the proxy list */
 554                 store = gtk_list_store_new (PROXY_CONFIG_NCOL, G_TYPE_STRING, G_TYPE_POINTER);
 555
 556                 gtk_tree_view_set_model(v,GTK_TREE_MODEL(store));
 557                 g_object_unref(G_OBJECT(store));
 558                 renderer = gtk_cell_renderer_text_new ();
 559                 column = gtk_tree_view_column_new_with_attributes (_("Account"),
 560                                                         renderer,
 561                                                         "text", PROXY_CONFIG_IDENTITY,
 562                                                         NULL);
 563                 gtk_tree_view_append_column (v, column);
 564
 565                 select = gtk_tree_view_get_selection (v);
 566                 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
 567                 model=GTK_TREE_MODEL(store);
 568         }else {
 569                 store=GTK_LIST_STORE(model);
 570         }
 571         gtk_list_store_clear(store);
 572         for(elem=linphone_core_get_proxy_config_list(linphone_gtk_get_core());elem!=NULL;elem=ms_list_next(elem)){
 573                 LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)elem->data;
 574                 GtkTreeIter iter;
 575                 gtk_list_store_append(store,&iter);
 576                 gtk_list_store_set(store,&iter,PROXY_CONFIG_IDENTITY,linphone_proxy_config_get_identity(cfg),
 577                                         PROXY_CONFIG_REF,cfg,-1);
 578         }
 579 }
 580
 581 static void linphone_gtk_proxy_closed(GtkWidget *w){
 582         LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(w),"config");
 583         if (cfg){
 584                 linphone_proxy_config_done(cfg);
 585         }
 586 }
 587
 588 void linphone_gtk_show_proxy_config(GtkWidget *pb, LinphoneProxyConfig *cfg){
 589         GtkWidget *w=linphone_gtk_create_window("sip_account");
 590         const char *tmp;
 591         if (cfg){
 592                 linphone_proxy_config_edit(cfg);
 593                 gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"identity")),
 594                         linphone_proxy_config_get_identity(cfg));
 595                 gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy")),
 596                         linphone_proxy_config_get_addr(cfg));
 597                 tmp=linphone_proxy_config_get_route(cfg);
 598                 if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"route")),tmp);
 599                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"regperiod")),
 600                         linphone_proxy_config_get_expires(cfg));
 601                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"register")),
 602                         linphone_proxy_config_register_enabled(cfg));
 603                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"publish")),
 604                         linphone_proxy_config_publish_enabled(cfg));
 605         }
 606         g_object_set_data(G_OBJECT(w),"config",(gpointer)cfg);
 607         g_object_set_data(G_OBJECT(w),"parameters",(gpointer)pb);
 608         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_gtk_proxy_closed,w);
 609         gtk_widget_show(w);
 610 }
 611
 612 void linphone_gtk_proxy_cancel(GtkButton *button){
 613         GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
 614         gtk_widget_destroy(w);
 615 }
 616
 617 void linphone_gtk_proxy_ok(GtkButton *button){
 618         GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
 619         LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(w),"config");
 620         gboolean was_editing=TRUE;
 621         if (!cfg){
 622                 was_editing=FALSE;
 623                 cfg=linphone_proxy_config_new();
 624         }
 625         linphone_proxy_config_set_identity(cfg,
 626                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"identity"))));
 627         linphone_proxy_config_set_server_addr(cfg,
 628                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy"))));
 629         linphone_proxy_config_set_route(cfg,
 630                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"route"))));
 631         linphone_proxy_config_expires(cfg,
 632                 (int)gtk_spin_button_get_value(
 633                         GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"regperiod"))));
 634         linphone_proxy_config_enable_publish(cfg,
 635                 gtk_toggle_button_get_active(
 636                         GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"publish"))));
 637         linphone_proxy_config_enable_register(cfg,
 638                 gtk_toggle_button_get_active(
 639                         GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"register"))));
 640         if (was_editing){
 641                 if (linphone_proxy_config_done(cfg)==-1)
 642                         return;
 643         }
 644         else {
 645                 if (linphone_core_add_proxy_config(linphone_gtk_get_core(),cfg)==-1) return;
 646                 linphone_core_set_default_proxy(linphone_gtk_get_core(),cfg);
 647         }
 648         g_object_set_data(G_OBJECT(w),"config",NULL);
 649         linphone_gtk_show_sip_accounts(GTK_WIDGET(g_object_get_data(G_OBJECT(w),"parameters")));
 650         gtk_widget_destroy(w);
 651         /* also update the main window's list of identities*/
 652         linphone_gtk_load_identities();
 653 }
 654
 655 static LinphoneProxyConfig *linphone_gtk_get_selected_proxy_config(GtkWidget* pb){
 656         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(pb,"proxy_list"));
 657         GtkTreeSelection *selection=gtk_tree_view_get_selection(v);
 658         GtkTreeIter iter;
 659         GtkTreeModel *model;
 660         if (gtk_tree_selection_get_selected(selection,&model,&iter)){
 661                 LinphoneProxyConfig *cfg=NULL;
 662                 gtk_tree_model_get(model,&iter,PROXY_CONFIG_REF,&cfg,-1);
 663                 return cfg;
 664         }
 665         return NULL;
 666 }
 667
 668 void linphone_gtk_add_proxy(GtkButton *button){
 669         linphone_gtk_show_proxy_config(gtk_widget_get_toplevel(GTK_WIDGET(button)),NULL);
 670 }
 671
 672 void linphone_gtk_remove_proxy(GtkButton *button){
 673         LinphoneProxyConfig *cfg=linphone_gtk_get_selected_proxy_config(
 674                         gtk_widget_get_toplevel(GTK_WIDGET(button)));
 675         if (cfg){
 676                 linphone_core_remove_proxy_config(linphone_gtk_get_core(),cfg);
 677                 linphone_gtk_show_sip_accounts(gtk_widget_get_toplevel(GTK_WIDGET(button)));
 678                 /* also update the main window's list of identities*/
 679                 linphone_gtk_load_identities();
 680         }
 681 }
 682
 683 void linphone_gtk_edit_proxy(GtkButton *button){
 684         GtkWidget *pb=gtk_widget_get_toplevel(GTK_WIDGET(button));
 685         LinphoneProxyConfig *cfg=linphone_gtk_get_selected_proxy_config(pb);
 686         if (cfg){
 687                 linphone_gtk_show_proxy_config(pb,cfg);
 688                 /* also update the main window's list of identities*/
 689                 linphone_gtk_load_identities();
 690         }
 691 }
 692
 693 typedef struct _LangCodes{
 694         const char *code;
 695         const char *name;
 696 }LangCodes;
 697
 698 static LangCodes supported_langs[]={
 699         {       "C"     ,       N_("English")   },
 700         {       "fr"    ,       N_("French")    },
 701         {       "sv"    ,       N_("Swedish")   },
 702         {       "it"    ,       N_("Italian")   },
 703         {       "es"    ,       N_("Spanish")   },
 704         {       "pt_BR" ,       N_("Brazilian Portugese")       },
 705         {       "pl"    ,       N_("Polish")    },
 706         {       "de"    ,       N_("German")    },
 707         {       "ru"    ,       N_("Russian")   },
 708         {       "ja"    ,       N_("Japanese")  },
 709         {       "nl"    ,       N_("Dutch")     },
 710         {       "hu"    ,       N_("Hungarian") },
 711         {       "cs"    ,       N_("Czech")     },
 712         {       "zh_CN" ,       N_("Chinese")   },
 713         {       "zh_TW" ,       N_("Traditional Chinese")       },
 714         {       "nb_NO" ,       N_("Norwegian") },
 715         {       NULL    ,       NULL            }
 716 };
 717
 718 static const char *lang_get_name(const char *code){
 719         LangCodes *p=supported_langs;
 720         while(p->code!=NULL){
 721                 if (strcmp(p->code,code)==0) return p->name;
 722                 p++;
 723         }
 724         return NULL;
 725 }
 726
 727 static gboolean lang_equals(const char *l1, const char *l2){
 728         return ((strncmp(l1,l2,5)==0 || strncmp(l1,l2,2)==0));
 729 }
 730
 731 static void linphone_gtk_fill_langs(GtkWidget *pb){
 732         GtkWidget *combo=linphone_gtk_get_widget(pb,"lang_combo");
 733         char code[10];
 734         const char *all_langs="C " LINPHONE_ALL_LANGS;
 735         const char *name;
 736         int i=0,index=0;
 737         const char *cur_lang=getenv("LANG");
 738         int cur_lang_index=-1;
 739         char text[256]={0};
 740         if (cur_lang==NULL) cur_lang="C";
 741         /* glade creates a combo box without list model and text renderer,
 742         unless we fill it with a dummy text.
 743         This dummy text needs to be removed first*/
 744         gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
 745         while(sscanf(all_langs+i,"%s",code)==1){
 746                 i+=strlen(code);
 747                 while(all_langs[i]==' ') ++i;
 748                 name=lang_get_name(code);
 749                 snprintf(text,sizeof(text)-1,"%s : %s",code,name!=NULL ? _(name) : code);
 750                 gtk_combo_box_append_text(GTK_COMBO_BOX(combo),text);
 751                 if (cur_lang_index==-1 && lang_equals(cur_lang,code))
 752                         cur_lang_index=index;
 753                 index++;
 754         }
 755         gtk_combo_box_set_active(GTK_COMBO_BOX(combo),cur_lang_index);
 756 }
 757
 758 void linphone_gtk_lang_changed(GtkComboBox *combo){
 759         const char *selected=gtk_combo_box_get_active_text(combo);
 760         char code[10];
 761         const char *cur_lang=getenv("LANG");
 762         if (selected!=NULL){
 763                 sscanf(selected,"%s",code);
 764                 if (cur_lang==NULL) cur_lang="C";
 765                 if (!lang_equals(cur_lang,code)){
 766                         GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(combo))),
 767                                 GTK_DIALOG_DESTROY_WITH_PARENT,
 768                                 GTK_MESSAGE_INFO,
 769                                 GTK_BUTTONS_CLOSE,
 770                                 "%s",
 771                                 (const gchar*)_("You need to restart linphone for the new language selection to take effect."));
 772                                 /* Destroy the dialog when the user responds to it (e.g. clicks a button) */
 773                         g_signal_connect_swapped (G_OBJECT (dialog), "response",
 774                                         G_CALLBACK (gtk_widget_destroy),
 775                                         G_OBJECT (dialog));
 776                         gtk_widget_show(dialog);
 777                         linphone_gtk_set_lang(code);
 778                 }
 779         }
 780 }
 781
 782 void linphone_gtk_proto_changed(GtkComboBox *combo){
 783     GtkWidget *pb=gtk_widget_get_toplevel(GTK_WIDGET(combo));
 784
 785     GtkWidget *proto_port = linphone_gtk_get_widget(pb, "proto_port");
 786     // When we change the network protocol, we call update_my_port to move the port number from the old protocol to the new one
 787     linphone_gtk_update_my_port(proto_port);
 788 }
 789
 790 static void linphone_gtk_ui_level_adapt(GtkWidget *top) {
 791         gboolean ui_advanced;
 792         const char *simple_ui = linphone_gtk_get_ui_config("simple_ui", "parameters.codec_tab parameters.transport_frame parameters.ports_frame");
 793
 794         ui_advanced = linphone_gtk_get_ui_config_int("advanced_ui", TRUE);
 795         if (ui_advanced) {
 796                 linphone_gtk_visibility_set(simple_ui, "parameters", top, TRUE);
 797         } else {
 798                 linphone_gtk_visibility_set(simple_ui, "parameters", top, FALSE);
 799         }
 800 }
 801
 802 void linphone_gtk_ui_level_toggled(GtkWidget *w) {
 803         gint ui_advanced;
 804         GtkWidget *top;
 805
 806         top = gtk_widget_get_toplevel(w);
 807         ui_advanced = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
 808         linphone_gtk_set_ui_config_int("advanced_ui", ui_advanced);
 809         linphone_gtk_ui_level_adapt(top);
 810 }
 811
 812 static void linphone_gtk_media_encryption_changed(GtkWidget *combo){
 813         char *selected=gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo));
 814         LinphoneCore *lc=linphone_gtk_get_core();
 815         if (selected!=NULL){
 816                 if (strcasecmp(selected,"SRTP")==0)
 817                         linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionSRTP);
 818                 else if (strcasecmp(selected,"ZRTP")==0)
 819                         linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionZRTP);
 820                 else linphone_core_set_media_encryption(lc,LinphoneMediaEncryptionNone);
 821                 g_free(selected);
 822         }else g_warning("gtk_combo_box_get_active_text() returned NULL");
 823 }
 824
 825 static void linphone_gtk_show_media_encryption(GtkWidget *pb){
 826         LinphoneCore *lc=linphone_gtk_get_core();
 827         GtkWidget *combo=linphone_gtk_get_widget(pb,"media_encryption_combo");
 828         bool_t no_enc=TRUE;
 829         int srtp_id=-1,zrtp_id=-1;
 830         GtkTreeModel *model;
 831         GtkListStore *store;
 832         GtkTreeIter iter;
 833         GtkCellRenderer *renderer=gtk_cell_renderer_text_new();
 834
 835         model=GTK_TREE_MODEL((store=gtk_list_store_new(1,G_TYPE_STRING)));
 836         gtk_combo_box_set_model(GTK_COMBO_BOX(combo),model);
 837         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),renderer,TRUE);
 838         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),renderer,"text",0,NULL);
 839
 840         gtk_list_store_append(store,&iter);
 841         gtk_list_store_set(store,&iter,0,_("None"),-1);
 842
 843         if (linphone_core_media_encryption_supported(lc,LinphoneMediaEncryptionSRTP)){
 844                 gtk_list_store_append(store,&iter);
 845                 gtk_list_store_set(store,&iter,0,_("SRTP"),-1);
 846                 srtp_id=1;
 847                 no_enc=FALSE;
 848         }
 849         if (linphone_core_media_encryption_supported(lc,LinphoneMediaEncryptionZRTP)){
 850                 gtk_list_store_append(store,&iter);
 851                 gtk_list_store_set(store,&iter,0,_("ZRTP"),-1);
 852                 no_enc=FALSE;
 853                 if (srtp_id!=-1) zrtp_id=2;
 854                 else zrtp_id=1;
 855         }
 856         if (no_enc){
 857                 /*hide this setting*/
 858                 gtk_widget_hide(combo);
 859                 gtk_widget_hide(linphone_gtk_get_widget(pb,"media_encryption_label"));
 860         }else{
 861                 LinphoneMediaEncryption menc=linphone_core_get_media_encryption(lc);
 862                 switch(menc){
 863                         case LinphoneMediaEncryptionNone:
 864                                 gtk_combo_box_set_active(GTK_COMBO_BOX(combo),0);
 865                         break;
 866                         case LinphoneMediaEncryptionSRTP:
 867                                 if (srtp_id!=-1) gtk_combo_box_set_active(GTK_COMBO_BOX(combo),srtp_id);
 868                         break;
 869                         case LinphoneMediaEncryptionZRTP:
 870                                 if (zrtp_id!=-1) gtk_combo_box_set_active(GTK_COMBO_BOX(combo),zrtp_id);
 871                         break;
 872                 }
 873                 g_signal_connect(G_OBJECT(combo),"changed",(GCallback)linphone_gtk_media_encryption_changed,NULL);
 874         }
 875         g_object_unref(G_OBJECT(model));
 876 }
 877
 878 void linphone_gtk_parameters_destroyed(GtkWidget *pb){
 879         GtkWidget *mw=linphone_gtk_get_main_window();
 880         g_object_set_data(G_OBJECT(mw),"parameters",NULL);
 881 }
 882
 883 void linphone_gtk_fill_soundcards(GtkWidget *pb){
 884         LinphoneCore *lc=linphone_gtk_get_core();
 885         const char **sound_devices=linphone_core_get_sound_devices(lc);
 886         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"playback_device"), sound_devices,
 887                                         linphone_core_get_playback_device(lc),CAP_PLAYBACK);
 888         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"ring_device"), sound_devices,
 889                                         linphone_core_get_ringer_device(lc),CAP_PLAYBACK);
 890         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"capture_device"), sound_devices,
 891                                         linphone_core_get_capture_device(lc), CAP_CAPTURE);
 892 }
 893
 894 void linphone_gtk_fill_webcams(GtkWidget *pb){
 895         LinphoneCore *lc=linphone_gtk_get_core();
 896         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"webcams"),linphone_core_get_video_devices(lc),
 897                                         linphone_core_get_video_device(lc),CAP_IGNORE);
 898 }
 899
 900 void linphone_gtk_show_parameters(void){
 901         GtkWidget *mw=linphone_gtk_get_main_window();
 902         GtkWidget *pb=(GtkWidget*)g_object_get_data(G_OBJECT(mw),"parameters");
 903         LinphoneCore *lc=linphone_gtk_get_core();
 904         const char *tmp;
 905         LinphoneAddress *contact;
 906         LinphoneFirewallPolicy pol;
 907         GtkWidget *codec_list;
 908         int mtu;
 909         int ui_advanced;
 910         LCSipTransports tr;
 911
 912         if (pb==NULL) {
 913                 pb=linphone_gtk_create_window("parameters");
 914                 g_object_set_data(G_OBJECT(mw),"parameters",pb);
 915         }else {
 916                 gtk_widget_show(pb);
 917                 return;
 918         }
 919         codec_list=linphone_gtk_get_widget(pb,"codec_list");
 920
 921         /* NETWORK CONFIG */
 922         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"ipv6_enabled")),
 923                                 linphone_core_ipv6_enabled(lc));
 924         linphone_core_get_sip_transports(lc,&tr);
 925
 926     if (tr.tcp_port > 0) {
 927         gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(pb,"proto_combo")), 1);
 928         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"proto_port")),
 929                                 tr.tcp_port);
 930     }
 931     else if (tr.tls_port > 0) {
 932         gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(pb,"proto_combo")), 2);
 933         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"proto_port")),
 934                                 tr.tls_port);
 935     }
 936     else {
 937         gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(pb,"proto_combo")), 0);
 938         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"proto_port")),
 939                                 tr.udp_port);
 940     }
 941
 942         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"audio_rtp_port")),
 943                                 linphone_core_get_audio_port(lc));
 944         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"video_rtp_port")),
 945                                 linphone_core_get_video_port(lc));
 946
 947         linphone_gtk_show_media_encryption(pb);
 948
 949         tmp=linphone_core_get_nat_address(lc);
 950         if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"nat_address")),tmp);
 951         tmp=linphone_core_get_stun_server(lc);
 952         if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"stun_server")),tmp);
 953         pol=linphone_core_get_firewall_policy(lc);
 954         switch(pol){
 955                 case LinphonePolicyNoFirewall:
 956                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"no_nat")),TRUE);
 957                 break;
 958                 case LinphonePolicyUseNatAddress:
 959                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_nat_address")),TRUE);
 960                 break;
 961                 case LinphonePolicyUseStun:
 962                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_stun")),TRUE);
 963                 break;
 964                 case LinphonePolicyUseIce:
 965                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_ice")),TRUE);
 966                 break;
 967         }
 968         mtu=linphone_core_get_mtu(lc);
 969         if (mtu<=0){
 970                 gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"mtu"),FALSE);
 971                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"mtu")),1500);
 972                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"mtu_set")),FALSE);
 973         }else{
 974                 gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"mtu"),TRUE);
 975                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"mtu")),mtu);
 976                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"mtu_set")),TRUE);
 977         }
 978         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"dtmf_sipinfo")),
 979                                         linphone_core_get_use_info_for_dtmf(lc));
 980         /* MUTIMEDIA CONFIG */
 981         linphone_gtk_fill_soundcards(pb);
 982         linphone_gtk_fill_webcams(pb);
 983
 984         linphone_gtk_fill_video_sizes(linphone_gtk_get_widget(pb,"video_size"));
 985         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"echo_cancelation")),
 986                                         linphone_core_echo_cancellation_enabled(lc));
 987
 988         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(linphone_gtk_get_widget(pb,"ring_chooser")),
 989                                         linphone_core_get_ring(lc));
 990         /* SIP CONFIG */
 991         contact=linphone_core_get_primary_contact_parsed(lc);
 992         if (contact){
 993                 if (linphone_address_get_display_name(contact)) {
 994                         const char *dn=linphone_address_get_display_name(contact);
 995                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"displayname")),dn);
 996                 }
 997                 if (linphone_address_get_username(contact))
 998                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"username")),linphone_address_get_username(contact));
 999         }
1000         linphone_address_destroy(contact);
1001         linphone_gtk_show_sip_accounts(pb);
1002         /* CODECS CONFIG */
1003         linphone_gtk_init_codec_list(GTK_TREE_VIEW(codec_list));
1004         linphone_gtk_draw_codec_list(GTK_TREE_VIEW(codec_list),0);
1005         gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(pb,"codec_view")),0);
1006         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"download_bw")),
1007                                 linphone_core_get_download_bandwidth(lc));
1008         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"upload_bw")),
1009                                 linphone_core_get_upload_bandwidth(lc));
1010         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"adaptive_rate_control")),
1011                                  linphone_core_adaptive_rate_control_enabled(lc));
1012
1013
1014         /* UI CONFIG */
1015         linphone_gtk_fill_langs(pb);
1016         ui_advanced = linphone_gtk_get_ui_config_int("advanced_ui", 1);
1017         linphone_gtk_set_ui_config_int("advanced_ui", ui_advanced);
1018         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"ui_level")),
1019                                 ui_advanced);
1020         linphone_gtk_ui_level_adapt(pb);
1021
1022         g_signal_connect(G_OBJECT(linphone_gtk_get_widget(pb,"proto_port")),"value-changed",(GCallback)linphone_gtk_update_my_port,NULL);
1023         g_signal_connect(G_OBJECT(linphone_gtk_get_widget(pb,"proto_combo")),"changed",(GCallback)linphone_gtk_proto_changed,NULL);
1024
1025
1026         if (linphone_core_tunnel_available()){
1027                 gtk_widget_set_visible(GTK_WIDGET(linphone_gtk_get_widget(pb,"tunnel_edit_button")), TRUE);
1028                 gtk_widget_set_visible(GTK_WIDGET(linphone_gtk_get_widget(pb,"tunnel_label")), TRUE);
1029         }
1030
1031         gtk_widget_show(pb);
1032 }
1033
1034
1035 void linphone_gtk_edit_tunnel_closed(GtkWidget *button){
1036         GtkWidget *pb=gtk_widget_get_toplevel(button);
1037         gtk_widget_destroy(pb);
1038 }
1039
1040
1041 static void tunnel_get_server_host_and_port(LinphoneTunnel *tunnel, char *host, int size, int *port){
1042         char *colon;
1043         char *addresses;
1044         char *str1;
1045         char *address;
1046         const char* configured_addresses;
1047
1048         configured_addresses=linphone_tunnel_get_servers(tunnel);
1049
1050         if (configured_addresses==NULL){
1051                 host[0]=0;
1052                 *port=0;
1053                 return;
1054         }
1055         addresses=ms_strdup(configured_addresses);
1056         str1=addresses;
1057         address=strtok(str1," "); // Not thread safe
1058         if (!address) return;
1059         colon=strchr(address, ':');
1060         if (!colon) return;
1061         *colon++='\0';
1062         *port=atoi(colon);
1063         strncpy(host,address,size);
1064         ms_free(addresses);
1065 }
1066
1067
1068 void linphone_gtk_edit_tunnel(GtkButton *button){
1069         GtkWidget *w=linphone_gtk_create_window("tunnel_config");
1070         LinphoneCore *lc=linphone_gtk_get_core();
1071         LinphoneTunnel *tunnel=linphone_core_get_tunnel(lc);
1072         char host[128]={'\0'};
1073         int port=0;
1074
1075         if (!tunnel) return;
1076
1077         tunnel_get_server_host_and_port(tunnel, host, sizeof(host), &port);
1078
1079         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"host")),host);
1080         if (port==0) port=443;
1081         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"port")), port);
1082
1083         if (linphone_tunnel_enabled(tunnel)){
1084                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"radio_enable")),1);
1085         } else{
1086                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"radio_disable")),1);
1087         }
1088         {
1089                 const char *proxy=NULL,*username=NULL,*password=NULL;
1090                 port=0;
1091                 linphone_tunnel_get_http_proxy(tunnel,&proxy,&port,&username,&password);
1092                 if (proxy)
1093                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"http_host")),proxy);
1094                 if (port>0)
1095                         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"http_port")), port);
1096                 if (username)
1097                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"username")),username);
1098                 if (password)
1099                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"password")),password);
1100         }
1101
1102         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_gtk_edit_tunnel_closed,w);
1103         gtk_widget_show(w);
1104 }
1105
1106 void linphone_gtk_tunnel_ok(GtkButton *button){
1107         GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
1108         LinphoneCore *lc=linphone_gtk_get_core();
1109         LinphoneTunnel *tunnel=linphone_core_get_tunnel(lc);
1110
1111         gint port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"port")));
1112         gboolean enabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"radio_enable")));
1113         const char *host=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"host")));
1114         const char *http_host=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"http_host")));
1115         gint http_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"http_port")));
1116         const char *username=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"username")));
1117         const char *password=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"password")));
1118
1119         if (tunnel==NULL) return;
1120         if (host && *host=='\0') host=NULL;
1121         if (http_port==0) http_port=8080;
1122         linphone_tunnel_clean_servers(tunnel);
1123         linphone_tunnel_add_server(tunnel,host,port);
1124         linphone_tunnel_enable(tunnel,enabled);
1125         linphone_tunnel_set_http_proxy(tunnel,http_host,http_port,username,password);
1126
1127         gtk_widget_destroy(w);
1128 }
1129
1130
1131 void linphone_gtk_tunnel_cancel(GtkButton *button){
1132
1133 }