← Back to branch summary

~ubuntu-branches/ubuntu/saucy/sflphone/saucy

« back to all changes in this revision

Viewing changes to sflphone-client-gnome/src/uimanager.c

  • Committer: Bazaar Package Importer
  • Author(s): Francois Marier
  • Date: 2010-12-24 16:33:55 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20101224163355-tkvvikqxbrbav6up
Tags: 0.9.11-1
* New upstream release
* Add new build dependencies on libwebkit-dev and libyaml-dev

* Bump Standards-Version up to 3.9.1
* Bump debhelper compatibility to 8
* Patch another typo in the upstream code (lintian notice)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sflphone-client-gnome/src/uimanager.c
37
37
#include <string.h>
38
38
#include <glib/gprintf.h>
39
39
#include <libgnome/gnome-help.h>
 
40
 
40
41
#include <uimanager.h>
41
42
#include <statusicon.h>
 
43
#include <widget/imwidget.h>
 
44
#include <eel-gconf-extensions.h>
 
45
#include "uimanager.h"
 
46
#include "statusicon.h"
 
47
#include "contacts/addressbook.h"
 
48
#include "accountlist.h"
 
49
#include "config/accountlistconfigdialog.h"
 
50
 
 
51
void show_edit_number (callable_obj_t *call);
42
52
 
43
53
static GtkWidget *toolbar;
44
54
static GtkWidget *toolbarWindows;
62
72
GtkWidget * recordWidget;
63
73
GtkAction * voicemailAction;
64
74
GtkWidget * voicemailToolbar;
 
75
GtkWidget * imToolbar;
 
76
GtkAction * imAction;
65
77
 
66
78
GtkWidget * editable_num;
67
79
GtkDialog * edit_dialog;
68
80
 
69
 
enum
70
 
{
71
 
  CALLTREE_CALLS, CALLTREE_HISTORY, CALLTREE_CONTACTS
 
81
enum {
 
82
    CALLTREE_CALLS, CALLTREE_HISTORY, CALLTREE_CONTACTS
72
83
};
73
84
 
74
85
static gboolean
75
 
is_inserted(GtkWidget* button, GtkWidget *current_toolbar)
 
86
is_inserted (GtkWidget* button, GtkWidget *current_toolbar)
76
87
{
77
 
  return (GTK_WIDGET (button)->parent == GTK_WIDGET (current_toolbar));
 
88
    return (GTK_WIDGET (button)->parent == GTK_WIDGET (current_toolbar));
78
89
}
79
90
 
80
91
void
81
92
update_actions()
82
93
{
83
94
 
84
 
  DEBUG("Update action");
85
 
 
86
 
  gtk_action_set_sensitive(GTK_ACTION (newCallAction), TRUE);
87
 
  gtk_action_set_sensitive(GTK_ACTION (pickUpAction), FALSE);
88
 
  gtk_action_set_sensitive(GTK_ACTION (hangUpAction), FALSE);
89
 
 
90
 
  g_object_ref(hangUpWidget);
91
 
  g_object_ref(recordWidget);
92
 
  g_object_ref(holdToolbar);
93
 
  g_object_ref(offHoldToolbar);
94
 
  g_object_ref(contactButton);
95
 
  g_object_ref(transferToolbar);
96
 
  g_object_ref(voicemailToolbar);
97
 
 
98
 
  if (is_inserted(GTK_WIDGET(hangUpWidget), GTK_WIDGET (toolbar)))
99
 
    {
100
 
      gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (hangUpWidget));
101
 
    }
102
 
 
103
 
  if (is_inserted(GTK_WIDGET(recordWidget), GTK_WIDGET (toolbar)))
104
 
    {
105
 
      gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (recordWidget));
106
 
    }
107
 
 
108
 
  if (is_inserted(GTK_WIDGET(transferToolbar), GTK_WIDGET (toolbar)))
109
 
    {
110
 
      gtk_container_remove(GTK_CONTAINER (toolbar),
111
 
          GTK_WIDGET (transferToolbar));
112
 
    }
113
 
 
114
 
  if (is_inserted(GTK_WIDGET(contactButton), GTK_WIDGET (toolbar)))
115
 
    {
116
 
      gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (contactButton));
117
 
    }
118
 
 
119
 
  if (is_inserted(GTK_WIDGET (voicemailToolbar), GTK_WIDGET (toolbar)))
120
 
    {
121
 
      gtk_container_remove(GTK_CONTAINER (toolbar),
122
 
          GTK_WIDGET (voicemailToolbar));
123
 
    }
124
 
 
125
 
  gtk_widget_set_sensitive(GTK_WIDGET (holdMenu), FALSE);
126
 
  gtk_widget_set_sensitive(GTK_WIDGET (holdToolbar), FALSE);
127
 
  gtk_widget_set_sensitive(GTK_WIDGET (offHoldToolbar), FALSE);
128
 
  gtk_action_set_sensitive(GTK_ACTION (recordAction), FALSE);
129
 
  gtk_widget_set_sensitive(GTK_WIDGET (recordWidget), FALSE);
130
 
  gtk_action_set_sensitive(GTK_ACTION (copyAction), FALSE);
131
 
  gtk_widget_set_sensitive(GTK_WIDGET(contactButton), FALSE);
132
 
  gtk_widget_set_tooltip_text(GTK_WIDGET (contactButton),
133
 
      _("No address book selected"));
134
 
 
135
 
  if (is_inserted(GTK_WIDGET (holdToolbar), GTK_WIDGET (toolbar)))
136
 
    gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (holdToolbar));
137
 
  if (is_inserted(GTK_WIDGET (offHoldToolbar), GTK_WIDGET (toolbar)))
138
 
    gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (offHoldToolbar));
139
 
 
140
 
  if (is_inserted(GTK_WIDGET (newCallWidget), GTK_WIDGET (toolbar)))
141
 
    gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));
142
 
  if (is_inserted(GTK_WIDGET (pickUpWidget), GTK_WIDGET (toolbar)))
143
 
    gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET (pickUpWidget));
144
 
  gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (newCallWidget), 0);
145
 
 
146
 
  // If addressbook support has been enabled and all addressbooks are loaded, display the icon
147
 
  if (addressbook_is_enabled() && addressbook_is_ready())
148
 
    {
149
 
      gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (contactButton),
150
 
          -1);
151
 
      // Make the icon clickable only if at least one address book is active
152
 
      if (addressbook_is_active())
153
 
        {
154
 
          gtk_widget_set_sensitive(GTK_WIDGET(contactButton), TRUE);
155
 
          gtk_widget_set_tooltip_text(GTK_WIDGET (contactButton),
156
 
              _("Address book"));
157
 
        }
158
 
    }
159
 
 
160
 
  // g_signal_handler_block (GTK_OBJECT (recordWidget), recordButtonConnId);
161
 
  // gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), FALSE);
162
 
  // g_signal_handler_unblock ( GTK_OBJECT (recordWidget), recordButtonConnId);
163
 
 
164
 
  callable_obj_t * selectedCall = calltab_get_selected_call(active_calltree);
165
 
  conference_obj_t * selectedConf = calltab_get_selected_conf(active_calltree);
166
 
 
167
 
  if (selectedCall)
168
 
    {
169
 
      // update icon in systray
170
 
      show_status_hangup_icon();
171
 
 
172
 
      gtk_action_set_sensitive(GTK_ACTION (copyAction), TRUE);
173
 
 
174
 
      switch (selectedCall->_state)
175
 
        {
176
 
      case CALL_STATE_INCOMING:
177
 
        // Make the button toolbar clickable
178
 
        gtk_action_set_sensitive(GTK_ACTION (pickUpAction), TRUE);
179
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
180
 
        // Replace the dial button with the hangup button
181
 
        g_object_ref(newCallWidget);
182
 
        gtk_container_remove(GTK_CONTAINER (toolbar), GTK_WIDGET(newCallWidget));
183
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (pickUpWidget),
184
 
            0);
185
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
186
 
            1);
187
 
        break;
188
 
      case CALL_STATE_HOLD:
189
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
190
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdMenu), TRUE);
191
 
        gtk_widget_set_sensitive(GTK_WIDGET (offHoldToolbar), TRUE);
192
 
        gtk_widget_set_sensitive(GTK_WIDGET (newCallWidget), TRUE);
193
 
        // Replace the hold button with the off-hold button
194
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
195
 
            1);
196
 
        gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
197
 
            GTK_TOOL_ITEM (offHoldToolbar), 2);
198
 
        break;
199
 
      case CALL_STATE_RINGING:
200
 
        gtk_action_set_sensitive(GTK_ACTION (pickUpAction), TRUE);
201
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
202
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
203
 
            1);
204
 
        break;
205
 
      case CALL_STATE_DIALING:
206
 
        gtk_action_set_sensitive(GTK_ACTION(pickUpAction), TRUE);
207
 
        if (active_calltree == current_calls)
208
 
          gtk_action_set_sensitive(GTK_ACTION(hangUpAction), TRUE);
209
 
        //gtk_action_set_sensitive( GTK_ACTION(newCallMenu),TRUE);
210
 
        g_object_ref(newCallWidget);
211
 
        gtk_container_remove(GTK_CONTAINER (toolbar),
212
 
            GTK_WIDGET (newCallWidget));
213
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (pickUpWidget),
214
 
            0);
215
 
        if (active_calltree == current_calls)
216
 
          gtk_toolbar_insert(GTK_TOOLBAR (toolbar),
217
 
              GTK_TOOL_ITEM (hangUpWidget), 1);
218
 
        break;
219
 
      case CALL_STATE_CURRENT:
220
 
      case CALL_STATE_RECORD:
221
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
222
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
223
 
            1);
224
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdMenu), TRUE);
225
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdToolbar), TRUE);
226
 
        gtk_widget_set_sensitive(GTK_WIDGET (transferToolbar), TRUE);
227
 
        gtk_action_set_sensitive(GTK_ACTION (recordAction), TRUE);
228
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar),
229
 
            2);
230
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar),
231
 
            GTK_TOOL_ITEM (transferToolbar), 3);
232
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget),
233
 
            4);
234
 
        gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
235
 
        gtk_toggle_tool_button_set_active(
236
 
            GTK_TOGGLE_TOOL_BUTTON (transferToolbar), FALSE);
237
 
        gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
238
 
 
239
 
        break;
240
 
      case CALL_STATE_BUSY:
241
 
      case CALL_STATE_FAILURE:
242
 
        gtk_action_set_sensitive(GTK_ACTION(hangUpAction), TRUE);
243
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
244
 
            1);
245
 
        break;
246
 
      case CALL_STATE_TRANSFERT:
247
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
248
 
            1);
249
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar),
250
 
            GTK_TOOL_ITEM (transferToolbar), 2);
251
 
        gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
252
 
        gtk_toggle_tool_button_set_active(
253
 
            GTK_TOGGLE_TOOL_BUTTON (transferToolbar), TRUE);
254
 
        gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
255
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
256
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdMenu), TRUE);
257
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdToolbar), TRUE);
258
 
        gtk_widget_set_sensitive(GTK_WIDGET (transferToolbar), TRUE);
259
 
        break;
260
 
      default:
261
 
        WARN("Should not happen in update_actions()!")
262
 
        ;
263
 
        break;
264
 
        }
265
 
    }
266
 
  else if (selectedConf)
267
 
    {
268
 
 
269
 
      // update icon in systray
270
 
      show_status_hangup_icon();
271
 
 
272
 
      switch (selectedConf->_state)
273
 
        {
274
 
 
275
 
      case CONFERENCE_STATE_ACTIVE_ATACHED:
276
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
277
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdToolbar), TRUE);
278
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
279
 
            1);
280
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar),
281
 
            2);
282
 
        break;
283
 
 
284
 
      case CONFERENCE_STATE_ACTIVE_DETACHED:
285
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
286
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdToolbar), TRUE);
287
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
288
 
            1);
289
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar),
290
 
            2);
291
 
        break;
292
 
 
293
 
      case CONFERENCE_STATE_RECORD:
294
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
295
 
        gtk_widget_set_sensitive(GTK_WIDGET (holdToolbar), TRUE);
296
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
297
 
            1);
298
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar),
299
 
            2);
300
 
        break;
301
 
 
302
 
      case CONFERENCE_STATE_HOLD:
303
 
        gtk_action_set_sensitive(GTK_ACTION (hangUpAction), TRUE);
304
 
        gtk_widget_set_sensitive(GTK_WIDGET (offHoldToolbar), TRUE);
305
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
306
 
            1);
307
 
        gtk_toolbar_insert(GTK_TOOLBAR (toolbar),
308
 
            GTK_TOOL_ITEM (offHoldToolbar), 2);
309
 
        break;
310
 
 
311
 
      default:
312
 
        WARN("Should not happen in update_action()!")
313
 
        ;
314
 
        break;
315
 
 
316
 
        }
317
 
    }
318
 
 
319
 
  else
320
 
    {
321
 
 
322
 
      // update icon in systray
323
 
      hide_status_hangup_icon();
324
 
 
325
 
      if (account_list_get_size() > 0 && current_account_has_mailbox())
326
 
        {
327
 
          gtk_toolbar_insert(GTK_TOOLBAR (toolbar),
328
 
              GTK_TOOL_ITEM (voicemailToolbar), -2);
329
 
          update_voicemail_status();
 
95
    DEBUG ("UIManager: Update action");
 
96
 
 
97
    gtk_action_set_sensitive (GTK_ACTION (newCallAction), TRUE);
 
98
    gtk_action_set_sensitive (GTK_ACTION (pickUpAction), FALSE);
 
99
    gtk_action_set_sensitive (GTK_ACTION (hangUpAction), FALSE);
 
100
    gtk_action_set_sensitive (GTK_ACTION (imAction), FALSE);
 
101
 
 
102
    g_object_ref (hangUpWidget);
 
103
    g_object_ref (recordWidget);
 
104
    g_object_ref (holdToolbar);
 
105
    g_object_ref (offHoldToolbar);
 
106
    g_object_ref (contactButton);
 
107
    g_object_ref (historyButton);
 
108
    g_object_ref (transferToolbar);
 
109
    g_object_ref (voicemailToolbar);
 
110
    g_object_ref (imToolbar);
 
111
 
 
112
    if (is_inserted (GTK_WIDGET (hangUpWidget), GTK_WIDGET (toolbar))) {
 
113
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (hangUpWidget));
 
114
    }
 
115
 
 
116
    if (is_inserted (GTK_WIDGET (recordWidget), GTK_WIDGET (toolbar))) {
 
117
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (recordWidget));
 
118
    }
 
119
 
 
120
    if (is_inserted (GTK_WIDGET (transferToolbar), GTK_WIDGET (toolbar))) {
 
121
        gtk_container_remove (GTK_CONTAINER (toolbar),
 
122
                              GTK_WIDGET (transferToolbar));
 
123
    }
 
124
 
 
125
    if (is_inserted (GTK_WIDGET (historyButton), GTK_WIDGET (toolbar))) {
 
126
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (historyButton));
 
127
    }
 
128
 
 
129
    if (is_inserted (GTK_WIDGET (contactButton), GTK_WIDGET (toolbar))) {
 
130
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (contactButton));
 
131
    }
 
132
 
 
133
    if (is_inserted (GTK_WIDGET (voicemailToolbar), GTK_WIDGET (toolbar))) {
 
134
        gtk_container_remove (GTK_CONTAINER (toolbar),
 
135
                              GTK_WIDGET (voicemailToolbar));
 
136
    }
 
137
 
 
138
    if (is_inserted (GTK_WIDGET (imToolbar), GTK_WIDGET (toolbar))) {
 
139
        gtk_container_remove (GTK_CONTAINER (toolbar),
 
140
                              GTK_WIDGET (imToolbar));
 
141
    }
 
142
 
 
143
    gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), FALSE);
 
144
    gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), FALSE);
 
145
    gtk_widget_set_sensitive (GTK_WIDGET (offHoldToolbar), FALSE);
 
146
    gtk_action_set_sensitive (GTK_ACTION (recordAction), FALSE);
 
147
    gtk_widget_set_sensitive (GTK_WIDGET (recordWidget), FALSE);
 
148
    gtk_action_set_sensitive (GTK_ACTION (copyAction), FALSE);
 
149
    gtk_widget_set_sensitive (GTK_WIDGET (contactButton), FALSE);
 
150
    gtk_widget_set_sensitive (GTK_WIDGET (historyButton), FALSE);
 
