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
  22 typedef enum {
  23         CAP_IGNORE,
  24         CAP_PLAYBACK,
  25         CAP_CAPTURE
  26 }DeviceCap;
  27
  28 static void linphone_gtk_fill_combo_box(GtkWidget *combo, const char **devices, const char *selected, DeviceCap cap){
  29         const char **p=devices;
  30         int i=0,active=0;
  31         /* glade creates a combo box without list model and text renderer,
  32         unless we fill it with a dummy text.
  33         This dummy text needs to be removed first*/
  34         gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
  35         for(;*p!=NULL;++p){
  36                 if ( cap==CAP_IGNORE
  37                         || (cap==CAP_CAPTURE && linphone_core_sound_device_can_capture(linphone_gtk_get_core(),*p))
  38                         || (cap==CAP_PLAYBACK && linphone_core_sound_device_can_playback(linphone_gtk_get_core(),*p)) ){
  39                         gtk_combo_box_append_text(GTK_COMBO_BOX(combo),*p);
  40                         if (strcmp(selected,*p)==0) active=i;
  41                         i++;
  42                 }
  43         }
  44         gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
  45 }
  46
  47 void linphone_gtk_fill_video_sizes(GtkWidget *combo){
  48         const MSVideoSizeDef *def=linphone_core_get_supported_video_sizes(linphone_gtk_get_core());;
  49         int i,active=0;
  50         char vsize_def[256];
  51         MSVideoSize cur=linphone_core_get_preferred_video_size(linphone_gtk_get_core());
  52         /* glade creates a combo box without list model and text renderer,
  53         unless we fill it with a dummy text.
  54         This dummy text needs to be removed first*/
  55         gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
  56         for(i=0;def->name!=NULL;++def,++i){
  57                 snprintf(vsize_def,sizeof(vsize_def),"%s (%ix%i)",def->name,def->vsize.width,def->vsize.height);
  58                 gtk_combo_box_append_text(GTK_COMBO_BOX(combo),vsize_def);
  59                 if (cur.width==def->vsize.width && cur.height==def->vsize.height) active=i;
  60         }
  61         gtk_combo_box_set_active(GTK_COMBO_BOX(combo),active);
  62 }
  63
  64 void linphone_gtk_parameters_closed(GtkWidget *button){
  65         GtkWidget *pb=gtk_widget_get_toplevel(button);
  66         gtk_widget_destroy(pb);
  67 }
  68
  69 void linphone_gtk_update_my_contact(GtkWidget *w){
  70         GtkWidget *pb=gtk_widget_get_toplevel(w);
  71         const char *username=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"username")));
  72         const char *displayname=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"displayname")));
  73         int port=linphone_core_get_sip_port(linphone_gtk_get_core());
  74         LinphoneAddress *parsed=linphone_core_get_primary_contact_parsed(linphone_gtk_get_core());
  75         char *contact;
  76         g_return_if_fail(parsed!=NULL);
  77         if (username[0]=='\0') return;
  78
  79         linphone_address_set_display_name(parsed,displayname);
  80         linphone_address_set_username(parsed,username);
  81         linphone_address_set_port_int(parsed,port);
  82         contact=linphone_address_as_string(parsed);
  83         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"sip_address")),contact);
  84         linphone_core_set_primary_contact(linphone_gtk_get_core(),contact);
  85         ms_free(contact);
  86         linphone_address_destroy(parsed);
  87         linphone_gtk_load_identities();
  88 }
  89
  90 void linphone_gtk_stun_server_changed(GtkWidget *w){
  91         const gchar *addr=gtk_entry_get_text(GTK_ENTRY(w));
  92         linphone_core_set_stun_server(linphone_gtk_get_core(),addr);
  93 }
  94
  95 void linphone_gtk_nat_address_changed(GtkWidget *w){
  96         const gchar *addr=gtk_entry_get_text(GTK_ENTRY(w));
  97         linphone_core_set_nat_address(linphone_gtk_get_core(),addr);
  98 }
  99
 100 void linphone_gtk_ipv6_toggled(GtkWidget *w){
 101         linphone_core_enable_ipv6(linphone_gtk_get_core(),
 102                                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
 103 }
 104
 105 void linphone_gtk_udp_sip_port_changed(GtkWidget *w){
 106         LCSipTransports tr;
 107         LinphoneCore *lc=linphone_gtk_get_core();
 108
 109         linphone_core_get_sip_transports(lc,&tr);
 110         tr.udp_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
 111         linphone_core_set_sip_transports(lc,&tr);
 112 }
 113
 114 void linphone_gtk_tcp_sip_port_changed(GtkWidget *w){
 115         LCSipTransports tr;
 116         LinphoneCore *lc=linphone_gtk_get_core();
 117
 118         linphone_core_get_sip_transports(lc,&tr);
 119         tr.tcp_port = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
 120         linphone_core_set_sip_transports(lc,&tr);
 121 }
 122
 123 void linphone_gtk_audio_port_changed(GtkWidget *w){
 124         linphone_core_set_audio_port(linphone_gtk_get_core(),
 125                         (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 126 }
 127
 128 void linphone_gtk_video_port_changed(GtkWidget *w){
 129         linphone_core_set_video_port(linphone_gtk_get_core(),
 130                         (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 131 }
 132
 133 void linphone_gtk_no_firewall_toggled(GtkWidget *w){
 134         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 135                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyNoFirewall);
 136 }
 137
 138 void linphone_gtk_use_nat_address_toggled(GtkWidget *w){
 139         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 140                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseNatAddress);
 141 }
 142
 143 void linphone_gtk_use_stun_toggled(GtkWidget *w){
 144         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)))
 145                 linphone_core_set_firewall_policy(linphone_gtk_get_core(),LinphonePolicyUseStun);
 146 }
 147
 148 void linphone_gtk_mtu_changed(GtkWidget *w){
 149         if (GTK_WIDGET_SENSITIVE(w))
 150                 linphone_core_set_mtu(linphone_gtk_get_core(),gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 151 }
 152
 153 void linphone_gtk_use_sip_info_dtmf_toggled(GtkWidget *w){
 154         linphone_core_set_use_info_for_dtmf(linphone_gtk_get_core(),
 155                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
 156 }
 157
 158 void linphone_gtk_mtu_set(GtkWidget *w){
 159         GtkWidget *mtu=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"mtu");
 160         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))){
 161                 gtk_widget_set_sensitive(mtu,TRUE);
 162                 linphone_gtk_mtu_changed(mtu);
 163         }else{
 164                 gtk_widget_set_sensitive(mtu,FALSE);
 165                 linphone_core_set_mtu(linphone_gtk_get_core(),0);
 166         }
 167 }
 168
 169 void linphone_gtk_playback_device_changed(GtkWidget *w){
 170         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 171         linphone_core_set_playback_device(linphone_gtk_get_core(),sel);
 172         g_free(sel);
 173 }
 174
 175 void linphone_gtk_capture_device_changed(GtkWidget *w){
 176         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 177         linphone_core_set_capture_device(linphone_gtk_get_core(),sel);
 178         g_free(sel);
 179 }
 180
 181 void linphone_gtk_ring_device_changed(GtkWidget *w){
 182         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 183         linphone_core_set_ringer_device(linphone_gtk_get_core(),sel);
 184         g_free(sel);
 185 }
 186
 187 void linphone_gtk_alsa_special_device_changed(GtkWidget *w){
 188         /*
 189         const gchar *dev=gtk_entry_get_text(GTK_ENTRY(w));
 190         ...*/
 191 }
 192
 193 void linphone_gtk_cam_changed(GtkWidget *w){
 194         gchar *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 195         linphone_core_set_video_device(linphone_gtk_get_core(),sel);
 196         g_free(sel);
 197 }
 198
 199 void linphone_gtk_video_size_changed(GtkWidget *w){
 200         int sel=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 201         const MSVideoSizeDef *defs=linphone_core_get_supported_video_sizes(linphone_gtk_get_core());
 202         if (sel<0) return;
 203         linphone_core_set_preferred_video_size(linphone_gtk_get_core(),
 204                                         defs[sel].vsize);
 205 }
 206
 207 void linphone_gtk_ring_file_set(GtkWidget *w){
 208         gchar *file=gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(w));
 209         linphone_core_set_ring(linphone_gtk_get_core(),file);
 210         g_free(file);
 211 }
 212
 213 static void linphone_gtk_end_of_ring(LinphoneCore *lc, void *user_data){
 214         gtk_widget_set_sensitive((GtkWidget*)user_data,TRUE);
 215 }
 216
 217 void linphone_gtk_play_ring_file(GtkWidget *w){
 218         if (linphone_core_preview_ring(linphone_gtk_get_core(),
 219                                 linphone_core_get_ring(linphone_gtk_get_core()),
 220                                 linphone_gtk_end_of_ring,
 221                                 w)==0){
 222                 gtk_widget_set_sensitive(w,FALSE);
 223         }
 224 }
 225
 226 void linphone_gtk_echo_cancelation_toggled(GtkWidget *w){
 227         linphone_core_enable_echo_cancellation(linphone_gtk_get_core(),
 228                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
 229 }
 230
 231 enum {
 232         CODEC_NAME,
 233         CODEC_RATE,
 234         CODEC_BITRATE,
 235         CODEC_STATUS,
 236         CODEC_PARAMS,
 237         CODEC_PRIVDATA,
 238         CODEC_COLOR,
 239         CODEC_INFO,
 240         CODEC_NCOLUMNS
 241 };
 242
 243 static void fmtp_edited(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer userdata){
 244         GtkListStore *store=(GtkListStore*)userdata;
 245         GtkTreeIter iter;
 246         if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),&iter,path)){
 247                 PayloadType *pt;
 248                 gtk_list_store_set(store,&iter,CODEC_PARAMS,new_text,-1);
 249                 gtk_tree_model_get(GTK_TREE_MODEL(store),&iter,CODEC_PRIVDATA,&pt,-1);
 250                 payload_type_set_recv_fmtp(pt,new_text);
 251         }
 252 }
 253
 254 static void linphone_gtk_init_codec_list(GtkTreeView *listview){
 255         GtkCellRenderer *renderer;
 256         GtkTreeViewColumn *column;
 257         GtkTreeSelection *select;
 258
 259         GtkListStore *store = gtk_list_store_new (CODEC_NCOLUMNS, G_TYPE_STRING,G_TYPE_INT,
 260                                                         G_TYPE_FLOAT,
 261                                                         G_TYPE_STRING,
 262                                                         G_TYPE_STRING,
 263                                                         G_TYPE_POINTER,
 264                                                         G_TYPE_STRING,
 265                                                         G_TYPE_STRING);
 266
 267         gtk_tree_view_set_model(listview,GTK_TREE_MODEL(store));
 268         g_object_unref(G_OBJECT(store));
 269
 270         renderer = gtk_cell_renderer_text_new ();
 271         column = gtk_tree_view_column_new_with_attributes (_("Name"),
 272                                                    renderer,
 273                                                    "text", CODEC_NAME,
 274                                                 "foreground",CODEC_COLOR,
 275                                                    NULL);
 276         gtk_tree_view_append_column (listview, column);
 277         column = gtk_tree_view_column_new_with_attributes (_("Rate (Hz)"),
 278                                                    renderer,
 279                                                    "text", CODEC_RATE,
 280                                                 "foreground",CODEC_COLOR,
 281                                                    NULL);
 282         gtk_tree_view_append_column (listview, column);
 283         column = gtk_tree_view_column_new_with_attributes (_("Status"),
 284                                                    renderer,
 285                                                    "text", CODEC_STATUS,
 286                                                 "foreground",CODEC_COLOR,
 287                                                    NULL);
 288         gtk_tree_view_append_column (listview, column);
 289         column = gtk_tree_view_column_new_with_attributes (_("Min bitrate (kbit/s)"),
 290                                                    renderer,
 291                                                    "text", CODEC_BITRATE,
 292                                                 "foreground",CODEC_COLOR,
 293                                                    NULL);
 294         gtk_tree_view_append_column (listview, column);
 295         renderer = gtk_cell_renderer_text_new ();
 296         column = gtk_tree_view_column_new_with_attributes (_("Parameters"),
 297                                                    renderer,
 298                                                    "text", CODEC_PARAMS,
 299                                                 "foreground",CODEC_COLOR,
 300                                         "editable",TRUE,
 301                                                    NULL);
 302         g_signal_connect(G_OBJECT(renderer),"edited",G_CALLBACK(fmtp_edited),store);
 303         gtk_tree_view_append_column (listview, column);
 304         /* Setup the selection handler */
 305         select = gtk_tree_view_get_selection (listview);
 306         gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
 307 }
 308
 309 static void linphone_gtk_show_codecs(GtkTreeView *listview, const MSList *codeclist)
 310 {
 311         const MSList *elem;
 312         GtkTreeIter iter;
 313         GtkListStore *store=GTK_LIST_STORE(gtk_tree_view_get_model(listview));
 314         GtkTreeSelection *selection;
 315
 316         gtk_list_store_clear(store);
 317
 318         for(elem=codeclist; elem!=NULL; elem=elem->next){
 319                 gchar *status;
 320                 gint rate;
 321                 gfloat bitrate;
 322                 gchar *color;
 323                 const char *params="";
 324                 struct _PayloadType *pt=(struct _PayloadType *)elem->data;
 325                 if (linphone_core_payload_type_enabled(linphone_gtk_get_core(),pt)) status=_("Enabled");
 326                 else status=_("Disabled");
 327                 if (linphone_core_check_payload_type_usability(linphone_gtk_get_core(),pt)) color="blue";
 328                 else color="red";
 329                 /* get an iterator */
 330                 gtk_list_store_append(store,&iter);
 331                 bitrate=payload_type_get_bitrate(pt)/1000.0;
 332                 rate=payload_type_get_rate(pt);
 333                 if (pt->recv_fmtp!=NULL) params=pt->recv_fmtp;
 334                 gtk_list_store_set(store,&iter, CODEC_NAME,payload_type_get_mime(pt),
 335                                         CODEC_RATE,rate,
 336                                         CODEC_BITRATE,bitrate,
 337                                         CODEC_STATUS,status,
 338                                         CODEC_PARAMS,params,
 339                                         CODEC_PRIVDATA,(gpointer)pt,
 340                                         CODEC_COLOR,(gpointer)color,
 341                                         CODEC_INFO,(gpointer)linphone_core_get_payload_type_description(linphone_gtk_get_core(),pt),
 342                                         -1);
 343         }
 344
 345
 346
 347         /* Setup the selection handler */
 348         selection = gtk_tree_view_get_selection (listview);
 349         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 350         //gtk_tree_view_columns_autosize(GTK_TREE_VIEW (sec->interfaces));
 351 #if GTK_CHECK_VERSION(2,12,0)
 352         gtk_tree_view_set_tooltip_column(listview,CODEC_INFO);
 353 #endif
 354 }
 355
 356 static void linphone_gtk_check_codec_bandwidth(GtkTreeView *v){
 357         GtkTreeIter iter;
 358         GtkTreeModel *model;
 359         model=gtk_tree_view_get_model(v);
 360         g_return_if_fail(gtk_tree_model_get_iter_first(model,&iter));
 361         do{
 362                 PayloadType *pt=NULL;
 363                 const gchar *color;
 364                 gfloat bitrate;
 365                 gtk_tree_model_get(model,&iter,CODEC_PRIVDATA,&pt,-1);
 366                 if (linphone_core_check_payload_type_usability(linphone_gtk_get_core(),pt)) color="blue";
 367                 else color="red";
 368                 bitrate=payload_type_get_bitrate(pt)/1000.0;
 369                 gtk_list_store_set(GTK_LIST_STORE(model),&iter,CODEC_COLOR, (gpointer)color,
 370                                         CODEC_BITRATE, bitrate,-1);
 371         }while(gtk_tree_model_iter_next(model,&iter));
 372 }
 373
 374 static void linphone_gtk_select_codec(GtkTreeView *v, PayloadType *ref){
 375         GtkTreeIter iter;
 376         GtkTreeModel *model;
 377         GtkTreeSelection *selection;
 378         selection=gtk_tree_view_get_selection(v);
 379         model=gtk_tree_view_get_model(v);
 380         g_return_if_fail(gtk_tree_model_get_iter_first(model,&iter));
 381         do{
 382                 PayloadType *pt=NULL;
 383                 gtk_tree_model_get(model,&iter,CODEC_PRIVDATA,&pt,-1);
 384                 if (pt==ref){
 385                         gtk_tree_selection_select_iter(selection,&iter);
 386                 }
 387
 388         }while(gtk_tree_model_iter_next(model,&iter));
 389 }
 390
 391 static void linphone_gtk_draw_codec_list(GtkTreeView *v, int type){ /* 0=audio, 1=video*/
 392         const MSList *list;
 393         if (type==0) list=linphone_core_get_audio_codecs(linphone_gtk_get_core());
 394         else list=linphone_core_get_video_codecs(linphone_gtk_get_core());
 395         linphone_gtk_show_codecs(v,list);
 396 }
 397
 398 void linphone_gtk_codec_view_changed(GtkWidget *w){
 399         GtkWidget *listview=linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"codec_list");
 400         int active=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 401         linphone_gtk_draw_codec_list(GTK_TREE_VIEW(listview),active);
 402 }
 403
 404 void linphone_gtk_download_bw_changed(GtkWidget *w){
 405         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"codec_list"));
 406         linphone_core_set_download_bandwidth(linphone_gtk_get_core(),
 407                                 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 408         linphone_gtk_check_codec_bandwidth(v);
 409 }
 410
 411 void linphone_gtk_upload_bw_changed(GtkWidget *w){
 412         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(w),"codec_list"));
 413         linphone_core_set_upload_bandwidth(linphone_gtk_get_core(),
 414                                 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(w)));
 415         linphone_gtk_check_codec_bandwidth(v);
 416 }
 417
 418 static void linphone_gtk_codec_move(GtkWidget *button, int dir){
 419         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"codec_list"));
 420         GtkTreeSelection *sel=gtk_tree_view_get_selection(v);
 421         GtkTreeModel *mod;
 422         GtkTreeIter iter;
 423         PayloadType *pt=NULL;
 424         LinphoneCore *lc=linphone_gtk_get_core();
 425         if (gtk_tree_selection_get_selected(sel,&mod,&iter)){
 426                 MSList *sel_elem,*before;
 427                 MSList *codec_list;
 428                 gtk_tree_model_get(mod,&iter,CODEC_PRIVDATA,&pt,-1);
 429                 if (pt->type==PAYLOAD_VIDEO)
 430                         codec_list=ms_list_copy(linphone_core_get_video_codecs(lc));
 431                 else codec_list=ms_list_copy(linphone_core_get_audio_codecs(lc));
 432                 sel_elem=ms_list_find(codec_list,pt);
 433                 if (dir>0) {
 434                         if (sel_elem->prev) before=sel_elem->prev;
 435                         else before=sel_elem;
 436                         codec_list=ms_list_insert(codec_list,before,pt);
 437                 }
 438                 else{
 439                         if (sel_elem->next) before=sel_elem->next->next;
 440                         else before=sel_elem;
 441                         codec_list=ms_list_insert(codec_list,before,pt);
 442                 }
 443                 codec_list=ms_list_remove_link(codec_list,sel_elem);
 444                 if (pt->type==PAYLOAD_VIDEO)
 445                         linphone_core_set_video_codecs(lc,codec_list);
 446                 else linphone_core_set_audio_codecs(lc,codec_list);
 447                 linphone_gtk_show_codecs(v,codec_list);
 448                 linphone_gtk_select_codec(v,pt);
 449         }
 450 }
 451
 452 static void linphone_gtk_codec_set_enable(GtkWidget *button, gboolean enabled){
 453         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(gtk_widget_get_toplevel(button),"codec_list"));
 454         GtkTreeSelection *sel=gtk_tree_view_get_selection(v);
 455         GtkTreeModel *mod;
 456         GtkListStore *store;
 457         GtkTreeIter iter;
 458         PayloadType *pt=NULL;
 459
 460         if (gtk_tree_selection_get_selected(sel,&mod,&iter)){
 461                 store=GTK_LIST_STORE(mod);
 462                 gtk_tree_model_get(mod,&iter,CODEC_PRIVDATA,&pt,-1);
 463                 linphone_core_enable_payload_type(linphone_gtk_get_core(),pt,enabled);
 464                 gtk_list_store_set(store,&iter,CODEC_STATUS, enabled ? _("Enabled") : _("Disabled"), -1);
 465         }
 466 }
 467
 468 void linphone_gtk_codec_up(GtkWidget *button){
 469         linphone_gtk_codec_move(button,+1);
 470 }
 471
 472 void linphone_gtk_codec_down(GtkWidget *button){
 473         linphone_gtk_codec_move(button,-1);
 474 }
 475
 476 void linphone_gtk_codec_enable(GtkWidget *button){
 477         linphone_gtk_codec_set_enable(button,TRUE);
 478 }
 479
 480 void linphone_gtk_codec_disable(GtkWidget *button){
 481         linphone_gtk_codec_set_enable(button,FALSE);
 482 }
 483
 484 void linphone_gtk_clear_passwords(GtkWidget *button){
 485         linphone_core_clear_all_auth_info(linphone_gtk_get_core());
 486 }
 487
 488 enum{
 489         PROXY_CONFIG_IDENTITY,
 490         PROXY_CONFIG_REF,
 491         PROXY_CONFIG_NCOL
 492 };
 493
 494 void linphone_gtk_show_sip_accounts(GtkWidget *w){
 495         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"proxy_list"));
 496         GtkTreeModel *model=gtk_tree_view_get_model(v);
 497         GtkListStore *store;
 498         GtkTreeSelection *select;
 499         const MSList *elem;
 500         if (!model){
 501                 GtkCellRenderer *renderer;
 502                 GtkTreeViewColumn *column;
 503                 /* create the proxy list */
 504                 store = gtk_list_store_new (PROXY_CONFIG_NCOL, G_TYPE_STRING, G_TYPE_POINTER);
 505
 506                 gtk_tree_view_set_model(v,GTK_TREE_MODEL(store));
 507                 g_object_unref(G_OBJECT(store));
 508                 renderer = gtk_cell_renderer_text_new ();
 509                 column = gtk_tree_view_column_new_with_attributes (_("Account"),
 510                                                         renderer,
 511                                                         "text", PROXY_CONFIG_IDENTITY,
 512                                                         NULL);
 513                 gtk_tree_view_append_column (v, column);
 514
 515                 select = gtk_tree_view_get_selection (v);
 516                 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
 517                 model=GTK_TREE_MODEL(store);
 518         }else {
 519                 store=GTK_LIST_STORE(model);
 520         }
 521         gtk_list_store_clear(store);
 522         for(elem=linphone_core_get_proxy_config_list(linphone_gtk_get_core());elem!=NULL;elem=ms_list_next(elem)){
 523                 LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)elem->data;
 524                 GtkTreeIter iter;
 525                 gtk_list_store_append(store,&iter);
 526                 gtk_list_store_set(store,&iter,PROXY_CONFIG_IDENTITY,linphone_proxy_config_get_identity(cfg),
 527                                         PROXY_CONFIG_REF,cfg,-1);
 528         }
 529 }
 530
 531 static void linphone_gtk_proxy_closed(GtkWidget *w){
 532         LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(w),"config");
 533         if (cfg){
 534                 linphone_proxy_config_done(cfg);
 535         }
 536 }
 537
 538 void linphone_gtk_show_proxy_config(GtkWidget *pb, LinphoneProxyConfig *cfg){
 539         GtkWidget *w=linphone_gtk_create_window("sip_account");
 540         const char *tmp;
 541         if (cfg){
 542                 linphone_proxy_config_edit(cfg);
 543                 gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"identity")),
 544                         linphone_proxy_config_get_identity(cfg));
 545                 gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy")),
 546                         linphone_proxy_config_get_addr(cfg));
 547                 tmp=linphone_proxy_config_get_route(cfg);
 548                 if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"route")),tmp);
 549                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"regperiod")),
 550                         linphone_proxy_config_get_expires(cfg));
 551                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"register")),
 552                         linphone_proxy_config_register_enabled(cfg));
 553                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"publish")),
 554                         linphone_proxy_config_publish_enabled(cfg));
 555         }
 556         g_object_set_data(G_OBJECT(w),"config",(gpointer)cfg);
 557         g_object_set_data(G_OBJECT(w),"parameters",(gpointer)pb);
 558         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_gtk_proxy_closed,w);
 559         gtk_widget_show(w);
 560 }
 561
 562 void linphone_gtk_proxy_cancel(GtkButton *button){
 563         GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
 564         gtk_widget_destroy(w);
 565 }
 566
 567 void linphone_gtk_proxy_ok(GtkButton *button){
 568         GtkWidget *w=gtk_widget_get_toplevel(GTK_WIDGET(button));
 569         LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(w),"config");
 570         gboolean was_editing=TRUE;
 571         if (!cfg){
 572                 was_editing=FALSE;
 573                 cfg=linphone_proxy_config_new();
 574         }
 575         linphone_proxy_config_set_identity(cfg,
 576                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"identity"))));
 577         linphone_proxy_config_set_server_addr(cfg,
 578                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"proxy"))));
 579         linphone_proxy_config_set_route(cfg,
 580                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(w,"route"))));
 581         linphone_proxy_config_expires(cfg,
 582                 (int)gtk_spin_button_get_value(
 583                         GTK_SPIN_BUTTON(linphone_gtk_get_widget(w,"regperiod"))));
 584         linphone_proxy_config_enable_publish(cfg,
 585                 gtk_toggle_button_get_active(
 586                         GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"publish"))));
 587         linphone_proxy_config_enable_register(cfg,
 588                 gtk_toggle_button_get_active(
 589                         GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(w,"register"))));
 590         if (was_editing){
 591                 if (linphone_proxy_config_done(cfg)==-1)
 592                         return;
 593         }
 594         else {
 595                 if (linphone_core_add_proxy_config(linphone_gtk_get_core(),cfg)==-1) return;
 596                 linphone_core_set_default_proxy(linphone_gtk_get_core(),cfg);
 597         }
 598         g_object_set_data(G_OBJECT(w),"config",NULL);
 599         linphone_gtk_show_sip_accounts(GTK_WIDGET(g_object_get_data(G_OBJECT(w),"parameters")));
 600         gtk_widget_destroy(w);
 601         /* also update the main window's list of identities*/
 602         linphone_gtk_load_identities();
 603 }
 604
 605 static LinphoneProxyConfig *linphone_gtk_get_selected_proxy_config(GtkWidget* pb){
 606         GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(pb,"proxy_list"));
 607         GtkTreeSelection *selection=gtk_tree_view_get_selection(v);
 608         GtkTreeIter iter;
 609         GtkTreeModel *model;
 610         if (gtk_tree_selection_get_selected(selection,&model,&iter)){
 611                 LinphoneProxyConfig *cfg=NULL;
 612                 gtk_tree_model_get(model,&iter,PROXY_CONFIG_REF,&cfg,-1);
 613                 return cfg;
 614         }
 615         return NULL;
 616 }
 617
 618 void linphone_gtk_add_proxy(GtkButton *button){
 619         linphone_gtk_show_proxy_config(gtk_widget_get_toplevel(GTK_WIDGET(button)),NULL);
 620 }
 621
 622 void linphone_gtk_remove_proxy(GtkButton *button){
 623         LinphoneProxyConfig *cfg=linphone_gtk_get_selected_proxy_config(
 624                         gtk_widget_get_toplevel(GTK_WIDGET(button)));
 625         if (cfg){
 626                 linphone_core_remove_proxy_config(linphone_gtk_get_core(),cfg);
 627                 linphone_gtk_show_sip_accounts(gtk_widget_get_toplevel(GTK_WIDGET(button)));
 628                 /* also update the main window's list of identities*/
 629                 linphone_gtk_load_identities();
 630         }
 631 }
 632
 633 void linphone_gtk_edit_proxy(GtkButton *button){
 634         GtkWidget *pb=gtk_widget_get_toplevel(GTK_WIDGET(button));
 635         LinphoneProxyConfig *cfg=linphone_gtk_get_selected_proxy_config(pb);
 636         if (cfg){
 637                 linphone_gtk_show_proxy_config(pb,cfg);
 638                 /* also update the main window's list of identities*/
 639                 linphone_gtk_load_identities();
 640         }
 641 }
 642
 643 typedef struct _LangCodes{
 644         const char *code;
 645         const char *name;
 646 }LangCodes;
 647
 648 static LangCodes supported_langs[]={
 649         {       "C"     ,       N_("English")   },
 650         {       "fr"    ,       N_("French")    },
 651         {       "sv"    ,       N_("Swedish")   },
 652         {       "it"    ,       N_("Italian")   },
 653         {       "es"    ,       N_("Spanish")   },
 654         {       "pt_BR" ,       N_("Brazilian Portugese")       },
 655         {       "pl"    ,       N_("Polish")    },
 656         {       "de"    ,       N_("German")    },
 657         {       "ru"    ,       N_("Russian")   },
 658         {       "ja"    ,       N_("Japanese")  },
 659         {       "nl"    ,       N_("Dutch")     },
 660         {       "hu"    ,       N_("Hungarian") },
 661         {       "cs"    ,       N_("Czech")     },
 662         {       "zh_CN" ,       N_("Chinese")   },
 663         {       NULL    ,       NULL            }
 664 };
 665
 666 static const char *lang_get_name(const char *code){
 667         LangCodes *p=supported_langs;
 668         while(p->code!=NULL){
 669                 if (strcmp(p->code,code)==0) return p->name;
 670                 p++;
 671         }
 672         return NULL;
 673 }
 674
 675 static gboolean lang_equals(const char *l1, const char *l2){
 676         return ((strncmp(l1,l2,5)==0 || strncmp(l1,l2,2)==0));
 677 }
 678
 679 static void linphone_gtk_fill_langs(GtkWidget *pb){
 680         GtkWidget *combo=linphone_gtk_get_widget(pb,"lang_combo");
 681         char code[10];
 682         const char *all_langs="C " LINPHONE_ALL_LANGS;
 683         const char *name;
 684         int i=0,index=0;
 685         const char *cur_lang=getenv("LANG");
 686         int cur_lang_index=-1;
 687         char text[256]={0};
 688         if (cur_lang==NULL) cur_lang="C";
 689         /* glade creates a combo box without list model and text renderer,
 690         unless we fill it with a dummy text.
 691         This dummy text needs to be removed first*/
 692         gtk_combo_box_remove_text(GTK_COMBO_BOX(combo),0);
 693         while(sscanf(all_langs+i,"%s",code)==1){
 694                 i+=strlen(code);
 695                 while(all_langs[i]==' ') ++i;
 696                 name=lang_get_name(code);
 697                 snprintf(text,sizeof(text)-1,"%s : %s",code,name!=NULL ? _(name) : code);
 698                 gtk_combo_box_append_text(GTK_COMBO_BOX(combo),text);
 699                 if (cur_lang_index==-1 && lang_equals(cur_lang,code))
 700                         cur_lang_index=index;
 701                 index++;
 702         }
 703         gtk_combo_box_set_active(GTK_COMBO_BOX(combo),cur_lang_index);
 704 }
 705
 706 void linphone_gtk_lang_changed(GtkComboBox *combo){
 707         const char *selected=gtk_combo_box_get_active_text(combo);
 708         char code[10];
 709         const char *cur_lang=getenv("LANG");
 710         if (selected!=NULL){
 711                 sscanf(selected,"%s",code);
 712                 if (cur_lang==NULL) cur_lang="C";
 713                 if (!lang_equals(cur_lang,code)){
 714                         GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(combo))),
 715                                 GTK_DIALOG_DESTROY_WITH_PARENT,
 716                                 GTK_MESSAGE_INFO,
 717                                 GTK_BUTTONS_CLOSE,
 718                                 "%s",
 719                                 (const gchar*)_("You need to restart linphone for the new language selection to take effect."));
 720                                 /* Destroy the dialog when the user responds to it (e.g. clicks a button) */
 721                         g_signal_connect_swapped (G_OBJECT (dialog), "response",
 722                                         G_CALLBACK (gtk_widget_destroy),
 723                                         G_OBJECT (dialog));
 724                         gtk_widget_show(dialog);
 725                         linphone_gtk_set_lang(code);
 726                 }
 727         }
 728 }
 729
 730 static void linphone_gtk_ui_level_adapt(GtkWidget *top) {
 731         gboolean ui_advanced;
 732         const char *simple_ui = linphone_gtk_get_ui_config("simple_ui", "parameters.codec_tab parameters.transport_frame parameters.ports_frame");
 733
 734         ui_advanced = linphone_gtk_get_ui_config_int("advanced_ui", TRUE);
 735         if (ui_advanced) {
 736                 linphone_gtk_visibility_set(simple_ui, "parameters", top, TRUE);
 737         } else {
 738                 linphone_gtk_visibility_set(simple_ui, "parameters", top, FALSE);
 739         }
 740 }
 741
 742 void linphone_gtk_ui_level_toggled(GtkWidget *w) {
 743         gint ui_advanced;
 744         GtkWidget *top;
 745
 746         top = gtk_widget_get_toplevel(w);
 747         ui_advanced = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
 748         linphone_gtk_set_ui_config_int("advanced_ui", ui_advanced);
 749         linphone_gtk_ui_level_adapt(top);
 750 }
 751
 752 void linphone_gtk_show_parameters(void){
 753         GtkWidget *pb=linphone_gtk_create_window("parameters");
 754         LinphoneCore *lc=linphone_gtk_get_core();
 755         const char **sound_devices=linphone_core_get_sound_devices(lc);
 756         const char *tmp;
 757         LinphoneAddress *contact;
 758         LinphoneFirewallPolicy pol;
 759         GtkWidget *codec_list=linphone_gtk_get_widget(pb,"codec_list");
 760         int mtu;
 761         int ui_advanced;
 762         LCSipTransports tr;
 763
 764         /* NETWORK CONFIG */
 765         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"ipv6_enabled")),
 766                                 linphone_core_ipv6_enabled(lc));
 767         linphone_core_get_sip_transports(lc,&tr);
 768         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"udp_sip_port")),
 769                                 tr.udp_port);
 770         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"tcp_sip_port")),
 771                                 tr.tcp_port);
 772         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"audio_rtp_port")),
 773                                 linphone_core_get_audio_port(lc));
 774         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"video_rtp_port")),
 775                                 linphone_core_get_video_port(lc));
 776         tmp=linphone_core_get_nat_address(lc);
 777         if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"nat_address")),tmp);
 778         tmp=linphone_core_get_stun_server(lc);
 779         if (tmp) gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"stun_server")),tmp);
 780         pol=linphone_core_get_firewall_policy(lc);
 781         switch(pol){
 782                 case LinphonePolicyNoFirewall:
 783                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"no_nat")),TRUE);
 784                 break;
 785                 case LinphonePolicyUseNatAddress:
 786                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_nat_address")),TRUE);
 787                 break;
 788                 case LinphonePolicyUseStun:
 789                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"use_stun")),TRUE);
 790                 break;
 791         }
 792         mtu=linphone_core_get_mtu(lc);
 793         if (mtu<=0){
 794                 gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"mtu"),FALSE);
 795                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"mtu")),1500);
 796                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"mtu_set")),FALSE);
 797         }else{
 798                 gtk_widget_set_sensitive(linphone_gtk_get_widget(pb,"mtu"),TRUE);
 799                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"mtu")),mtu);
 800                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"mtu_set")),TRUE);
 801         }
 802         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"dtmf_sipinfo")),
 803                                         linphone_core_get_use_info_for_dtmf(lc));
 804         /* MUTIMEDIA CONFIG */
 805         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"playback_device"), sound_devices,
 806                                         linphone_core_get_playback_device(lc),CAP_PLAYBACK);
 807         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"ring_device"), sound_devices,
 808                                         linphone_core_get_ringer_device(lc),CAP_PLAYBACK);
 809         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"capture_device"), sound_devices,
 810                                         linphone_core_get_capture_device(lc), CAP_CAPTURE);
 811         linphone_gtk_fill_combo_box(linphone_gtk_get_widget(pb,"webcams"),linphone_core_get_video_devices(lc),
 812                                         linphone_core_get_video_device(lc),CAP_IGNORE);
 813         linphone_gtk_fill_video_sizes(linphone_gtk_get_widget(pb,"video_size"));
 814         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"echo_cancelation")),
 815                                         linphone_core_echo_cancellation_enabled(lc));
 816
 817         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(linphone_gtk_get_widget(pb,"ring_chooser")),
 818                                         linphone_core_get_ring(lc));
 819         /* SIP CONFIG */
 820         contact=linphone_core_get_primary_contact_parsed(lc);
 821         if (contact){
 822                 if (linphone_address_get_display_name(contact)) {
 823                         const char *dn=linphone_address_get_display_name(contact);
 824                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"displayname")),dn);
 825                 }
 826                 if (linphone_address_get_username(contact))
 827                         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(pb,"username")),linphone_address_get_username(contact));
 828         }
 829         linphone_address_destroy(contact);
 830         linphone_gtk_show_sip_accounts(pb);
 831         /* CODECS CONFIG */
 832         linphone_gtk_init_codec_list(GTK_TREE_VIEW(codec_list));
 833         linphone_gtk_draw_codec_list(GTK_TREE_VIEW(codec_list),0);
 834         gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(pb,"codec_view")),0);
 835         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"download_bw")),
 836                                 linphone_core_get_download_bandwidth(lc));
 837         gtk_spin_button_set_value(GTK_SPIN_BUTTON(linphone_gtk_get_widget(pb,"upload_bw")),
 838                                 linphone_core_get_upload_bandwidth(lc));
 839
 840
 841         /* UI CONFIG */
 842         linphone_gtk_fill_langs(pb);
 843         ui_advanced = linphone_gtk_get_ui_config_int("advanced_ui", 1);
 844         linphone_gtk_set_ui_config_int("advanced_ui", ui_advanced);
 845         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(pb,"ui_level")),
 846                                 ui_advanced);
 847         linphone_gtk_ui_level_adapt(pb);
 848
 849         gtk_widget_show(pb);
 850 }