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();
 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         LinphoneCall *call=linphone_gtk_get_currently_displayed_call ();
 741         if (call)
 742                 linphone_core_terminate_call(linphone_gtk_get_core(),call);
 743 }
 744
 745 void linphone_gtk_decline_clicked(GtkWidget *button){
 746         LinphoneCall *call=linphone_gtk_get_currently_displayed_call ();
 747         if (call)
 748                 linphone_core_terminate_call(linphone_gtk_get_core(),call);
 749 }
 750
 751 void linphone_gtk_answer_clicked(GtkWidget *button){
 752         LinphoneCall *call=linphone_gtk_get_currently_displayed_call ();
 753         if (call){
 754                 linphone_core_pause_all_calls(linphone_gtk_get_core());
 755                 linphone_core_accept_call(linphone_gtk_get_core(),call);
 756                 linphone_gtk_show_main_window(); /* useful when the button is clicked on a notification */
 757         }
 758 }
 759
 760 void linphone_gtk_enable_video(GtkWidget *w){
 761         gboolean val=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w));
 762         GtkWidget *selfview_item=linphone_gtk_get_widget(linphone_gtk_get_main_window(),"selfview_item");
 763         linphone_core_enable_video(linphone_gtk_get_core(),val,val);
 764         gtk_widget_set_sensitive(selfview_item,val);
 765         if (val){
 766                 linphone_core_enable_video_preview(linphone_gtk_get_core(),
 767                 linphone_gtk_get_ui_config_int("videoselfview",VIDEOSELFVIEW_DEFAULT));
 768         }else{
 769                 linphone_core_enable_video_preview(linphone_gtk_get_core(),FALSE);
 770         }
 771 }
 772
 773 void linphone_gtk_enable_self_view(GtkWidget *w){
 774         gboolean val=gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w));
 775         LinphoneCore *lc=linphone_gtk_get_core();
 776         linphone_core_enable_video_preview(lc,val);
 777         linphone_core_enable_self_view(lc,val);
 778         linphone_gtk_set_ui_config_int("videoselfview",val);
 779 }
 780
 781 void linphone_gtk_used_identity_changed(GtkWidget *w){
 782         int active=gtk_combo_box_get_active(GTK_COMBO_BOX(w));
 783         char *sel=gtk_combo_box_get_active_text(GTK_COMBO_BOX(w));
 784         if (sel && strlen(sel)>0){ //avoid a dummy "changed" at gui startup
 785                 linphone_core_set_default_proxy_index(linphone_gtk_get_core(),(active==0) ? -1 : (active-1));
 786                 linphone_gtk_show_directory_search();
 787         }
 788         if (sel) g_free(sel);
 789 }
 790
 791 static void linphone_gtk_notify_recv(LinphoneCore *lc, LinphoneFriend * fid){
 792         linphone_gtk_show_friends();
 793 }
 794
 795 static void linphone_gtk_new_subscriber_response(GtkWidget *dialog, guint response_id, LinphoneFriend *lf){
 796         switch(response_id){
 797                 case GTK_RESPONSE_YES:
 798                         linphone_gtk_show_contact(lf);
 799                 break;
 800                 default:
 801                         linphone_core_reject_subscriber(linphone_gtk_get_core(),lf);
 802         }
 803         gtk_widget_destroy(dialog);
 804 }
 805
 806 static void linphone_gtk_new_unknown_subscriber(LinphoneCore *lc, LinphoneFriend *lf, const char *url){
 807         GtkWidget *dialog;
 808
 809         if (linphone_gtk_get_ui_config_int("subscribe_deny_all",0)){
 810                 linphone_core_reject_subscriber(linphone_gtk_get_core(),lf);
 811                 return;
 812         }
 813
 814         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);
 815         dialog = gtk_message_dialog_new (
 816                                 GTK_WINDOW(linphone_gtk_get_main_window()),
 817                                 GTK_DIALOG_DESTROY_WITH_PARENT,
 818                                 GTK_MESSAGE_QUESTION,
 819                                 GTK_BUTTONS_YES_NO,
 820                                 "%s",
 821                                 message);
 822         g_free(message);
 823         g_signal_connect(G_OBJECT (dialog), "response",
 824                 G_CALLBACK (linphone_gtk_new_subscriber_response),lf);
 825         /* actually show the box */
 826         gtk_widget_show(dialog);
 827 }
 828
 829 typedef struct _AuthTimeout{
 830         GtkWidget *w;
 831 } AuthTimeout;
 832
 833
 834 static void auth_timeout_clean(AuthTimeout *tout){
 835         tout->w=NULL;
 836 }
 837
 838 static gboolean auth_timeout_destroy(AuthTimeout *tout){
 839         if (tout->w)  {
 840                 g_object_weak_unref(G_OBJECT(tout->w),(GWeakNotify)auth_timeout_clean,tout);
 841                 gtk_widget_destroy(tout->w);
 842         }
 843         g_free(tout);
 844         return FALSE;
 845 }
 846
 847 static AuthTimeout * auth_timeout_new(GtkWidget *w){
 848         AuthTimeout *tout=g_new(AuthTimeout,1);
 849         tout->w=w;
 850         /*so that the timeout no more references the widget when it is destroyed:*/
 851         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)auth_timeout_clean,tout);
 852         /*so that the widget is automatically destroyed after some time */
 853         g_timeout_add(30000,(GtkFunction)auth_timeout_destroy,tout);
 854         return tout;
 855 }
 856
 857 void linphone_gtk_password_cancel(GtkWidget *w){
 858         LinphoneAuthInfo *info;
 859         GtkWidget *window=gtk_widget_get_toplevel(w);
 860         info=(LinphoneAuthInfo*)g_object_get_data(G_OBJECT(window),"auth_info");
 861         linphone_core_abort_authentication(linphone_gtk_get_core(),info);
 862         gtk_widget_destroy(window);
 863 }
 864
 865 void linphone_gtk_password_ok(GtkWidget *w){
 866         GtkWidget *entry;
 867         GtkWidget *window=gtk_widget_get_toplevel(w);
 868         LinphoneAuthInfo *info;
 869         info=(LinphoneAuthInfo*)g_object_get_data(G_OBJECT(window),"auth_info");
 870         g_object_weak_unref(G_OBJECT(window),(GWeakNotify)linphone_auth_info_destroy,info);
 871         entry=linphone_gtk_get_widget(window,"password_entry");
 872         linphone_auth_info_set_passwd(info,gtk_entry_get_text(GTK_ENTRY(entry)));
 873         linphone_auth_info_set_userid(info,
 874                 gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(window,"userid_entry"))));
 875         linphone_core_add_auth_info(linphone_gtk_get_core(),info);
 876         gtk_widget_destroy(window);
 877 }
 878
 879 static void linphone_gtk_auth_info_requested(LinphoneCore *lc, const char *realm, const char *username){
 880         GtkWidget *w=linphone_gtk_create_window("password");
 881         GtkWidget *label=linphone_gtk_get_widget(w,"message");
 882         LinphoneAuthInfo *info;
 883         gchar *msg;
 884         GtkWidget *mw=linphone_gtk_get_main_window();
 885
 886         if (mw && GTK_WIDGET_VISIBLE(linphone_gtk_get_widget(mw,"login_frame"))){
 887                 /*don't prompt for authentication when login frame is visible*/
 888                 linphone_core_abort_authentication(lc,NULL);
 889                 return;
 890         }
 891
 892         msg=g_strdup_printf(_("Please enter your password for username <i>%s</i>\n at domain <i>%s</i>:"),
 893                 username,realm);
 894         gtk_label_set_markup(GTK_LABEL(label),msg);
 895         g_free(msg);
 896         gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(w,"userid_entry")),username);
 897         info=linphone_auth_info_new(username, NULL, NULL, NULL,realm);
 898         g_object_set_data(G_OBJECT(w),"auth_info",info);
 899         g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_auth_info_destroy,info);
 900         gtk_widget_show(w);
 901         auth_timeout_new(w);
 902 }
 903
 904 static void linphone_gtk_display_status(LinphoneCore *lc, const char *status){
 905         GtkWidget *w=linphone_gtk_get_main_window();
 906         GtkWidget *status_bar=linphone_gtk_get_widget(w,"status_bar");
 907         gtk_statusbar_push(GTK_STATUSBAR(status_bar),
 908                         gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar),""),
 909                         status);
 910 }
 911
 912 static void linphone_gtk_display_message(LinphoneCore *lc, const char *msg){
 913         linphone_gtk_display_something(GTK_MESSAGE_INFO,msg);
 914 }
 915
 916 static void linphone_gtk_display_warning(LinphoneCore *lc, const char *warning){
 917         linphone_gtk_display_something(GTK_MESSAGE_WARNING,warning);
 918 }
 919
 920 static void linphone_gtk_display_url(LinphoneCore *lc, const char *msg, const char *url){
 921         char richtext[4096];
 922         snprintf(richtext,sizeof(richtext),"%s %s",msg,url);
 923         linphone_gtk_display_something(GTK_MESSAGE_INFO,richtext);
 924 }
 925
 926 static void linphone_gtk_call_log_updated(LinphoneCore *lc, LinphoneCallLog *cl){
 927         GtkWidget *w=(GtkWidget*)g_object_get_data(G_OBJECT(linphone_gtk_get_main_window()),"call_logs");
 928         if (w) linphone_gtk_call_log_update(w);
 929         linphone_gtk_call_log_update(linphone_gtk_get_main_window());
 930 }
 931
 932 #ifdef HAVE_NOTIFY
 933 static bool_t notify_actions_supported() {
 934         bool_t accepts_actions = FALSE;
 935         GList *capabilities = notify_get_server_caps();
 936         GList *c;
 937         if(capabilities != NULL) {
 938                 for(c = capabilities; c != NULL; c = c->next) {
 939                         if(strcmp((char*)c->data, "actions") == 0 ) {
 940                                 accepts_actions = TRUE;
 941                                 break;
 942                         }
 943                 }
 944                 g_list_foreach(capabilities, (GFunc)g_free, NULL);
 945                 g_list_free(capabilities);
 946         }
 947         return accepts_actions;
 948 }
 949
 950 static NotifyNotification* build_notification(const char *title, const char *body){
 951          return notify_notification_new(title,body,linphone_gtk_get_ui_config("icon",LINPHONE_ICON)
 952 #ifdef HAVE_NOTIFY1
 953         ,NULL
 954 #endif
 955         );
 956 }
 957
 958 static void show_notification(NotifyNotification* n){
 959         if (n && !notify_notification_show(n,NULL))
 960                 ms_error("Failed to send notification.");
 961 }
 962
 963 static void make_notification(const char *title, const char *body){
 964         show_notification(build_notification(title,body));
 965 }
 966
 967 #endif
 968
 969 static void linphone_gtk_notify(LinphoneCall *call, const char *msg){
 970 #ifdef HAVE_NOTIFY
 971         if (!notify_is_initted())
 972                 if (!notify_init ("Linphone")) ms_error("Libnotify failed to init.");
 973 #endif
 974         if (!call) {
 975 #ifdef HAVE_NOTIFY
 976                 if (!notify_notification_show(notify_notification_new("Linphone",msg,NULL
 977 #ifdef HAVE_NOTIFY1
 978         ,NULL
 979 #endif
 980 ),NULL))
 981                                 ms_error("Failed to send notification.");
 982 #else
 983                 linphone_gtk_show_main_window();
 984 #endif
 985         } else if (!gtk_window_is_active((GtkWindow*)linphone_gtk_get_main_window())) {
 986 #ifdef HAVE_NOTIFY
 987                 char *body=NULL;
 988                 char *remote=call!=NULL ? linphone_call_get_remote_address_as_string(call) : NULL;
 989                 NotifyNotification *n;
 990                 switch(linphone_call_get_state(call)){
 991                         case LinphoneCallError:
 992                                 make_notification(_("Call error"),body=g_markup_printf_escaped("<span size=\"large\">%s</span>\n%s",msg,remote));
 993                         break;
 994                         case LinphoneCallEnd:
 995                                 make_notification(_("Call ended"),body=g_markup_printf_escaped("<span size=\"large\">%s</span>",remote));
 996                         break;
 997                         case LinphoneCallIncomingReceived:
 998                                 n=build_notification(_("Incoming call"),body=g_markup_printf_escaped("<span size=\"large\">%s</span>",remote));
 999                                 if (notify_actions_supported()) {
1000                                         notify_notification_add_action (n,"answer", _("Answer"),
1001                                                 NOTIFY_ACTION_CALLBACK(linphone_gtk_answer_clicked),NULL,NULL);
1002                                         notify_notification_add_action (n,"decline",_("Decline"),
1003                                                 NOTIFY_ACTION_CALLBACK(linphone_gtk_decline_clicked),NULL,NULL);
1004                                 }
1005                                 show_notification(n);
1006                         break;
1007                         case LinphoneCallPausedByRemote:
1008                                 make_notification(_("Call paused"),body=g_markup_printf_escaped(_("<span size=\"large\">by %s</span>"),remote));
1009                         break;
1010                         default:
1011                         break;
1012                 }
1013                 if (body) g_free(body);
1014                 if (remote) g_free(remote);
1015 #endif
1016         }
1017 }
1018
1019 static void linphone_gtk_call_state_changed(LinphoneCore *lc, LinphoneCall *call, LinphoneCallState cs, const char *msg){
1020         switch(cs){
1021                 case LinphoneCallOutgoingInit:
1022                         linphone_gtk_create_in_call_view (call);
1023                 break;
1024                 case LinphoneCallOutgoingProgress:
1025                         linphone_gtk_in_call_view_set_calling (call);
1026                 break;
1027                 case LinphoneCallStreamsRunning:
1028                         linphone_gtk_in_call_view_set_in_call(call);
1029                 break;
1030                 case LinphoneCallError:
1031                         linphone_gtk_in_call_view_terminate (call,msg);
1032                 break;
1033                 case LinphoneCallEnd:
1034                         linphone_gtk_in_call_view_terminate(call,NULL);
1035                         linphone_gtk_status_icon_set_blinking(FALSE);
1036                 break;
1037                 case LinphoneCallIncomingReceived:
1038                         linphone_gtk_create_in_call_view (call);
1039                         linphone_gtk_in_call_view_set_incoming(call);
1040                         linphone_gtk_status_icon_set_blinking(TRUE);
1041                         if (auto_answer)  {
1042                                 linphone_call_ref(call);
1043                                 g_timeout_add(2000,(GSourceFunc)linphone_gtk_auto_answer ,call);
1044                         }
1045                 break;
1046                 case LinphoneCallResuming:
1047                         linphone_gtk_enable_hold_button(call,TRUE,TRUE);
1048                         linphone_gtk_in_call_view_set_in_call (call);
1049                 break;
1050                 case LinphoneCallPausing:
1051                         linphone_gtk_enable_hold_button(call,TRUE,FALSE);
1052                 case LinphoneCallPausedByRemote:
1053                         linphone_gtk_in_call_view_set_paused(call);
1054                 break;
1055                 case LinphoneCallConnected:
1056                         linphone_gtk_enable_hold_button (call,TRUE,TRUE);
1057                         linphone_gtk_status_icon_set_blinking(FALSE);
1058                 break;
1059                 default:
1060                 break;
1061         }
1062         linphone_gtk_notify(call, msg);
1063         linphone_gtk_update_call_buttons (call);
1064 }
1065
1066 static void update_registration_status(LinphoneProxyConfig *cfg, LinphoneRegistrationState rs){
1067         GtkComboBox *box=GTK_COMBO_BOX(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"identities"));
1068         GtkTreeModel *model=gtk_combo_box_get_model(box);
1069         GtkTreeIter iter;
1070         gboolean found=FALSE;
1071         const char *stock_id=NULL;
1072
1073         if (gtk_tree_model_get_iter_first(model,&iter)){
1074                 gpointer p;
1075                 do{
1076                         gtk_tree_model_get(model,&iter,2,&p,-1);
1077                         if (p==cfg) {
1078                                 found=TRUE;
1079                                 break;
1080                         }
1081                 }while(gtk_tree_model_iter_next(model,&iter));
1082         }
1083         if (!found) {
1084                 g_warning("Could not find proxy config in combo box of identities.");
1085                 return;
1086         }
1087         switch (rs){
1088                 case LinphoneRegistrationOk:
1089                         stock_id=GTK_STOCK_YES;
1090                 break;
1091                 case LinphoneRegistrationProgress:
1092                         stock_id=GTK_STOCK_REFRESH;
1093                 break;
1094                 case LinphoneRegistrationCleared:
1095                         stock_id=NULL;
1096                 break;
1097                 case LinphoneRegistrationFailed:
1098                         stock_id=GTK_STOCK_DIALOG_WARNING;
1099                 break;
1100                 default:
1101                 break;
1102         }
1103         gtk_list_store_set(GTK_LIST_STORE(model),&iter,1,stock_id,-1);
1104 }
1105
1106 static void linphone_gtk_registration_state_changed(LinphoneCore *lc, LinphoneProxyConfig *cfg,
1107                                                     LinphoneRegistrationState rs, const char *msg){
1108         switch (rs){
1109                 case LinphoneRegistrationOk:
1110                         if (cfg){
1111                                 SipSetup *ss=linphone_proxy_config_get_sip_setup(cfg);
1112                                 if (ss && (sip_setup_get_capabilities(ss) & SIP_SETUP_CAP_LOGIN)){
1113                                         linphone_gtk_exit_login_frame();
1114                                 }
1115                         }
1116                 break;
1117                 default:
1118                 break;
1119         }
1120         update_registration_status(cfg,rs);
1121 }
1122
1123
1124 static void icon_popup_menu(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data){
1125         GtkWidget *menu=(GtkWidget*)g_object_get_data(G_OBJECT(status_icon),"menu");
1126         gtk_menu_popup(GTK_MENU(menu),NULL,NULL,gtk_status_icon_position_menu,status_icon,button,activate_time);
1127 }
1128
1129 void linphone_gtk_open_browser(const char *url){
1130         /*in gtk 2.16, gtk_show_uri does not work...*/
1131 #ifndef WIN32
1132 #if GTK_CHECK_VERSION(2,18,3)
1133         gtk_show_uri(NULL,url,GDK_CURRENT_TIME,NULL);
1134 #else
1135         char cl[255];
1136         snprintf(cl,sizeof(cl),"/usr/bin/x-www-browser %s",url);
1137         g_spawn_command_line_async(cl,NULL);
1138 #endif
1139 #else /*WIN32*/
1140         ShellExecute(0,"open",url,NULL,NULL,1);
1141 #endif
1142 }
1143
1144 void linphone_gtk_link_to_website(GtkWidget *item){
1145         const gchar *home=(const gchar*)g_object_get_data(G_OBJECT(item),"home");
1146         linphone_gtk_open_browser(home);
1147 }
1148
1149 static GtkWidget *create_icon_menu(){
1150         GtkWidget *menu=gtk_menu_new();
1151         GtkWidget *menu_item;
1152         GtkWidget *image;
1153         gchar *tmp;
1154         const gchar *homesite;
1155
1156         homesite=linphone_gtk_get_ui_config("home","http://www.linphone.org");
1157         menu_item=gtk_image_menu_item_new_with_label(_("Website link"));
1158         tmp=g_strdup(homesite);
1159         g_object_set_data(G_OBJECT(menu_item),"home",tmp);
1160         g_object_weak_ref(G_OBJECT(menu_item),(GWeakNotify)g_free,tmp);
1161
1162         image=gtk_image_new_from_stock(GTK_STOCK_HELP,GTK_ICON_SIZE_MENU);
1163         gtk_widget_show(image);
1164         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image);
1165         //g_object_unref(G_OBJECT(image));
1166         gtk_widget_show(menu_item);
1167         gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
1168         g_signal_connect(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_link_to_website,NULL);
1169
1170         menu_item=gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
1171         gtk_widget_show(menu_item);
1172         gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
1173         g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_show_about,NULL);
1174         menu_item=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,NULL);
1175         gtk_widget_show(menu_item);
1176         gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
1177         g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)gtk_main_quit,NULL);
1178         gtk_widget_show(menu);
1179         return menu;
1180 }
1181
1182 static GtkStatusIcon *icon=NULL;
1183
1184 static void handle_icon_click() {
1185         GtkWidget *mw=linphone_gtk_get_main_window();
1186         if (!gtk_window_is_active((GtkWindow*)mw)) {
1187                 linphone_gtk_show_main_window();
1188         } else {
1189                 gtk_widget_hide(mw);
1190         }
1191 }
1192
1193 static void linphone_gtk_init_status_icon(){
1194         const char *icon_path=linphone_gtk_get_ui_config("icon",LINPHONE_ICON);
1195         const char *call_icon_path=linphone_gtk_get_ui_config("start_call_icon","startcall-green.png");
1196         GdkPixbuf *pbuf=create_pixbuf(icon_path);
1197         GtkWidget *menu=create_icon_menu();
1198         const char *title;
1199         title=linphone_gtk_get_ui_config("title",_("Linphone - a video internet phone"));
1200         icon=gtk_status_icon_new_from_pixbuf(pbuf);
1201         gtk_status_icon_set_name(icon,title);
1202         g_signal_connect_swapped(G_OBJECT(icon),"activate",(GCallback)handle_icon_click,NULL);
1203         g_signal_connect(G_OBJECT(icon),"popup-menu",(GCallback)icon_popup_menu,NULL);
1204         gtk_status_icon_set_tooltip(icon,title);
1205         gtk_status_icon_set_visible(icon,TRUE);
1206         g_object_set_data(G_OBJECT(icon),"menu",menu);
1207         g_object_weak_ref(G_OBJECT(icon),(GWeakNotify)gtk_widget_destroy,menu);
1208         g_object_set_data(G_OBJECT(icon),"icon",pbuf);
1209         g_object_weak_ref(G_OBJECT(icon),(GWeakNotify)g_object_unref,pbuf);
1210         pbuf=create_pixbuf(call_icon_path);
1211         g_object_set_data(G_OBJECT(icon),"call_icon",pbuf);
1212 }
1213
1214 static gboolean do_icon_blink(GtkStatusIcon *gi){
1215         GdkPixbuf *call_icon=g_object_get_data(G_OBJECT(gi),"call_icon");
1216         GdkPixbuf *normal_icon=g_object_get_data(G_OBJECT(gi),"icon");
1217         GdkPixbuf *cur_icon=gtk_status_icon_get_pixbuf(gi);
1218         if (cur_icon==call_icon){
1219                 gtk_status_icon_set_from_pixbuf(gi,normal_icon);
1220         }else{
1221                 gtk_status_icon_set_from_pixbuf(gi,call_icon);
1222         }
1223         return TRUE;
1224 }
1225
1226 static void linphone_gtk_status_icon_set_blinking(gboolean val){
1227         guint tout;
1228         tout=(unsigned)GPOINTER_TO_INT(g_object_get_data(G_OBJECT(icon),"timeout"));
1229         if (val && tout==0){
1230                 tout=g_timeout_add(500,(GSourceFunc)do_icon_blink,icon);
1231                 g_object_set_data(G_OBJECT(icon),"timeout",GINT_TO_POINTER(tout));
1232         }else if (!val && tout!=0){
1233                 GdkPixbuf *normal_icon=g_object_get_data(G_OBJECT(icon),"icon");
1234                 g_source_remove(tout);
1235                 g_object_set_data(G_OBJECT(icon),"timeout",NULL);
1236                 gtk_status_icon_set_from_pixbuf(icon,normal_icon);
1237         }
1238 }
1239
1240 static void init_identity_combo(GtkComboBox *box){
1241         GtkListStore *store;
1242         GtkCellRenderer *r1,*r2;
1243         store=gtk_list_store_new(3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER);
1244         gtk_cell_layout_clear(GTK_CELL_LAYOUT(box));
1245         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(box),(r1=gtk_cell_renderer_text_new()),TRUE);
1246         gtk_cell_layout_pack_end(GTK_CELL_LAYOUT(box),(r2=gtk_cell_renderer_pixbuf_new()),FALSE);
1247         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(box),r1,"text",0);
1248         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(box),r2,"stock-id",1);
1249         g_object_set(G_OBJECT(r1),"ellipsize",PANGO_ELLIPSIZE_END,NULL);
1250         gtk_combo_box_set_model(box,GTK_TREE_MODEL(store));
1251 }
1252
1253 void linphone_gtk_load_identities(void){
1254         const MSList *elem;
1255         GtkComboBox *box=GTK_COMBO_BOX(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"identities"));
1256         char *def_identity;
1257         LinphoneProxyConfig *def=NULL;
1258         int def_index=0,i;
1259         GtkListStore *store;
1260         GtkTreeIter iter;
1261
1262         store=GTK_LIST_STORE(gtk_combo_box_get_model(box));
1263         if (gtk_tree_model_get_n_columns(GTK_TREE_MODEL(store))==1){
1264                 /* model is empty, this is the first time we go here */
1265                 init_identity_combo(box);
1266                 store=GTK_LIST_STORE(gtk_combo_box_get_model(box));
1267         }
1268         gtk_list_store_clear(store);
1269         linphone_core_get_default_proxy(linphone_gtk_get_core(),&def);
1270         def_identity=g_strdup_printf(_("%s (Default)"),linphone_core_get_primary_contact(linphone_gtk_get_core()));
1271         gtk_list_store_append(store,&iter);
1272         gtk_list_store_set(store,&iter,0,def_identity,1,NULL,2,NULL,-1);
1273         g_free(def_identity);
1274         for(i=1,elem=linphone_core_get_proxy_config_list(linphone_gtk_get_core());
1275                         elem!=NULL;
1276                         elem=ms_list_next(elem),i++){
1277                 LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)elem->data;
1278                 gtk_list_store_append(store,&iter);
1279                 gtk_list_store_set(store,&iter,0,linphone_proxy_config_get_identity(cfg),1,
1280                                    linphone_proxy_config_is_registered(cfg) ? GTK_STOCK_YES : NULL,
1281                                    2,cfg,-1);
1282                 if (cfg==def) {
1283                         def_index=i;
1284                 }
1285         }
1286         gtk_combo_box_set_active(box,def_index);
1287 }
1288
1289 static void linphone_gtk_dtmf_pressed(GtkButton *button){
1290         const char *label=gtk_button_get_label(button);
1291         GtkWidget *uri_bar=linphone_gtk_get_widget(gtk_widget_get_toplevel(GTK_WIDGET(button)),"uribar");
1292         int pos=-1;
1293         gtk_editable_insert_text(GTK_EDITABLE(uri_bar),label,1,&pos);
1294         linphone_core_play_dtmf (linphone_gtk_get_core(),label[0],-1);
1295         if (linphone_core_in_call(linphone_gtk_get_core())){
1296                 linphone_core_send_dtmf(linphone_gtk_get_core(),label[0]);
1297         }
1298 }
1299
1300 static void linphone_gtk_dtmf_released(GtkButton *button){
1301         linphone_core_stop_dtmf (linphone_gtk_get_core());
1302 }
1303
1304 static void linphone_gtk_connect_digits(void){
1305         GtkContainer *cont=GTK_CONTAINER(linphone_gtk_get_widget(linphone_gtk_get_main_window(),"dtmf_table"));
1306         GList *children=gtk_container_get_children(cont);
1307         GList *elem;
1308         for(elem=children;elem!=NULL;elem=elem->next){
1309                 GtkButton *button=GTK_BUTTON(elem->data);
1310                 g_signal_connect(G_OBJECT(button),"pressed",(GCallback)linphone_gtk_dtmf_pressed,NULL);
1311                 g_signal_connect(G_OBJECT(button),"released",(GCallback)linphone_gtk_dtmf_released,NULL);
1312         }
1313 }
1314
1315 static void linphone_gtk_check_menu_items(void){
1316         bool_t video_enabled=linphone_core_video_enabled(linphone_gtk_get_core());
1317         bool_t selfview=linphone_gtk_get_ui_config_int("videoselfview",VIDEOSELFVIEW_DEFAULT);
1318         GtkWidget *selfview_item=linphone_gtk_get_widget(
1319                                         linphone_gtk_get_main_window(),"selfview_item");
1320         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(linphone_gtk_get_widget(
1321                                         linphone_gtk_get_main_window(),"enable_video_item")), video_enabled);
1322         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(selfview_item),selfview);
1323         gtk_widget_set_sensitive(selfview_item,video_enabled);
1324 }
1325
1326 static gboolean linphone_gtk_can_manage_accounts(){
1327         LinphoneCore *lc=linphone_gtk_get_core();
1328         const MSList *elem;
1329         for(elem=linphone_core_get_sip_setups(lc);elem!=NULL;elem=elem->next){
1330                 SipSetup *ss=(SipSetup*)elem->data;
1331                 if (sip_setup_get_capabilities(ss) & SIP_SETUP_CAP_ACCOUNT_MANAGER){
1332                         return TRUE;
1333                 }
1334         }
1335         return FALSE;
1336 }
1337
1338 static void linphone_gtk_configure_main_window(){
1339         static gboolean config_loaded=FALSE;
1340         static const char *title;
1341         static const char *home;
1342         static const char *start_call_icon;
1343         static const char *add_call_icon;
1344         static const char *stop_call_icon;
1345         static const char *search_icon;
1346         static gboolean update_check_menu;
1347         static gboolean buttons_have_borders;
1348         static gboolean show_abcd;
1349         GtkWidget *w=linphone_gtk_get_main_window();
1350         if (!config_loaded){
1351                 title=linphone_gtk_get_ui_config("title","Linphone");
1352                 home=linphone_gtk_get_ui_config("home","http://www.linphone.org");
1353                 start_call_icon=linphone_gtk_get_ui_config("start_call_icon","startcall-green.png");
1354                 add_call_icon=linphone_gtk_get_ui_config("add_call_icon","addcall-green.png");
1355                 stop_call_icon=linphone_gtk_get_ui_config("stop_call_icon","stopcall-red.png");
1356                 search_icon=linphone_gtk_get_ui_config("directory_search_icon",NULL);
1357                 update_check_menu=linphone_gtk_get_ui_config_int("update_check_menu",0);
1358                 buttons_have_borders=linphone_gtk_get_ui_config_int("buttons_border",1);
1359                 show_abcd=linphone_gtk_get_ui_config_int("show_abcd",1);
1360                 config_loaded=TRUE;
1361         }
1362         linphone_gtk_configure_window(w,"main_window");
1363         if (title) {
1364                 gtk_window_set_title(GTK_WINDOW(w),title);
1365         }
1366         if (start_call_icon){
1367                 gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"start_call")),
1368                                     create_pixmap (start_call_icon));
1369                 if (!buttons_have_borders)
1370                         gtk_button_set_relief(GTK_BUTTON(linphone_gtk_get_widget(w,"start_call")),GTK_RELIEF_NONE);
1371         }
1372         if (add_call_icon){
1373                 gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"add_call")),
1374                                     create_pixmap (add_call_icon));
1375                 if (!buttons_have_borders)
1376                         gtk_button_set_relief(GTK_BUTTON(linphone_gtk_get_widget(w,"add_call")),GTK_RELIEF_NONE);
1377         }
1378         if (stop_call_icon){
1379                 gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"terminate_call")),
1380                                     create_pixmap (stop_call_icon));
1381                 if (!buttons_have_borders)
1382                         gtk_button_set_relief(GTK_BUTTON(linphone_gtk_get_widget(w,"terminate_call")),GTK_RELIEF_NONE);
1383         }
1384         if (search_icon){
1385                 GdkPixbuf *pbuf=create_pixbuf(search_icon);
1386                 gtk_image_set_from_pixbuf(GTK_IMAGE(linphone_gtk_get_widget(w,"directory_search_button_icon")),pbuf);
1387                 g_object_unref(G_OBJECT(pbuf));
1388         }
1389         if (home){
1390                 gchar *tmp;
1391                 GtkWidget *menu_item=linphone_gtk_get_widget(w,"home_item");
1392                 tmp=g_strdup(home);
1393                 g_object_set_data(G_OBJECT(menu_item),"home",tmp);
1394         }
1395         {
1396                 /*
1397                 GdkPixbuf *pbuf=create_pixbuf("contact-orange.png");
1398                 if (pbuf) {
1399                         gtk_image_set_from_pixbuf(GTK_IMAGE(linphone_gtk_get_widget(w,"contact_tab_icon")),pbuf);
1400                         g_object_unref(G_OBJECT(pbuf));
1401                 }
1402                 */
1403         }
1404         {
1405                 GdkPixbuf *pbuf=create_pixbuf("dialer-orange.png");
1406                 if (pbuf) {
1407                         gtk_image_set_from_pixbuf(GTK_IMAGE(linphone_gtk_get_widget(w,"keypad_tab_icon")),pbuf);
1408                         g_object_unref(G_OBJECT(pbuf));
1409                 }
1410         }
1411         if (linphone_gtk_can_manage_accounts())
1412                 gtk_widget_show(linphone_gtk_get_widget(w,"assistant_item"));
1413         if (update_check_menu){
1414                 gtk_widget_show(linphone_gtk_get_widget(w,"versioncheck_item"));
1415         }
1416         if (!show_abcd){
1417                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_A"));
1418                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_B"));
1419                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_C"));
1420                 gtk_widget_hide(linphone_gtk_get_widget(w,"dtmf_D"));
1421                 gtk_table_resize(GTK_TABLE(linphone_gtk_get_widget(w,"dtmf_table")),4,3);
1422         }
1423 }
1424
1425 void linphone_gtk_manage_login(void){
1426         LinphoneCore *lc=linphone_gtk_get_core();
1427         LinphoneProxyConfig *cfg=NULL;
1428         linphone_core_get_default_proxy(lc,&cfg);
1429         if (cfg){
1430                 SipSetup *ss=linphone_proxy_config_get_sip_setup(cfg);
1431                 if (ss && (sip_setup_get_capabilities(ss) & SIP_SETUP_CAP_LOGIN)){
1432                         linphone_gtk_show_login_frame(cfg);
1433                 }
1434         }
1435 }
1436
1437
1438 gboolean linphone_gtk_close(GtkWidget *mw){
1439         /*shutdown calls if any*/
1440         LinphoneCore *lc=linphone_gtk_get_core();
1441         if (linphone_core_in_call(lc)){
1442                 linphone_core_terminate_all_calls(lc);
1443         }
1444         linphone_core_enable_video_preview(lc,FALSE);
1445 #ifdef __APPLE__ /*until with have a better option*/
1446         gtk_window_iconify(GTK_WINDOW(mw));
1447 #else
1448         gtk_widget_hide(mw);
1449 #endif
1450         return TRUE;
1451 }
1452
1453 #ifdef HAVE_GTK_OSX
1454 static gboolean on_window_state_event(GtkWidget *w, GdkEventWindowState *event){
1455         if ((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ||(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ){
1456                 linphone_core_enable_video_preview(linphone_gtk_get_core(),FALSE);
1457         }else{
1458                 linphone_core_enable_video_preview(linphone_gtk_get_core(),
1459                 linphone_gtk_get_ui_config_int("videoselfview",VIDEOSELFVIEW_DEFAULT) && linphone_core_video_enabled(linphone_gtk_get_core()));
1460         }
1461         return FALSE;
1462 }
1463 #endif
1464
1465
1466 static void linphone_gtk_init_main_window(){
1467         GtkWidget *main_window;
1468
1469         linphone_gtk_configure_main_window();
1470         linphone_gtk_manage_login();
1471         load_uri_history();
1472         linphone_gtk_load_identities();
1473         linphone_gtk_set_my_presence(linphone_core_get_presence_info(linphone_gtk_get_core()));
1474         linphone_gtk_show_friends();
1475         linphone_gtk_connect_digits();
1476         main_window=linphone_gtk_get_main_window();
1477         linphone_gtk_call_log_update(main_window);
1478
1479         linphone_gtk_update_call_buttons (NULL);
1480         /*prevent the main window from being destroyed by a user click on WM controls, instead we hide it*/
1481         g_signal_connect (G_OBJECT (main_window), "delete-event",
1482                 G_CALLBACK (linphone_gtk_close), main_window);
1483 #ifdef HAVE_GTK_OSX
1484         {
1485                 GtkWidget *menubar=linphone_gtk_get_widget(main_window,"menubar1");
1486                 GtkOSXApplication *theMacApp = (GtkOSXApplication*)g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
1487                 gtk_osxapplication_set_menu_bar(theMacApp,GTK_MENU_SHELL(menubar));
1488                 gtk_widget_hide(menubar);
1489                 gtk_osxapplication_ready(theMacApp);
1490         }
1491         g_signal_connect(G_OBJECT(main_window), "window-state-event",G_CALLBACK(on_window_state_event), NULL);
1492 #endif
1493         linphone_gtk_check_menu_items();
1494 }
1495
1496
1497 void linphone_gtk_log_handler(OrtpLogLevel lev, const char *fmt, va_list args){
1498         if (verbose){
1499                 const char *lname="undef";
1500                 char *msg;
1501 #if defined(__linux) || defined(__APPLE__)
1502                 va_list cap;/*copy of our argument list: a va_list cannot be re-used (SIGSEGV on linux 64 bits)*/
1503 #endif
1504                 switch(lev){
1505                         case ORTP_DEBUG:
1506                                 lname="debug";
1507                                 break;
1508                         case ORTP_MESSAGE:
1509                                 lname="message";
1510                                 break;
1511                         case ORTP_WARNING:
1512                                 lname="warning";
1513                                 break;
1514                         case ORTP_ERROR:
1515                                 lname="error";
1516                                 break;
1517                         case ORTP_FATAL:
1518                                 lname="fatal";
1519                                 break;
1520                         default:
1521                                 g_error("Bad level !");
1522                 }
1523 #if defined(__linux) || defined(__APPLE__)
1524                 va_copy(cap,args);
1525                 msg=g_strdup_vprintf(fmt,cap);
1526                 va_end(cap);
1527 #else
1528                 msg=g_strdup_vprintf(fmt,args);
1529 #endif
1530                 fprintf(stdout,"linphone-%s : %s\n",lname,msg);
1531                 ortp_free(msg);
1532         }
1533         linphone_gtk_log_push(lev,fmt,args);
1534 }
1535
1536
1537 void linphone_gtk_refer_received(LinphoneCore *lc, const char *refer_to){
1538         GtkEntry * uri_bar =GTK_ENTRY(linphone_gtk_get_widget(
1539                 linphone_gtk_get_main_window(), "uribar"));
1540         char *text;
1541         linphone_gtk_notify(NULL,(text=ms_strdup_printf(_("We are transferred to %s"),refer_to)));
1542         g_free(text);
1543         gtk_entry_set_text(uri_bar, refer_to);
1544         linphone_gtk_start_call(linphone_gtk_get_main_window());
1545 }
1546
1547 static void linphone_gtk_check_soundcards(){
1548         const char **devices=linphone_core_get_sound_devices(linphone_gtk_get_core());
1549         if (devices==NULL || devices[0]==NULL){
1550                 linphone_gtk_display_something(GTK_MESSAGE_WARNING,
1551                         _("No sound cards have been detected on this computer.\n"
1552                                 "You won't be able to send or receive audio calls."));
1553         }
1554 }
1555
1556 static void linphone_gtk_quit(void){
1557         linphone_gtk_uninit_instance();
1558         linphone_gtk_destroy_log_window();
1559         linphone_core_destroy(the_core);
1560         linphone_gtk_log_uninit();
1561 #ifdef HAVE_NOTIFY
1562         notify_uninit();
1563 #endif
1564         gdk_threads_leave();
1565 }
1566
1567 #ifdef HAVE_GTK_OSX
1568 /*
1569 This is not the correct way to implement block termination.
1570 The good way would be to call gtk_main_quit(), and return TRUE.
1571 Unfortunately this does not work, because if we return TRUE the NSApplication sometimes calls the CFRunLoop recursively, which prevents gtk_main() to exit.
1572 As a result the program cannot exit at all.
1573 As a workaround we do all the cleanup (unregistration and config save) within the handler.
1574 */
1575 static gboolean on_block_termination(void){
1576         gtk_main_quit();
1577         linphone_gtk_quit();
1578         return FALSE;
1579 }
1580 #endif
1581
1582 int main(int argc, char *argv[]){
1583 #ifdef ENABLE_NLS
1584         void *p;
1585 #endif
1586         const char *config_file;
1587         const char *factory_config_file;
1588         const char *lang;
1589         GtkSettings *settings;
1590         GdkPixbuf *pbuf;
1591         const char *app_name="Linphone";
1592
1593         g_thread_init(NULL);
1594         gdk_threads_init();
1595
1596         progpath = strdup(argv[0]);
1597
1598         config_file=linphone_gtk_get_config_file();
1599
1600
1601 #ifdef WIN32
1602         /*workaround for windows: sometimes LANG is defined to an integer value, not understood by gtk */
1603         if ((lang=getenv("LANG"))!=NULL){
1604                 if (atoi(lang)!=0){
1605                         char tmp[128];
1606                         snprintf(tmp,sizeof(tmp),"LANG=",lang);
1607                         _putenv(tmp);
1608                 }
1609         }
1610 #else
1611         /*for pulseaudio:*/
1612         g_setenv("PULSE_PROP_media.role", "phone", TRUE);
1613 #endif
1614
1615         if ((lang=linphone_gtk_get_lang(config_file))!=NULL && lang[0]!='\0'){
1616 #ifdef WIN32
1617                 char tmp[128];
1618                 snprintf(tmp,sizeof(tmp),"LANG=%s",lang);
1619                 _putenv(tmp);
1620 #else
1621                 setenv("LANG",lang,1);
1622 #endif
1623         }
1624
1625 #ifdef ENABLE_NLS
1626         p=bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
1627         if (p==NULL) perror("bindtextdomain failed");
1628         bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1629         textdomain (GETTEXT_PACKAGE);
1630 #else
1631         g_message("NLS disabled.\n");
1632 #endif
1633 #ifdef WIN32
1634         gtk_rc_add_default_file("./gtkrc");
1635 #endif
1636         gdk_threads_enter();
1637
1638         if (!gtk_init_with_args(&argc,&argv,_("A free SIP video-phone"),
1639                                 linphone_options,NULL,NULL)){
1640                 gdk_threads_leave();
1641                 return -1;
1642         }
1643
1644         settings=gtk_settings_get_default();
1645         g_type_class_unref (g_type_class_ref (GTK_TYPE_IMAGE_MENU_ITEM));
1646         g_type_class_unref (g_type_class_ref (GTK_TYPE_BUTTON));
1647         g_object_set(settings, "gtk-menu-images", TRUE, NULL);
1648         g_object_set(settings, "gtk-button-images", TRUE, NULL);
1649
1650         if (workingdir!=NULL){
1651                 if (chdir(workingdir)==-1){
1652                         g_error("Could not change directory to %s : %s",workingdir,strerror(errno));
1653                 }
1654         }
1655
1656         /* Now, look for the factory configuration file, we do it this late
1657                  since we want to have had time to change directory and to parse
1658                  the options, in case we needed to access the working directory */
1659         factory_config_file = linphone_gtk_get_factory_config_file();
1660
1661         if (linphone_gtk_init_instance(app_name, addr_to_call) == FALSE){
1662                 g_warning("Another running instance of linphone has been detected. It has been woken-up.");
1663                 g_warning("This instance is going to exit now.");
1664                 gdk_threads_leave();
1665                 return 0;
1666         }
1667
1668         add_pixmap_directory("pixmaps");
1669         add_pixmap_directory(PACKAGE_DATA_DIR "/pixmaps/linphone");
1670
1671 #ifdef HAVE_GTK_OSX
1672         GtkOSXApplication *theMacApp = (GtkOSXApplication*)g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
1673         g_signal_connect(G_OBJECT(theMacApp),"NSApplicationDidBecomeActive",(GCallback)linphone_gtk_show_main_window,NULL);
1674         g_signal_connect(G_OBJECT(theMacApp),"NSApplicationWillTerminate",(GCallback)gtk_main_quit,NULL);
1675         /*never block termination:*/
1676         g_signal_connect(G_OBJECT(theMacApp),"NSApplicationBlockTermination",(GCallback)on_block_termination,NULL);
1677 #endif
1678
1679         the_ui=linphone_gtk_create_window("main");
1680
1681         linphone_gtk_create_log_window();
1682         linphone_core_enable_logs_with_cb(linphone_gtk_log_handler);
1683
1684         linphone_gtk_init_liblinphone(config_file, factory_config_file);
1685
1686         g_set_application_name(app_name);
1687         pbuf=create_pixbuf(linphone_gtk_get_ui_config("icon",LINPHONE_ICON));
1688         if (pbuf!=NULL) gtk_window_set_default_icon(pbuf);
1689
1690         /* do not lower timeouts under 30 ms because it exhibits a bug on gtk+/win32, with cpu running 20% all the time...*/
1691         gtk_timeout_add(30,(GtkFunction)linphone_gtk_iterate,(gpointer)linphone_gtk_get_core());
1692         gtk_timeout_add(30,(GtkFunction)linphone_gtk_check_logs,(gpointer)NULL);
1693         linphone_gtk_init_main_window();
1694 #ifndef HAVE_GTK_OSX
1695         linphone_gtk_init_status_icon();
1696 #endif
1697         if (!iconified){
1698                 linphone_gtk_show_main_window();
1699                 linphone_gtk_check_soundcards();
1700         }
1701         if (linphone_gtk_get_ui_config_int("update_check_menu",0)==0)
1702                 linphone_gtk_check_for_new_version();
1703
1704         gtk_main();
1705         linphone_gtk_quit();
1706 #ifndef HAVE_GTK_OSX
1707         /*workaround a bug on win32 that makes status icon still present in the systray even after program exit.*/
1708         gtk_status_icon_set_visible(icon,FALSE);
1709 #endif
1710         free(progpath);
1711         return 0;
1712 }
1713