151
    gtk_widget_set_tooltip_text (GTK_WIDGET (contactButton),
 
152
                                 _ ("No address book selected"));
 
153
 
 
154
    if (is_inserted (GTK_WIDGET (holdToolbar), GTK_WIDGET (toolbar)))
 
155
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (holdToolbar));
 
156
 
 
157
    if (is_inserted (GTK_WIDGET (offHoldToolbar), GTK_WIDGET (toolbar)))
 
158
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (offHoldToolbar));
 
159
 
 
160
    if (is_inserted (GTK_WIDGET (newCallWidget), GTK_WIDGET (toolbar)))
 
161
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));
 
162
 
 
163
    if (is_inserted (GTK_WIDGET (pickUpWidget), GTK_WIDGET (toolbar)))
 
164
        gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (pickUpWidget));
 
165
 
 
166
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (newCallWidget), 0);
 
167
 
 
168
 
 
169
    if (eel_gconf_get_integer (HISTORY_ENABLED)) {
 
170
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (historyButton), -1);
 
171
        gtk_widget_set_sensitive (GTK_WIDGET (historyButton), TRUE);
 
172
    }
 
173
 
 
174
    // If addressbook support has been enabled and all addressbooks are loaded, display the icon
 
175
    if (addressbook_is_enabled() && addressbook_is_ready()) {
 
176
        gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (contactButton),
 
177
                            -1);
 
178
 
 
179
        // Make the icon clickable only if at least one address book is active
 
180
        if (addressbook_is_active()) {
 
181
            gtk_widget_set_sensitive (GTK_WIDGET (contactButton), TRUE);
 
182
            gtk_widget_set_tooltip_text (GTK_WIDGET (contactButton),
 
183
                                         _ ("Address book"));
 
184
        }
 
185
    }
 
186
 
 
187
    // g_signal_handler_block (GTK_OBJECT (recordWidget), recordButtonConnId);
 
188
    // gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), FALSE);
 
189
    // g_signal_handler_unblock (GTK_OBJECT (recordWidget), recordButtonConnId);
 
190
 
 
191
    callable_obj_t * selectedCall = calltab_get_selected_call (active_calltree);
 
192
    conference_obj_t * selectedConf = calltab_get_selected_conf (active_calltree);
 
193
 
 
194
    gboolean instant_messaging_enabled = TRUE;
 
195
 
 
196
    if (eel_gconf_key_exists (INSTANT_MESSAGING_ENABLED))
 
197
        instant_messaging_enabled = eel_gconf_get_integer (INSTANT_MESSAGING_ENABLED);
 
198
 
 
199
    if (selectedCall) {
 
200
        // update icon in systray
 
201
        show_status_hangup_icon();
 
202
 
 
203
        gtk_action_set_sensitive (GTK_ACTION (copyAction), TRUE);
 
204
 
 
205
        switch (selectedCall->_state) {
 
206
            case CALL_STATE_INCOMING:
 
207
                // Make the button toolbar clickable
 
208
                gtk_action_set_sensitive (GTK_ACTION (pickUpAction), TRUE);
 
209
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
210
                // Replace the dial button with the hangup button
 
211
                g_object_ref (newCallWidget);
 
212
                gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));
 
213
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (pickUpWidget),
 
214
                                    0);
 
215
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
 
216
                                    1);
 
217
                break;
 
218
            case CALL_STATE_HOLD:
 
219
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
220
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
 
221
                gtk_widget_set_sensitive (GTK_WIDGET (offHoldToolbar), TRUE);
 
222
                gtk_widget_set_sensitive (GTK_WIDGET (newCallWidget), TRUE);
 
223
 
 
224
                // Replace the hold button with the off-hold button
 
225
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
226
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (offHoldToolbar), 2);
 
227
 
 
228
                if (instant_messaging_enabled) {
 
229
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
230
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 3);
 
231
                }
 
232
 
 
233
                break;
 
234
            case CALL_STATE_RINGING:
 
235
                gtk_action_set_sensitive (GTK_ACTION (pickUpAction), TRUE);
 
236
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
237
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget),
 
238
                                    1);
 
239
                break;
 
240
            case CALL_STATE_DIALING:
 
241
                gtk_action_set_sensitive (GTK_ACTION (pickUpAction), TRUE);
 
242
 
 
243
                if (active_calltree == current_calls)
 
244
                    gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
245
 
 
246
                //gtk_action_set_sensitive( GTK_ACTION(newCallMenu),TRUE);
 
247
                g_object_ref (newCallWidget);
 
248
                gtk_container_remove (GTK_CONTAINER (toolbar), GTK_WIDGET (newCallWidget));
 
249
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (pickUpWidget), 0);
 
250
 
 
251
                if (active_calltree == current_calls)
 
252
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
253
 
 
254
                break;
 
255
            case CALL_STATE_CURRENT:
 
256
                DEBUG ("UIManager: Call State Current");
 
257
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
258
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
259
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
 
260
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
 
261
                gtk_widget_set_sensitive (GTK_WIDGET (transferToolbar), TRUE);
 
262
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
 
263
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
 
264
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (transferToolbar), 3);
 
265
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 4);
 
266
                gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
 
267
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (transferToolbar), FALSE);
 
268
                gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
 
269
                g_signal_handler_block (GTK_OBJECT (recordWidget), recordButtonConnId);
 
270
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), FALSE);
 
271
                g_signal_handler_unblock (GTK_OBJECT (recordWidget), recordButtonConnId);
 
272
 
 
273
                if (instant_messaging_enabled) {
 
274
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
275
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 5);
 
276
                }
 
277
 
 
278
                break;
 
279
 
 
280
            case CALL_STATE_RECORD:
 
281
                DEBUG ("UIManager: Call State Record");
 
282
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
283
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
284
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
 
285
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
 
286
                gtk_widget_set_sensitive (GTK_WIDGET (transferToolbar), TRUE);
 
287
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
 
288
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
 
289
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (transferToolbar), 3);
 
290
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 4);
 
291
                gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
 
292
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (transferToolbar), FALSE);
 
293
                gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
 
294
                g_signal_handler_block (GTK_OBJECT (recordWidget), recordButtonConnId);
 
295
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), TRUE);
 
296
                g_signal_handler_unblock (GTK_OBJECT (recordWidget), recordButtonConnId);
 
297
 
 
298
                if (instant_messaging_enabled) {
 
299
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
300
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 5);
 
301
                }
 
302
 
 
303
                break;
 
304
            case CALL_STATE_BUSY:
 
305
            case CALL_STATE_FAILURE:
 
306
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
307
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
308
                break;
 
309
            case CALL_STATE_TRANSFERT:
 
310
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
311
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (transferToolbar), 2);
 
312
                gtk_signal_handler_block (GTK_OBJECT (transferToolbar), transfertButtonConnId);
 
313
                gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (transferToolbar), TRUE);
 
314
                gtk_signal_handler_unblock (transferToolbar, transfertButtonConnId);
 
315
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
316
                gtk_widget_set_sensitive (GTK_WIDGET (holdMenu), TRUE);
 
317
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
 
318
                gtk_widget_set_sensitive (GTK_WIDGET (transferToolbar), TRUE);
 
319
                break;
 
320
            default:
 
321
                WARN ("Should not happen in update_actions()!");
 
322
                break;
 
323
        }
 
324
    } else if (selectedConf) {
 
325
 
 
326
        // update icon in systray
 
327
        show_status_hangup_icon();
 
328
 
 
329
        switch (selectedConf->_state) {
 
330
 
 
331
            case CONFERENCE_STATE_ACTIVE_ATACHED:
 
332
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
333
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
 
334
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
 
335
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
336
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
 
337
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
 
338
 
 
339
                if (instant_messaging_enabled) {
 
340
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
341
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
 
342
                }
 
343
 
 
344
                break;
 
345
 
 
346
            case CONFERENCE_STATE_ACTIVE_DETACHED:
 
347
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
348
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
 
349
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
 
350
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
351
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
 
352
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
 
353
 
 
354
                if (instant_messaging_enabled) {
 
355
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
356
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
 
357
                }
 
358
 
 
359
                break;
 
360
 
 
361
            case CONFERENCE_STATE_RECORD:
 
362
                DEBUG ("UIManager: Conference state record");
 
363
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
364
                gtk_widget_set_sensitive (GTK_WIDGET (holdToolbar), TRUE);
 
365
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
 
366
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
367
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (holdToolbar), 2);
 
368
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
 
369
 
 
370
                if (instant_messaging_enabled) {
 
371
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
372
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
 
373
                }
 
374
 
 
375
                break;
 
376
 
 
377
            case CONFERENCE_STATE_HOLD:
 
378
                gtk_action_set_sensitive (GTK_ACTION (hangUpAction), TRUE);
 
379
                gtk_widget_set_sensitive (GTK_WIDGET (offHoldToolbar), TRUE);
 
380
                gtk_action_set_sensitive (GTK_ACTION (recordAction), TRUE);
 
381
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (hangUpWidget), 1);
 
382
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (offHoldToolbar), 2);
 
383
                gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (recordWidget), 3);
 
384
 
 
385
                if (instant_messaging_enabled) {
 
386
                    gtk_action_set_sensitive (GTK_ACTION (imAction), TRUE);
 
387
                    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (imToolbar), 4);
 
388
                }
 
389
 
 
390
                break;
 
391
 
 
392
            default:
 
393
                WARN ("Should not happen in update_action()!");
 
394
                break;
 
395
 
 
396
        }
 
397
    }
 
398
 
 
399
    else {
 
400
 
 
401
        // update icon in systray
 
402
        hide_status_hangup_icon();
 
403
 
 
404
        if (account_list_get_size() > 0 && current_account_has_mailbox()) {
 
405
            gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
 
406
                                GTK_TOOL_ITEM (voicemailToolbar), -2);
 
407
            update_voicemail_status();
330
408
        }
331
409
    }
332
410
}
333
411
 
334
412
void
335
 
update_voicemail_status(void)
336
 
{
337
 
  gchar *messages = "";
338
 
  messages = g_markup_printf_escaped(_("Voicemail (%i)"),
339
 
      current_account_get_message_number());
340
 
  (current_account_has_new_message()) ? gtk_tool_button_set_icon_name(
341
 
      GTK_TOOL_BUTTON (voicemailToolbar), "mail-message-new")
342
 
      : gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (voicemailToolbar),
343
 
          "mail-read");
344
 
  gtk_tool_button_set_label(GTK_TOOL_BUTTON (voicemailToolbar), messages);
345
 
  g_free(messages);
346
 
}
347
 
 
348
 
static void
349
 
volume_bar_cb(GtkToggleAction *togglemenuitem, gpointer user_data)
350
 
{
351
 
  gboolean toggled = gtk_toggle_action_get_active(togglemenuitem);
352
 
  if (toggled == SHOW_VOLUME)
353
 
    return;
354
 
  main_window_volume_controls(toggled);
355
 
  if (toggled || SHOW_VOLUME)
356
 
    dbus_set_volume_controls(toggled);
357
 
}
358
 
 
359
 
static void
360
 
dialpad_bar_cb(GtkToggleAction *togglemenuitem, gpointer user_data)
361
 
{
362
 
  gboolean toggled = gtk_toggle_action_get_active(togglemenuitem);
363
 
  if (toggled == SHOW_DIALPAD)
364
 
    return;
365
 
  main_window_dialpad(toggled);
366
 
  if (toggled || SHOW_DIALPAD)
367
 
    dbus_set_dialpad(toggled);
368
 
}
369
 
 
370
 
static void
371
 
help_contents_cb(GtkAction *action)
372
 
{
373
 
  GError *error = NULL;
374
 
 
375
 
  gnome_help_display("sflphone.xml", NULL, &error);
376
 
  if (error != NULL) {
377
 
      g_warning("%s", error->message);
378
 
      g_error_free(error);
379
 
  }
380
 
}
381
 
 
382
 
static void
383
 
help_about(void * foo UNUSED)
384
 
{
385
 
  gchar
386
 
      *authors[] =
387
 
        {
388
 
            "Pierre-Luc Bacon <pierre-luc.bacon@savoirfairelinux.com>",
389
 
            "Jean-Philippe Barrette-LaPierre",
390
 
            "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
391
 
            "Julien Bonjean <julien.bonjean@savoirfairelinux.com>",
392
 
            "Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>",
393
 
            "Laurielle Lea",
394
 
            "Yun Liu <yun.liu@savoirfairelinux.com>",
395
 
            "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>",
396
 
            "Yan Morin <yan.morin@savoirfairelinux.com>",
397
 
            "Jérôme Oufella <jerome.oufella@savoirfairelinux.com>",
398
 
            "Julien Plissonneau Duquene <julien.plissonneau.duquene@savoirfairelinux.com>",
399
 
            "Alexandre Savard <alexandre.savard@savoirfairelinux.com>", NULL };
400
 
  gchar *artists[] =
401
 
    { "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
402
 
        "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>", NULL };
403
 
 
404
 
  gtk_show_about_dialog(GTK_WINDOW(get_main_window()), "artists", artists,
405
 
      "authors", authors, "comments",
406
 
      _("SFLphone is a VoIP client compatible with SIP and IAX2 protocols."),
407
 
      "copyright", "Copyright © 2004-2009 Savoir-faire Linux Inc.", "name",
408
 
      PACKAGE, "title", _("About SFLphone"), "version", VERSION, "website",
409
 
      "http://www.sflphone.org", NULL);
 
413
update_voicemail_status (void)
 
414
{
 
415
    gchar *messages = "";
 
416
    messages = g_markup_printf_escaped (_ ("Voicemail (%i)"),
 
417
                                        current_account_get_message_number());
 
418
    (current_account_has_new_message()) ? gtk_tool_button_set_icon_name (
 
419
        GTK_TOOL_BUTTON (voicemailToolbar), "mail-message-new")
 
420
    : gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (voicemailToolbar),
 
421
                                     "mail-read");
 
422
    gtk_tool_button_set_label (GTK_TOOL_BUTTON (voicemailToolbar), messages);
 
423
    g_free (messages);
 
424
}
 
425
 
 
426
static void
 
427
volume_bar_cb (GtkToggleAction *togglemenuitem, gpointer user_data UNUSED)
 
428
{
 
429
    gboolean toggled = gtk_toggle_action_get_active (togglemenuitem);
 
430
 
 
431
    if (toggled == SHOW_VOLUME)
 
432
        return;
 
433
 
 
434
    main_window_volume_controls (toggled);
 
435
 
 
436
    if (toggled || SHOW_VOLUME)
 
437
        eel_gconf_set_integer (SHOW_VOLUME_CONTROLS, toggled);
 
438
}
 
439
 
 
440
static void
 
441
dialpad_bar_cb (GtkToggleAction *togglemenuitem, gpointer user_data UNUSED)
 
442
{
 
443
    gboolean toggled = gtk_toggle_action_get_active (togglemenuitem);
 
444
    gboolean conf_dialpad = eel_gconf_get_boolean (CONF_SHOW_DIALPAD);
 
445
 
 
446
    if (toggled == conf_dialpad)
 
447
        return;
 
448
 
 
449
    main_window_dialpad (toggled);
 
450
 
 
451
    if (toggled || conf_dialpad)
 
452
        eel_gconf_set_boolean (CONF_SHOW_DIALPAD, toggled); //dbus_set_dialpad (toggled);
 
453
 
 
454
}
 
455
 
 
456
static void
 
457
help_contents_cb (GtkAction *action UNUSED)
 
458
{
 
459
    GError *error = NULL;
 
460
 
 
461
    gnome_help_display ("sflphone.xml", NULL, &error);
 
462
 
 
463
    if (error != NULL) {
 
464
        g_warning ("%s", error->message);
 
465
        g_error_free (error);
 
466
    }
 
467
}
 
468
 
 
469
static void
 
470
help_about (void * foo UNUSED)
 
