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

   1 /*
   2 linphone, gtk-glade interface.
   3 Copyright (C) 2008  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
  21 #define VIDEOSELFVIEW_DEFAULT 1
  22
  23 #include "linphone.h"
  24 #include "lpconfig.h"
  25
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #ifdef HAVE_GTK_OSX
  32 #include <gtkosxapplication.h>
  33 #endif
  34
  35 #ifdef WIN32
  36 #define chdir _chdir
  37 #endif
  38
  39 #if defined(HAVE_NOTIFY1) || defined(HAVE_NOTIFY4)
  40 #define HAVE_NOTIFY
  41 #endif
  42
  43 #ifdef HAVE_NOTIFY
  44 #include <libnotify/notify.h>
  45 #endif
  46
  47 #define LINPHONE_ICON "linphone.png"
  48
  49 const char *this_program_ident_string="linphone_ident_string=" LINPHONE_VERSION;
  50
  51 static LinphoneCore *the_core=NULL;
  52 static GtkWidget *the_ui=NULL;
  53
  54 static void linphone_gtk_registration_state_changed(LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState rs, const char *msg);
  55 static void linphone_gtk_show(LinphoneCore *lc);
  56 static void linphone_gtk_notify_recv(LinphoneCore *lc, LinphoneFriend * fid);
  57 static void linphone_gtk_new_unknown_subscriber(LinphoneCore *lc, LinphoneFriend *lf, const char *url);
  58 static void linphone_gtk_auth_info_requested(LinphoneCore *lc, const char *realm, const char *username);
  59 static void linphone_gtk_display_status(LinphoneCore *lc, const char *status);
  60 static void linphone_gtk_display_message(LinphoneCore *lc, const char *msg);
  61 static void linphone_gtk_display_warning(LinphoneCore *lc, const char *warning);
  62 static void linphone_gtk_display_url(LinphoneCore *lc, const char *msg, const char *url);
  63 static void linphone_gtk_call_log_updated(LinphoneCore *lc, LinphoneCallLog *cl);
  64 static void linphone_gtk_call_state_changed(LinphoneCore *lc, LinphoneCall *call, LinphoneCallState cs, const char *msg);
  65 static gboolean linphone_gtk_auto_answer(LinphoneCall *call);
  66 static void linphone_gtk_status_icon_set_blinking(gboolean val);
  67
  68
  69 static gboolean verbose=0;
  70 static gboolean auto_answer = 0;
  71 static gchar * addr_to_call = NULL;
  72 static gboolean iconified=FALSE;
  73 static gchar *workingdir=NULL;
  74 static char *progpath=NULL;
  75 gchar *linphone_logfile=NULL;
  76
  77 static GOptionEntry linphone_options[]={
  78         {
  79                 .long_name="verbose",
  80                 .short_name= '\0',
  81                 .arg=G_OPTION_ARG_NONE,
  82                 .arg_data= (gpointer)&verbose,
  83                 .description=N_("log to stdout some debug information while running.")
  84         },
  85         {
  86             .long_name = "logfile",
  87             .short_name = 'l',
  88             .arg = G_OPTION_ARG_STRING,
  89             .arg_data = &linphone_logfile,
  90             .description = N_("path to a file to write logs into.")
  91         },
  92         {
  93                 .long_name="iconified",
  94                 .short_name= '\0',
  95                 .arg=G_OPTION_ARG_NONE,
  96                 .arg_data= (gpointer)&iconified,
  97                 .description=N_("Start only in the system tray, do not show the main interface.")
  98         },
  99         {
 100             .long_name = "call",
 101             .short_name = 'c',
 102             .arg = G_OPTION_ARG_STRING,
 103             .arg_data = &addr_to_call,
 104             .description = N_("address to call right now")
 105         },
 106         {
 107             .long_name = "auto-answer",
 108             .short_name = 'a',
 109             .arg = G_OPTION_ARG_NONE,
 110             .arg_data = (gpointer) & auto_answer,
 111             .description = N_("if set automatically answer incoming calls")
 112         },
 113         {
 114             .long_name = "workdir",
 115             .short_name = '\0',
 116             .arg = G_OPTION_ARG_STRING,
 117             .arg_data = (gpointer) & workingdir,
 118             .description = N_("Specifiy a working directory (should be the base of the installation, eg: c:\\Program Files\\Linphone)")
 119         },
 120         {0}
 121 };
 122
 123 #define INSTALLED_XML_DIR PACKAGE_DATA_DIR "/linphone"
 124 #define RELATIVE_XML_DIR
 125 #define BUILD_TREE_XML_DIR "gtk"
 126
 127 #ifndef WIN32
 128 #define CONFIG_FILE ".linphonerc"
 129 #else
 130 #define CONFIG_FILE "linphonerc"
 131 #endif
 132
 133
 134
 135 static char _config_file[1024];
 136
 137
 138 const char *linphone_gtk_get_config_file(){
 139         /*try accessing a local file first if exists*/
 140         if (access(CONFIG_FILE,F_OK)==0){
 141                 snprintf(_config_file,sizeof(_config_file),"%s",CONFIG_FILE);
 142         }else{
 143 #ifdef WIN32
 144                 const char *appdata=getenv("APPDATA");
 145                 if (appdata){
 146                         snprintf(_config_file,sizeof(_config_file),"%s\\%s",appdata,LINPHONE_CONFIG_DIR);
 147                         CreateDirectory(_config_file,NULL);
 148                         snprintf(_config_file,sizeof(_config_file),"%s\\%s",appdata,LINPHONE_CONFIG_DIR "\\" CONFIG_FILE);
 149                 }
 150 #else
 151                 const char *home=getenv("HOME");
 152                 if (home==NULL) home=".";
 153                 snprintf(_config_file,sizeof(_config_file),"%s/%s",home,CONFIG_FILE);
 154 #endif
 155         }
 156         return _config_file;
 157 }
 158
 159
 160 #define FACTORY_CONFIG_FILE "linphonerc.factory"
 161 static char _factory_config_file[1024];
 162 static const char *linphone_gtk_get_factory_config_file(){
 163         /*try accessing a local file first if exists*/
 164         if (access(FACTORY_CONFIG_FILE,F_OK)==0){
 165                 snprintf(_factory_config_file,sizeof(_factory_config_file),
 166                                                  "%s",FACTORY_CONFIG_FILE);
 167         } else {
 168                 char *progdir;
 169
 170                 if (progpath != NULL) {
 171                         char *basename;
 172                         progdir = strdup(progpath);
 173 #ifdef WIN32
 174                         basename = strrchr(progdir, '\\');
 175                         if (basename != NULL) {
 176                                 basename ++;
 177                                 *basename = '\0';
 178                                 snprintf(_factory_config_file, sizeof(_factory_config_file),
 179                                                                  "%s\\..\\%s", progdir, FACTORY_CONFIG_FILE);
 180                         } else {
 181                                 if (workingdir!=NULL) {
 182                                         snprintf(_factory_config_file, sizeof(_factory_config_file),
 183                                                                          "%s\\%s", workingdir, FACTORY_CONFIG_FILE);
 184                                 } else {
 185                                         free(progdir);
 186                                         return NULL;
 187                                 }
 188                         }
 189 #else
 190                         basename = strrchr(progdir, '/');
 191                         if (basename != NULL) {
 192                                 basename ++;
 193                                 *basename = '\0';
 194                                 snprintf(_factory_config_file, sizeof(_factory_config_file),
 195                                                                  "%s/../share/Linphone/%s", progdir, FACTORY_CONFIG_FILE);
 196                         } else {
 197                                 free(progdir);
 198                                 return NULL;
 199                         }
 200 #endif
 201                         free(progdir);
 202                 }
 203         }
 204         return _factory_config_file;
 205 }
 206
 207 static void linphone_gtk_init_liblinphone(const char *config_file,
 208                 const char *factory_config_file) {
 209         LinphoneCoreVTable vtable={0};
 210
 211         vtable.call_state_changed=linphone_gtk_call_state_changed;
 212         vtable.registration_state_changed=linphone_gtk_registration_state_changed;
 213         vtable.show=linphone_gtk_show;
 214         vtable.notify_presence_recv=linphone_gtk_notify_recv;
 215         vtable.new_subscription_request=linphone_gtk_new_unknown_subscriber;
 216         vtable.auth_info_requested=linphone_gtk_auth_info_requested;
 217         vtable.display_status=linphone_gtk_display_status;
 218         vtable.display_message=linphone_gtk_display_message;
 219         vtable.display_warning=linphone_gtk_display_warning;
 220         vtable.display_url=linphone_gtk_display_url;
 221         vtable.call_log_updated=linphone_gtk_call_log_updated;
 222         vtable.text_received=linphone_gtk_text_received;
 223         vtable.refer_received=linphone_gtk_refer_received;
 224         vtable.buddy_info_updated=linphone_gtk_buddy_info_updated;
 225
 226         linphone_core_set_user_agent("Linphone", LINPHONE_VERSION);
 227         the_core=linphone_core_new(&vtable,config_file,factory_config_file,NULL);
 228         linphone_core_set_waiting_callback(the_core,linphone_gtk_wait,NULL);
 229 }
 230
 231
 232
 233 LinphoneCore *linphone_gtk_get_core(void){
 234         return the_core;
 235 }
 236
 237 GtkWidget *linphone_gtk_get_main_window(){
 238         return the_ui;
 239 }
 240
 241 static void linphone_gtk_configure_window(GtkWidget *w, const char *window_name){
 242         static const char *icon_path=NULL;
 243         static const char *hiddens=NULL;
 244         static const char *shown=NULL;
 245         static bool_t config_loaded=FALSE;
 246         if (linphone_gtk_get_core()==NULL) return;
 247         if (config_loaded==FALSE){
 248                 hiddens=linphone_gtk_get_ui_config("hidden_widgets",NULL);
 249                 shown=linphone_gtk_get_ui_config("shown_widgets",NULL);
 250                 icon_path=linphone_gtk_get_ui_config("icon",LINPHONE_ICON);
 251                 config_loaded=TRUE;
 252         }
 253         if (hiddens)
 254                 linphone_gtk_visibility_set(hiddens,window_name,w,FALSE);
 255         if (shown)
 256                 linphone_gtk_visibility_set(shown,window_name,w,TRUE);
 257         if (icon_path) {
 258                 GdkPixbuf *pbuf=create_pixbuf(icon_path);
 259                 gtk_window_set_icon(GTK_WINDOW(w),pbuf);
 260                 g_object_unref(G_OBJECT(pbuf));
 261         }
 262 }
 263
 264 static int get_ui_file(const char *name, char *path, int pathsize){
 265         snprintf(path,pathsize,"%s/%s.ui",BUILD_TREE_XML_DIR,name);
 266         if (access(path,F_OK)!=0){
 267                 snprintf(path,pathsize,"%s/%s.ui",INSTALLED_XML_DIR,name);
 268                 if (access(path,F_OK)!=0){
 269                         g_error("Could not locate neither %s/%s.ui nor %s/%s.ui",BUILD_TREE_XML_DIR,name,
 270                                 INSTALLED_XML_DIR,name);
 271                         return -1;
 272                 }
 273         }
 274         return 0;
 275 }
 276
 277 GtkWidget *linphone_gtk_create_window(const char *window_name){
 278         GError* error = NULL;
 279         GtkBuilder* builder = gtk_builder_new ();
 280         char path[512];
 281         GtkWidget *w;
 282
 283         if (get_ui_file(window_name,path,sizeof(path))==-1) return NULL;
 284
 285         if (!gtk_builder_add_from_file (builder, path, &error)){
 286                 g_error("Couldn't load builder file: %s", error->message);
 287                 g_error_free (error);
 288                 return NULL;
 289         }
 290         w=GTK_WIDGET(gtk_builder_get_object (builder,window_name));
 291         if (w==NULL){
 292                 g_error("Could not retrieve '%s' window from xml file",window_name);
 293                 return NULL;
 294         }
 295         g_object_set_data(G_OBJECT(w),"builder",builder);
 296         gtk_builder_connect_signals(builder,w);
 297         linphone_gtk_configure_window(w,window_name);
 298         return w;
 299 }
 300
 301 GtkWidget *linphone_gtk_create_widget(const char *filename, const char *widget_name){
 302         char path[2048];
 303         GtkWidget *w;
 304         GtkBuilder* builder = gtk_builder_new ();
 305         GError *error=NULL;
 306         gchar *object_ids[2];
 307         object_ids[0]=g_strdup(widget_name);
 308         object_ids[1]=NULL;
 309
 310         if (get_ui_file(filename,path,sizeof(path))==-1) return NULL;
 311         if (!gtk_builder_add_objects_from_file(builder,path,object_ids,&error)){
 312                 g_error("Couldn't load %s from builder file %s: %s", widget_name,path,error->message);
 313                 g_error_free (error);
 314                 g_free(object_ids[0]);
 315                 return NULL;
 316         }
 317         g_free(object_ids[0]);
 318         w=GTK_WIDGET(gtk_builder_get_object (builder,widget_name));
 319         if (w==NULL){
 320                 g_error("Could not retrieve '%s' window from xml file",widget_name);
 321                 return NULL;
 322         }
 323         g_object_set_data(G_OBJECT(w),"builder",builder);
 324         g_signal_connect_swapped(G_OBJECT(w),"destroy",(GCallback)g_object_unref,builder);
 325         gtk_builder_connect_signals(builder,w);
 326         return w;
 327 }
 328
 329 GtkWidget *linphone_gtk_get_widget(GtkWidget *window, const char *name){
 330         GtkBuilder *builder=(GtkBuilder*)g_object_get_data(G_OBJECT(window),"builder");
 331         GObject *w;
 332         if (builder==NULL){
 333                 g_error("Fail to retrieve builder from window !");
 334                 return NULL;
 335         }
 336         w=gtk_builder_get_object(builder,name);
 337         if (w==NULL){
 338                 g_error("No widget named %s found in xml interface.",name);
 339         }
 340         return GTK_WIDGET(w);
 341 }
 342
 343
 344 void linphone_gtk_display_something(GtkMessageType type,const gchar *message){
 345         GtkWidget *dialog;
 346         GtkWidget *main_window=linphone_gtk_get_main_window();
 347
 348         gtk_widget_show(main_window);
 349         if (type==GTK_MESSAGE_QUESTION)
 350         {
 351                 /* draw a question box. link to dialog_click callback */
 352                 dialog = gtk_message_dialog_new (
 353                                 GTK_WINDOW(main_window),
 354                                 GTK_DIALOG_DESTROY_WITH_PARENT,
 355                                 GTK_MESSAGE_QUESTION,
 356                                 GTK_BUTTONS_YES_NO,
 357                                 "%s",
 358                                 (const gchar*)message);
 359                 /* connect to some callback : REVISIT */
 360                 /*
 361                 g_signal_connect_swapped (G_OBJECT (dialog), "response",
 362                            G_CALLBACK (dialog_click),
 363                            G_OBJECT (dialog));
 364                 */
 365                 /* actually show the box */
 366                 gtk_widget_show(dialog);
 367         }
 368         else
 369         {
 370                 dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
 371                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 372                                   type,
 373                                   GTK_BUTTONS_CLOSE,
 374                                   "%s",
 375                                   (const gchar*)message);
 376                 /* Destroy the dialog when the user responds to it (e.g. clicks a button) */
 377                 g_signal_connect_swapped (G_OBJECT (dialog), "response",
 378                            G_CALLBACK (gtk_widget_destroy),
 379                            G_OBJECT (dialog));
 380                 gtk_widget_show(dialog);
 381         }
 382 }
 383
 384 void linphone_gtk_about_response(GtkDialog *dialog, gint id){
 385         if (id==GTK_RESPONSE_CANCEL){
 386                 gtk_widget_destroy(GTK_WIDGET(dialog));
 387         }
 388 }
 389
 390 static void about_url_clicked(GtkAboutDialog *dialog, const char *url, gpointer data){
 391         g_message("About url clicked");
 392         linphone_gtk_open_browser(url);
 393 }
 394
 395 void linphone_gtk_show_about(){
 396         struct stat filestat;
 397         const char *license_file=PACKAGE_DATA_DIR "/linphone/COPYING";
 398         GtkWidget *about;
 399         const char *tmp;
 400         GdkPixbuf *logo=create_pixbuf(
 401             linphone_gtk_get_ui_config("logo","linphone-banner.png"));
 402         static const char *defcfg="defcfg";
 403
 404         about=linphone_gtk_create_window("about");
 405         gtk_about_dialog_set_url_hook(about_url_clicked,NULL,NULL);
 406         memset(&filestat,0,sizeof(filestat));
 407         if (stat(license_file,&filestat)!=0){
 408                 license_file="COPYING";
 409                 stat(license_file,&filestat);
 410         }
 411         if (filestat.st_size>0){
 412                 char *license=g_malloc(filestat.st_size+1);
 413                 FILE *f=fopen(license_file,"r");
 414                 if (f && fread(license,filestat.st_size,1,f)==1){
 415                         license[filestat.st_size]='\0';
 416                         gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(about),license);
 417                 }
 418                 g_free(license);
 419         }
 420         gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about),LINPHONE_VERSION);
 421         gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about),linphone_gtk_get_ui_config("title","Linphone"));
 422         gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about),linphone_gtk_get_ui_config("home","http://www.linphone.org"));
 423         if (logo)       gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about),logo);
 424         tmp=linphone_gtk_get_ui_config("artists",defcfg);
 425         if (tmp!=defcfg){
 426                 const char *tmp2[2];
 427                 tmp2[0]=tmp;
 428                 tmp2[1]=NULL;
 429                 gtk_about_dialog_set_artists(GTK_ABOUT_DIALOG(about),tmp2);
 430         }
 431         tmp=linphone_gtk_get_ui_config("translators",defcfg);
 432         if (tmp!=defcfg)
 433                 gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG(about),tmp);
 434         tmp=linphone_gtk_get_ui_config("comments",defcfg);
 435         if (tmp!=defcfg)
 436                 gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about),tmp);
 437         gtk_widget_show(about);
 438 }
 439
 440 static void set_video_window_decorations(GdkWindow *w){
 441         const char *title=linphone_gtk_get_ui_config("title","Linphone");
 442         const char *icon_path=linphone_gtk_get_ui_config("icon",LINPHONE_ICON);
 443         char video_title[256];
 444         GdkPixbuf *pbuf=create_pixbuf(icon_path);
 445         if (!linphone_core_in_call(linphone_gtk_get_core())){
 446                 snprintf(video_title,sizeof(video_title),"%s video",title);
 447                 /* When not in call, treat the video as a normal window */
 448                 gdk_window_set_keep_above(w, FALSE);
 449         }else{
 450                 LinphoneAddress *uri =
 451                         linphone_address_clone(linphone_core_get_current_call_remote_address(linphone_gtk_get_core()));
 452                 char *display_name;
 453
 454                 linphone_address_clean(uri);
 455                 if (linphone_address_get_display_name(uri)!=NULL){
 456                         display_name=ms_strdup(linphone_address_get_display_name(uri));
 457                 }else{
 458                         display_name=linphone_address_as_string(uri);
 459                 }
 460                 snprintf(video_title,sizeof(video_title),_("Call with %s"),display_name);
 461                 linphone_address_destroy(uri);
 462                 ms_free(display_name);
 463
 464                 /* During calls, bring up the video window, arrange so that
 465                 it is above all the other windows */
 466                 gdk_window_deiconify(w);
 467                 gdk_window_set_keep_above(w,TRUE);
 468                 /* Maybe we should have the following, but then we want to
 469                 have a timer that turns it off after a little while. */
 470                 /* gdk_window_set_urgency_hint(w,TRUE); */
 471         }
 472         gdk_window_set_title(w,video_title);
 473         /* Refrain the video window to be closed at all times. */
 474         gdk_window_set_functions(w,
 475                                  GDK_FUNC_RESIZE|GDK_FUNC_MOVE|
 476                                  GDK_FUNC_MINIMIZE|GDK_FUNC_MAXIMIZE);
 477         if (pbuf){
 478                 GList *l=NULL;
 479                 l=g_list_append(l,pbuf);
 480                 gdk_window_set_icon_list(w,l);
 481                 g_list_free(l);
 482                 g_object_unref(G_OBJECT(pbuf));
 483         }
 484 }
 485
 486 static gboolean video_needs_update=FALSE;
 487
 488 static void update_video_title(){
 489         video_needs_update=TRUE;
 490 }
 491
 492 static gboolean linphone_gtk_iterate(LinphoneCore *lc){
 493         static gboolean first_time=TRUE;
 494         unsigned long id;
 495         static unsigned long previd=0;
 496         static unsigned long preview_previd=0;
 497         static gboolean in_iterate=FALSE;
 498
 499         /*avoid reentrancy*/
 500         if (in_iterate) return TRUE;
 501         in_iterate=TRUE;
 502         linphone_core_iterate(lc);
 503         if (first_time){
 504                 /*after the first call to iterate, SipSetupContexts should be ready, so take actions:*/
 505                 linphone_gtk_show_directory_search();
 506                 first_time=FALSE;
 507         }
 508
 509         id=linphone_core_get_native_video_window_id(lc);
 510         if (id!=previd || video_needs_update){
 511                 GdkWindow *w;
 512                 previd=id;
 513                 if (id!=0){
 514                         ms_message("Updating window decorations");
 515 #ifndef WIN32
 516                         w=gdk_window_foreign_new(id);
 517 #else
 518                         w=gdk_window_foreign_new((HANDLE)id);
 519 #endif
 520                         if (w) {
 521                                 set_video_window_decorations(w);
 522                                 g_object_unref(G_OBJECT(w));
 523                         }
 524                         else ms_error("gdk_window_foreign_new() failed");
 525                         if (video_needs_update) video_needs_update=FALSE;
 526                 }
 527         }
 528         id=linphone_core_get_native_preview_window_id (lc);
 529         if (id!=preview_previd ){
 530                 GdkWindow *w;
 531                 preview_previd=id;
 532                 if (id!=0){
 533                         ms_message("Updating window decorations for preview");
 534 #ifndef WIN32
 535                         w=gdk_window_foreign_new(id);
 536 #else
 537                         w=gdk_window_foreign_new((HANDLE)id);
 538 #endif
 539                         if (w) {
 540                                 set_video_window_decorations(w);
 541                                 g_object_unref(G_OBJECT(w));
 542                         }
 543                         else ms_error("gdk_window_foreign_new() failed");
 544                         if (video_needs_update) video_needs_update=FALSE;
 545                 }
 546         }
 547         if (addr_to_call!=NULL){
 548                 /*make sure we are not showing the login screen*/
 549                 GtkWidget *mw=linphone_gtk_get_main_window();
 550                 GtkWidget *login_frame=linphone_gtk_get_widget(mw,"login_frame");
 551                 if (!GTK_WIDGET_VISIBLE(login_frame)){
 552                         GtkWidget *uri_bar=linphone_gtk_get_widget(mw,"uribar");
 553                         gtk_entry_set_text(GTK_ENTRY(uri_bar),addr_to_call);
 554                         addr_to_call=NULL;
 555                         linphone_gtk_start_call(uri_bar);
 556                 }
 557         }
 558         in_iterate=FALSE;
 559         return TRUE;
 560 }
 561
 562 static void load_uri_history(){
 563         GtkEntry *uribar=GTK_ENTRY(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"uribar"));
 564         char key[20];
 565         int i;
 566         GtkEntryCompletion *gep=gtk_entry_completion_new();
 567         GtkListStore *model=gtk_list_store_new(1,G_TYPE_STRING);
 568         for (i=0;;i++){
 569                 const char *uri;
 570                 snprintf(key,sizeof(key),"uri%i",i);
 571                 uri=linphone_gtk_get_ui_config(key,NULL);
 572                 if (uri!=NULL) {
 573                         GtkTreeIter iter;
 574                         gtk_list_store_append(model,&iter);
 575                         gtk_list_store_set(model,&iter,0,uri,-1);
 576                         if (i==0) gtk_entry_set_text(uribar,uri);
 577                 }
 578                 else break;
 579         }
 580         gtk_entry_completion_set_model(gep,GTK_TREE_MODEL(model));
 581         gtk_entry_completion_set_text_column(gep,0);
 582         gtk_entry_set_completion(uribar,gep);
 583 }
 584
 585 static void save_uri_history(){
 586         LinphoneCore *lc=linphone_gtk_get_core();
 587         LpConfig *cfg=linphone_core_get_config(lc);
 588         GtkEntry *uribar=GTK_ENTRY(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"uribar"));
 589         char key[20];
 590         int i=0;
 591         char *uri=NULL;
 592         GtkTreeIter iter;
 593         GtkTreeModel *model=gtk_entry_completion_get_model(gtk_entry_get_completion(uribar));
 594
 595         if (!gtk_tree_model_get_iter_first(model,&iter)) return;
 596         do {
 597                 gtk_tree_model_get(model,&iter,0,&uri,-1);
 598                 if (uri) {
 599                         snprintf(key,sizeof(key),"uri%i",i);
 600                         lp_config_set_string(cfg,"GtkUi",key,uri);
 601                         g_free(uri);
 602                 }else break;
 603                 i++;
 604                 if (i>5) break;
 605         }while(gtk_tree_model_iter_next(model,&iter));
 606         lp_config_sync(cfg);
 607 }
 608
 609 static void completion_add_text(GtkEntry *entry, const char *text){
 610         GtkTreeIter iter;
 611         GtkTreeModel *model=gtk_entry_completion_get_model(gtk_entry_get_completion(entry));
 612
 613         if (gtk_tree_model_get_iter_first(model,&iter)){
 614                 do {
 615                         gchar *uri=NULL;
 616                         gtk_tree_model_get(model,&iter,0,&uri,-1);
 617                         if (uri!=NULL){
 618                                 if (strcmp(uri,text)==0) {
 619                                         /*remove text */
 620                                         gtk_list_store_remove(GTK_LIST_STORE(model),&iter);
 621                                         g_free(uri);
 622                                         break;
 623                                 }
 624                                 g_free(uri);
 625                         }
 626                 }while (gtk_tree_model_iter_next(model,&iter));
 627         }
 628         /* and prepend it on top of the list */
 629         gtk_list_store_prepend(GTK_LIST_STORE(model),&iter);
 630         gtk_list_store_set(GTK_LIST_STORE(model),&iter,0,text,-1);
 631         save_uri_history();
 632 }
 633
 634
 635 void linphone_gtk_show_main_window(){
 636         GtkWidget *w=linphone_gtk_get_main_window();
 637         LinphoneCore *lc=linphone_gtk_get_core();
 638         if (linphone_core_video_enabled(lc)){
 639                 linphone_core_enable_video_preview(lc,linphone_gtk_get_ui_config_int("videoselfview",
 640                 VIDEOSELFVIEW_DEFAULT));
 641         }
 642         gtk_widget_show(w);
 643         gtk_window_present(GTK_WINDOW(w));
 644 }
 645
 646 static void linphone_gtk_show(LinphoneCore *lc){
 647 #ifndef HAVE_NOTIFY
 648         linphone_gtk_show_main_window();
 649 #endif
 650 }
 651
 652 void linphone_gtk_call_terminated(LinphoneCall *call, const char *error){
 653         GtkWidget *mw=linphone_gtk_get_main_window();
 654         if (linphone_core_get_calls(linphone_gtk_get_core())==NULL){
 655             gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"terminate_call"),FALSE);
 656             gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"start_call"),TRUE);
 657         }
 658         if (linphone_gtk_use_in_call_view() && call)
 659                 linphone_gtk_in_call_view_terminate(call,error);
 660         update_video_title();
 661 }
 662
 663 static void linphone_gtk_update_call_buttons(LinphoneCall *call){
 664         LinphoneCore *lc=linphone_gtk_get_core();
 665         GtkWidget *mw=linphone_gtk_get_main_window();
 666         const MSList *calls=linphone_core_get_calls(lc);
 667         GtkWidget *button;
 668         bool_t start_active=TRUE;
 669         bool_t stop_active=FALSE;
 670         bool_t add_call=FALSE;
 671         int call_list_size=ms_list_size(calls);
 672
 673         if (calls==NULL){
 674                 start_active=TRUE;
 675                 stop_active=FALSE;
 676         }else{
 677                 stop_active=TRUE;
 678                 start_active=TRUE;
 679                 add_call=TRUE;
 680         }
 681         button=linphone_gtk_get_widget(mw,"start_call");
 682         gtk_widget_set_sensitive(button,start_active);
 683         gtk_widget_set_visible(button,!add_call);
 684
 685         button=linphone_gtk_get_widget(mw,"add_call");
 686         gtk_widget_set_sensitive(button,start_active);
 687         gtk_widget_set_visible(button,add_call);
 688
 689         gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"terminate_call"),stop_active);
 690
 691         linphone_gtk_enable_transfer_button(lc,call_list_size>1);
 692         linphone_gtk_enable_conference_button(lc,call_list_size>1);
 693         update_video_title();
 694 }
 695
 696 static gboolean linphone_gtk_start_call_do(GtkWidget *uri_bar){
 697         const char *entered=gtk_entry_get_text(GTK_ENTRY(uri_bar));
 698         if (linphone_core_invite(linphone_gtk_get_core(),entered)!=NULL) {
 699                 completion_add_text(GTK_ENTRY(uri_bar),entered);
 700         }else{
 701                 linphone_gtk_call_terminated(NULL,NULL);
 702         }
 703         return FALSE;
 704 }
 705
 706 static gboolean linphone_gtk_auto_answer(LinphoneCall *call){
 707         if (linphone_call_get_state(call)==LinphoneCallIncomingReceived){
 708                 linphone_core_accept_call (linphone_gtk_get_core(),call);
 709                 linphone_call_unref(call);
 710         }
 711         return FALSE;
 712 }
 713
 714
 715 void linphone_gtk_start_call(GtkWidget *w){
 716         LinphoneCore *lc=linphone_gtk_get_core();
 717         LinphoneCall *call;
 718         /*change into in-call mode, then do the work later as it might block a bit */
 719         GtkWidget *mw=gtk_widget_get_toplevel(w);
 720         GtkWidget *uri_bar=linphone_gtk_get_widget(mw,"uribar");
 721
 722         call=linphone_gtk_get_currently_displayed_call(NULL);
 723         if (call!=NULL && linphone_call_get_state(call)==LinphoneCallIncomingReceived){
 724                 linphone_core_accept_call(lc,call);
 725         }else{
 726                 /*immediately disable the button and delay a bit the execution the linphone_core_invite()
 727                 so that we don't freeze the button. linphone_core_invite() might block for some hundreds of milliseconds*/
 728                 gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"start_call"),FALSE);
 729                 g_timeout_add(100,(GSourceFunc)linphone_gtk_start_call_do,uri_bar);
 730         }
 731
 732 }
 733
 734 void linphone_gtk_uri_bar_activate(GtkWidget *w){
 735         linphone_gtk_start_call(w);
 736 }
 737
 738
 739 void linphone_gtk_terminate_call(GtkWidget *button){
 740         gboolean is_conf;
 741         LinphoneCall *call=linphone_gtk_get_currently_displayed_call(&is_conf);
 742         if (call){
 743                 linphone_core_terminate_call(linphone_gtk_get_core(),call);
 744         }else if (is_conf){
 745                 linphone_core_terminate_conference(linphone_gtk_get_core());
 746         }
 747 }
 748
 749 void linphone_gtk_decline_clicked(GtkWidget *button){
 750         LinphoneCall *call=linphone_gtk_get_currently_displayed_call(NULL);
 751         if (call)
 752                 linphone_core_terminate_call(linphone_gtk_get_core(),call);
 753 }
 754
 755 void linphone_gtk_answer_clicked(GtkWidget *button){
 756         LinphoneCall *call=linphone_gtk_get_currently_displayed_call(NULL);
 757         if (call){
 758                 linphone_core_accept_call(linphone_gtk_get_core(),call);
 759                 linphone_gtk_show_main_window(); /* useful when the button is clicked on a notification */
 760         }
 761 }
 762
 763 void linphone_gtk_enable_video(GtkWidget *w){
 764         gboolean val=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w));
 765         GtkWidget *selfview_item=linphone_gtk_get_widget(linphone_gtk_get_main_window(),"selfview_item");
 766         linphone_core_enable_video(linphone_gtk_get_core(),val,val);
 767         gtk_widget_set_sensitive(selfview_item,val);
 768         if (val){
 769                 linphone_core_enable_video_preview(linphone_gtk_get_core(),
 770                 linphone_gtk_get_ui_config_int("videoselfview",VIDEOSELFVIEW_DEFAULT));
 771         }else{
 772                 linphone_core_enable_video_preview(linphone_gtk_get_core(),FALSE);
 773         }
 774 }
 775
 776 void linphone_gtk_enable_self_view(GtkWidget *w){
 777         gboolean val=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w));
 778         LinphoneCore *lc=linphone_gtk_get_core();
 779         linphone_core_enable_video_preview(lc,val);
 780         linphone_core_enable_self_view(lc,val);
 781         linphone_gtk_set_ui_config_int("videoselfview",val);
 782 }
 783
 784 void linphone_gtk_used_identity_changed(GtkWidget *w){
 785         int active=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 786         char *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 787         if (sel && strlen(sel)>0){ //avoid a dummy "changed" at gui startup
 788                 linphone_core_set_default_proxy_index(linphone_gtk_get_core(),(active==0) ? -1 : (active-1));
 789                 linphone_gtk_show_directory_search();
 790         }
 791         if (sel) g_free(sel);
 792 }
 793
 794 static void linphone_gtk_notify_recv(LinphoneCore *lc, LinphoneFriend * fid){
 795         linphone_gtk_show_friends();
 796 }
 797
 798 static void linphone_gtk_new_subscriber_response(GtkWidget *dialog, guint response_id, LinphoneFriend *lf){
 799         switch(response_id){
 800                 case GTK_RESPONSE_YES:
 801                         linphone_gtk_show_contact(lf);
 802                 break;
 803                 default:
 804                         linphone_core_reject_subscriber(linphone_gtk_get_core(),lf);
 805         }
 806         gtk_widget_destroy(dialog);
 807 }
 808
 809 static void linphone_gtk_new_unknown_subscriber(LinphoneCore *lc, LinphoneFriend *lf, const char *url){
 810         GtkWidget *dialog;
 811
 812         if (linphone_gtk_get_ui_config_int("subscribe_deny_all",0)){
 813                 linphone_core_reject_subscriber(linphone_gtk_get_core(),lf);
 814                 return;
 815         }
 816
 817         gchar *message=g_strdup_printf(_("%s would like to add you to his contact list.\nWould you allow him to see your presence status or add him to your contact list ?\nIf you answer no, this person will be temporarily blacklisted."),url);
 818         dialog = gtk_message_dialog_new (
 819                                 GTK_WINDOW(linphone_gtk_get_main_window()),
 820                                 GTK_DIALOG_DESTROY_WITH_PARENT,
 821                                 GTK_MESSAGE_QUESTION,
 822                                 GTK_BUTTONS_YES_NO,
 823                                 "%s",
 824                                 message);
 825         g_free(message);
 826         g_signal_connect(G_OBJECT (dialog), "response",
 827                 G_CALLBACK (linphone_gtk_new_subscriber_response),lf);
 828         /* actually show the box */
 829         gtk_widget_show(dialog);
 830 }
 831
 832 typedef struct _AuthTimeout{
 833         GtkWidget *w;
 834 } AuthTimeout;
 835
 836
 837 static void auth_timeout_clean(AuthTimeout *tout){
 838         tout->w=NULL;
 839 }
 840
 841 static gboolean auth_timeout_destroy(AuthTimeout *tout){
 842         if (tout->w)  {
 843                 g_object_weak_unref(G_OBJECT(tout->w),(GWeakNotify)auth_timeout_clean,tout);
 844                 gtk_widget_destroy(tout->w);
 845         }
 846         g_free(tout);
 847         return FALSE;
 848 }
 849
 850 static AuthTimeout * auth_timeout_new(GtkWidget *w){
 851         AuthTimeout *tout=g_new(AuthTimeout,1);
 852         tout->w=w;
 853         /*so that the timeout no more references the widget when it is destroyed:*/
 854         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)auth_timeout_clean,tout);
 855         /*so that the widget is automatically destroyed after some time */
 856         g_timeout_add(30000,(GtkFunction)auth_timeout_destroy,tout);
 857         return tout;
 858 }
 859
 860 void linphone_gtk_password_cancel(GtkWidget *w){
 861         LinphoneAuthInfo *info;
 862         GtkWidget *window=gtk_widget_get_toplevel(w);
 863         info=(LinphoneAuthInfo*)g_object_get_data(G_OBJECT(window),"auth_info");
 864         linphone_core_abort_authentication(linphone_gtk_get_core(),info);
 865         gtk_widget_destroy(window);
 866 }
 867
 868 void linphone_gtk_password_ok(GtkWidget *w){
 869         GtkWidget *entry;
 870         GtkWidget *window=gtk_widget_get_toplevel(w);
 871         LinphoneAuthInfo *info;
 872         info=(LinphoneAuthInfo*)g_object_get_data(G_OBJECT(window),"auth_info");
 873         g_object_weak_unref(G_OBJECT(window),(GWeakNotify)linphone_auth_info_destroy,info);
 874         entry=linphone_gtk_get_widget(window,"password_entry");
 875         linphone_auth_info_set_passwd(info,gtk_entry_get_text(GTK_ENTRY(entry)));
 876         linphone_auth_info_set_userid(info,
 877                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(window,"userid_entry"))));
 878         linphone_core_add_auth_info(linphone_gtk_get_core(),info);
 879         gtk_widget_destroy(window);
 880 }
 881
 882 static void linphone_gtk_auth_info_requested(LinphoneCore *lc, const char *realm, const char *username){
 883         GtkWidget *w=linphone_gtk_create_window("password");
 884         GtkWidget *label=linphone_gtk_get_widget(w,"message");
 885         LinphoneAuthInfo *info;
 886         gchar *msg;
 887         GtkWidget *mw=linphone_gtk_get_main_window();
 888
 889         if (mw && GTK_WIDGET_VISIBLE(linphone_gtk_get_widget(mw,"login_frame"))){
 890                 /*don't prompt for authentication when login frame is visible*/
 891                 linphone_core_abort_authentication(lc,NULL);
 892                 return;
 893         }
 894
 895         msg=g_strdup_printf(_("Please enter your password for username <i>%s</i>\n at domain <i>%s</i>:"),
 896                 username,realm);
 897         gtk_label_set_markup(GTK_LABEL(label),msg);
 898         g_free(msg);
 899         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"userid_entry")),username);
 900         info=linphone_auth_info_new(username, NULL, NULL, NULL,realm);
 901         g_object_set_data(G_OBJECT(w),"auth_info",info);
 902         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_auth_info_destroy,info);
 903         gtk_widget_show(w);
 904         auth_timeout_new(w);
 905 }
 906
 907 static void linphone_gtk_display_status(LinphoneCore *lc, const char *status){
 908         GtkWidget *w=linphone_gtk_get_main_window();
 909         GtkWidget *status_bar=linphone_gtk_get_widget(w,"status_bar");
 910         gtk_statusbar_push(GTK_STATUSBAR(status_bar),
 911                         gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar),""),
 912                         status);
 913 }
 914
 915 static void linphone_gtk_display_message(LinphoneCore *lc, const char *msg){
 916         linphone_gtk_display_something(GTK_MESSAGE_INFO,msg);
 917 }
 918
 919 static void linphone_gtk_display_warning(LinphoneCore *lc, const char *warning){
 920         linphone_gtk_display_something(GTK_MESSAGE_WARNING,warning);
 921 }
 922
 923 static void linphone_gtk_display_url(LinphoneCore *lc, const char *msg, const char *url){
 924         char richtext[4096];
 925         snprintf(richtext,sizeof(richtext),"%s %s",msg,url);
 926         linphone_gtk_display_something(GTK_MESSAGE_INFO,richtext);
 927 }
 928
 929 static void linphone_gtk_call_log_updated(LinphoneCore *lc, LinphoneCallLog *cl){
 930         GtkWidget *w=(GtkWidget*)g_object_get_data(G_OBJECT(linphone_gtk_get_main_window()),"call_logs");
 931         if (w) linphone_gtk_call_log_update(w);
 932         linphone_gtk_call_log_update(linphone_gtk_get_main_window());
 933 }
 934
 935 #ifdef HAVE_NOTIFY
 936 static bool_t notify_actions_supported() {
 937         bool_t accepts_actions = FALSE;
 938         GList *capabilities = notify_get_server_caps();
 939         GList *c;
 940         if(capabilities != NULL) {
 941                 for(c = capabilities; c != NULL; c = c->next) {
 942                         if(strcmp((char*)c->data, "actions") == 0 ) {
 943                                 accepts_actions = TRUE;
 944                                 break;
 945                         }
 946                 }
 947                 g_list_foreach(capabilities, (GFunc)g_free, NULL);
 948                 g_list_free(capabilities);
 949         }
 950         return accepts_actions;
 951 }
 952
 953 static NotifyNotification* build_notification(const char *title, const char *body){
 954          return notify_notification_new(title,body,linphone_gtk_get_ui_config("icon",LINPHONE_ICON)
 955 #ifdef HAVE_NOTIFY1
 956         ,NULL
 957 #endif
 958         );
 959 }
 960
 961 static void show_notification(NotifyNotification* n){
 962         if (n && !notify_notification_show(n,NULL))
 963                 ms_error("Failed to send notification.");
 964 }
 965
 966 static void make_notification(const char *title, const char *body){
 967         show_notification(build_notification(title,body));
 968 }
 969
 970 #endif
 971
 972 static void linphone_gtk_notify(LinphoneCall *call, const char *msg){
 973 #ifdef HAVE_NOTIFY
 974         if (!notify_is_initted())
 975                 if (!notify_init ("Linphone")) ms_error("Libnotify failed to init.");
 976 #endif
 977         if (!call) {
 978 #ifdef HAVE_NOTIFY
 979                 if (!notify_notification_show(notify_notification_new("Linphone",msg,NULL
 980 #ifdef HAVE_NOTIFY1
 981         ,NULL
 982 #endif
 983 ),NULL))
 984                                 ms_error("Failed to send notification.");
 985 #else
 986                 linphone_gtk_show_main_window();
 987 #endif
 988         } else if (!gtk_window_is_active((GtkWindow*)linphone_gtk_get_main_window())) {
 989 #ifdef HAVE_NOTIFY
 990                 char *body=NULL;
 991                 char *remote=call!=NULL ? linphone_call_get_remote_address_as_string(call) : NULL;
 992                 NotifyNotification *n;
 993                 switch(linphone_call_get_state(call)){
 994                         case LinphoneCallError:
 995                                 make_notification(_("Call error"),body=g_markup_printf_escaped("<span size=\"large\">%s</span>\n%s",msg,remote));
 996                         break;
 997                         case LinphoneCallEnd:
 998                                 make_notification(_("Call ended"),body=g_markup_printf_escaped("<span size=\"large\">%s</span>",remote));
 999                         break;
1000                         case LinphoneCallIncomingReceived:
1001                                 n=build_notification(_("Incoming call"),body=g_markup_printf_escaped("<span size=\"large\">%s</span>",remote));
1002                                 if (notify_actions_supported()) {
1003                                         notify_notification_add_action (n,"answer", _("Answer"),
1004                                                 NOTIFY_ACTION_CALLBACK(linphone_gtk_answer_clicked),NULL,NULL);
1005                                         notify_notification_add_action (n,"decline",_("Decline"),
1006                                                 NOTIFY_ACTION_CALLBACK(linphone_gtk_decline_clicked),NULL,NULL);
1007                                 }
1008                                 show_notification(n);
1009                         break;
1010                         case LinphoneCallPausedByRemote:
1011                                 make_notification(_("Call paused"),body=g_markup_printf_escaped(_("<span size=\"large\">by %s</span>"),remote));
1012                         break;
1013                         default:
1014                         break;
1015                 }
1016                 if (body) g_free(body);
1017                 if (remote) g_free(remote);
1018 #endif
1019         }
1020 }
1021
1022 static void linphone_gtk_call_state_changed(LinphoneCore *lc, LinphoneCall *call, LinphoneCallState cs, const char *msg){
1023         switch(cs){
1024                 case LinphoneCallOutgoingInit:
1025                         linphone_gtk_create_in_call_view (call);
1026                 break;
1027                 case LinphoneCallOutgoingProgress:
1028                         linphone_gtk_in_call_view_set_calling (call);
1029                 break;
1030                 case LinphoneCallStreamsRunning:
1031                         linphone_gtk_in_call_view_set_in_call(call);
1032                 break;
1033                 case LinphoneCallError:
1034                         linphone_gtk_in_call_view_terminate (call,msg);
1035                 break;
1036                 case LinphoneCallEnd:
1037                         linphone_gtk_in_call_view_terminate(call,NULL);
1038                         linphone_gtk_status_icon_set_blinking(FALSE);
1039                 break;
1040                 case LinphoneCallIncomingReceived:
1041                         linphone_gtk_create_in_call_view (call);
1042                         linphone_gtk_in_call_view_set_incoming(call);
1043                         linphone_gtk_status_icon_set_blinking(TRUE);
1044                         if (auto_answer)  {
1045                                 linphone_call_ref(call);
1046                                 g_timeout_add(2000,(GSourceFunc)linphone_gtk_auto_answer ,call);
1047                         }
1048                 break;
1049                 case LinphoneCallResuming:
1050                         linphone_gtk_enable_hold_button(call,TRUE,TRUE);
1051                         linphone_gtk_in_call_view_set_in_call (call);
1052                 break;
1053                 case LinphoneCallPausing:
1054                         linphone_gtk_enable_hold_button(call,TRUE,FALSE);
1055                 case LinphoneCallPausedByRemote:
1056                         linphone_gtk_in_call_view_set_paused(call);
1057                 break;
1058                 case LinphoneCallConnected:
1059                         linphone_gtk_enable_hold_button (call,TRUE,TRUE);
1060                         linphone_gtk_status_icon_set_blinking(FALSE);
1061                 break;
1062                 default:
1063                 break;
1064         }
1065         linphone_gtk_notify(call, msg);
1066         linphone_gtk_update_call_buttons (call);
1067 }
1068
1069 static void update_registration_status(LinphoneProxyConfig *cfg, LinphoneRegistrationState rs){
1070         GtkComboBox *box=GTK_COMBO_BOX(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"identities"));
1071         GtkTreeModel *model=gtk_combo_box_get_model(box);
1072         GtkTreeIter iter;
1073         gboolean found=FALSE;
1074         const char *stock_id=NULL;
1075
1076         if (gtk_tree_model_get_iter_first(model,&iter)){
1077                 gpointer p;
1078                 do{
1079                         gtk_tree_model_get(model,&iter,2,&p,-1);
1080                         if (p==cfg) {
1081                                 found=TRUE;
1082                                 break;
1083                         }
1084                 }while(gtk_tree_model_iter_next(model,&iter));
1085         }
1086         if (!found) {
1087                 g_warning("Could not find proxy config in combo box of identities.");
1088                 return;
1089         }
1090         switch (rs){
1091                 case LinphoneRegistrationOk:
1092                         stock_id=GTK_STOCK_YES;
1093                 break;
1094                 case LinphoneRegistrationProgress:
1095                         stock_id=GTK_STOCK_REFRESH;
1096                 break;
1097                 case LinphoneRegistrationCleared:
1098                         stock_id=NULL;
1099                 break;
1100                 case LinphoneRegistrationFailed:
1101                         stock_id=GTK_STOCK_DIALOG_WARNING;
1102                 break;
1103                 default:
1104                 break;
1105         }
1106         gtk_list_store_set(GTK_LIST_STORE(model),&iter,1,stock_id,-1);
1107 }
1108
1109 static void linphone_gtk_registration_state_changed(LinphoneCore *lc, LinphoneProxyConfig *cfg,
1110                                                     LinphoneRegistrationState rs, const char *msg){
1111         switch (rs){
1112                 case LinphoneRegistrationOk:
1113                         if (cfg){
1114                                 SipSetup *ss=linphone_proxy_config_get_sip_setup(cfg);
1115                                 if (ss && (sip_setup_get_capabilities(ss) & SIP_SETUP_CAP_LOGIN)){
1116                                         linphone_gtk_exit_login_frame();
1117                                 }
1118                         }
1119                 break;
1120                 default:
1121                 break;
1122         }
1123         update_registration_status(cfg,rs);
1124 }
1125
1126
1127 static void icon_popup_menu(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data){
1128         GtkWidget *menu=(GtkWidget*)g_object_get_data(G_OBJECT(status_icon),"menu");
1129         gtk_menu_popup(GTK_MENU(menu),NULL,NULL,gtk_status_icon_position_menu,status_icon,button,activate_time);
1130 }
1131
1132 void linphone_gtk_open_browser(const char *url){
1133         /*in gtk 2.16, gtk_show_uri does not work...*/
1134 #ifndef WIN32
1135 #if GTK_CHECK_VERSION(2,18,3)
1136         gtk_show_uri(NULL,url,GDK_CURRENT_TIME,NULL);
1137 #else
1138         char cl[255];
1139         snprintf(cl,sizeof(cl),"/usr/bin/x-www-browser %s",url);
1140         g_spawn_command_line_async(cl,NULL);
1141 #endif
1142 #else /*WIN32*/
1143         ShellExecute(0,"open",url,NULL,NULL,1);
1144 #endif
1145 }
1146
1147 void linphone_gtk_link_to_website(GtkWidget *item){
1148         const gchar *home=(const gchar*)g_object_get_data(G_OBJECT(item),"home");
1149         linphone_gtk_open_browser(home);
1150 }
1151
1152 static GtkWidget *create_icon_menu(){
1153         GtkWidget *menu=gtk_menu_new();
1154         GtkWidget *menu_item;
1155         GtkWidget *image;
1156         gchar *tmp;
1157         const gchar *homesite;
1158
1159         homesite=linphone_gtk_get_ui_config("home","http://www.linphone.org");
1160         menu_item=gtk_image_menu_item_new_with_label(_("Website link"));
1161         tmp=g_strdup(homesite);
1162         g_object_set_data(G_OBJECT(menu_item),"home",tmp);
1163         g_object_weak_ref(G_OBJECT(menu_item),(GWeakNotify)g_free,tmp);
1164
1165         image=gtk_image_new_from_stock(GTK_STOCK_HELP,GTK_ICON_SIZE_MENU);
1166         gtk_widget_show(image);
1167         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image);
1168         //g_object_unref(G_OBJECT(image));
1169         gtk_widget_show(menu_item);
1170         gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
1171         g_signal_connect(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_link_to_website,NULL);
1172
1173         menu_item=gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
1174         gtk_widget_show(menu_item);
1175         gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
1176         g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_show_about,NULL);
1177         menu_item=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,NULL);
1178         gtk_widget_show(menu_item);
1179         gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
1180         g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)gtk_main_quit,NULL);
1181         gtk_widget_show(menu);
1182         return menu;
1183 }
1184
1185 static GtkStatusIcon *icon=NULL;
1186
1187 static void handle_icon_click() {
1188         GtkWidget *mw=linphone_gtk_get_main_window();
1189         if (!gtk_window_is_active((GtkWindow*)mw)) {
1190                 linphone_gtk_show_main_window();
1191         } else {
1192                 gtk_widget_hide(mw);
1193         }
1194 }
1195
1196 static void linphone_gtk_init_status_icon(){
1197         const char *icon_path=linphone_gtk_get_ui_config("icon",LINPHONE_ICON);
1198         const char *call_icon_path=linphone_gtk_get_ui_config("start_call_icon","startcall-green.png");
1199         GdkPixbuf *pbuf=create_pixbuf(icon_path);
1200         GtkWidget *menu=create_icon_menu();
1201         const char *title;
1202         title=linphone_gtk_get_ui_config("title",_("Linphone - a video internet phone"));
1203         icon=gtk_status_icon_new_from_pixbuf(pbuf);
1204         gtk_status_icon_set_name(icon,title);
1205         g_signal_connect_swapped(G_OBJECT(icon),"activate",(GCallback)handle_icon_click,NULL);
1206         g_signal_connect(G_OBJECT(icon),"popup-menu",(GCallback)icon_popup_menu,NULL);
1207         gtk_status_icon_set_tooltip(icon,title);
1208         gtk_status_icon_set_visible(icon,TRUE);
1209         g_object_set_data(G_OBJECT(icon),"menu",menu);
1210         g_object_weak_ref(G_OBJECT(icon),(GWeakNotify)gtk_widget_destroy,menu);
1211         g_object_set_data(G_OBJECT(icon),"icon",pbuf);
1212         g_object_weak_ref(G_OBJECT(icon),(GWeakNotify)g_object_unref,pbuf);
1213         pbuf=create_pixbuf(call_icon_path);
1214         g_object_set_data(G_OBJECT(icon),"call_icon",pbuf);
1215 }
1216
1217 static gboolean do_icon_blink(GtkStatusIcon *gi){
1218         GdkPixbuf *call_icon=g_object_get_data(G_OBJECT(gi),"call_icon");
1219         GdkPixbuf *normal_icon=g_object_get_data(G_OBJECT(gi),"icon");
1220         GdkPixbuf *cur_icon=gtk_status_icon_get_pixbuf(gi);
1221         if (cur_icon==call_icon){
1222                 gtk_status_icon_set_from_pixbuf(gi,normal_icon);
1223         }else{
1224                 gtk_status_icon_set_from_pixbuf(gi,call_icon);
1225         }
1226         return TRUE;
1227 }
1228
1229 static void linphone_gtk_status_icon_set_blinking(gboolean val){
1230         guint tout;
1231         tout=(unsigned)GPOINTER_TO_INT(g_object_get_data(G_OBJECT(icon),"timeout"));
1232         if (val && tout==0){
1233                 tout=g_timeout_add(500,(GSourceFunc)do_icon_blink,icon);
1234                 g_object_set_data(G_OBJECT(icon),"timeout",GINT_TO_POINTER(tout));
1235         }else if (!val && tout!=0){
1236                 GdkPixbuf *normal_icon=g_object_get_data(G_OBJECT(icon),"icon");
1237                 g_source_remove(tout);
1238                 g_object_set_data(G_OBJECT(icon),"timeout",NULL);
1239                 gtk_status_icon_set_from_pixbuf(icon,normal_icon);
1240         }
1241 }
1242
1243 static void init_identity_combo(GtkComboBox *box){
1244         GtkListStore *store;
1245         GtkCellRenderer *r1,*r2;
1246         store=gtk_list_store_new(3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER);
1247         gtk_cell_layout_clear(GTK_CELL_LAYOUT(box));
1248         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(box),(r1=gtk_cell_renderer_text_new()),TRUE);
1249         gtk_cell_layout_pack_end(GTK_CELL_LAYOUT(box),(r2=gtk_cell_renderer_pixbuf_new()),FALSE);
1250         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(box),r1,"text",0);
1251         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(box),r2,"stock-id",1);
1252         g_object_set(G_OBJECT(r1),"ellipsize",PANGO_ELLIPSIZE_END,NULL);
1253         gtk_combo_box_set_model(box,GTK_TREE_MODEL(store));
1254 }
1255
1256 void linphone_gtk_load_identities(void){
1257         const MSList *elem;
1258         GtkComboBox *box=GTK_COMBO_BOX(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"identities"));
1259         char *def_identity;
1260         LinphoneProxyConfig *def=NULL;
1261         int def_index=0,i;
1262         GtkListStore *store;
1263         GtkTreeIter iter;
1264
1265         store=GTK_LIST_STORE(gtk_combo_box_get_model(box));
1266         if (gtk_tree_model_get_n_columns(GTK_TREE_MODEL(store))==1){
1267                 /* model is empty, this is the first time we go here */
1268                 init_identity_combo(box);
1269                 store=GTK_LIST_STORE(gtk_combo_box_get_model(box));
1270         }
1271         gtk_list_store_clear(store);
1272         linphone_core_get_default_proxy(linphone_gtk_get_core(),&def);
1273         def_identity=g_strdup_printf(_("%s (Default)"),linphone_core_get_primary_contact(linphone_gtk_get_core()));
1274         gtk_list_store_append(store,&iter);
1275         gtk_list_store_set(store,&iter,0,def_identity,1,NULL,2,NULL,-1);
1276         g_free(def_identity);
1277         for(i=1,elem=linphone_core_get_proxy_config_list(linphone_gtk_get_core());
1278                         elem!=NULL;
1279                         elem=ms_list_next(elem),i++){
1280                 LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)elem->data;
1281                 gtk_list_store_append(store,&iter);
1282                 gtk_list_store_set(store,&iter,0,linphone_proxy_config_get_identity(cfg),1,
1283                                    linphone_proxy_config_is_registered(cfg) ? GTK_STOCK_YES : NULL,
1284                                    2,cfg,-1);
1285                 if (cfg==def) {
1286                         def_index=i;
1287                 }
1288         }
1289         gtk_combo_box_set_active(box,def_index);
1290 }
1291
1292 static void linphone_gtk_dtmf_pressed(GtkButton *button){
1293         const char *label=gtk_button_get_label(button);
1294         GtkWidget *uri_bar=linphone_gtk_get_widget(gtk_widget_get_toplevel(GTK_WIDGET(button)),"uribar");
1295         int pos=-1;
1296         gtk_editable_insert_text(GTK_EDITABLE(uri_bar),label,1,&pos);
1297         linphone_core_play_dtmf (linphone_gtk_get_core(),label[0],-1);
1298         if (linphone_core_in_call(linphone_gtk_get_core())){
1299                 linphone_core_send_dtmf(linphone_gtk_get_core(),label[0]);
1300         }
1301 }
1302
1303 static void linphone_gtk_dtmf_released(GtkButton *button){
1304         linphone_core_stop_dtmf (linphone_gtk_get_core());
1305 }
1306
1307 static void linphone_gtk_connect_digits(void){
1308         GtkContainer *cont=GTK_CONTAINER(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"dtmf_table"));
1309         GList *children=gtk_container_get_children(cont);
1310         GList *elem;
1311         for(elem=children;elem!=NULL;elem=elem->next){
1312                 GtkButton *button=GTK_BUTTON(elem->data);
1313                 g_signal_connect(G_OBJECT(button),"pressed",(GCallback)linphone_gtk_dtmf_pressed,NULL);
1314                 g_signal_connect(G_OBJECT(button),"released",(GCallback)linphone_gtk_dtmf_released,NULL);
1315         }
1316 }
1317
1318 static void linphone_gtk_check_menu_items(void){
1319         bool_t video_enabled=linphone_core_video_enabled(linphone_gtk_get_core());
1320         bool_t selfview=linphone_gtk_get_ui_config_int("videoselfview",VIDEOSELFVIEW_DEFAULT);
1321         GtkWidget *selfview_item=linphone_gtk_get_widget(
1322                                         linphone_gtk_get_main_window(),"selfview_item");
1323         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(linphone_gtk_get_widget(
1324                                         linphone_gtk_get_main_window(),"enable_video_item")), video_enabled);
1325         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(selfview_item),selfview);
1326         gtk_widget_set_sensitive(selfview_item,video_enabled);
1327 }
1328
1329 static gboolean linphone_gtk_can_manage_accounts(){
1330         LinphoneCore *lc=linphone_gtk_get_core();
1331         const MSList *elem;
1332         for(elem=linphone_core_get_sip_setups(lc);elem!=NULL;elem=elem->next){
1333                 SipSetup *ss=(SipSetup*)elem->data;
1334                 if (sip_setup_get_capabilities(ss) & SIP_SETUP_CAP_ACCOUNT_MANAGER){
1335                         return TRUE;
1336                 }
1337         }
1338         return FALSE;
1339 }
1340
1341 static void linphone_gtk_configure_main_window(){
1342         static gboolean config_loaded=FALSE;
1343         static const char *title;
1344         static const char *home;
1345         static const char *start_call_icon;
1346         static const char *add_call_icon;
1347         static const char *stop_call_icon;
1348         static const char *search_icon;
1349         static gboolean update_check_menu;
1350         static gboolean buttons_have_borders;
1351         static gboolean show_abcd;
1352         GtkWidget *w=linphone_gtk_get_main_window();
1353         if (!config_loaded){
1354                 title=linphone_gtk_get_ui_config("title","Linphone");
1355                 home=linphone_gtk_get_ui_config("home","http://www.linphone.org");
1356                 start_call_icon=linphone_gtk_get_ui_config("start_call_icon","startcall-green.png");
1357                 add_call_icon=linphone_gtk_get_ui_config("add_call_icon","addcall-green.png");
1358                 stop_call_icon=linphone_gtk_get_ui_config("stop_call_icon","stopcall-red.png");
1359                 search_icon=linphone_gtk_get_ui_config("directory_search_icon",NULL);
1360                 update_check_menu=linphone_gtk_get_ui_config_int("update_check_menu",0);
1361                 buttons_have_borders=linphone_gtk_get_ui_config_int("buttons_border",1);
1362                 show_abcd=linphone_gtk_get_ui_config_int("show_abcd",1);
1363                 config_loaded=TRUE;
1364         }
1365         linphone_gtk_configure_window(w,"main_window");
1366         if (title) {
1367                 gtk_window_set_title(GTK_WINDOW(w),title);
1368         }
1369         if (start_call_icon){
1370                 gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"start_call")),
1371                                     create_pixmap (start_call_icon));
1372                 if (!buttons_have_borders)
1373                         gtk_button_set_relief(GTK_BUTTON(linphone_gtk_get_widget(w,"start_call")),GTK_RELIEF_NONE);
1374         }
1375         if (add_call_icon){
1376                 gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"add_call")),
1377                                     create_pixmap (add_call_icon));
1378                 if (!buttons_have_borders)
1379                         gtk_button_set_relief(GTK_BUTTON(linphone_gtk_get_widget(w,"add_call")),GTK_RELIEF_NONE);
1380         }
1381         if (stop_call_icon){
1382                 gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"terminate_call")),
1383                                     create_pixmap (stop_call_icon));
1384                 if (!buttons_have_borders)
1385                         gtk_button_set_relief(GTK_BUTTON(linphone_gtk_get_widget(w,"terminate_call")),GTK_RELIEF_NONE);
1386         }
1387         if (search_icon){
1388                 GdkPixbuf *pbuf=create_pixbuf(search_icon);
1389                 gtk_image_set_from_pixbuf(GTK_IMAGE(linphone_gtk_get_widget(w,"directory_search_button_icon")),pbuf);
1390                 g_object_unref(G_OBJECT(pbuf));
1391         }
1392         if (home){
1393                 gchar *tmp;
1394                 GtkWidget *menu_item=linphone_gtk_get_widget(w,"home_item");
1395                 tmp=g_strdup(home);
1396                 g_object_set_data(G_OBJECT(menu_item),"home",tmp);
1397         }
1398         {
1399                 /*
1400                 GdkPixbuf *pbuf=create_pixbuf("contact-orange.png");
1401                 if (pbuf) {
1402                         gtk_image_set_from_pixbuf(GTK_IMAGE(linphone_gtk_get_widget(w,"contact_tab_icon")),pbuf);
1403                         g_object_unref(G_OBJECT(pbuf));
1404                 }
1405                 */
1406         }
1407         {
1408                 GdkPixbuf *pbuf=create_pixbuf("dialer-orange.png");
1409                 if (pbuf) {
1410                         gtk_image_set_from_pixbuf(GTK_IMAGE(linphone_gtk_get_widget(w,"keypad_tab_icon")),pbuf);
1411                         g_object_unref(G_OBJECT(pbuf));
1412                 }
1413         }
1414         if (linphone_gtk_can_manage_accounts())
1415                 gtk_widget_show(linphone_gtk_get_widget(w,"assistant_item"));
1416         if (update_check_menu){
1417                 gtk_widget_show(linphone_gtk_get_widget(w,"versioncheck_item"));
1418         }
1419         if (!show_abcd){
1420                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_A"));
1421                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_B"));
1422                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_C"));
1423                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_D"));
1424                 gtk_table_resize(GTK_TABLE(linphone_gtk_get_widget(w,"dtmf_table")),4,3);
1425         }
1426 }
1427
1428 void linphone_gtk_manage_login(void){
1429         LinphoneCore *lc=linphone_gtk_get_core();
1430         LinphoneProxyConfig *cfg=NULL;
1431         linphone_core_get_default_proxy(lc,&cfg);
1432         if (cfg){
1433                 SipSetup *ss=linphone_proxy_config_get_sip_setup(cfg);
1434                 if (ss && (sip_setup_get_capabilities(ss) & SIP_SETUP_CAP_LOGIN)){
1435                         linphone_gtk_show_login_frame(cfg);
1436                 }
1437         }
1438 }
1439
1440
1441 gboolean linphone_gtk_close(GtkWidget *mw){
1442         /*shutdown calls if any*/
1443         LinphoneCore *lc=linphone_gtk_get_core();
1444         if (linphone_core_in_call(lc)){
1445                 linphone_core_terminate_all_calls(lc);
1446         }
1447         linphone_core_enable_video_preview(lc,FALSE);
1448 #ifdef __APPLE__ /*until with have a better option*/
1449         gtk_window_iconify(GTK_WINDOW(mw));
1450 #else
1451         gtk_widget_hide(mw);
1452 #endif
1453         return TRUE;
1454 }
1455
1456 #ifdef HAVE_GTK_OSX
1457 static gboolean on_window_state_event(GtkWidget *w, GdkEventWindowState *event){
1458         if ((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ||(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ){
1459                 linphone_core_enable_video_preview(linphone_gtk_get_core(),FALSE);
1460         }else{
1461                 linphone_core_enable_video_preview(linphone_gtk_get_core(),
1462                 linphone_gtk_get_ui_config_int("videoselfview",VIDEOSELFVIEW_DEFAULT) && linphone_core_video_enabled(linphone_gtk_get_core()));
1463         }
1464         return FALSE;
1465 }
1466 #endif
1467
1468
1469 static void linphone_gtk_init_main_window(){
1470         GtkWidget *main_window;
1471
1472         linphone_gtk_configure_main_window();
1473         linphone_gtk_manage_login();
1474         load_uri_history();
1475         linphone_gtk_load_identities();
1476         linphone_gtk_set_my_presence(linphone_core_get_presence_info(linphone_gtk_get_core()));
1477         linphone_gtk_show_friends();
1478         linphone_gtk_connect_digits();
1479         main_window=linphone_gtk_get_main_window();
1480         linphone_gtk_call_log_update(main_window);
1481
1482         linphone_gtk_update_call_buttons (NULL);
1483         /*prevent the main window from being destroyed by a user click on WM controls, instead we hide it*/
1484         g_signal_connect (G_OBJECT (main_window), "delete-event",
1485                 G_CALLBACK (linphone_gtk_close), main_window);
1486 #ifdef HAVE_GTK_OSX
1487         {
1488                 GtkWidget *menubar=linphone_gtk_get_widget(main_window,"menubar1");
1489                 GtkOSXApplication *theMacApp = (GtkOSXApplication*)g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
1490                 gtk_osxapplication_set_menu_bar(theMacApp,GTK_MENU_SHELL(menubar));
1491                 gtk_widget_hide(menubar);
1492                 gtk_osxapplication_ready(theMacApp);
1493         }
1494         g_signal_connect(G_OBJECT(main_window), "window-state-event",G_CALLBACK(on_window_state_event), NULL);
1495 #endif
1496         linphone_gtk_check_menu_items();
1497 }
1498
1499
1500 void linphone_gtk_log_handler(OrtpLogLevel lev, const char *fmt, va_list args){
1501         if (verbose){
1502                 const char *lname="undef";
1503                 char *msg;
1504 #if defined(__linux) || defined(__APPLE__)
1505                 va_list cap;/*copy of our argument list: a va_list cannot be re-used (SIGSEGV on linux 64 bits)*/
1506 #endif
1507                 switch(lev){
1508                         case ORTP_DEBUG:
1509                                 lname="debug";
1510                                 break;
1511                         case ORTP_MESSAGE:
1512                                 lname="message";
1513                                 break;
1514                         case ORTP_WARNING:
1515                                 lname="warning";
1516                                 break;
1517                         case ORTP_ERROR:
1518                                 lname="error";
1519                                 break;
1520                         case ORTP_FATAL:
1521                                 lname="fatal";
1522                                 break;
1523                         default:
1524                                 g_error("Bad level !");
1525                 }
1526 #if defined(__linux) || defined(__APPLE__)
1527                 va_copy(cap,args);
1528                 msg=g_strdup_vprintf(fmt,cap);
1529                 va_end(cap);
1530 #else
1531                 msg=g_strdup_vprintf(fmt,args);
1532 #endif
1533                 fprintf(stdout,"linphone-%s : %s\n",lname,msg);
1534                 ortp_free(msg);
1535         }
1536         linphone_gtk_log_push(lev,fmt,args);
1537 }
1538
1539
1540 void linphone_gtk_refer_received(LinphoneCore *lc, const char *refer_to){
1541         GtkEntry * uri_bar =GTK_ENTRY(linphone_gtk_get_widget(
1542                 linphone_gtk_get_main_window(), "uribar"));
1543         char *text;
1544         linphone_gtk_notify(NULL,(text=ms_strdup_printf(_("We are transferred to %s"),refer_to)));
1545         g_free(text);
1546         gtk_entry_set_text(uri_bar, refer_to);
1547         linphone_gtk_start_call(linphone_gtk_get_main_window());
1548 }
1549
1550 static void linphone_gtk_check_soundcards(){
1551         const char **devices=linphone_core_get_sound_devices(linphone_gtk_get_core());
1552         if (devices==NULL || devices[0]==NULL){
1553                 linphone_gtk_display_something(GTK_MESSAGE_WARNING,
1554                         _("No sound cards have been detected on this computer.\n"
1555                                 "You won't be able to send or receive audio calls."));
1556         }
1557 }
1558
1559 static void linphone_gtk_quit(void){
1560         linphone_gtk_uninit_instance();
1561         linphone_gtk_destroy_log_window();
1562         linphone_core_destroy(the_core);
1563         linphone_gtk_log_uninit();
1564 #ifdef HAVE_NOTIFY
1565         notify_uninit();
1566 #endif
1567         gdk_threads_leave();
1568 }
1569
1570 #ifdef HAVE_GTK_OSX
1571 /*
1572 This is not the correct way to implement block termination.
1573 The good way would be to call gtk_main_quit(), and return TRUE.
1574 Unfortunately this does not work, because if we return TRUE the NSApplication sometimes calls the CFRunLoop recursively, which prevents gtk_main() to exit.
1575 As a result the program cannot exit at all.
1576 As a workaround we do all the cleanup (unregistration and config save) within the handler.
1577 */
1578 static gboolean on_block_termination(void){
1579         gtk_main_quit();
1580         linphone_gtk_quit();
1581         return FALSE;
1582 }
1583 #endif
1584
1585 int main(int argc, char *argv[]){
1586 #ifdef ENABLE_NLS
1587         void *p;
1588 #endif
1589         const char *config_file;
1590         const char *factory_config_file;
1591         const char *lang;
1592         GtkSettings *settings;
1593         GdkPixbuf *pbuf;
1594         const char *app_name="Linphone";
1595
1596         g_thread_init(NULL);
1597         gdk_threads_init();
1598
1599         progpath = strdup(argv[0]);
1600
1601         config_file=linphone_gtk_get_config_file();
1602
1603
1604 #ifdef WIN32
1605         /*workaround for windows: sometimes LANG is defined to an integer value, not understood by gtk */
1606         if ((lang=getenv("LANG"))!=NULL){
1607                 if (atoi(lang)!=0){
1608                         char tmp[128];
1609                         snprintf(tmp,sizeof(tmp),"LANG=",lang);
1610                         _putenv(tmp);
1611                 }
1612         }
1613 #else
1614         /*for pulseaudio:*/
1615         g_setenv("PULSE_PROP_media.role", "phone", TRUE);
1616 #endif
1617
1618         if ((lang=linphone_gtk_get_lang(config_file))!=NULL && lang[0]!='\0'){
1619 #ifdef WIN32
1620                 char tmp[128];
1621                 snprintf(tmp,sizeof(tmp),"LANG=%s",lang);
1622                 _putenv(tmp);
1623 #else
1624                 setenv("LANG",lang,1);
1625 #endif
1626         }
1627
1628 #ifdef ENABLE_NLS
1629         p=bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
1630         if (p==NULL) perror("bindtextdomain failed");
1631         bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1632         textdomain (GETTEXT_PACKAGE);
1633 #else
1634         g_message("NLS disabled.\n");
1635 #endif
1636 #ifdef WIN32
1637         gtk_rc_add_default_file("./gtkrc");
1638 #endif
1639         gdk_threads_enter();
1640
1641         if (!gtk_init_with_args(&argc,&argv,_("A free SIP video-phone"),
1642                                 linphone_options,NULL,NULL)){
1643                 gdk_threads_leave();
1644                 return -1;
1645         }
1646
1647         settings=gtk_settings_get_default();
1648         g_type_class_unref (g_type_class_ref (GTK_TYPE_IMAGE_MENU_ITEM));
1649         g_type_class_unref (g_type_class_ref (GTK_TYPE_BUTTON));
1650         g_object_set(settings, "gtk-menu-images", TRUE, NULL);
1651         g_object_set(settings, "gtk-button-images", TRUE, NULL);
1652
1653         if (workingdir!=NULL){
1654                 if (chdir(workingdir)==-1){
1655                         g_error("Could not change directory to %s : %s",workingdir,strerror(errno));
1656                 }
1657         }
1658
1659         /* Now, look for the factory configuration file, we do it this late
1660                  since we want to have had time to change directory and to parse
1661                  the options, in case we needed to access the working directory */
1662         factory_config_file = linphone_gtk_get_factory_config_file();
1663
1664         if (linphone_gtk_init_instance(app_name, addr_to_call) == FALSE){
1665                 g_warning("Another running instance of linphone has been detected. It has been woken-up.");
1666                 g_warning("This instance is going to exit now.");
1667                 gdk_threads_leave();
1668                 return 0;
1669         }
1670
1671         add_pixmap_directory("pixmaps");
1672         add_pixmap_directory(PACKAGE_DATA_DIR "/pixmaps/linphone");
1673
1674 #ifdef HAVE_GTK_OSX
1675         GtkOSXApplication *theMacApp = (GtkOSXApplication*)g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
1676         g_signal_connect(G_OBJECT(theMacApp),"NSApplicationDidBecomeActive",(GCallback)linphone_gtk_show_main_window,NULL);
1677         g_signal_connect(G_OBJECT(theMacApp),"NSApplicationWillTerminate",(GCallback)gtk_main_quit,NULL);
1678         /*never block termination:*/
1679         g_signal_connect(G_OBJECT(theMacApp),"NSApplicationBlockTermination",(GCallback)on_block_termination,NULL);
1680 #endif
1681
1682         the_ui=linphone_gtk_create_window("main");
1683
1684         linphone_gtk_create_log_window();
1685         linphone_core_enable_logs_with_cb(linphone_gtk_log_handler);
1686
1687         linphone_gtk_init_liblinphone(config_file, factory_config_file);
1688
1689         g_set_application_name(app_name);
1690         pbuf=create_pixbuf(linphone_gtk_get_ui_config("icon",LINPHONE_ICON));
1691         if (pbuf!=NULL) gtk_window_set_default_icon(pbuf);
1692
1693         /* do not lower timeouts under 30 ms because it exhibits a bug on gtk+/win32, with cpu running 20% all the time...*/
1694         gtk_timeout_add(30,(GtkFunction)linphone_gtk_iterate,(gpointer)linphone_gtk_get_core());
1695         gtk_timeout_add(30,(GtkFunction)linphone_gtk_check_logs,(gpointer)NULL);
1696         linphone_gtk_init_main_window();
1697 #ifndef HAVE_GTK_OSX
1698         linphone_gtk_init_status_icon();
1699 #endif
1700         if (!iconified){
1701                 linphone_gtk_show_main_window();
1702                 linphone_gtk_check_soundcards();
1703         }
1704         if (linphone_gtk_get_ui_config_int("update_check_menu",0)==0)
1705                 linphone_gtk_check_for_new_version();
1706
1707         gtk_main();
1708         linphone_gtk_quit();
1709 #ifndef HAVE_GTK_OSX
1710         /*workaround a bug on win32 that makes status icon still present in the systray even after program exit.*/
1711         gtk_status_icon_set_visible(icon,FALSE);
1712 #endif
1713         free(progpath);
1714         return 0;
1715 }
1716