Skip to content
Snippets Groups Projects
Select Git revision
  • 2ace080038f813796329b37aa5f089cef4afb0ca
  • master default protected
  • release/202005
  • release/202001
  • release/201912
  • release/201911
  • release/releaseWindowsTestOne
  • release/windowsReleaseTest
  • release/releaseTest
  • release/releaseWindowsTest
  • release/201910
  • release/qt/201910
  • release/windows-test/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • 4.0.0
  • 2.2.0
  • 2.1.0
  • 2.0.1
  • 2.0.0
  • 1.4.1
  • 1.4.0
  • 1.3.0
  • 1.2.0
  • 1.1.0
31 results

menus.c

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    menus.c 28.17 KiB
    /*
     *  Copyright (C) 2007 Savoir-Faire Linux inc.
     *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
     *  Author: Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>
     *
     *  This program is free software; you can redistribute it and/or modify
     *  it under the terms of the GNU General Public License as published by
     *  the Free Software Foundation; either version 3 of the License, or
     *  (at your option) any later version.
     *
     *  This program is distributed in the hope that it will be useful,
     *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     *  GNU General Public License for more details.
     *
     *  You should have received a copy of the GNU General Public License
     *  along with this program; if not, write to the Free Software
     *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     */
    
    #include <menus.h>
    #include <actions.h>
    #include <calllist.h>
    #include <calltree.h>
    #include <config.h>
    #include <configwindow.h>
    #include <dbus.h>
    #include <mainwindow.h>
    #include <calltab.h>
    #include <assistant.h>
    #include <gtk/gtk.h>
    #include <glib/gprintf.h>
    #include <string.h> // for strlen
    
    GtkWidget * pickUpMenu;
    GtkWidget * hangUpMenu;
    GtkWidget * newCallMenu;
    GtkWidget * holdMenu;
    GtkWidget * copyMenu;
    GtkWidget * pasteMenu;
    GtkWidget * recordMenu;
    
    guint holdConnId;     //The hold_menu signal connection ID
    
    GtkWidget * dialpadMenu;
    GtkWidget * volumeMenu;
    GtkWidget * searchbarMenu;
    
    
    void update_menus()
    {
      //Block signals for holdMenu
      gtk_signal_handler_block(GTK_OBJECT(holdMenu), holdConnId);
    
      gtk_widget_set_sensitive( GTK_WIDGET(pickUpMenu), FALSE);
      gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), FALSE);
      gtk_widget_set_sensitive( GTK_WIDGET(newCallMenu),FALSE);
      gtk_widget_set_sensitive( GTK_WIDGET(holdMenu),   FALSE);
      gtk_widget_set_sensitive( GTK_WIDGET(recordMenu), FALSE);
      gtk_widget_set_sensitive( GTK_WIDGET(copyMenu),   FALSE);
    
      call_t * selectedCall = call_get_selected(active_calltree);
      if (selectedCall)
      {
        gtk_widget_set_sensitive( GTK_WIDGET(copyMenu),   TRUE);
        switch(selectedCall->state)
        {
          case CALL_STATE_INCOMING:
    	gtk_widget_set_sensitive( GTK_WIDGET(pickUpMenu), TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), TRUE);
    	break;
          case CALL_STATE_HOLD:
    	gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(holdMenu),   TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(newCallMenu),TRUE);
            gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( holdMenu ), gtk_image_new_from_file( ICONS_DIR "/icon_unhold.svg"));
    	break;
          case CALL_STATE_RINGING:
    	gtk_widget_set_sensitive( GTK_WIDGET(pickUpMenu), TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), TRUE);
    	break;
          case CALL_STATE_DIALING:
    	gtk_widget_set_sensitive( GTK_WIDGET(pickUpMenu), TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(newCallMenu),TRUE);
    	break;
          case CALL_STATE_CURRENT:
          case CALL_STATE_RECORD:
    	gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(holdMenu),   TRUE);
    	gtk_widget_set_sensitive( GTK_WIDGET(newCallMenu),TRUE);
            gtk_widget_set_sensitive( GTK_WIDGET(recordMenu), TRUE);
            gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( holdMenu ), gtk_image_new_from_file( ICONS_DIR "/icon_hold.svg"));
    	break;
          case CALL_STATE_BUSY:
          case CALL_STATE_FAILURE:
    	gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), TRUE);
    	break;
          default:
    	g_warning("Should not happen in update_menus()!");
    	break;
        }
      }
      else
      {
        gtk_widget_set_sensitive( GTK_WIDGET(newCallMenu), TRUE);
      }
      gtk_signal_handler_unblock(holdMenu, holdConnId);
    
    }
    /* ----------------------------------------------------------------- */
      static void
    help_about ( void * foo UNUSED)
    {
      gchar *authors[] = {
        "Yan Morin <yan.morin@savoirfairelinux.com>",
        "Jérôme Oufella <jerome.oufella@savoirfairelinux.com>",
        "Julien Plissonneau Duquene <julien.plissonneau.duquene@savoirfairelinux.com>",
        "Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>",
        "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
        "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>",
        "Yun Liu <yun.liu@savoirfairelinux.com>"
        "Alexandre Savard <alexandre.savard@savoirfairelinux.com>",
        "Jean-Philippe Barrette-LaPierre",
        "Laurielle Lea",
        NULL};
      gchar *artists[] = {
        "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
        "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>",
        NULL};
    
      gtk_show_about_dialog( GTK_WINDOW(get_main_window()),
          "artists", artists,
          "authors", authors,
          "comments", _("SFLphone is a VoIP client compatible with SIP and IAX2 protocols."),
          "copyright", "Copyright © 2004-2009 Savoir-faire Linux Inc.",
          "name", PACKAGE,
          "title", _("About SFLphone"),
          "version", VERSION,
          "website", "http://www.sflphone.org",
          NULL);
    }
    
    
      GtkWidget *
    create_help_menu()
    {
      GtkWidget * menu;
      GtkWidget * root_menu;
      GtkWidget * menu_items;
    
      menu      = gtk_menu_new ();
    
      menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_ABOUT, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
          G_CALLBACK (help_about),
          NULL);
      gtk_widget_show (menu_items);
    
      root_menu = gtk_menu_item_new_with_mnemonic (_("_Help"));
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
    
      return root_menu;
    }
    /* ----------------------------------------------------------------- */
      GtkWidget *
    create_waiting_icon()
    {
      GtkWidget * waiting_icon;
      waiting_icon = gtk_image_menu_item_new_with_label("");
      gtk_image_menu_item_set_image (
            GTK_IMAGE_MENU_ITEM(waiting_icon),
            gtk_image_new_from_animation(
                gdk_pixbuf_animation_new_from_file(ICONS_DIR "/wait-on.gif", NULL)));
      gtk_menu_item_set_right_justified(GTK_MENU_ITEM(waiting_icon),TRUE);
    
      return waiting_icon;
    }
    /* ----------------------------------------------------------------- */
      static void
    call_new_call ( void * foo UNUSED)
    {
      sflphone_new_call();
    }
    
      static void
    call_quit ( void * foo UNUSED)
    {
      sflphone_quit();
    }
    
      static void
    call_minimize ( void * foo UNUSED)
    {
    #if GTK_CHECK_VERSION(2,10,0)
      gtk_widget_hide(GTK_WIDGET( get_main_window() ));
      set_minimized( TRUE );
    #endif
    }
    
      static void
    switch_account(  GtkWidget* item , gpointer data UNUSED)
    {
      account_t* acc = g_object_get_data( G_OBJECT(item) , "account" );
      g_print("%s\n" , acc->accountID);
      account_list_set_current_id( acc->accountID );
    }
    
      static void
    call_hold  (void* foo UNUSED)
    {
      call_t * selectedCall = call_get_selected(current_calls);
    
      if(selectedCall)
      {
        if(selectedCall->state == CALL_STATE_HOLD)
        {
          gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( holdMenu ), gtk_image_new_from_file( ICONS_DIR "/icon_unhold.svg"));
          sflphone_off_hold();
        }
        else
        {
          gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( holdMenu ), gtk_image_new_from_file( ICONS_DIR "/icon_hold.svg"));
          sflphone_on_hold();
        }
      }
    }
    
      static void
    call_pick_up ( void * foo UNUSED)
    {
      sflphone_pick_up();
    }
    
      static void
    call_hang_up ( void * foo UNUSED)
    {
      sflphone_hang_up();
    }
    
    static void
    call_record ( void * foo UNUSED)
    {
      sflphone_rec_call();
    }
    
      static void
    call_wizard ( void * foo UNUSED)
    {
    #if GTK_CHECK_VERSION(2,10,0)
      build_wizard();
    #endif
    }
    
    static void
    remove_from_history( void * foo UNUSED)
    {
      call_t* c = call_get_selected( history );
      if(c){
        g_print("Remove the call from the history\n");
        call_list_remove_from_history( c );
      }
    }
    
    static void
    call_back( void * foo UNUSED)
    {
        call_t *selected_call, *new_call;
        gchar *to, *from;
    
        selected_call = call_get_selected( active_calltree );
    
        if( selected_call )
        {
            to = g_strdup(call_get_number(selected_call));
            from = g_strconcat("\"\" <", call_get_number(selected_call), ">",NULL);
    
            create_new_call (to, from, CALL_STATE_DIALING, "", &new_call);
    
            call_list_add(current_calls, new_call);
            update_call_tree_add(current_calls, new_call);
            sflphone_place_call(new_call);
            display_calltree (current_calls);
        }
    }
    
      GtkWidget *
    create_call_menu()
    {
      GtkWidget * menu;
      GtkWidget * root_menu;
      GtkWidget * menu_items;
      GtkWidget * image;
    
      menu      = gtk_menu_new ();
    
      image = gtk_image_new_from_file( ICONS_DIR "/icon_call.svg");
      newCallMenu = gtk_image_menu_item_new_with_mnemonic(_("_New call"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( newCallMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), newCallMenu);
      g_signal_connect_swapped (G_OBJECT (newCallMenu), "activate",
          G_CALLBACK (call_new_call),
          NULL);
      gtk_widget_show (newCallMenu);
    
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    
      image = gtk_image_new_from_file( ICONS_DIR "/icon_accept.svg");
      pickUpMenu = gtk_image_menu_item_new_with_mnemonic(_("_Pick up"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( pickUpMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), pickUpMenu);
      gtk_widget_set_sensitive( GTK_WIDGET(pickUpMenu), FALSE);
      g_signal_connect_swapped (G_OBJECT (pickUpMenu), "activate",
          G_CALLBACK (call_pick_up),
          NULL);
      gtk_widget_show (pickUpMenu);
    
      image = gtk_image_new_from_file( ICONS_DIR "/icon_hangup.svg");
      hangUpMenu = gtk_image_menu_item_new_with_mnemonic(_("_Hang up"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( hangUpMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), hangUpMenu);
      gtk_widget_set_sensitive( GTK_WIDGET(hangUpMenu), FALSE);
      g_signal_connect_swapped (G_OBJECT (hangUpMenu), "activate",
          G_CALLBACK (call_hang_up),
          NULL);
      gtk_widget_show (hangUpMenu);
    
      image = gtk_image_new_from_file( ICONS_DIR "/icon_hold.svg");
      holdMenu = gtk_image_menu_item_new_with_mnemonic (_("On _Hold"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( holdMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), holdMenu);
      gtk_widget_set_sensitive( GTK_WIDGET(holdMenu),   FALSE);
      //Here we connect only to activate
      //The toggled state is managed from update_menus()
      holdConnId = g_signal_connect(G_OBJECT (holdMenu), "activate",
          G_CALLBACK (call_hold),
          NULL);
      gtk_widget_show (menu_items);
    
      image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_MENU);
      recordMenu = gtk_image_menu_item_new_with_mnemonic(_("_Record"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( recordMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), recordMenu);
      gtk_widget_set_sensitive( GTK_WIDGET(recordMenu), FALSE);
      g_signal_connect_swapped (G_OBJECT (recordMenu), "activate",
          G_CALLBACK (call_record),
          NULL);
      gtk_widget_show (recordMenu);
    
      // Separator
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    
    #if GTK_CHECK_VERSION(2,10,0)
      menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Account Assistant"));
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped( G_OBJECT( menu_items ) , "activate" , G_CALLBACK( call_wizard  ) , NULL );
      gtk_widget_show (menu_items);
      // Separator
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    #endif
    
      // Close menu to minimize the main window to the system tray
      menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_CLOSE, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
          G_CALLBACK (call_minimize),
          NULL);
      gtk_widget_show (menu_items);
    
      // Separator
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    
      // Quit Menu - quit SFLphone
      menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_QUIT, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
          G_CALLBACK (call_quit),
          NULL);
      gtk_widget_show (menu_items);
    
    
      root_menu = gtk_menu_item_new_with_mnemonic (_("_Call"));
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
    
      return root_menu;
    }
    /* ----------------------------------------------------------------- */
    
      static void
    edit_preferences ( void * foo UNUSED)
    {
      show_config_window();
    }
    
      static void
    edit_accounts ( void * foo UNUSED)
    {
      show_accounts_window();
    }
    
    // The menu Edit/Copy should copy the current selected call's number
      static void
    edit_copy ( void * foo UNUSED)
    {
      GtkClipboard* clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
      call_t * selectedCall = call_get_selected(current_calls);
      gchar * no = NULL;
    
      if(selectedCall)
      {
        switch(selectedCall->state)
        {
          case CALL_STATE_TRANSFERT:
          case CALL_STATE_DIALING:
          case CALL_STATE_RINGING:
    	no = selectedCall->to;
    	break;
          case CALL_STATE_CURRENT:
          case CALL_STATE_HOLD:
          case CALL_STATE_BUSY:
          case CALL_STATE_FAILURE:
          case CALL_STATE_INCOMING:
          default:
    	no = call_get_number(selectedCall);
    	break;
        }
    
        gtk_clipboard_set_text (clip, no, strlen(no) );
      }
    
    }
    
    // The menu Edit/Paste should paste the clipboard into the current selected call
      static void
    edit_paste ( void * foo UNUSED)
    {
      GtkClipboard* clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
      call_t * selectedCall = call_get_selected(current_calls);
      gchar * no = gtk_clipboard_wait_for_text (clip);
    
      if(no && selectedCall)
      {
        switch(selectedCall->state)
        {
          case CALL_STATE_TRANSFERT:
          case CALL_STATE_DIALING:
    	// Add the text to the number
    	{
    	  gchar * before = selectedCall->to;
    	  selectedCall->to = g_strconcat(selectedCall->to, no, NULL);
    	  g_free(before);
    	  g_print("TO: %s\n", selectedCall->to);
    
    	  if(selectedCall->state == CALL_STATE_DIALING)
    	  {
    	    g_free(selectedCall->from);
    	    selectedCall->from = g_strconcat("\"\" <", selectedCall->to, ">", NULL);
    	  }
    	  update_call_tree(current_calls, selectedCall);
    	}
    	break;
          case CALL_STATE_RINGING:
          case CALL_STATE_INCOMING:
          case CALL_STATE_BUSY:
          case CALL_STATE_FAILURE:
          case CALL_STATE_HOLD:
    	{ // Create a new call to hold the new text
    	  selectedCall = sflphone_new_call();
    
    	  gchar * before = selectedCall->to;
    	  selectedCall->to = g_strconcat(selectedCall->to, no, NULL);
    	  g_free(before);
    	  g_print("TO: %s\n", selectedCall->to);
    
    	  g_free(selectedCall->from);
    	  selectedCall->from = g_strconcat("\"\" <", selectedCall->to, ">", NULL);
    
    	  update_call_tree(current_calls, selectedCall);
    	}
    	break;
          case CALL_STATE_CURRENT:
          default:
    	{
    	  unsigned int i;
    	  for(i = 0; i < strlen(no); i++)
    	  {
    	    gchar * oneNo = g_strndup(&no[i], 1);
    	    g_print("<%s>\n", oneNo);
    	    dbus_play_dtmf(oneNo);
    
    	    gchar * temp = g_strconcat(call_get_number(selectedCall), oneNo, NULL);
    	    gchar * before = selectedCall->from;
    	    selectedCall->from = g_strconcat("\"",call_get_name(selectedCall) ,"\" <", temp, ">", NULL);
    	    g_free(before);
    	    g_free(temp);
    	    update_call_tree(current_calls, selectedCall);
    
    	  }
    	}
    	break;
        }
    
      }
      else // There is no current call, create one
      {
        selectedCall = sflphone_new_call();
    
        gchar * before = selectedCall->to;
        selectedCall->to = g_strconcat(selectedCall->to, no, NULL);
        g_free(before);
        g_print("TO: %s\n", selectedCall->to);
    
        g_free(selectedCall->from);
        selectedCall->from = g_strconcat("\"\" <", selectedCall->to, ">", NULL);
        update_call_tree(current_calls,selectedCall);
      }
    
    }
    
      static void
    clear_history (void)
    {
      if( call_list_get_size( history ) != 0 ){
          call_list_clean_history();
        }
    }
    
      GtkWidget *
    create_edit_menu()
    {
      GtkWidget * menu;
      GtkWidget * image;
      GtkWidget * root_menu;
      GtkWidget * menu_items;
    
      menu      = gtk_menu_new ();
    
      copyMenu = gtk_image_menu_item_new_from_stock( GTK_STOCK_COPY, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), copyMenu);
      g_signal_connect_swapped (G_OBJECT (copyMenu), "activate",
          G_CALLBACK (edit_copy),
          NULL);
      gtk_widget_show (copyMenu);
    
      pasteMenu = gtk_image_menu_item_new_from_stock( GTK_STOCK_PASTE, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), pasteMenu);
      g_signal_connect_swapped (G_OBJECT (pasteMenu), "activate",
          G_CALLBACK (edit_paste),
          NULL);
      gtk_widget_show (pasteMenu);
    
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    
      menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Clear history"));
      image = gtk_image_new_from_stock( GTK_STOCK_CLEAR , GTK_ICON_SIZE_MENU );
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( menu_items ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
          G_CALLBACK (clear_history),
          NULL);
      gtk_widget_show (menu_items);
    
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    
      menu_items = gtk_menu_item_new_with_mnemonic( _("_Accounts") );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
          G_CALLBACK (edit_accounts),
          NULL);
      gtk_widget_show (menu_items);
    
      menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_PREFERENCES, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect_swapped (G_OBJECT (menu_items), "activate",
          G_CALLBACK (edit_preferences),
          NULL);
      gtk_widget_show (menu_items);
    
    
      root_menu = gtk_menu_item_new_with_mnemonic (_("_Edit"));
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
    
      return root_menu;
    }
    /* ----------------------------------------------------------------- */
      static void
    view_dialpad  (GtkImageMenuItem *imagemenuitem UNUSED,
        void* foo UNUSED)
    {
      gboolean state;
      main_window_dialpad( &state );
      if( state )
        gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( dialpadMenu ),
    				  gtk_image_new_from_file( ICONS_DIR "/icon_dialpad_off.svg"));
      else
        gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( dialpadMenu ),
    				  gtk_image_new_from_file( ICONS_DIR "/icon_dialpad.svg"));
      dbus_set_dialpad( state );
    
    
    }
    
      static void
    view_volume_controls  (GtkImageMenuItem *imagemenuitem UNUSED,
        void* foo UNUSED)
    {
      gboolean state;
      main_window_volume_controls( &state );
      if( state )
        gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( volumeMenu ),
    				  gtk_image_new_from_file( ICONS_DIR "/icon_volume_off.svg"));
      else
        gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( volumeMenu ),
    				  gtk_image_new_from_file( ICONS_DIR "/icon_volume.svg"));
      dbus_set_volume_controls( state );
    }
    
      static void
    view_searchbar  (GtkImageMenuItem *imagemenuitem UNUSED,
        void* foo UNUSED)
    {
      gboolean state;
      main_window_searchbar( &state );
      dbus_set_searchbar( state );
    }
    
      GtkWidget *
    create_view_menu()
    {
      GtkWidget * menu;
      GtkWidget * root_menu;
      GtkWidget * image;
    
      menu      = gtk_menu_new ();
    
      if( SHOW_DIALPAD )
        image = gtk_image_new_from_file( ICONS_DIR "/icon_dialpad_off.svg");
      else
        image = gtk_image_new_from_file( ICONS_DIR "/icon_dialpad.svg");
      dialpadMenu = gtk_image_menu_item_new_with_mnemonic (_("_Dialpad"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( dialpadMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), dialpadMenu);
      g_signal_connect(G_OBJECT ( dialpadMenu ), "activate",
          G_CALLBACK (view_dialpad),
          NULL);
      gtk_widget_show (dialpadMenu);
    
      if( SHOW_VOLUME )
        image = gtk_image_new_from_file( ICONS_DIR "/icon_volume.svg");
      else
        image = gtk_image_new_from_file( ICONS_DIR "/icon_volume.svg");
      volumeMenu = gtk_image_menu_item_new_with_mnemonic (_("_Volume controls"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( volumeMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), volumeMenu);
      g_signal_connect(G_OBJECT (volumeMenu), "activate",
          G_CALLBACK (view_volume_controls),
          NULL);
      gtk_widget_show (volumeMenu);
    
      image = gtk_image_new_from_stock( GTK_STOCK_FIND , GTK_ICON_SIZE_MENU );
      searchbarMenu = gtk_image_menu_item_new_with_mnemonic (_("_Search contact"));
      gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( searchbarMenu ), image );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), searchbarMenu);
      g_signal_connect(G_OBJECT (searchbarMenu), "activate",
          G_CALLBACK (view_searchbar),
          NULL);
      gtk_widget_show (searchbarMenu);
    
      root_menu = gtk_menu_item_new_with_mnemonic (_("_View"));
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), menu);
    
      return root_menu;
    }
    /* ----------------------------------------------------------------- */
      GtkWidget *
    create_menus ( )
    {
    
      GtkWidget * menu_bar;
      GtkWidget * root_menu;
    
      menu_bar  = gtk_menu_bar_new ();
    
      root_menu = create_call_menu();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);
    
      root_menu = create_edit_menu();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);
    
      root_menu = create_view_menu();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);
    
      root_menu = create_help_menu();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), root_menu);
    
      // Create waiting icon
      waitingLayer = create_waiting_icon();
      gtk_menu_shell_append(GTK_MENU_SHELL (menu_bar),waitingLayer);
    
      return menu_bar;
    }
    
    /* ----------------------------------------------------------------- */
    
      void
    show_popup_menu (GtkWidget *my_widget, GdkEventButton *event)
    {
      // TODO update the selection to make sure the call under the mouse is the call selected
    
      gboolean pickup = FALSE, hangup = FALSE, hold = FALSE, copy = FALSE, record = FALSE;
      gboolean accounts = FALSE;
    
      call_t * selectedCall = call_get_selected(current_calls);
      if (selectedCall)
      {
        copy = TRUE;
        switch(selectedCall->state)
        {
          case CALL_STATE_INCOMING:
    	pickup = TRUE;
    	hangup = TRUE;
    	break;
          case CALL_STATE_HOLD:
    	hangup = TRUE;
    	hold   = TRUE;
    	break;
          case CALL_STATE_RINGING:
    	hangup = TRUE;
    	break;
          case CALL_STATE_DIALING:
    	pickup = TRUE;
    	hangup = TRUE;
    	accounts = TRUE;
    	break;
          case CALL_STATE_RECORD:
          case CALL_STATE_CURRENT:
    	hangup = TRUE;
    	hold   = TRUE;
            record = TRUE;
    	break;
          case CALL_STATE_BUSY:
          case CALL_STATE_FAILURE:
    	hangup = TRUE;
    	break;
          default:
    	g_warning("Should not happen in show_popup_menu!");
    	break;
        }
      }
    
      GtkWidget *menu;
      GtkWidget *image;
      int button, event_time;
      GtkWidget * menu_items;
    
      menu = gtk_menu_new ();
      //g_signal_connect (menu, "deactivate",
      //       G_CALLBACK (gtk_widget_destroy), NULL);
    
      if(copy)
      {
        menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_COPY, get_accel_group());
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        g_signal_connect (G_OBJECT (menu_items), "activate",
    	G_CALLBACK (edit_copy),
    	NULL);
        gtk_widget_show (menu_items);
      }
    
      menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_PASTE, get_accel_group());
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      g_signal_connect (G_OBJECT (menu_items), "activate",
          G_CALLBACK (edit_paste),
          NULL);
      gtk_widget_show (menu_items);
    
      if(pickup || hangup || hold)
      {
        menu_items = gtk_separator_menu_item_new ();
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        gtk_widget_show (menu_items);
      }
    
      if(pickup)
      {
    
        menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Pick up"));
        image = gtk_image_new_from_file( ICONS_DIR "/icon_accept.svg");
        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        g_signal_connect (G_OBJECT (menu_items), "activate",
    	G_CALLBACK (call_pick_up),
    	NULL);
        gtk_widget_show (menu_items);
      }
    
      if(hangup)
      {
        menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Hang up"));
        image = gtk_image_new_from_file( ICONS_DIR "/icon_hangup.svg");
        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        g_signal_connect (G_OBJECT (menu_items), "activate",
    	G_CALLBACK (call_hang_up),
    	NULL);
        gtk_widget_show (menu_items);
      }
    
      if(hold)
      {
        menu_items = gtk_check_menu_item_new_with_mnemonic (_("On _Hold"));
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items),
    	(selectedCall->state == CALL_STATE_HOLD ? TRUE : FALSE));
        g_signal_connect(G_OBJECT (menu_items), "activate",
    	G_CALLBACK (call_hold),
    	NULL);
        gtk_widget_show (menu_items);
      }
    
       if(record)
      {
        menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Record"));
        image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_MENU);
        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        g_signal_connect (G_OBJECT (menu_items), "activate",
    	G_CALLBACK (call_record),
    	NULL);
        gtk_widget_show (menu_items);
      }
    
      if(accounts)
      {
        menu_items = gtk_separator_menu_item_new ();
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        gtk_widget_show (menu_items);
    
        unsigned int i;
        account_t* acc;
        gchar* alias;
        for( i = 0 ; i < account_list_get_size() ; i++ ){
          acc = account_list_get_nth(i);
          // Display only the registered accounts
          if( g_strcasecmp( account_state_name(acc -> state) , account_state_name(ACCOUNT_STATE_REGISTERED) ) == 0 ){
    	alias = g_strconcat( g_hash_table_lookup(acc->properties , ACCOUNT_ALIAS) , " - ",g_hash_table_lookup(acc->properties , ACCOUNT_TYPE), NULL);
    	menu_items = gtk_check_menu_item_new_with_mnemonic(alias);
    	gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
    	g_object_set_data( G_OBJECT( menu_items ) , "account" , acc );
    	g_free( alias );
    	if( account_list_get_current() != NULL ){
    	  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items),
    	      (g_strcasecmp( acc->accountID , account_list_get_current()->accountID) == 0)? TRUE : FALSE);
    	}
    	g_signal_connect (G_OBJECT (menu_items), "activate",
    	    G_CALLBACK (switch_account),
    	    NULL);
    	gtk_widget_show (menu_items);
          } // fi
        }
      }
    
      if (event)
      {
        button = event->button;
        event_time = event->time;
      }
      else
      {
        button = 0;
        event_time = gtk_get_current_event_time ();
      }
    
      gtk_menu_attach_to_widget (GTK_MENU (menu), my_widget, NULL);
      gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
          button, event_time);
    }
    
    
    void
    show_popup_menu_history(GtkWidget *my_widget, GdkEventButton *event)
    {
    
      gboolean pickup = FALSE;
      gboolean remove = FALSE;
    
      call_t * selectedCall = call_get_selected( history );
      if (selectedCall)
      {
        remove = TRUE;
        pickup = TRUE;
      }
    
      GtkWidget *menu;
      GtkWidget *image;
      int button, event_time;
      GtkWidget * menu_items;
    
      menu = gtk_menu_new ();
      //g_signal_connect (menu, "deactivate",
      //       G_CALLBACK (gtk_widget_destroy), NULL);
    
      if(pickup)
      {
    
        menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Call back"));
        image = gtk_image_new_from_file( ICONS_DIR "/icon_accept.svg");
        gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM ( menu_items ), image );
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (call_back), NULL);
        gtk_widget_show (menu_items);
      }
    
      menu_items = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
      gtk_widget_show (menu_items);
    
      if(remove)
      {
        menu_items = gtk_image_menu_item_new_from_stock( GTK_STOCK_DELETE, get_accel_group());
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
        g_signal_connect (G_OBJECT (menu_items), "activate", G_CALLBACK (remove_from_history),  NULL);
        gtk_widget_show (menu_items);
      }
    
      if (event)
      {
        button = event->button;
        event_time = event->time;
      }
      else
      {
        button = 0;
        event_time = gtk_get_current_event_time ();
      }
    
      gtk_menu_attach_to_widget (GTK_MENU (menu), my_widget, NULL);
      gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
          button, event_time);
    }