471
{
 
472
    gchar
 
473
    *authors[] = {
 
474
        "Pierre-Luc Bacon <pierre-luc.bacon@savoirfairelinux.com>",
 
475
        "Jean-Philippe Barrette-LaPierre",
 
476
        "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
 
477
        "Julien Bonjean <julien.bonjean@savoirfairelinux.com>",
 
478
        "Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>",
 
479
        "Laurielle Lea",
 
480
        "Yun Liu <yun.liu@savoirfairelinux.com>",
 
481
        "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>",
 
482
        "Yan Morin <yan.morin@savoirfairelinux.com>",
 
483
        "Jérôme Oufella <jerome.oufella@savoirfairelinux.com>",
 
484
        "Julien Plissonneau Duquene <julien.plissonneau.duquene@savoirfairelinux.com>",
 
485
        "Alexandre Savard <alexandre.savard@savoirfairelinux.com>", NULL
 
486
    };
 
487
    gchar *artists[] = { "Pierre-Luc Beaudoin <pierre-luc.beaudoin@savoirfairelinux.com>",
 
488
                         "Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>", NULL
 
489
                       };
 
490
 
 
491
    gtk_show_about_dialog (GTK_WINDOW (get_main_window()), "artists", artists,
 
492
                           "authors", authors, "comments",
 
493
                           _ ("SFLphone is a VoIP client compatible with SIP and IAX2 protocols."),
 
494
                           "copyright", "Copyright © 2004-2009 Savoir-faire Linux Inc.", "name",
 
495
                           PACKAGE, "title", _ ("About SFLphone"), "version", VERSION, "website",
 
496
                           "http://www.sflphone.org", NULL);
410
497
 
411
498
}
412
499
 
413
500
/* ----------------------------------------------------------------- */
414
501
 
415
502
static void
416
 
call_new_call(void * foo UNUSED)
417
 
{
418
 
  sflphone_new_call();
419
 
}
420
 
 
421
 
static void
422
 
call_quit(void * foo UNUSED)
423
 
{
424
 
  sflphone_quit();
425
 
}
426
 
 
427
 
static void
428
 
call_minimize(void * foo UNUSED)
429
 
{
430
 
 
431
 
    if (g_strcasecmp (dbus_is_status_icon_enabled (), "true") == 0) {
432
 
        gtk_widget_hide(GTK_WIDGET( get_main_window() ));
433
 
        set_minimized(TRUE);
434
 
    }
435
 
    else {
436
 
          sflphone_quit ();
437
 
    }
438
 
}
439
 
 
440
 
static void
441
 
switch_account(GtkWidget* item, gpointer data UNUSED)
442
 
{
443
 
  account_t* acc = g_object_get_data(G_OBJECT(item), "account");
444
 
  DEBUG("%s" , acc->accountID);
445
 
  account_list_set_current(acc);
446
 
  status_bar_display_account();
447
 
}
448
 
 
449
 
static void
450
 
call_hold(void* foo UNUSED)
451
 
{
452
 
  callable_obj_t * selectedCall = calltab_get_selected_call(current_calls);
453
 
  conference_obj_t * selectedConf = calltab_get_selected_conf();
454
 
 
455
 
  if (selectedCall)
456
 
    {
457
 
      if (selectedCall->_state == CALL_STATE_HOLD)
458
 
        {
459
 
          sflphone_off_hold();
460
 
        }
461
 
      else
462
 
        {
463
 
          sflphone_on_hold();
464
 
        }
465
 
    }
466
 
  else if (selectedConf)
467
 
    {
468
 
 
469
 
      switch (selectedConf->_state)
470
 
        {
471
 
 
472
 
      case CONFERENCE_STATE_HOLD:
473
 
        {
474
 
          selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATACHED;
475
 
          sflphone_conference_off_hold(selectedConf);
476
 
        }
477
 
        break;
478
 
 
479
 
      case CONFERENCE_STATE_ACTIVE_ATACHED:
480
 
      case CONFERENCE_STATE_ACTIVE_DETACHED:
481
 
        {
482
 
          selectedConf->_state = CONFERENCE_STATE_HOLD;
483
 
          sflphone_conference_on_hold(selectedConf);
484
 
        }
485
 
        break;
486
 
      default:
487
 
        break;
488
 
        }
489
 
 
490
 
    }
491
 
}
492
 
 
493
 
static void
494
 
conference_hold(void* foo UNUSED)
495
 
{
496
 
  conference_obj_t * selectedConf = calltab_get_selected_conf();
497
 
 
498
 
  switch (selectedConf->_state)
499
 
    {
500
 
  case CONFERENCE_STATE_HOLD:
501
 
    {
502
 
      selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATACHED;
503
 
      sflphone_conference_off_hold(selectedConf);
504
 
    }
505
 
    break;
506
 
 
507
 
  case CONFERENCE_STATE_ACTIVE_ATACHED:
508
 
  case CONFERENCE_STATE_ACTIVE_DETACHED:
509
 
    {
510
 
      selectedConf->_state = CONFERENCE_STATE_HOLD;
511
 
      sflphone_conference_on_hold(selectedConf);
512
 
    }
513
 
    break;
514
 
  default:
515
 
    break;
516
 
    }
517
 
}
518
 
 
519
 
static void
520
 
call_pick_up(void * foo UNUSED)
521
 
{
522
 
  DEBUG("------ call_button -----");
523
 
  callable_obj_t * selectedCall;
524
 
  callable_obj_t* new_call;
525
 
 
526
 
  selectedCall = calltab_get_selected_call(active_calltree);
527
 
 
528
 
  if (calllist_get_size(current_calls) > 0)
529
 
    sflphone_pick_up();
530
 
 
531
 
  else if (calllist_get_size(active_calltree) > 0)
532
 
    {
533
 
      if (selectedCall)
534
 
        {
535
 
          create_new_call(CALL, CALL_STATE_DIALING, "", "", "",
536
 
              selectedCall->_peer_number, &new_call);
537
 
 
538
 
          calllist_add(current_calls, new_call);
539
 
          calltree_add_call(current_calls, new_call, NULL);
540
 
          sflphone_place_call(new_call);
541
 
          calltree_display(current_calls);
542
 
        }
543
 
      else
544
 
        {
545
 
          sflphone_new_call();
546
 
          calltree_display(current_calls);
547
 
        }
548
 
    }
549
 
  else
550
 
    {
551
 
      sflphone_new_call();
552
 
      calltree_display(current_calls);
553
 
    }
554
 
}
555
 
 
556
 
static void
557
 
call_hang_up(void)
558
 
{
559
 
        /* 
560
 
         * [#3020]      Restore the record toggle button 
561
 
         *                      We set it to FALSE, as when we hang up a call, the recording is stopped.
562
 
         */
563
 
        gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), FALSE);
564
 
  
565
 
        sflphone_hang_up();
566
 
 
567
 
}
568
 
 
569
 
static void
570
 
conference_hang_up(void)
571
 
{
572
 
  sflphone_conference_hang_up();
573
 
}
574
 
 
575
 
static void
576
 
call_record(void)
577
 
{
578
 
  sflphone_rec_call();
579
 
}
580
 
 
581
 
static void
582
 
call_configuration_assistant(void * foo UNUSED)
 
503
call_new_call (void * foo UNUSED)
 
504
{
 
505
    DEBUG ("UIManager: New call button pressed");
 
506
 
 
507
    sflphone_new_call();
 
508
}
 
509
 
 
510
static void
 
511
call_quit (void * foo UNUSED)
 
512
{
 
513
    sflphone_quit();
 
514
}
 
515
 
 
516
static void
 
517
call_minimize (void * foo UNUSED)
 
518
{
 
519
 
 
520
    if (eel_gconf_get_integer (SHOW_STATUSICON)) {
 
521
        gtk_widget_hide (GTK_WIDGET (get_main_window()));
 
522
        set_minimized (TRUE);
 
523
    } else {
 
524
        sflphone_quit ();
 
525
    }
 
526
}
 
527
 
 
528
static void
 
529
switch_account (GtkWidget* item, gpointer data UNUSED)
 
530
{
 
531
    account_t* acc = g_object_get_data (G_OBJECT (item), "account");
 
532
    DEBUG ("%s" , acc->accountID);
 
533
    account_list_set_current (acc);
 
534
    status_bar_display_account();
 
535
}
 
536
 
 
537
static void
 
538
call_hold (void* foo UNUSED)
 
539
{
 
540
    callable_obj_t * selectedCall = calltab_get_selected_call (current_calls);
 
541
    conference_obj_t * selectedConf = calltab_get_selected_conf();
 
542
 
 
543
    DEBUG ("UIManager: Hold button pressed (call)");
 
544
 
 
545
    if (selectedCall) {
 
546
        if (selectedCall->_state == CALL_STATE_HOLD) {
 
547
            sflphone_off_hold();
 
548
        } else {
 
549
            sflphone_on_hold();
 
550
        }
 
551
    } else if (selectedConf) {
 
552
 
 
553
        switch (selectedConf->_state) {
 
554
 
 
555
            case CONFERENCE_STATE_HOLD: {
 
556
                selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATACHED;
 
557
                sflphone_conference_off_hold (selectedConf);
 
558
            }
 
559
            break;
 
560
 
 
561
            case CONFERENCE_STATE_ACTIVE_ATACHED:
 
562
            case CONFERENCE_STATE_ACTIVE_DETACHED: {
 
563
                selectedConf->_state = CONFERENCE_STATE_HOLD;
 
564
                sflphone_conference_on_hold (selectedConf);
 
565
            }
 
566
            break;
 
567
            default:
 
568
                break;
 
569
        }
 
570
 
 
571
    }
 
572
}
 
573
 
 
574
static void
 
575
call_im (void* foo UNUSED)
 
576
{
 
577
    callable_obj_t *selectedCall = calltab_get_selected_call (current_calls);
 
578
    conference_obj_t *selectedConf = calltab_get_selected_conf();
 
579
 
 
580
    if (calltab_get_selected_type (current_calls) == A_CALL) {
 
581
 
 
582
        if (selectedCall) {
 
583
            im_widget_display ( (IMWidget **) (&selectedCall->_im_widget), NULL, selectedCall->_callID, NULL);
 
584
        } else {
 
585
            WARN ("Sorry. Instant messaging is not allowed outside a call\n");
 
586
        }
 
587
    } else {
 
588
        if (selectedConf) {
 
589
            im_widget_display ( (IMWidget **) (&selectedConf->_im_widget), NULL, selectedConf->_confID, NULL);
 
590
        } else {
 
591
            WARN ("Sorry. Instant messaging is not allowed outside a call\n");
 
592
        }
 
593
    }
 
594
}
 
595
 
 
596
static void
 
597
conference_hold (void* foo UNUSED)
 
598
{
 
599
    conference_obj_t * selectedConf = calltab_get_selected_conf();
 
600
 
 
601
    DEBUG ("UIManager: Hold button pressed (conference)");
 
602
 
 
603
    switch (selectedConf->_state) {
 
604
        case CONFERENCE_STATE_HOLD: {
 
605
            selectedConf->_state = CONFERENCE_STATE_ACTIVE_ATACHED;
 
606
            sflphone_conference_off_hold (selectedConf);
 
607
        }
 
608
        break;
 
609
 
 
610
        case CONFERENCE_STATE_ACTIVE_ATACHED:
 
611
        case CONFERENCE_STATE_ACTIVE_DETACHED: {
 
612
            selectedConf->_state = CONFERENCE_STATE_HOLD;
 
613
            sflphone_conference_on_hold (selectedConf);
 
614
        }
 
615
        break;
 
616
        default:
 
617
            break;
 
618
    }
 
619
}
 
620
 
 
621
static void
 
622
call_pick_up (void * foo UNUSED)
 
623
{
 
624
    DEBUG ("------ call_button -----");
 
625
    callable_obj_t * selectedCall;
 
626
    callable_obj_t* new_call;
 
627
 
 
628
    selectedCall = calltab_get_selected_call (active_calltree);
 
629
 
 
630
    if (calllist_get_size (current_calls) > 0)
 
631
        sflphone_pick_up();
 
632
 
 
633
    else if (calllist_get_size (active_calltree) > 0) {
 
634
        if (selectedCall) {
 
635
            create_new_call (CALL, CALL_STATE_DIALING, "", "", "",
 
636
                             selectedCall->_peer_number, &new_call);
 
637
 
 
638
            calllist_add (current_calls, new_call);
 
639
            calltree_add_call (current_calls, new_call, NULL);
 
640
            sflphone_place_call (new_call);
 
641
            calltree_display (current_calls);
 
642
        } else {
 
643
            sflphone_new_call();
 
644
            calltree_display (current_calls);
 
645
        }
 
646
    } else {
 
647
        sflphone_new_call();
 
648
        calltree_display (current_calls);
 
649
    }
 
650
}
 
651
 
 
652
static void
 
653
call_hang_up (void)
 
654
{
 
655
 
 
656
    DEBUG ("UIManager: Hang up button pressed (call)");
 
657
    /*
 
658
     * [#3020]  Restore the record toggle button
 
659
     *                  We set it to FALSE, as when we hang up a call, the recording is stopped.
 
660
     */
 
661
    gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (recordWidget), FALSE);
 
662
 
 
663
    sflphone_hang_up();
 
664
 
 
665
}
 
666
 
 
667
static void
 
668
conference_hang_up (void)
 
669
{
 
670
    DEBUG ("UIManager: Hang up button pressed (conference)");
 
671
 
 
672
    sflphone_conference_hang_up();
 
673
}
 
674
 
 
675
static void
 
676
call_record (void)
 
677
{
 
678
    DEBUG ("UIManager: Record button pressed");
 
679
 
 
680
    sflphone_rec_call();
 
681
}
 
682
 
 
683
static void
 
684
call_configuration_assistant (void * foo UNUSED)
583
685
{
584
686
#if GTK_CHECK_VERSION(2,10,0)
585
 
  build_wizard();
 
687
    build_wizard();
586
688
#endif
587
689
}
588
690
 
589
691
static void
590
 
remove_from_history(void * foo UNUSED)
591
 
{
592
 
  callable_obj_t* c = calltab_get_selected_call(history);
593
 
  if (c)
594
 
    {
595
 
      DEBUG("Remove the call from the history");
596
 
      calllist_remove_from_history(c);
597
 
    }
598
 
}
599
 
 
600
 
static void
601
 
call_back(void * foo UNUSED)
602
 
{
603
 
  callable_obj_t *selected_call, *new_call;
604
 
 
605
 
  selected_call = calltab_get_selected_call(active_calltree);
606
 
 
607
 
  if (selected_call)
608
 
    {
609
 
      create_new_call(CALL, CALL_STATE_DIALING, "", "",
610
 
          selected_call->_peer_name, selected_call->_peer_number, &new_call);
611
 
 
612
 
      calllist_add(current_calls, new_call);
613
 
      calltree_add_call(current_calls, new_call, NULL);
614
 
      sflphone_place_call(new_call);
615
 
      calltree_display(current_calls);
616
 
    }
617
 
}
618
 
 
619
 
static void
620
 
edit_preferences(void * foo UNUSED)
621
 
{
622
 
  show_preferences_dialog();
623
 
}
624
 
 
625
 
static void
626
 
edit_accounts(void * foo UNUSED)
627
 
{
628
 
  show_account_list_config_dialog();
 
692
remove_from_history (void * foo UNUSED)
 
693
{
 
694
    callable_obj_t* c = calltab_get_selected_call (history);
 
695
 
 
696
    if (c) {
 
697
        DEBUG ("UIManager: Remove the call from the history");
 
698
        calllist_remove_from_history (c);
 
699
    }
 
700
}
 
701
 
 
702
static void
 
703
call_back (void * foo UNUSED)
 
704
{
 
705
    callable_obj_t *selected_call, *new_call;
 
706
 
 
707
    selected_call = calltab_get_selected_call (active_calltree);
 
708
 
 
709
    if (selected_call) {
 
710
        create_new_call (CALL, CALL_STATE_DIALING, "", "",
 
711
                         selected_call->_peer_name, selected_call->_peer_number, &new_call);
 
712
 
 
713
        calllist_add (current_calls, new_call);
 
714
        calltree_add_call (current_calls, new_call, NULL);
 
715
        sflphone_place_call (new_call);
 
716
        calltree_display (current_calls);
 
717
    }
 
718
}
 
719
 
 
720
static void
 
721
edit_preferences (void * foo UNUSED)
 
722
{
 
723
    show_preferences_dialog();
 
724
}
 
725
 
 
726
static void
 
727
edit_accounts (void * foo UNUSED)
 
728
{
 
729
    show_account_list_config_dialog();
629
730
}
630
731
 
631
732
// The menu Edit/Copy should copy the current selected call's number
632
733
static void
633
 
edit_copy(void * foo UNUSED)
 
734
edit_copy (void * foo UNUSED)
634
735
{
635
 
  GtkClipboard* clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
636
 
  callable_obj_t * selectedCall = calltab_get_selected_call(current_calls);
637
 
  gchar * no = NULL;
 
736
    GtkClipboard* clip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
 
737
    callable_obj_t * selectedCall = calltab_get_selected_call (current_calls);
 
738
    gchar * no = NULL;
638
739
 
639
 
  if (selectedCall)
640
 
    {
641
 
      switch (selectedCall->_state)
642
 
        {
643
 
      case CALL_STATE_TRANSFERT:
644
 
      case CALL_STATE_DIALING:
645
 
      case CALL_STATE_RINGING:
646
 
        no = selectedCall->_peer_number;
647
 
        break;
648
 
      case CALL_STATE_CURRENT:
649
 
      case CALL_STATE_HOLD:
650
 
      case CALL_STATE_BUSY:
651
 
      case CALL_STATE_FAILURE:
652
 
      case CALL_STATE_INCOMING:
653
 
      default:
654
 
        no = selectedCall->_peer_number;
655
 
        break;
 
740
    if (selectedCall) {
 
741
        switch (selectedCall->_state) {
 
742
            case CALL_STATE_TRANSFERT:
 
743
            case CALL_STATE_DIALING:
 
744
            case CALL_STATE_RINGING:
 
745
                no = selectedCall->_peer_number;
 
746
                break;
 
747
            case CALL_STATE_CURRENT:
 
748
            case CALL_STATE_HOLD:
 
749
            case CALL_STATE_BUSY:
 
750
            case CALL_STATE_FAILURE:
 
751
            case CALL_STATE_INCOMING:
 
752
            default:
 
753
                no = selectedCall->_peer_number;
 
754
                break;
656
755
        }
657
 
      DEBUG("Clipboard number: %s\n", no);
658
 
      gtk_clipboard_set_text(clip, no, strlen(no));
 
756
 
 
757
        DEBUG ("UIManager: Clipboard number: %s\n", no);
 
758
        gtk_clipboard_set_text (clip, no, strlen (no));
659
759
    }
660
760
 
661
761
}
662
762
 
663
763
// The menu Edit/Paste should paste the clipboard into the current selected call
664
764
static void
665
 
edit_paste(void * foo UNUSED)
 
765
edit_paste (void * foo UNUSED)
666
766
{
667
767
 
668
 
  GtkClipboard* clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
669
 
  callable_obj_t * selectedCall = calltab_get_selected_call(current_calls);
670
 
  gchar * no = gtk_clipboard_wait_for_text(clip);
671
 
 
672
 
  if (no && selectedCall)
673
 
    {
674
 
      switch (selectedCall->_state)
675
 
        {
676
 
      case CALL_STATE_TRANSFERT:
677
 
      case CALL_STATE_DIALING:
678
 
        // Add the text to the number
679
 
        {
680
 
          gchar * before;
681
 
          before = selectedCall->_peer_number;
682
 
          DEBUG("TO: %s\n", before);
683
 
          selectedCall->_peer_number = g_strconcat(before, no, NULL);
684
 
 
685
 
          if (selectedCall->_state == CALL_STATE_DIALING)
686
 
            {
687
 
              selectedCall->_peer_info = g_strconcat("\"\" <",
688
 
                  selectedCall->_peer_number, ">", NULL);
689
 
            }
690
 
          calltree_update_call(current_calls, selectedCall, NULL);
691
 
        }
692
 
        break;
693
 
      case CALL_STATE_RINGING:
694
 
      case CALL_STATE_INCOMING:
695
 
      case CALL_STATE_BUSY:
696
 
      case CALL_STATE_FAILURE:
697
 
      case CALL_STATE_HOLD:
698
 
        { // Create a new call to hold the new text
699
 
          selectedCall = sflphone_new_call();
700
 
 
701
 
          gchar * before = selectedCall->_peer_number;
702
 
          selectedCall->_peer_number = g_strconcat(selectedCall->_peer_number,
703
 
              no, NULL);
704
 
          DEBUG("TO: %s", selectedCall->_peer_number);
705
 
 
706
 
          selectedCall->_peer_info = g_strconcat("\"\" <",
707
 
              selectedCall->_peer_number, ">", NULL);
708
 
 
709
 
          calltree_update_call(current_calls, selectedCall, NULL);
710
 
        }
711
 
        break;
712
 
      case CALL_STATE_CURRENT:
713
 
      default:
714
 
        {
715
 
          unsigned int i;
716
 
          for (i = 0; i < strlen(no); i++)
717
 
            {
718
 
              gchar * oneNo = g_strndup(&no[i], 1);
719
 
              DEBUG("<%s>", oneNo);
720
 
              dbus_play_dtmf(oneNo);
721
 
 
722
 
              gchar * temp = g_strconcat(selectedCall->_peer_number, oneNo,
723
 
                  NULL);
724
 
              selectedCall->_peer_info = get_peer_info(temp,
725
 
                  selectedCall->_peer_name);
726
 
              // g_free(temp);
727
 
              calltree_update_call(current_calls, selectedCall, NULL);
728
 
 
729
 
            }
730
 
        }
731
 
        break;
732
 
        }
733
 
 
734
 
    }
735
 
  else // There is no current call, create one
736
 
    {
737
 
      selectedCall = sflphone_new_call();
738
 
 
739
 
      gchar * before = selectedCall->_peer_number;
740
 
      selectedCall->_peer_number = g_strconcat(selectedCall->_peer_number, no,
741
 
          NULL);
742
 
      g_free(before);
743
 
      DEBUG("TO: %s", selectedCall->_peer_number);
744
 
 
745
 
      g_free(selectedCall->_peer_info);
746
 
      selectedCall->_peer_info = g_strconcat("\"\" <",
747
 
          selectedCall->_peer_number, ">", NULL);
748
 
      calltree_update_call(current_calls, selectedCall, NULL);
 
768
    GtkClipboard* clip = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
 
769
    callable_obj_t * selectedCall = calltab_get_selected_call (current_calls);
 
770
    gchar * no = gtk_clipboard_wait_for_text (clip);
 
771
 
 
772
    if (no && selectedCall) {
 
773
        switch (selectedCall->_state) {
 
774
            case CALL_STATE_TRANSFERT:
 
775
            case CALL_STATE_DIALING:
 
776
                // Add the text to the number
 
777
            {
 
778
                gchar * before;
 
779
                before = selectedCall->_peer_number;
 
780
                DEBUG ("TO: %s\n", before);
 
781
                selectedCall->_peer_number = g_strconcat (before, no, NULL);
 
782
 
 
783
                if (selectedCall->_state == CALL_STATE_DIALING) {
 
784
                    selectedCall->_peer_info = g_strconcat ("\"\" <",
 
785
                                                            selectedCall->_peer_number, ">", NULL);
 
786
                }
 
787
 
 
788
                calltree_update_call (current_calls, selectedCall, NULL);
 
789
            }
 
790
            break;
 
791
            case CALL_STATE_RINGING:
 
792
            case CALL_STATE_INCOMING:
 
793
            case CALL_STATE_BUSY:
 
794
            case CALL_STATE_FAILURE:
 
795
            case CALL_STATE_HOLD: { // Create a new call to hold the new text
 
796
                selectedCall = sflphone_new_call();
 
797
 
 
798
                selectedCall->_peer_number = g_strconcat (selectedCall->_peer_number,
 
799
                                             no, NULL);
 
800
                DEBUG ("TO: %s", selectedCall->_peer_number);
 
801
 
 
802
                selectedCall->_peer_info = g_strconcat ("\"\" <",
 
803
                                                        selectedCall->_peer_number, ">", NULL);
 
804
 
 
805
                calltree_update_call (current_calls, selectedCall, NULL);
 
806
            }
 
807
            break;
 
808
            case CALL_STATE_CURRENT:
 
809
            default: {
 
810
                unsigned int i;
 
811
 
 
812
                for (i = 0; i < strlen (no); i++) {
 
813
                    gchar * oneNo = g_strndup (&no[i], 1);
 
814
                    DEBUG ("<%s>", oneNo);
 
815
                    dbus_play_dtmf (oneNo);
 
816
 
 
817
                    gchar * temp = g_strconcat (selectedCall->_peer_number, oneNo,
 
818
                                                NULL);
 
819
                    selectedCall->_peer_info = get_peer_info (temp,
 
820
                                               selectedCall->_peer_name);
 
821
                    // g_free(temp);
 
822
                    calltree_update_call (current_calls, selectedCall, NULL);
 
823
 
 
824
                }
 
825
            }
 
826
            break;
 
827
        }
 
828
 
 
829
    } else { // There is no current call, create one
 
830
        selectedCall = sflphone_new_call();
 
831
 
 
832
        gchar * before = selectedCall->_peer_number;
 
833
        selectedCall->_peer_number = g_strconcat (selectedCall->_peer_number, no,
 
834
                                     NULL);
 
835
        g_free (before);
 
836
        DEBUG ("UIManager: TO: %s", selectedCall->_peer_number);
 
837
 
 
838
        g_free (selectedCall->_peer_info);
 
839
        selectedCall->_peer_info = g_strconcat ("\"\" <",
 
840
                                                selectedCall->_peer_number, ">", NULL);
 
841
        calltree_update_call (current_calls, selectedCall, NULL);
749
842
    }
750
843
 
751
844
}
752
845
 
753
846
static void
754
 
clear_history(void)
 
847
clear_history (void)
755
848
{
756
 
  if (calllist_get_size(history) != 0)
757
 
    {
758
 
      calllist_clean_history();
 
849
    if (calllist_get_size (history) != 0) {
 
850
        calllist_clean_history();
759
851
    }
760
852
}
761
853
 
765
857
static void
766
858
call_transfer_cb()
767
859
{
768
 
  gboolean active = gtk_toggle_tool_button_get_active(
769
 
      GTK_TOGGLE_TOOL_BUTTON (transferToolbar));
770
 
  active ? sflphone_set_transfert() : sflphone_unset_transfert();
771
 
}
772
 
 
773
 
static void
774
 
call_mailbox_cb(void)
775
 
{
776
 
  account_t* current;
777
 
  callable_obj_t *mailbox_call;
778
 
  gchar *to, *from, *account_id;
779
 
 
780
 
  current = account_list_get_current();
781
 
  if (current == NULL) // Should not happens
782
 
    return;
783
 
 
784
 
  to = g_strdup(g_hash_table_lookup(current->properties, ACCOUNT_MAILBOX));
785
 
  account_id = g_strdup(current->accountID);
786
 
 
787
 
  create_new_call(CALL, CALL_STATE_DIALING, "", account_id, _("Voicemail"), to,
788
 
      &mailbox_call);
789
 
  DEBUG("TO : %s" , mailbox_call->_peer_number);
790
 
  calllist_add(current_calls, mailbox_call);
791
 
  calltree_add_call(current_calls, mailbox_call, NULL);
792
 
  update_actions();
793
 
  sflphone_place_call(mailbox_call);
794
 
  calltree_display(current_calls);
795
 
}
796
 
 
797
 
static void
798
 
toggle_history_cb(GtkToggleAction *action, gpointer user_data)
799
 
{
800
 
  gboolean toggle;
801
 
  toggle = gtk_toggle_action_get_active(action);
802
 
  (toggle) ? calltree_display(history) : calltree_display(current_calls);
803
 
}
804
 
 
805
 
static void
806
 
toggle_addressbook_cb(GtkToggleAction *action, gpointer user_data)
807
 
{
808
 
  gboolean toggle;
809
 
  toggle = gtk_toggle_action_get_active(action);
810
 
  (toggle) ? calltree_display(contacts) : calltree_display(current_calls);
811
 
}
812
 
 
813
 
static const GtkActionEntry menu_entries[] =
814
 
  {
815
 
 
816
 
  // Call Menu
817
 
        { "Call", NULL, N_("Call") },
818
 
        { "NewCall", GTK_STOCK_DIAL, N_("_New call"), "<control>N",
819
 
            N_("Place a new call"), G_CALLBACK (call_new_call) },
820
 
        { "PickUp", GTK_STOCK_PICKUP, N_("_Pick up"), NULL,
821
 
            N_("Answer the call"), G_CALLBACK (call_pick_up) },
822
 
        { "HangUp", GTK_STOCK_HANGUP, N_("_Hang up"), "<control>S",
823
 
            N_("Finish the call"), G_CALLBACK (call_hang_up) },
824
 
        { "OnHold", GTK_STOCK_ONHOLD, N_("O_n hold"), "<control>P",
825
 
            N_("Place the call on hold"), G_CALLBACK (call_hold) },
826
 
        { "OffHold", GTK_STOCK_OFFHOLD, N_("O_ff hold"), "<control>P",
827
 
            N_("Place the call off hold"), G_CALLBACK (call_hold) },
828
 
        { "AccountAssistant", NULL, N_("Configuration _Assistant"), NULL,
829
 
            N_("Run the configuration assistant"),
830
 
            G_CALLBACK (call_configuration_assistant) },
831
 
        { "Voicemail", "mail-read", N_("Voicemail"), NULL,
832
 
            N_("Call your voicemail"), G_CALLBACK (call_mailbox_cb) },
833
 
        { "Close", GTK_STOCK_CLOSE, N_("_Close"), "<control>W",
834
 
            N_("Minimize to system tray"), G_CALLBACK (call_minimize) },
835
 
        { "Quit", GTK_STOCK_CLOSE, N_("_Quit"), "<control>Q",
836
 
            N_("Quit the program"), G_CALLBACK (call_quit) },
837
 
 
838
 
      // Edit Menu
839
 
        { "Edit", NULL, N_("_Edit") },
840
 
        { "Copy", GTK_STOCK_COPY, N_("_Copy"), "<control>C",
841
 
            N_("Copy the selection"), G_CALLBACK (edit_copy) },
842
 
        { "Paste", GTK_STOCK_PASTE, N_("_Paste"), "<control>V",
843
 
            N_("Paste the clipboard"), G_CALLBACK (edit_paste) },
844
 
        { "ClearHistory", GTK_STOCK_CLEAR, N_("Clear _history"), NULL,
845
 
            N_("Clear the call history"), G_CALLBACK (clear_history) },
846
 
        { "Accounts", NULL, N_("_Accounts"), NULL, N_("Edit your accounts"),
847
 
            G_CALLBACK (edit_accounts) },
848
 
        { "Preferences", GTK_STOCK_PREFERENCES, N_("_Preferences"), NULL,
849
 
            N_("Change your preferences"), G_CALLBACK (edit_preferences) },
850
 
 
851
 
      // View Menu
852
 
        { "View", NULL, N_("_View") },
853
 
 
854
 
      // Help menu
855
 
        { "Help", NULL, N_("_Help") },
856
 
        { "HelpContents", GTK_STOCK_HELP, N_("Contents"), "F1",
857
 
            N_("Open the manual"), G_CALLBACK (help_contents_cb) },
858
 
        { "About", GTK_STOCK_ABOUT, NULL, NULL, N_("About this application"),
859
 
            G_CALLBACK (help_about) }
860
 
 
861
 
  };
862
 
 
863
 
static const GtkToggleActionEntry toggle_menu_entries[] =
864
 
  {
865
 
 
866
 
    { "Transfer", GTK_STOCK_TRANSFER, N_("_Transfer"), "<control>T",
867
 
        N_("Transfer the call"), NULL }, //G_CALLBACK (call_transfer_cb) },
868
 
        { "Record", GTK_STOCK_MEDIA_RECORD, N_("_Record"), "<control>R",
869
 
            N_("Record the current conversation"), NULL }, // G_CALLBACK (call_record) },
870
 
        { "Toolbar", NULL, N_("_Show toolbar"), "<control>T",
871
 
            N_("Show the toolbar"), NULL },
872
 
        { "Dialpad", NULL, N_("_Dialpad"), "<control>D",
873
 
            N_("Show the dialpad"), G_CALLBACK (dialpad_bar_cb) },
874
 
        { "VolumeControls", NULL, N_("_Volume controls"), "<control>V",
875
 
            N_("Show the volume controls"), G_CALLBACK (volume_bar_cb) },
876
 
        { "History", "appointment-soon", N_("_History"), NULL,
877
 
            N_("Calls history"), G_CALLBACK (toggle_history_cb), FALSE },
878
 
        { "Addressbook", GTK_STOCK_ADDRESSBOOK, N_("_Address book"), NULL,
879
 
            N_("Address book"), G_CALLBACK (toggle_addressbook_cb), FALSE }
880
 
 
881
 
  };
 
860
    gboolean active = gtk_toggle_tool_button_get_active (
 
861
                          GTK_TOGGLE_TOOL_BUTTON (transferToolbar));
 
862
    active ? sflphone_set_transfert() : sflphone_unset_transfert();
 
863
}
 
864
 
 
865
static void
 
866
call_mailbox_cb (void)
 
867
{
 
868
    account_t* current;
 
869
    callable_obj_t *mailbox_call;
 
870
    gchar *to, *account_id;
 
871
 
 
872
    current = account_list_get_current();
 
873
 
 
874
    if (current == NULL) // Should not happens
 
875
        return;
 
876
 
 
877
    to = g_strdup (g_hash_table_lookup (current->properties, ACCOUNT_MAILBOX));
 
878
    account_id = g_strdup (current->accountID);
 
879
 
 
880
    create_new_call (CALL, CALL_STATE_DIALING, "", account_id, _ ("Voicemail"), to,
 
881
                     &mailbox_call);
 
882
    DEBUG ("TO : %s" , mailbox_call->_peer_number);
 
883
    calllist_add (current_calls, mailbox_call);
 
884
    calltree_add_call (current_calls, mailbox_call, NULL);
 
885
    update_actions();
 
886
    sflphone_place_call (mailbox_call);
 
887
    calltree_display (current_calls);
 
888
}
 
889
 
 
890
static void
 
891
toggle_history_cb (GtkToggleAction *action, gpointer user_data UNUSED)
 
892
{
 
893
    gboolean toggle;
 
894
    toggle = gtk_toggle_action_get_active (action);
 
895
    (toggle) ? calltree_display (history) : calltree_display (current_calls);
 
896
}
 
897
 
 
898
static void
 
899
toggle_addressbook_cb (GtkToggleAction *action, gpointer user_data UNUSED)
 
900
{
 
901
    gboolean toggle;
 
902
    toggle = gtk_toggle_action_get_active (action);
 
903
    (toggle) ? calltree_display (contacts) : calltree_display (current_calls);
 
904
}
 
905
 
 
906
static const GtkActionEntry menu_entries[] = {
 
907
 
 
908
    // Call Menu
 
909
    { "Call", NULL, N_ ("Call") },
 
910
    {
 
911
        "NewCall", GTK_STOCK_DIAL, N_ ("_New call"), "<control>N",
 
912
        N_ ("Place a new call"), G_CALLBACK (call_new_call)
 
913
    },
 
914
    {
 
915
        "PickUp", GTK_STOCK_PICKUP, N_ ("_Pick up"), NULL,
 
916
        N_ ("Answer the call"), G_CALLBACK (call_pick_up)
 
917
    },
 
918
    {
 
919
        "HangUp", GTK_STOCK_HANGUP, N_ ("_Hang up"), "<control>S",
 
920
        N_ ("Finish the call"), G_CALLBACK (call_hang_up)
 
921
    },
 
922
    {
 
923
        "OnHold", GTK_STOCK_ONHOLD, N_ ("O_n hold"), "<control>P",
 
924
        N_ ("Place the call on hold"), G_CALLBACK (call_hold)
 
925
    },
 
926
    {
 
927
        "OffHold", GTK_STOCK_OFFHOLD, N_ ("O_ff hold"), "<control>P",
 
928
        N_ ("Place the call off hold"), G_CALLBACK (call_hold)
 
929
    },
 
930
    {
 
931
        "InstantMessaging", GTK_STOCK_IM, N_ ("Send _message"), "<control>M",
 
932
        N_ ("Send message"), G_CALLBACK (call_im)
 
933
    },
 
934
    {
 
935
        "AccountAssistant", NULL, N_ ("Configuration _Assistant"), NULL,
 
936
        N_ ("Run the configuration assistant"),
 
937
        G_CALLBACK (call_configuration_assistant)
 
938
    },
 
939
    {
 
940
        "Voicemail", "mail-read", N_ ("Voicemail"), NULL,
 
941
        N_ ("Call your voicemail"), G_CALLBACK (call_mailbox_cb)
 
942
    },
 
943
    {
 
944
        "Close", GTK_STOCK_CLOSE, N_ ("_Close"), "<control>W",
 
945
        N_ ("Minimize to system tray"), G_CALLBACK (call_minimize)
 
946
    },
 
947
    {
 
948
        "Quit", GTK_STOCK_CLOSE, N_ ("_Quit"), "<control>Q",
 
949
        N_ ("Quit the program"), G_CALLBACK (call_quit)
 
950
    },
 
951
 
 
952
    // Edit Menu
 
953
    { "Edit", NULL, N_ ("_Edit") },
 
954
    {
 
955
        "Copy", GTK_STOCK_COPY, N_ ("_Copy"), "<control>C",
 
956
        N_ ("Copy the selection"), G_CALLBACK (edit_copy)
 
957
    },
 
958
    {
 
959
        "Paste", GTK_STOCK_PASTE, N_ ("_Paste"), "<control>V",
 
960
        N_ ("Paste the clipboard"), G_CALLBACK (edit_paste)
 
961
    },
 
962
    {
 
963
        "ClearHistory", GTK_STOCK_CLEAR, N_ ("Clear _history"), NULL,
 
964
        N_ ("Clear the call history"), G_CALLBACK (clear_history)
 
965
    },
 
966
    {
 
967
        "Accounts", NULL, N_ ("_Accounts"), NULL, N_ ("Edit your accounts"),
 
968
        G_CALLBACK (edit_accounts)
 
969
    },
 
970
    {
 
971
        "Preferences", GTK_STOCK_PREFERENCES, N_ ("_Preferences"), NULL,
 
972
        N_ ("Change your preferences"), G_CALLBACK (edit_preferences)
 
973
    },
 
974
 
 
975
    // View Menu
 
976
    { "View", NULL, N_ ("_View") },
 
977
 
 
978
    // Help menu
 
979
    { "Help", NULL, N_ ("_Help") },
 
980
    {
 
981
        "HelpContents", GTK_STOCK_HELP, N_ ("Contents"), "F1",
 
982
        N_ ("Open the manual"), G_CALLBACK (help_contents_cb)
 
983
    },
 
984
    {
 
985
        "About", GTK_STOCK_ABOUT, NULL, NULL, N_ ("About this application"),
 
986
        G_CALLBACK (help_about)
 
987
    }
 
988
 
 
989
};
 
990
 
 
991
static const GtkToggleActionEntry toggle_menu_entries[] = {
 
992
 
 
993
    { "Transfer", GTK_STOCK_TRANSFER, N_ ("_Transfer"), "<control>T", N_ ("Transfer the call"), NULL, TRUE },
 
994
    { "Record", GTK_STOCK_MEDIA_RECORD, N_ ("_Record"), "<control>R", N_ ("Record the current conversation"), NULL, TRUE },
 
995
    { "Toolbar", NULL, N_ ("_Show toolbar"), "<control>T", N_ ("Show the toolbar"), NULL, TRUE },
 
996
    { "Dialpad", NULL, N_ ("_Dialpad"), "<control>D", N_ ("Show the dialpad"), G_CALLBACK (dialpad_bar_cb), TRUE },
 
997
    { "VolumeControls", NULL, N_ ("_Volume controls"), "<control>V", N_ ("Show the volume controls"), G_CALLBACK (volume_bar_cb), TRUE },
 
998
    { "History", "appointment-soon", N_ ("_History"), NULL, N_ ("Calls history"), G_CALLBACK (toggle_history_cb), FALSE },
 
999
    { "Addressbook", GTK_STOCK_ADDRESSBOOK, N_ ("_Address book"), NULL, N_ ("Address book"), G_CALLBACK (toggle_addressbook_cb), FALSE }
 
1000
};
882
1001
 
883
1002
gboolean
884
 
uimanager_new(GtkUIManager **_ui_manager)
 
1003
uimanager_new (GtkUIManager **_ui_manager)
885
1004
{
886
1005
 
887
 
  GtkUIManager *ui_manager;
888
 
  GtkActionGroup *action_group;
889
 
  GtkWidget *window;
890
 
  gchar *path;
891
 
  GError *error = NULL;
892
 
 
893
 
  window = get_main_window();
894
 
  ui_manager = gtk_ui_manager_new();
895
 
 
896
 
  /* Create an accel group for window's shortcuts */
897
 
  path = g_build_filename(SFLPHONE_UIDIR_UNINSTALLED, "./ui.xml", NULL);
898
 
  if (g_file_test(path, G_FILE_TEST_EXISTS))
899
 
    {
900
 
      gtk_ui_manager_add_ui_from_file(ui_manager, path, &error);
901
 
 
902
 
      if (error != NULL)
903
 
        {
904
 
          g_error_free(error);
905
 
          return FALSE;
 
1006
    GtkUIManager *ui_manager;
 
1007
    GtkActionGroup *action_group;
 
1008
    GtkWidget *window;
 
1009
    gchar *path;
 
1010
    GError *error = NULL;
 
1011
 
 
1012
    window = get_main_window();
 
1013
    ui_manager = gtk_ui_manager_new();
 
1014
 
 
1015
    /* Create an accel group for window's shortcuts */
 
1016
    path = g_build_filename (SFLPHONE_UIDIR_UNINSTALLED, "./ui.xml", NULL);
 
1017
 
 
1018
    if (g_file_test (path, G_FILE_TEST_EXISTS)) {
 
1019
        gtk_ui_manager_add_ui_from_file (ui_manager, path, &error);
 
1020
 
 
1021
        if (error != NULL) {
 
1022
            g_error_free (error);
 
1023
            return FALSE;
906
1024
        }
907
 
      g_free(path);
908
 
    }
909
 
  else
910
 
    {
911
 
      path = g_build_filename(SFLPHONE_UIDIR, "./ui.xml", NULL);
912
 
      if (g_file_test(path, G_FILE_TEST_EXISTS))
913
 
        {
914
 
          gtk_ui_manager_add_ui_from_file(ui_manager, path, &error);
915
 
 
916
 
          if (error != NULL)
917
 
            {
918
 
              g_error_free(error);
919
 
              return FALSE;
 
1025
 
 
1026
        g_free (path);
 
1027
    } else {
 
1028
        path = g_build_filename (SFLPHONE_UIDIR, "./ui.xml", NULL);
 
1029
 
 
1030
        if (g_file_test (path, G_FILE_TEST_EXISTS)) {
 
1031
            gtk_ui_manager_add_ui_from_file (ui_manager, path, &error);
 
1032
 
 
1033
            if (error != NULL) {
 
1034
                g_error_free (error);
 
1035
                return FALSE;
920
1036
            }
921
 
          g_free(path);
922
 
        }
923
 
      else
924
 
        return FALSE;
 
1037
 
 
1038
            g_free (path);
 
1039
        } else
 
1040
            return FALSE;
925
1041
    }
926
 
  action_group = gtk_action_group_new("SFLphoneWindowActions");
927
 
  // To translate label and tooltip entries
928
 
  gtk_action_group_set_translation_domain(action_group, "sflphone-client-gnome");
929
 
  gtk_action_group_add_actions(action_group, menu_entries,
930
 
      G_N_ELEMENTS (menu_entries), window);
931
 
  gtk_action_group_add_toggle_actions(action_group, toggle_menu_entries,
932
 
      G_N_ELEMENTS (toggle_menu_entries), window);
933
 
  //gtk_action_group_add_radio_actions (action_group, radio_menu_entries, G_N_ELEMENTS (radio_menu_entries), CALLTREE_CALLS, G_CALLBACK (calltree_switch_cb), window);
934
 
  gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
935
 
 
936
 
  *_ui_manager = ui_manager;
937
 
 
938
 
  return TRUE;
 
1042
 
 
1043
    action_group = gtk_action_group_new ("SFLphoneWindowActions");
 
1044
    // To translate label and tooltip entries
 
1045
    gtk_action_group_set_translation_domain (action_group, "sflphone-client-gnome");
 
1046
    gtk_action_group_add_actions (action_group, menu_entries,
 
1047
                                  G_N_ELEMENTS (menu_entries), window);
 
1048
    gtk_action_group_add_toggle_actions (action_group, toggle_menu_entries,
 
1049
                                         G_N_ELEMENTS (toggle_menu_entries), window);
 
1050
    //gtk_action_group_add_radio_actions (action_group, radio_menu_entries, G_N_ELEMENTS (radio_menu_entries), CALLTREE_CALLS, G_CALLBACK (calltree_switch_cb), window);
 
1051
    gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
 
1052
 
 
1053
    *_ui_manager = ui_manager;
 
1054
 
 
1055
    return TRUE;
939
1056
}
940
1057
 
941
1058
static void
942
 
edit_number_cb(GtkWidget *widget UNUSED, gpointer user_data)
 
1059
edit_number_cb (GtkWidget *widget UNUSED, gpointer user_data)
943
1060
{
944
1061
 
945
 
  show_edit_number((callable_obj_t*) user_data);
 
1062
    show_edit_number ( (callable_obj_t*) user_data);
946
1063
}
947
1064
 
948
1065
void
949
 
add_registered_accounts_to_menu(GtkWidget *menu)
 
1066
add_registered_accounts_to_menu (GtkWidget *menu)
950
1067
{
951
1068
 
952
 
  GtkWidget *menu_items;
953
 
  unsigned int i;
954
 
  account_t* acc, *current;
955
 
  gchar* alias;
956
 
 
957
 
  menu_items = gtk_separator_menu_item_new();
958
 
  gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
959
 
  gtk_widget_show(menu_items);
960
 
 
961
 
  for (i = 0; i < account_list_get_size(); i++)
962
 
    {
963
 
      acc = account_list_get_nth(i);
964
 
      // Display only the registered accounts
965
 
      if (g_strcasecmp(account_state_name(acc->state), account_state_name(
966
 
          ACCOUNT_STATE_REGISTERED)) == 0)
967
 
        {
968
 
          alias = g_strconcat(g_hash_table_lookup(acc->properties,
969
 
              ACCOUNT_ALIAS), " - ", g_hash_table_lookup(acc->properties,
970
 
              ACCOUNT_TYPE), NULL);
971
 
          menu_items = gtk_check_menu_item_new_with_mnemonic(alias);
972
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
973
 
          g_object_set_data(G_OBJECT( menu_items ), "account", acc);
974
 
          g_free(alias);
975
 
          current = account_list_get_current();
976
 
          if (current)
977
 
            {
978
 
              gtk_check_menu_item_set_active(
979
 
                  GTK_CHECK_MENU_ITEM(menu_items),
980
 
                  (g_strcasecmp(acc->accountID, current->accountID) == 0) ? TRUE
981
 
                      : FALSE);
 
1069
    GtkWidget *menu_items;
 
1070
    unsigned int i;
 
1071
    account_t* acc, *current;
 
1072
    gchar* alias;
 
1073
 
 
1074
    menu_items = gtk_separator_menu_item_new();
 
1075
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1076
    gtk_widget_show (menu_items);
 
1077
 
 
1078
    for (i = 0; i < account_list_get_size(); i++) {
 
1079
        acc = account_list_get_nth (i);
 
1080
 
 
1081
        // Display only the registered accounts
 
1082
        if (g_strcasecmp (account_state_name (acc->state), account_state_name (
 
1083
                              ACCOUNT_STATE_REGISTERED)) == 0) {
 
1084
            alias = g_strconcat (g_hash_table_lookup (acc->properties,
 
1085
                                 ACCOUNT_ALIAS), " - ", g_hash_table_lookup (acc->properties,
 
1086
                                         ACCOUNT_TYPE), NULL);
 
1087
            menu_items = gtk_check_menu_item_new_with_mnemonic (alias);
 
1088
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1089
            g_object_set_data (G_OBJECT (menu_items), "account", acc);
 
1090
            g_free (alias);
 
1091
            current = account_list_get_current();
 
1092
 
 
1093
            if (current) {
 
1094
                gtk_check_menu_item_set_active (
 
1095
                    GTK_CHECK_MENU_ITEM (menu_items),
 
1096
                    (g_strcasecmp (acc->accountID, current->accountID) == 0) ? TRUE
 
1097
                    : FALSE);
982
1098
            }
983
 
          g_signal_connect (G_OBJECT (menu_items), "activate",
984
 
              G_CALLBACK (switch_account),
985
 
              NULL);
986
 
          gtk_widget_show(menu_items);
 
1099
 
 
1100
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1101
                              G_CALLBACK (switch_account),
 
1102
                              NULL);
 
1103
            gtk_widget_show (menu_items);
987
1104
        } // fi
988
1105
    }
989
1106
 
990
1107
}
991
1108
 
992
1109
void
993
 
show_popup_menu(GtkWidget *my_widget, GdkEventButton *event)
994
 
{
995
 
  // TODO update the selection to make sure the call under the mouse is the call selected
996
 
 
997
 
  // call type boolean
998
 
  gboolean pickup = FALSE, hangup = FALSE, hold = FALSE, copy = FALSE, record =
999
 
      FALSE, detach = FALSE;
1000
 
  gboolean accounts = FALSE;
1001
 
 
1002
 
  // conference type boolean
1003
 
  gboolean hangup_conf = FALSE, hold_conf = FALSE;
1004
 
 
1005
 
  callable_obj_t * selectedCall;
1006
 
  conference_obj_t * selectedConf;
1007
 
 
1008
 
  if (calltab_get_selected_type(current_calls) == A_CALL)
1009
 
    {
1010
 
      DEBUG("MENUS: SELECTED A CALL");
1011
 
      selectedCall = calltab_get_selected_call(current_calls);
1012
 
 
1013
 
      if (selectedCall)
1014
 
        {
1015
 
          copy = TRUE;
1016
 
          switch (selectedCall->_state)
1017
 
            {
1018
 
          case CALL_STATE_INCOMING:
1019
 
            pickup = TRUE;
1020
 
            hangup = TRUE;
1021
 
            detach = TRUE;
1022
 
            break;
1023
 
          case CALL_STATE_HOLD:
1024
 
            hangup = TRUE;
1025
 
            hold = TRUE;
1026
 
            detach = TRUE;
1027
 
            break;
1028
 
          case CALL_STATE_RINGING:
1029
 
            hangup = TRUE;
1030
 
            detach = TRUE;
1031
 
            break;
1032
 
          case CALL_STATE_DIALING:
1033
 
            pickup = TRUE;
1034
 
            hangup = TRUE;
1035
 
            accounts = TRUE;
1036
 
            break;
1037
 
          case CALL_STATE_RECORD:
1038
 
          case CALL_STATE_CURRENT:
1039
 
            hangup = TRUE;
1040
 
            hold = TRUE;
1041
 
            record = TRUE;
1042
 
            detach = TRUE;
1043
 
            break;
1044
 
          case CALL_STATE_BUSY:
1045
 
          case CALL_STATE_FAILURE:
1046
 
            hangup = TRUE;
1047
 
            break;
1048
 
          default:
1049
 
            WARN("Should not happen in show_popup_menu for calls!")
1050
 
            ;
1051
 
            break;
1052
 
            }
1053
 
        }
1054
 
    }
1055
 
  else
1056
 
    {
1057
 
      DEBUG("MENUS: SELECTED A CONF");
1058
 
      selectedConf = calltab_get_selected_conf();
1059
 
 
1060
 
      if (selectedConf)
1061
 
        {
1062
 
          switch (selectedConf->_state)
1063
 
            {
1064
 
          case CONFERENCE_STATE_ACTIVE_ATACHED:
1065
 
            hangup_conf = TRUE;
1066
 
            hold_conf = TRUE;
1067
 
            break;
1068
 
          case CONFERENCE_STATE_ACTIVE_DETACHED:
1069
 
            break;
1070
 
          case CONFERENCE_STATE_HOLD:
1071
 
            hangup_conf = TRUE;
1072
 
            hold_conf = TRUE;
1073
 
            break;
1074
 
          default:
1075
 
            WARN("Should not happen in show_popup_menu for conferences!")
1076
 
            ;
1077
 
            break;
1078
 
            }
1079
 
        }
1080
 
 
1081
 
    }
1082
 
 
1083
 
  GtkWidget *menu;
1084
 
  GtkWidget *image;
1085
 
  int button, event_time;
1086
 
  GtkWidget * menu_items;
1087
 
 
1088
 
  menu = gtk_menu_new();
1089
 
  //g_signal_connect (menu, "deactivate",
1090
 
  //       G_CALLBACK (gtk_widget_destroy), NULL);
1091
 
  if (calltab_get_selected_type(current_calls) == A_CALL)
1092
 
    {
1093
 
      DEBUG("BUILD CALL MENU");
1094
 
 
1095
 
      if (copy)
1096
 
        {
1097
 
          menu_items = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY,
1098
 
              get_accel_group());
1099
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1100
 
          g_signal_connect (G_OBJECT (menu_items), "activate",
1101
 
              G_CALLBACK (edit_copy),
1102
 
              NULL);
1103
 
          gtk_widget_show(menu_items);
1104
 
        }
1105
 
 
1106
 
      menu_items = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE,
1107
 
          get_accel_group());
1108
 
      gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1109
 
      g_signal_connect (G_OBJECT (menu_items), "activate",
1110
 
          G_CALLBACK (edit_paste),
1111
 
          NULL);
1112
 
      gtk_widget_show(menu_items);
1113
 
 
1114
 
      if (pickup || hangup || hold)
1115
 
        {
1116
 
          menu_items = gtk_separator_menu_item_new();
1117
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1118
 
          gtk_widget_show(menu_items);
1119
 
        }
1120
 
 
1121
 
      if (pickup)
1122
 
        {
1123
 
 
1124
 
          menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Pick up"));
1125
 
          image = gtk_image_new_from_file(ICONS_DIR "/icon_accept.svg");
1126
 
          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
1127
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1128
 
          g_signal_connect (G_OBJECT (menu_items), "activate",
1129
 
              G_CALLBACK (call_pick_up),
1130
 
              NULL);
1131
 
          gtk_widget_show(menu_items);
1132
 
        }
1133
 
 
1134
 
      if (hangup)
1135
 
        {
1136
 
          menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Hang up"));
1137
 
          image = gtk_image_new_from_file(ICONS_DIR "/icon_hangup.svg");
1138
 
          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
1139
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1140
 
          g_signal_connect (G_OBJECT (menu_items), "activate",
1141
 
              G_CALLBACK (call_hang_up),
1142
 
              NULL);
1143
 
          gtk_widget_show(menu_items);
1144
 
        }
1145
 
 
1146
 
      if (hold)
1147
 
        {
1148
 
          menu_items = gtk_check_menu_item_new_with_mnemonic(_("On _Hold"));
1149
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1150
 
          gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items),
1151
 
              (selectedCall->_state == CALL_STATE_HOLD ? TRUE : FALSE));
1152
 
          g_signal_connect(G_OBJECT (menu_items), "activate",
1153
 
              G_CALLBACK (call_hold),
1154
 
              NULL);
1155
 
          gtk_widget_show(menu_items);
1156
 
        }
1157
 
 
1158
 
      if (record)
1159
 
        {
1160
 
          menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Record"));
1161
 
          image = gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD,
1162
 
              GTK_ICON_SIZE_MENU);
1163
 
          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
1164
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1165
 
          g_signal_connect (G_OBJECT (menu_items), "activate",
1166
 
              G_CALLBACK (call_record),
1167
 
              NULL);
1168
 
          gtk_widget_show(menu_items);
1169
 
        }
1170
 
 
1171
 
    }
1172
 
  else
1173
 
    {
1174
 
      DEBUG("BUILD CONFERENCE MENU");
1175
 
 
1176
 
      if (hangup_conf)
1177
 
        {
1178
 
          menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Hang up"));
1179
 
          image = gtk_image_new_from_file(ICONS_DIR "/icon_hangup.svg");
1180
 
          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
1181
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1182
 
          g_signal_connect (G_OBJECT (menu_items), "activate",
1183
 
              G_CALLBACK (conference_hang_up),
1184
 
              NULL);
1185
 
          gtk_widget_show(menu_items);
1186
 
        }
1187
 
 
1188
 
      if (hold_conf)
1189
 
        {
1190
 
          menu_items = gtk_check_menu_item_new_with_mnemonic(_("On _Hold"));
1191
 
          gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1192
 
          gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items),
1193
 
              (selectedCall->_state == CALL_STATE_HOLD ? TRUE : FALSE));
1194
 
          g_signal_connect(G_OBJECT (menu_items), "activate",
1195
 
              G_CALLBACK (conference_hold),
1196
 
              NULL);
1197
 
          gtk_widget_show(menu_items);
1198
 
        }
1199
 
    }
1200
 
 
1201
 
  if (accounts)
1202
 
    {
1203
 
      add_registered_accounts_to_menu(menu);
1204
 
    }
1205
 
 
1206
 
  if (event)
1207
 
    {
1208
 
      button = event->button;
1209
 
      event_time = event->time;
1210
 
    }
1211
 
  else
1212
 
    {
1213
 
      button = 0;
1214
 
      event_time = gtk_get_current_event_time();
1215
 
    }
1216
 
 
1217
 
  gtk_menu_attach_to_widget(GTK_MENU (menu), my_widget, NULL);
1218
 
  gtk_menu_popup(GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
1219
 
}
1220
 
 
1221
 
void
1222
 
show_popup_menu_history(GtkWidget *my_widget, GdkEventButton *event)
1223
 
{
1224
 
 
1225
 
  gboolean pickup = FALSE;
1226
 
  gboolean remove = FALSE;
1227
 
  gboolean edit = FALSE;
1228
 
  gboolean accounts = FALSE;
1229
 
 
1230
 
  callable_obj_t * selectedCall = calltab_get_selected_call(history);
1231
 
  if (selectedCall)
1232
 
    {
1233
 
      remove = TRUE;
1234
 
      pickup = TRUE;
1235
 
      edit = TRUE;
1236
 
      accounts = TRUE;
1237
 
    }
1238
 
 
1239
 
  GtkWidget *menu;
1240
 
  GtkWidget *image;
1241
 
  int button, event_time;
1242
 
  GtkWidget * menu_items;
1243
 
 
1244
 
  menu = gtk_menu_new();
1245
 
  //g_signal_connect (menu, "deactivate",
1246
 
  //       G_CALLBACK (gtk_widget_destroy), NULL);
1247
 
 
1248
 
  if (pickup)
1249
 
    {
1250
 
 
1251
 
      menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Call back"));
1252
 
      image = gtk_image_new_from_file(ICONS_DIR "/icon_accept.svg");
1253
 
      gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM ( menu_items ), image);
1254
 
      gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1255
 
      g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (call_back), NULL);
1256
 
      gtk_widget_show(menu_items);
1257
 
    }
1258
 
 
1259
 
  menu_items = gtk_separator_menu_item_new();
1260
 
  gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1261
 
  gtk_widget_show(menu_items);
1262
 
 
1263
 
  if (edit)
1264
 
    {
1265
 
      menu_items = gtk_image_menu_item_new_from_stock(GTK_STOCK_EDIT,
1266
 
          get_accel_group());
1267
 
      gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1268
 
      g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (edit_number_cb), selectedCall);
1269
 
      gtk_widget_show(menu_items);
1270
 
    }
1271
 
 
1272
 
  if (remove)
1273
 
    {
1274
 
      menu_items = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE,
1275
 
          get_accel_group());
1276
 
      gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1277
 
      g_signal_connect (G_OBJECT (menu_items), "activate", G_CALLBACK (remove_from_history), NULL);
1278
 
      gtk_widget_show(menu_items);
1279
 
    }
1280
 
 
1281
 
  if (accounts)
1282
 
    {
1283
 
      add_registered_accounts_to_menu(menu);
1284
 
    }
1285
 
 
1286
 
  if (event)
1287
 
    {
1288
 
      button = event->button;
1289
 
      event_time = event->time;
1290
 
    }
1291
 
  else
1292
 
    {
1293
 
      button = 0;
1294
 
      event_time = gtk_get_current_event_time();
1295
 
    }
1296
 
 
1297
 
  gtk_menu_attach_to_widget(GTK_MENU (menu), my_widget, NULL);
1298
 
  gtk_menu_popup(GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
1299
 
}
1300
 
void
1301
 
show_popup_menu_contacts(GtkWidget *my_widget, GdkEventButton *event)
1302
 
{
1303
 
 
1304
 
  gboolean pickup = FALSE;
1305
 
  gboolean accounts = FALSE;
1306
 
  gboolean edit = FALSE;
1307
 
 
1308
 
  callable_obj_t * selectedCall = calltab_get_selected_call(contacts);
1309
 
  if (selectedCall)
1310
 
    {
1311
 
      pickup = TRUE;
1312
 
      accounts = TRUE;
1313
 
      edit = TRUE;
1314
 
    }
1315
 
 
1316
 
  GtkWidget *menu;
1317
 
  GtkWidget *image;
1318
 
  int button, event_time;
1319
 
  GtkWidget * menu_items;
1320
 
 
1321
 
  menu = gtk_menu_new();
1322
 
  //g_signal_connect (menu, "deactivate",
1323
 
  //       G_CALLBACK (gtk_widget_destroy), NULL);
1324
 
 
1325
 
  if (pickup)
1326
 
    {
1327
 
 
1328
 
      menu_items = gtk_image_menu_item_new_with_mnemonic(_("_New call"));
1329
 
      image = gtk_image_new_from_file(ICONS_DIR "/icon_accept.svg");
1330
 
      gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM ( menu_items ), image);
1331
 
      gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1332
 
      g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (call_back), NULL);
1333
 
      gtk_widget_show(menu_items);
1334
 
    }
1335
 
 
1336
 
  if (edit)
1337
 
    {
1338
 
      menu_items = gtk_image_menu_item_new_from_stock(GTK_STOCK_EDIT,
1339
 
          get_accel_group());
1340
 
      gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_items);
1341
 
      g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (edit_number_cb), selectedCall);
1342
 
      gtk_widget_show(menu_items);
1343
 
    }
1344
 
 
1345
 
  if (accounts)
1346
 
    {
1347
 
      add_registered_accounts_to_menu(menu);
1348
 
    }
1349
 
 
1350
 
  if (event)
1351
 
    {
1352
 
      button = event->button;
1353
 
      event_time = event->time;
1354
 
    }
1355
 
  else
1356
 
    {
1357
 
      button = 0;
1358
 
      event_time = gtk_get_current_event_time();
1359
 
    }
1360
 
 
1361
 
  gtk_menu_attach_to_widget(GTK_MENU (menu), my_widget, NULL);
1362
 
  gtk_menu_popup(GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
1363
 
}
1364
 
 
1365
 
static void
1366
 
ok_cb(GtkWidget *widget UNUSED, gpointer userdata)
1367
 
{
1368
 
 
1369
 
  gchar *new_number;
1370
 
  callable_obj_t *modified_call, *original;
1371
 
 
1372
 
  // Change the number of the selected call before calling
1373
 
  new_number = (gchar*) gtk_entry_get_text(GTK_ENTRY (editable_num));
1374
 
  original = (callable_obj_t*) userdata;
1375
 
 
1376
 
  // Create the new call
1377
 
  create_new_call(CALL, CALL_STATE_DIALING, "", g_strdup(original->_accountID),
1378
 
      original->_peer_name, g_strdup(new_number), &modified_call);
1379
 
 
1380
 
  // Update the internal data structure and the GUI
1381
 
  calllist_add(current_calls, modified_call);
1382
 
  calltree_add_call(current_calls, modified_call, NULL);
1383
 
  sflphone_place_call(modified_call);
1384
 
  calltree_display(current_calls);
1385
 
 
1386
 
  // Close the contextual menu
1387
 
  gtk_widget_destroy(GTK_WIDGET (edit_dialog));
1388
 
}
1389
 
 
1390
 
static void
1391
 
on_delete(GtkWidget * widget)
1392
 
{
1393
 
  gtk_widget_destroy(widget);
1394
 
}
1395
 
 
1396
 
void
1397
 
show_edit_number(callable_obj_t *call)
1398
 
{
1399
 
 
1400
 
  GtkWidget *ok, *hbox, *image;
1401
 
  GdkPixbuf *pixbuf;
1402
 
 
1403
 
  edit_dialog = GTK_DIALOG (gtk_dialog_new());
1404
 
 
1405
 
  // Set window properties
1406
 
  gtk_window_set_default_size(GTK_WINDOW(edit_dialog), 300, 20);
1407
 
  gtk_window_set_title(GTK_WINDOW(edit_dialog), _("Edit phone number"));
1408
 
  gtk_window_set_resizable(GTK_WINDOW (edit_dialog), FALSE);
1409
 
 
1410
 
  g_signal_connect (G_OBJECT (edit_dialog), "delete-event", G_CALLBACK (on_delete), NULL);
1411
 
 
1412
 
  hbox = gtk_hbox_new(FALSE, 0);
1413
 
  gtk_box_pack_start(GTK_BOX (edit_dialog->vbox), hbox, TRUE, TRUE, 0);
1414
 
 
1415
 
  // Set the number to be edited
1416
 
  editable_num = gtk_entry_new();
 
1110
show_popup_menu (GtkWidget *my_widget, GdkEventButton *event)
 
1111
{
 
1112
    // TODO update the selection to make sure the call under the mouse is the call selected
 
1113
 
 
1114
    // call type boolean
 
1115
    gboolean pickup = FALSE, hangup = FALSE, hold = FALSE, copy = FALSE, record =
 
1116
                                          FALSE, detach = FALSE, im = FALSE;
 
1117
    gboolean accounts = FALSE;
 
1118
 
 
1119
    // conference type boolean
 
1120
    gboolean hangup_conf = FALSE, hold_conf = FALSE;
 
1121
 
 
1122
    callable_obj_t * selectedCall = NULL;
 
1123
    conference_obj_t * selectedConf;
 
1124
 
 
1125
    if (calltab_get_selected_type (current_calls) == A_CALL) {
 
1126
        DEBUG ("UIManager: Menus: Selected a call");
 
1127
        selectedCall = calltab_get_selected_call (current_calls);
 
1128
 
 
1129
        if (selectedCall) {
 
1130
            copy = TRUE;
 
1131
 
 
1132
            switch (selectedCall->_state) {
 
1133
                case CALL_STATE_INCOMING:
 
1134
                    pickup = TRUE;
 
1135
                    hangup = TRUE;
 
1136
                    detach = TRUE;
 
1137
                    break;
 
1138
                case CALL_STATE_HOLD:
 
1139
                    hangup = TRUE;
 
1140
                    hold = TRUE;
 
1141
                    detach = TRUE;
 
1142
                    break;
 
1143
                case CALL_STATE_RINGING:
 
1144
                    hangup = TRUE;
 
1145
                    detach = TRUE;
 
1146
                    break;
 
1147
                case CALL_STATE_DIALING:
 
1148
                    pickup = TRUE;
 
1149
                    hangup = TRUE;
 
1150
                    accounts = TRUE;
 
1151
                    break;
 
1152
                case CALL_STATE_RECORD:
 
1153
                case CALL_STATE_CURRENT:
 
1154
                    hangup = TRUE;
 
1155
                    hold = TRUE;
 
1156
                    record = TRUE;
 
1157
                    detach = TRUE;
 
1158
                    im = TRUE;
 
1159
                    break;
 
1160
                case CALL_STATE_BUSY:
 
1161
                case CALL_STATE_FAILURE:
 
1162
                    hangup = TRUE;
 
1163
                    break;
 
1164
                default:
 
1165
                    WARN ("UIManager: Should not happen in show_popup_menu for calls!")
 
1166
                    ;
 
1167
                    break;
 
1168
            }
 
1169
        }
 
1170
    } else {
 
1171
        DEBUG ("UIManager: Menus: selected a conf");
 
1172
        selectedConf = calltab_get_selected_conf();
 
1173
 
 
1174
        if (selectedConf) {
 
1175
            switch (selectedConf->_state) {
 
1176
                case CONFERENCE_STATE_ACTIVE_ATACHED:
 
1177
                    hangup_conf = TRUE;
 
1178
                    hold_conf = TRUE;
 
1179
                    break;
 
1180
                case CONFERENCE_STATE_ACTIVE_DETACHED:
 
1181
                    break;
 
1182
                case CONFERENCE_STATE_HOLD:
 
1183
                    hangup_conf = TRUE;
 
1184
                    hold_conf = TRUE;
 
1185
                    break;
 
1186
                default:
 
1187
                    WARN ("UIManager: Should not happen in show_popup_menu for conferences!")
 
1188
                    ;
 
1189
                    break;
 
1190
            }
 
1191
        }
 
1192
 
 
1193
    }
 
1194
 
 
1195
    GtkWidget *menu;
 
1196
    GtkWidget *image;
 
1197
    int button, event_time;
 
1198
    GtkWidget * menu_items;
 
1199
 
 
1200
    menu = gtk_menu_new();
 
1201
 
 
1202
    //g_signal_connect (menu, "deactivate",
 
1203
    //       G_CALLBACK (gtk_widget_destroy), NULL);
 
1204
    if (calltab_get_selected_type (current_calls) == A_CALL) {
 
1205
        DEBUG ("UIManager: Build call menu");
 
1206
 
 
1207
        if (copy) {
 
1208
            menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_COPY,
 
1209
                         get_accel_group());
 
1210
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1211
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1212
                              G_CALLBACK (edit_copy),
 
1213
                              NULL);
 
1214
            gtk_widget_show (menu_items);
 
1215
        }
 
1216
 
 
1217
        menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_PASTE,
 
1218
                     get_accel_group());
 
1219
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1220
        g_signal_connect (G_OBJECT (menu_items), "activate",
 
1221
                          G_CALLBACK (edit_paste),
 
1222
                          NULL);
 
1223
        gtk_widget_show (menu_items);
 
1224
 
 
1225
        if (pickup || hangup || hold) {
 
1226
            menu_items = gtk_separator_menu_item_new();
 
1227
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1228
            gtk_widget_show (menu_items);
 
1229
        }
 
1230
 
 
1231
        if (pickup) {
 
1232
 
 
1233
            menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_Pick up"));
 
1234
            image = gtk_image_new_from_file (ICONS_DIR "/icon_accept.svg");
 
1235
            gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1236
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1237
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1238
                              G_CALLBACK (call_pick_up),
 
1239
                              NULL);
 
1240
            gtk_widget_show (menu_items);
 
1241
        }
 
1242
 
 
1243
        if (hangup) {
 
1244
            menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_Hang up"));
 
1245
            image = gtk_image_new_from_file (ICONS_DIR "/icon_hangup.svg");
 
1246
            gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1247
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1248
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1249
                              G_CALLBACK (call_hang_up),
 
1250
                              NULL);
 
1251
            gtk_widget_show (menu_items);
 
1252
        }
 
1253
 
 
1254
        if (hold) {
 
1255
            menu_items = gtk_check_menu_item_new_with_mnemonic (_ ("On _Hold"));
 
1256
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1257
            gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_items),
 
1258
                                            (selectedCall->_state == CALL_STATE_HOLD ? TRUE : FALSE));
 
1259
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1260
                              G_CALLBACK (call_hold),
 
1261
                              NULL);
 
1262
            gtk_widget_show (menu_items);
 
1263
        }
 
1264
 
 
1265
        if (record) {
 
1266
            menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_Record"));
 
1267
            image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_RECORD,
 
1268
                                              GTK_ICON_SIZE_MENU);
 
1269
            gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1270
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1271
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1272
                              G_CALLBACK (call_record),
 
1273
                              NULL);
 
1274
            gtk_widget_show (menu_items);
 
1275
        }
 
1276
 
 
1277
        if (im) {
 
1278
 
 
1279
            // do not display message if instant messaging is disabled
 
1280
            gboolean instant_messaging_enabled = TRUE;
 
1281
 
 
1282
            if (eel_gconf_key_exists (INSTANT_MESSAGING_ENABLED))
 
1283
                instant_messaging_enabled = eel_gconf_get_integer (INSTANT_MESSAGING_ENABLED);
 
1284
 
 
1285
            if (instant_messaging_enabled) {
 
1286
 
 
1287
                menu_items = gtk_separator_menu_item_new();
 
1288
                gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1289
                gtk_widget_show (menu_items);
 
1290
 
 
1291
                menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("Send _message"));
 
1292
                image = gtk_image_new_from_stock (GTK_STOCK_IM, GTK_ICON_SIZE_MENU);
 
1293
                gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1294
                gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1295
                g_signal_connect (G_OBJECT (menu_items), "activate",
 
1296
                                  G_CALLBACK (call_im),
 
1297
                                  NULL);
 
1298
                gtk_widget_show (menu_items);
 
1299
            }
 
1300
        }
 
1301
 
 
1302
    } else {
 
1303
        DEBUG ("UIManager: Build call menus");
 
1304
 
 
1305
        if (hangup_conf) {
 
1306
            menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_Hang up"));
 
1307
            image = gtk_image_new_from_file (ICONS_DIR "/icon_hangup.svg");
 
1308
            gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1309
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1310
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1311
                              G_CALLBACK (conference_hang_up),
 
1312
                              NULL);
 
1313
            gtk_widget_show (menu_items);
 
1314
        }
 
1315
 
 
1316
        if (hold_conf) {
 
1317
            menu_items = gtk_check_menu_item_new_with_mnemonic (_ ("On _Hold"));
 
1318
            gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1319
            gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_items),
 
1320
                                            (selectedCall->_state == CALL_STATE_HOLD ? TRUE : FALSE));
 
1321
            g_signal_connect (G_OBJECT (menu_items), "activate",
 
1322
                              G_CALLBACK (conference_hold),
 
1323
                              NULL);
 
1324
            gtk_widget_show (menu_items);
 
1325
        }
 
1326
    }
 
1327
 
 
1328
    if (accounts) {
 
1329
        add_registered_accounts_to_menu (menu);
 
1330
    }
 
1331
 
 
1332
    if (event) {
 
1333
        button = event->button;
 
1334
        event_time = event->time;
 
1335
    } else {
 
1336
        button = 0;
 
1337
        event_time = gtk_get_current_event_time();
 
1338
    }
 
1339
 
 
1340
    gtk_menu_attach_to_widget (GTK_MENU (menu), my_widget, NULL);
 
1341
    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
 
1342
}
 
1343
 
 
1344
void
 
1345
show_popup_menu_history (GtkWidget *my_widget, GdkEventButton *event)
 
1346
{
 
1347
 
 
1348
    DEBUG ("UIManager: Show popup menu history");
 
1349
 
 
1350
    gboolean pickup = FALSE;
 
1351
    gboolean remove = FALSE;
 
1352
    gboolean edit = FALSE;
 
1353
    gboolean accounts = FALSE;
 
1354
 
 
1355
    callable_obj_t * selectedCall = calltab_get_selected_call (history);
 
1356
 
 
1357
    if (selectedCall) {
 
1358
        remove = TRUE;
 
1359
        pickup = TRUE;
 
1360
        edit = TRUE;
 
1361
        accounts = TRUE;
 
1362
    }
 
1363
 
 
1364
    GtkWidget *menu;
 
1365
    GtkWidget *image;
 
1366
    int button, event_time;
 
1367
    GtkWidget * menu_items;
 
1368
 
 
1369
    menu = gtk_menu_new();
 
1370
    //g_signal_connect (menu, "deactivate",
 
1371
    //       G_CALLBACK (gtk_widget_destroy), NULL);
 
1372
 
 
1373
    if (pickup) {
 
1374
 
 
1375
        menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_Call back"));
 
1376
        image = gtk_image_new_from_file (ICONS_DIR "/icon_accept.svg");
 
1377
        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1378
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1379
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (call_back), NULL);
 
1380
        gtk_widget_show (menu_items);
 
1381
    }
 
1382
 
 
1383
    menu_items = gtk_separator_menu_item_new();
 
1384
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1385
    gtk_widget_show (menu_items);
 
1386
 
 
1387
    if (edit) {
 
1388
        menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_EDIT,
 
1389
                     get_accel_group());
 
1390
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1391
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (edit_number_cb), selectedCall);
 
1392
        gtk_widget_show (menu_items);
 
1393
    }
 
1394
 
 
1395
    if (remove) {
 
1396
        menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE,
 
1397
                     get_accel_group());
 
1398
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1399
        g_signal_connect (G_OBJECT (menu_items), "activate", G_CALLBACK (remove_from_history), NULL);
 
1400
        gtk_widget_show (menu_items);
 
1401
    }
 
1402
 
 
1403
    if (accounts) {
 
1404
        add_registered_accounts_to_menu (menu);
 
1405
    }
 
1406
 
 
1407
    if (event) {
 
1408
        button = event->button;
 
1409
        event_time = event->time;
 
1410
    } else {
 
1411
        button = 0;
 
1412
        event_time = gtk_get_current_event_time();
 
1413
    }
 
1414
 
 
1415
    gtk_menu_attach_to_widget (GTK_MENU (menu), my_widget, NULL);
 
1416
    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
 
1417
}
 
1418
 
 
1419
/*
 
1420
void
 
1421
show_popup_menu_addressbook (GtkWidget *my_widget, GdkEventButton *event)
 
1422
{
 
1423
 
 
1424
    if (selectedCall) {
 
1425
        remove = TRUE;
 
1426
        pickup = TRUE;
 
1427
        edit = TRUE;
 
1428
        accounts = TRUE;
 
1429
    }
 
1430
 
 
1431
    GtkWidget *menu;
 
1432
    GtkWidget *image;
 
1433
    int button, event_time;
 
1434
    GtkWidget * menu_items;
 
1435
 
 
1436
    menu = gtk_menu_new();
 
1437
    //g_signal_connect (menu, "deactivate",
 
1438
    //       G_CALLBACK (gtk_widget_destroy), NULL);
 
1439
 
 
1440
    if (pickup) {
 
1441
 
 
1442
        menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_Call back"));
 
1443
        image = gtk_image_new_from_file (ICONS_DIR "/icon_accept.svg");
 
1444
        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1445
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1446
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (call_back), NULL);
 
1447
        gtk_widget_show (menu_items);
 
1448
    }
 
1449
 
 
1450
    menu_items = gtk_separator_menu_item_new();
 
1451
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1452
    gtk_widget_show (menu_items);
 
1453
 
 
1454
    if (edit) {
 
1455
        menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_EDIT,
 
1456
                     get_accel_group());
 
1457
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1458
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (edit_number_cb), selectedCall);
 
1459
        gtk_widget_show (menu_items);
 
1460
    }
 
1461
 
 
1462
    if (remove) {
 
1463
        menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE,
 
1464
                     get_accel_group());
 
1465
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1466
        g_signal_connect (G_OBJECT (menu_items), "activate", G_CALLBACK (remove_from_history), NULL);
 
1467
        gtk_widget_show (menu_items);
 
1468
    }
 
1469
 
 
1470
    if (accounts) {
 
1471
        add_registered_accounts_to_menu (menu);
 
1472
    }
 
1473
 
 
1474
    if (event) {
 
1475
        button = event->button;
 
1476
        event_time = event->time;
 
1477
    } else {
 
1478
        button = 0;
 
1479
        event_time = gtk_get_current_event_time();
 
1480
    }
 
1481
 
 
1482
    gtk_menu_attach_to_widget (GTK_MENU (menu), my_widget, NULL);
 
1483
    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
 
1484
}
 
1485
*/
 
1486
 
 
1487
void
 
1488
show_popup_menu_contacts (GtkWidget *my_widget, GdkEventButton *event)
 
1489
{
 
1490
 
 
1491
    gboolean pickup = FALSE;
 
1492
    gboolean accounts = FALSE;
 
1493
    gboolean edit = FALSE;
 
1494
 
 
1495
    callable_obj_t * selectedCall = calltab_get_selected_call (contacts);
 
1496
 
 
1497
    if (selectedCall) {
 
1498
        pickup = TRUE;
 
1499
        accounts = TRUE;
 
1500
        edit = TRUE;
 
1501
    }
 
1502
 
 
1503
    GtkWidget *menu;
 
1504
    GtkWidget *image;
 
1505
    int button, event_time;
 
1506
    GtkWidget * menu_items;
 
1507
 
 
1508
    menu = gtk_menu_new();
 
1509
    //g_signal_connect (menu, "deactivate",
 
1510
    //       G_CALLBACK (gtk_widget_destroy), NULL);
 
1511
 
 
1512
    if (pickup) {
 
1513
 
 
1514
        menu_items = gtk_image_menu_item_new_with_mnemonic (_ ("_New call"));
 
1515
        image = gtk_image_new_from_file (ICONS_DIR "/icon_accept.svg");
 
1516
        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_items), image);
 
1517
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1518
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (call_back), NULL);
 
1519
        gtk_widget_show (menu_items);
 
1520
    }
 
1521
 
 
1522
    if (edit) {
 
1523
        menu_items = gtk_image_menu_item_new_from_stock (GTK_STOCK_EDIT,
 
1524
                     get_accel_group());
 
1525
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_items);
 
1526
        g_signal_connect (G_OBJECT (menu_items), "activate",G_CALLBACK (edit_number_cb), selectedCall);
 
1527
        gtk_widget_show (menu_items);
 
1528
    }
 
1529
 
 
1530
    if (accounts) {
 
1531
        add_registered_accounts_to_menu (menu);
 
1532
    }
 
1533
 
 
1534
    if (event) {
 
1535
        button = event->button;
 
1536
        event_time = event->time;
 
1537
    } else {
 
1538
        button = 0;
 
1539
        event_time = gtk_get_current_event_time();
 
1540
    }
 
1541
 
 
1542
    gtk_menu_attach_to_widget (GTK_MENU (menu), my_widget, NULL);
 
1543
    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
 
1544
}
 
1545
 
 
1546
static void
 
1547
ok_cb (GtkWidget *widget UNUSED, gpointer userdata)
 
1548
{
 
1549
 
 
1550
    gchar *new_number;
 
1551
    callable_obj_t *modified_call, *original;
 
1552
 
 
1553
    // Change the number of the selected call before calling
 
1554
    new_number = (gchar*) gtk_entry_get_text (GTK_ENTRY (editable_num));
 
1555
    original = (callable_obj_t*) userdata;
 
1556
 
 
1557
    // Create the new call
 
1558
    create_new_call (CALL, CALL_STATE_DIALING, "", g_strdup (original->_accountID),
 
1559
                     original->_peer_name, g_strdup (new_number), &modified_call);
 
1560
 
 
1561
    // Update the internal data structure and the GUI
 
1562
    calllist_add (current_calls, modified_call);
 
1563
    calltree_add_call (current_calls, modified_call, NULL);
 
1564
    sflphone_place_call (modified_call);
 
1565
    calltree_display (current_calls);
 
1566
 
 
1567
    // Close the contextual menu
 
1568
    gtk_widget_destroy (GTK_WIDGET (edit_dialog));
 
1569
}
 
1570
 
 
1571
static void
 
1572
on_delete (GtkWidget * widget)
 
1573
{
 
1574
    gtk_widget_destroy (widget);
 
1575
}
 
1576
 
 
1577
void
 
1578
show_edit_number (callable_obj_t *call)
 
1579
{
 
1580
 
 
1581
    GtkWidget *ok, *hbox, *image;
 
1582
    GdkPixbuf *pixbuf;
 
1583
 
 
1584
    edit_dialog = GTK_DIALOG (gtk_dialog_new());
 
1585
 
 
1586
    // Set window properties
 
1587
    gtk_window_set_default_size (GTK_WINDOW (edit_dialog), 300, 20);
 
1588
    gtk_window_set_title (GTK_WINDOW (edit_dialog), _ ("Edit phone number"));
 
1589
    gtk_window_set_resizable (GTK_WINDOW (edit_dialog), FALSE);
 
1590
 
 
1591
    g_signal_connect (G_OBJECT (edit_dialog), "delete-event", G_CALLBACK (on_delete), NULL);
 
1592
 
 
1593
    hbox = gtk_hbox_new (FALSE, 0);
 
1594
    gtk_box_pack_start (GTK_BOX (edit_dialog->vbox), hbox, TRUE, TRUE, 0);
 
1595
 
 
1596
    // Set the number to be edited
 
1597
    editable_num = gtk_entry_new();
1417
1598
#if GTK_CHECK_VERSION(2,12,0)
1418
 
  gtk_widget_set_tooltip_text(GTK_WIDGET(editable_num),
1419
 
      _("Edit the phone number before making a call"));
 
1599
    gtk_widget_set_tooltip_text (GTK_WIDGET (editable_num),
 
1600
                                 _ ("Edit the phone number before making a call"));
1420
1601
#endif
1421
 
  if (call)
1422
 
    gtk_entry_set_text(GTK_ENTRY(editable_num), g_strdup(call->_peer_number));
1423
 
  else
1424
 
    ERROR ("This a bug, the call should be defined. menus.c line 1051");
1425
 
 
1426
 
  gtk_box_pack_start(GTK_BOX (hbox), editable_num, TRUE, TRUE, 0);
1427
 
 
1428
 
  // Set a custom image for the button
1429
 
  pixbuf = gdk_pixbuf_new_from_file_at_scale(ICONS_DIR "/outgoing.svg", 32, 32,
1430
 
      TRUE, NULL);
1431
 
  image = gtk_image_new_from_pixbuf(pixbuf);
1432
 
  ok = gtk_button_new();
1433
 
  gtk_button_set_image(GTK_BUTTON (ok), image);
1434
 
  gtk_box_pack_start(GTK_BOX (hbox), ok, TRUE, TRUE, 0);
1435
 
  g_signal_connect(G_OBJECT (ok), "clicked", G_CALLBACK (ok_cb), call);
1436
 
 
1437
 
  gtk_widget_show_all(edit_dialog->vbox);
1438
 
 
1439
 
  gtk_dialog_run(edit_dialog);
 
1602
 
 
1603
    if (call)
 
1604
        gtk_entry_set_text (GTK_ENTRY (editable_num), g_strdup (call->_peer_number));
 
1605
    else
 
1606
        ERROR ("This a bug, the call should be defined. menus.c line 1051");
 
1607
 
 
1608
    gtk_box_pack_start (GTK_BOX (hbox), editable_num, TRUE, TRUE, 0);
 
1609
 
 
1610
    // Set a custom image for the button
 
1611
    pixbuf = gdk_pixbuf_new_from_file_at_scale (ICONS_DIR "/outgoing.svg", 32, 32,
 
1612
             TRUE, NULL);
 
1613
    image = gtk_image_new_from_pixbuf (pixbuf);
 
1614
    ok = gtk_button_new();
 
1615
    gtk_button_set_image (GTK_BUTTON (ok), image);
 
1616
    gtk_box_pack_start (GTK_BOX (hbox), ok, TRUE, TRUE, 0);
 
1617
    g_signal_connect (G_OBJECT (ok), "clicked", G_CALLBACK (ok_cb), call);
 
1618
 
 
1619
    gtk_widget_show_all (edit_dialog->vbox);
 
1620
 
 
1621
    gtk_dialog_run (edit_dialog);
1440
1622
 
1441
1623
}
1442
1624
 
1443
1625
GtkWidget*
1444
1626
create_waiting_icon()
1445
1627
{
1446
 
  GtkWidget * waiting_icon;
1447
 
  waiting_icon = gtk_image_menu_item_new_with_label("");
1448
 
  gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(waiting_icon),
1449
 
      gtk_image_new_from_animation(gdk_pixbuf_animation_new_from_file(
1450
 
          ICONS_DIR "/wait-on.gif", NULL)));
1451
 
  gtk_menu_item_set_right_justified(GTK_MENU_ITEM(waiting_icon), TRUE);
1452
 
 
1453
 
  return waiting_icon;
1454
 
}
1455
 
 
1456
 
void
1457
 
create_menus(GtkUIManager *ui_manager, GtkWidget **widget)
1458
 
{
1459
 
 
1460
 
  GtkWidget * menu_bar;
1461
 
 
1462
 
  menu_bar = gtk_ui_manager_get_widget(ui_manager, "/MenuBar");
1463
 
  pickUpAction = gtk_ui_manager_get_action(ui_manager,
1464
 
      "/MenuBar/CallMenu/PickUp");
1465
 
  newCallAction = gtk_ui_manager_get_action(ui_manager,
1466
 
      "/MenuBar/CallMenu/NewCall");
1467
 
  hangUpAction = gtk_ui_manager_get_action(ui_manager,
1468
 
      "/MenuBar/CallMenu/HangUp");
1469
 
  holdMenu = gtk_ui_manager_get_widget(ui_manager,
1470
 
      "/MenuBar/CallMenu/OnHoldMenu");
1471
 
  recordAction = gtk_ui_manager_get_action(ui_manager,
1472
 
      "/MenuBar/CallMenu/Record");
1473
 
  copyAction = gtk_ui_manager_get_action(ui_manager, "/MenuBar/EditMenu/Copy");
1474
 
  pasteAction
1475
 
      = gtk_ui_manager_get_action(ui_manager, "/MenuBar/EditMenu/Paste");
1476
 
  volumeToggle = gtk_ui_manager_get_action(ui_manager,
1477
 
      "/MenuBar/ViewMenu/VolumeControls");
1478
 
 
1479
 
  // Set the toggle buttons
1480
 
  gtk_toggle_action_set_active(
1481
 
      GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (ui_manager, "/MenuBar/ViewMenu/Dialpad")),
1482
 
      (gboolean) SHOW_DIALPAD);
1483
 
  gtk_toggle_action_set_active(GTK_TOGGLE_ACTION (volumeToggle),
1484
 
      (gboolean) SHOW_VOLUME);
1485
 
 
1486
 
  gtk_action_set_sensitive(GTK_ACTION (volumeToggle), SHOW_ALSA_CONF);
1487
 
 
1488
 
  // Disable it right now
1489
 
  gtk_action_set_sensitive(
1490
 
      GTK_ACTION (gtk_ui_manager_get_action (ui_manager, "/MenuBar/ViewMenu/Toolbar")),
1491
 
      FALSE);
1492
 
 
1493
 
  waitingLayer = create_waiting_icon();
1494
 
  gtk_menu_shell_append(GTK_MENU_SHELL (menu_bar), waitingLayer);
1495
 
 
1496
 
  *widget = menu_bar;
1497
 
}
1498
 
 
1499
 
void
1500
 
create_toolbar_actions(GtkUIManager *ui_manager, GtkWidget **widget)
1501
 
{
1502
 
  toolbar = gtk_ui_manager_get_widget(ui_manager, "/ToolbarActions");
1503
 
 
1504
 
  holdToolbar = gtk_ui_manager_get_widget(ui_manager,
1505
 
      "/ToolbarActions/OnHoldToolbar");
1506
 
  offHoldToolbar = gtk_ui_manager_get_widget(ui_manager,
1507
 
      "/ToolbarActions/OffHoldToolbar");
1508
 
  transferToolbar = gtk_ui_manager_get_widget(ui_manager,
1509
 
      "/ToolbarActions/TransferToolbar");
1510
 
  voicemailAction = gtk_ui_manager_get_action(ui_manager,
1511
 
      "/ToolbarActions/Voicemail");
1512
 
  voicemailToolbar = gtk_ui_manager_get_widget(ui_manager,
1513
 
      "/ToolbarActions/VoicemailToolbar");
1514
 
  newCallWidget = gtk_ui_manager_get_widget(ui_manager,
1515
 
      "/ToolbarActions/NewCallToolbar");
1516
 
  pickUpWidget = gtk_ui_manager_get_widget(ui_manager,
1517
 
      "/ToolbarActions/PickUpToolbar");
1518
 
  hangUpWidget = gtk_ui_manager_get_widget(ui_manager,
1519
 
      "/ToolbarActions/HangUpToolbar");
1520
 
  recordWidget = gtk_ui_manager_get_widget(ui_manager,
1521
 
      "/ToolbarActions/RecordToolbar");
1522
 
  historyButton = gtk_ui_manager_get_widget(ui_manager,
1523
 
      "/ToolbarActions/HistoryToolbar");
1524
 
  contactButton = gtk_ui_manager_get_widget(ui_manager,
1525
 
      "/ToolbarActions/AddressbookToolbar");
1526
 
 
1527
 
  // Set the handler ID for the transfer
1528
 
  transfertButtonConnId
1529
 
      = g_signal_connect (G_OBJECT (transferToolbar), "toggled", G_CALLBACK (call_transfer_cb), NULL);
1530
 
  recordButtonConnId
1531
 
      = g_signal_connect (G_OBJECT (recordWidget), "toggled", G_CALLBACK (call_record), NULL);
1532
 
  active_calltree = current_calls;
1533
 
 
1534
 
  *widget = toolbar;
 
1628
    GtkWidget * waiting_icon;
 
1629
    waiting_icon = gtk_image_menu_item_new_with_label ("");
 
1630
    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (waiting_icon),
 
1631
                                   gtk_image_new_from_animation (gdk_pixbuf_animation_new_from_file (
 
1632
                                           ICONS_DIR "/wait-on.gif", NULL)));
 
1633
    gtk_menu_item_set_right_justified (GTK_MENU_ITEM (waiting_icon), TRUE);
 
1634
 
 
1635
    return waiting_icon;
 
1636
}
 
1637
 
 
1638
void
 
1639
create_menus (GtkUIManager *ui_manager, GtkWidget **widget)
 
1640
{
 
1641
 
 
1642
    GtkWidget * menu_bar;
 
1643
 
 
1644
    menu_bar = gtk_ui_manager_get_widget (ui_manager, "/MenuBar");
 
1645
    pickUpAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/CallMenu/PickUp");
 
1646
    newCallAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/CallMenu/NewCall");
 
1647
    hangUpAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/CallMenu/HangUp");
 
1648
    holdMenu = gtk_ui_manager_get_widget (ui_manager, "/MenuBar/CallMenu/OnHoldMenu");
 
1649
    recordAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/CallMenu/Record");
 
1650
    imAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/CallMenu/InstantMessaging");
 
1651
    copyAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/EditMenu/Copy");
 
1652
    pasteAction = gtk_ui_manager_get_action (ui_manager, "/MenuBar/EditMenu/Paste");
 
1653
    volumeToggle = gtk_ui_manager_get_action (ui_manager, "/MenuBar/ViewMenu/VolumeControls");
 
1654
 
 
1655
    // Set the toggle buttons
 
1656
    gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (ui_manager, "/MenuBar/ViewMenu/Dialpad")), eel_gconf_get_boolean (CONF_SHOW_DIALPAD));
 
1657
    gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (volumeToggle), (gboolean) SHOW_VOLUME);
 
1658
 
 
1659
    gtk_action_set_sensitive (GTK_ACTION (volumeToggle), SHOW_ALSA_CONF);
 
1660
 
 
1661
    // Disable it right now
 
1662
    gtk_action_set_sensitive (GTK_ACTION (gtk_ui_manager_get_action (ui_manager, "/MenuBar/ViewMenu/Toolbar")), FALSE);
 
1663
 
 
1664
    /* Add the loading icon at the right of the toolbar. It is used for addressbook searches. */
 
1665
    waitingLayer = create_waiting_icon ();
 
1666
    gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), waitingLayer);
 
1667
 
 
1668
    *widget = menu_bar;
 
1669
}
 
1670
 
 
1671
void
 
1672
create_toolbar_actions (GtkUIManager *ui_manager, GtkWidget **widget)
 
1673
{
 
1674
    toolbar = gtk_ui_manager_get_widget (ui_manager, "/ToolbarActions");
 
1675
 
 
1676
    holdToolbar = gtk_ui_manager_get_widget (ui_manager,
 
1677
                  "/ToolbarActions/OnHoldToolbar");
 
1678
    offHoldToolbar = gtk_ui_manager_get_widget (ui_manager,
 
1679
                     "/ToolbarActions/OffHoldToolbar");
 
1680
    transferToolbar = gtk_ui_manager_get_widget (ui_manager,
 
1681
                      "/ToolbarActions/TransferToolbar");
 
1682
    voicemailAction = gtk_ui_manager_get_action (ui_manager,
 
1683
                      "/ToolbarActions/Voicemail");
 
1684
    voicemailToolbar = gtk_ui_manager_get_widget (ui_manager,
 
1685
                       "/ToolbarActions/VoicemailToolbar");
 
1686
    newCallWidget = gtk_ui_manager_get_widget (ui_manager,
 
1687
                    "/ToolbarActions/NewCallToolbar");
 
1688
    pickUpWidget = gtk_ui_manager_get_widget (ui_manager,
 
1689
                   "/ToolbarActions/PickUpToolbar");
 
1690
    hangUpWidget = gtk_ui_manager_get_widget (ui_manager,
 
1691
                   "/ToolbarActions/HangUpToolbar");
 
1692
    recordWidget = gtk_ui_manager_get_widget (ui_manager,
 
1693
                   "/ToolbarActions/RecordToolbar");
 
1694
    imToolbar = gtk_ui_manager_get_widget (ui_manager,
 
1695
                                           "/ToolbarActions/InstantMessagingToolbar");
 
1696
    historyButton = gtk_ui_manager_get_widget (ui_manager,
 
1697
                    "/ToolbarActions/HistoryToolbar");
 
1698
    contactButton = gtk_ui_manager_get_widget (ui_manager,
 
1699
                    "/ToolbarActions/AddressbookToolbar");
 
1700
 
 
1701
    // Set the handler ID for the transfer
 
1702
    transfertButtonConnId
 
1703
    = g_signal_connect (G_OBJECT (transferToolbar), "toggled", G_CALLBACK (call_transfer_cb), NULL);
 
1704
    recordButtonConnId
 
1705
    = g_signal_connect (G_OBJECT (recordWidget), "toggled", G_CALLBACK (call_record), NULL);
 
1706
    active_calltree = current_calls;
 
1707
 
 
1708
    *widget = toolbar;
1535
1709
}