← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to gnome/src/uimanager.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome/src/uimanager.c
33
33
#endif
34
34
 
35
35
#include "str_utils.h"
 
36
#include "actions.h"
36
37
#include "preferencesdialog.h"
37
38
#include "icons/icon_factory.h"
38
39
#include "dbus/dbus.h"
88
89
static GtkAction * pasteAction_;
89
90
static GtkAction * recordAction_;
90
91
static GtkAction * imAction_;
 
92
#ifdef SFL_VIDEO
 
93
static GtkAction * screenshareAction_;
 
94
#endif
91
95
 
92
96
static GtkWidget * pickUpWidget_;
93
97
static GtkWidget * newCallWidget_;
99
103
static GtkWidget * recordWidget_;
100
104
static GtkWidget * voicemailToolbar_;
101
105
static GtkWidget * imToolbar_;
 
106
static GtkWidget * screenshareToolbar_;
102
107
 
103
108
static GtkWidget * editable_num_;
104
109
static GtkWidget * edit_dialog_;
129
134
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item), pos);
130
135
}
131
136
 
 
137
#ifdef SFL_VIDEO
 
138
static gboolean
 
139
is_video_call(callable_obj_t *call)
 
140
{
 
141
    gboolean video_enabled = FALSE;
 
142
    account_t *account = account_list_get_by_id(call->_accountID);
 
143
 
 
144
    if (account) {
 
145
        gchar *ptr = (gchar *) account_lookup(account, CONFIG_VIDEO_ENABLED);
 
146
        video_enabled = g_strcmp0(ptr, "true") == 0;
 
147
    }
 
148
 
 
149
    return video_enabled;
 
150
}
 
151
#endif
 
152
 
132
153
static void
133
154
update_toolbar_for_call(callable_obj_t *selectedCall, gboolean instant_messaging_enabled, SFLPhoneClient *client)
134
155
{
221
242
        }
222
243
        case CALL_STATE_CURRENT:
223
244
        {
 
245
#ifdef SFL_VIDEO
 
246
            const gboolean video_enabled = is_video_call(selectedCall);
 
247
#endif
 
248
 
224
249
                g_debug("Call State Current");
225
250
                g_signal_handler_block(transferToolbar_, transferButtonConnId_);
226
251
                g_signal_handler_block(recordWidget_, recordButtonConnId_);
232
257
                gtk_widget_set_sensitive(transferToolbar_, TRUE);
233
258
                if (instant_messaging_enabled)
234
259
                    gtk_action_set_sensitive(imAction_, TRUE);
 
260
#ifdef SFL_VIDEO
 
261
                if (video_enabled)
 
262
                    gtk_action_set_sensitive(screenshareAction_, TRUE);
 
263
#endif
235
264
 
236
265
                pos = 1;
237
266
                add_to_toolbar(toolbar, hangUpWidget_, pos++);
240
269
                add_to_toolbar(toolbar, recordWidget_, pos++);
241
270
                if (instant_messaging_enabled)
242
271
                    add_to_toolbar(toolbar, imToolbar_, pos++);
 
272
#ifdef SFL_VIDEO
 
273
                if (video_enabled)
 
274
                    add_to_toolbar(toolbar, screenshareToolbar_, pos++);
 
275
#endif
243
276
 
244
277
                gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(transferToolbar_), FALSE);
245
278
                gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(recordWidget_), dbus_get_is_recording(selectedCall));
376
409
    gtk_action_set_sensitive(recordAction_, FALSE);
377
410
    gtk_action_set_sensitive(copyAction_, FALSE);
378
411
    gtk_action_set_sensitive(imAction_, FALSE);
 
412
#ifdef SFL_VIDEO
 
413
    gtk_action_set_sensitive(screenshareAction_, FALSE);
 
414
#endif
379
415
 
380
416
    gtk_widget_set_sensitive(holdMenu_, FALSE);
381
417
    gtk_widget_set_sensitive(holdToolbar_, FALSE);
392
428
    g_object_ref(transferToolbar_);
393
429
    g_object_ref(voicemailToolbar_);
394
430
    g_object_ref(imToolbar_);
 
431
#ifdef SFL_VIDEO
 
432
    g_object_ref(screenshareToolbar_);
 
433
#endif
395
434
 
396
435
    if (addrbook)
397
436
        g_object_ref(contactButton_);
406
445
    remove_from_toolbar(toolbar, historyButton_);
407
446
    remove_from_toolbar(toolbar, voicemailToolbar_);
408
447
    remove_from_toolbar(toolbar, imToolbar_);
 
448
    remove_from_toolbar(toolbar, screenshareToolbar_);
409
449
    remove_from_toolbar(toolbar, holdToolbar_);
410
450
    remove_from_toolbar(toolbar, offHoldToolbar_);
411
451
    remove_from_toolbar(toolbar, newCallWidget_);
470
510
                      current_account_get_message_number());
471
511
 
472
512
    if (current_account_has_new_message())
473
 
        gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(voicemailToolbar_),
474
 
                                      "mail-message-new");
 
513
        gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(voicemailToolbar_),
 
514
                                      GTK_STOCK_NEWVOICEMAIL);
475
515
    else
476
 
        gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(voicemailToolbar_),
477
 
                                      "mail-read");
 
516
        gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(voicemailToolbar_),
 
517
                                      GTK_STOCK_VOICEMAIL);
478
518
 
479
519
    gtk_tool_button_set_label(GTK_TOOL_BUTTON(voicemailToolbar_), messages);
480
520
    g_free(messages);
662
702
}
663
703
 
664
704
static void
 
705
call_screenshare(G_GNUC_UNUSED GtkAction *action, G_GNUC_UNUSED SFLPhoneClient *client)
 
706
{
 
707
#ifdef SFL_VIDEO
 
708
    sflphone_toggle_screenshare();
 
709
#endif
 
710
}
 
711
 
 
712
static gchar *
 
713
choose_file(void)
 
714
{
 
715
    gchar *uri = NULL;
 
716
    GtkWidget *dialog = gtk_file_chooser_dialog_new(NULL, NULL,
 
717
            GTK_FILE_CHOOSER_ACTION_OPEN,
 
718
            _("_Cancel"), GTK_RESPONSE_CANCEL,
 
719
            _("_Open"), GTK_RESPONSE_ACCEPT,
 
720
            NULL);
 
721
 
 
722
    if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 
723
        GtkFileChooser *chooser = GTK_FILE_CHOOSER(dialog);
 
724
        uri = gtk_file_chooser_get_uri(chooser);
 
725
    }
 
726
 
 
727
    gtk_widget_destroy(dialog);
 
728
    return uri;
 
729
}
 
730
 
 
731
#ifdef SFL_VIDEO
 
732
static void
 
733
call_switch_video_input(G_GNUC_UNUSED GtkWidget *widget, gchar *device)
 
734
{
 
735
    gchar *resource;
 
736
 
 
737
    if (g_strcmp0(device, _("Screen")) == 0) {
 
738
        resource = sflphone_get_display();
 
739
    } else if (g_strcmp0(device, _("Choose file...")) == 0) {
 
740
        resource = choose_file();
 
741
        if (!resource)
 
742
            return;
 
743
    } else {
 
744
        dbus_video_set_default_device(device);
 
745
        resource = g_strconcat("v4l2://", device, NULL);
 
746
    }
 
747
 
 
748
    sflphone_switch_video_input(resource);
 
749
    g_free(resource);
 
750
}
 
751
#endif
 
752
 
 
753
static void
665
754
conference_hold(G_GNUC_UNUSED gpointer foo)
666
755
{
667
756
    conference_obj_t * selectedConf = calltab_get_selected_conf(current_calls_tab);
846
935
                    selectedCall->_peer_info = g_strconcat("\"\" <",
847
936
                                                           selectedCall->_peer_number, ">", NULL);
848
937
 
849
 
                calltree_update_call(current_calls_tab, selectedCall, client, FALSE);
 
938
                calltree_update_call(current_calls_tab, selectedCall, client);
850
939
            }
851
940
            break;
852
941
            case CALL_STATE_RINGING:
865
954
                selectedCall->_peer_info = g_strconcat("\"\" <",
866
955
                                                       selectedCall->_peer_number, ">", NULL);
867
956
 
868
 
                calltree_update_call(current_calls_tab, selectedCall, client, FALSE);
 
957
                calltree_update_call(current_calls_tab, selectedCall, client);
869
958
            }
870
959
            break;
871
960
            case CALL_STATE_CURRENT:
881
970
                    selectedCall->_peer_info = get_peer_info(temp, selectedCall->_display_name);
882
971
                    g_free(temp);
883
972
                    g_free(oneNo);
884
 
                    calltree_update_call(current_calls_tab, selectedCall, client, TRUE);
 
973
                    calltree_update_call(current_calls_tab, selectedCall, client);
885
974
                }
886
975
            }
887
976
            break;
897
986
        g_free(selectedCall->_peer_info);
898
987
        selectedCall->_peer_info = g_strconcat("\"\" <",
899
988
                                               selectedCall->_peer_number, ">", NULL);
900
 
        calltree_update_call(current_calls_tab, selectedCall, client, FALSE);
 
989
        calltree_update_call(current_calls_tab, selectedCall, client);
901
990
    }
902
991
 
903
992
    g_free(no);
1010
1099
        N_("Send message"), G_CALLBACK(call_im)
1011
1100
    },
1012
1101
    {
 
1102
        "ScreenSharing", GTK_STOCK_SCREENSHARING, N_("Share screen"), "<control>X",
 
1103
        N_("Share screen"), G_CALLBACK(call_screenshare)
 
1104
    },
 
1105
    {
1013
1106
        "AccountAssistant", NULL, N_("Configuration _Assistant"), NULL,
1014
1107
        N_("Run the configuration assistant"), G_CALLBACK(call_configuration_assistant)
1015
1108
    },
1062
1155
 
1063
1156
static const GtkToggleActionEntry toggle_menu_entries[] = {
1064
1157
    { "Transfer", GTK_STOCK_TRANSFER, N_("_Transfer"), "<control>T", N_("Transfer the call"), NULL, TRUE },
1065
 
    { "Record", GTK_STOCK_MEDIA_RECORD, N_("_Record"), "<control>R", N_("Record the current conversation"), NULL, TRUE },
 
1158
    { "Record", GTK_STOCK_RECORD, N_("_Record"), "<control>R", N_("Record the current conversation"), NULL, TRUE },
1066
1159
    { "Toolbar", NULL, N_("_Show toolbar"), "<control>T", N_("Show the toolbar"), NULL, TRUE },
1067
1160
    { "Dialpad", NULL, N_("_Dialpad"), "<control>D", N_("Show the dialpad"), G_CALLBACK(dialpad_bar_cb), TRUE },
1068
1161
    { "VolumeControls", NULL, N_("_Volume controls"), "<control>V", N_("Show the volume controls"), G_CALLBACK(volume_bar_cb), TRUE },
1069
 
    { "History", "appointment-soon", N_("_History"), NULL, N_("Calls history"), G_CALLBACK(toggle_history_cb), FALSE },
 
1162
    { "History", GTK_STOCK_HISTORY, N_("_History"), NULL, N_("Call history"), G_CALLBACK(toggle_history_cb), FALSE },
1070
1163
    { "Addressbook", GTK_STOCK_ADDRESSBOOK, N_("_Address book"), NULL, N_("Address book"), G_CALLBACK(toggle_addressbook_cb), FALSE },
1071
1164
#ifdef SFL_PRESENCE
1072
1165
    { "Buddies", NULL, N_("_Buddy list"), NULL, N_("Display the buddy list"), G_CALLBACK(toggle_presence_window_cb), FALSE},
1208
1301
                       gtk_get_current_event_time());
1209
1302
}
1210
1303
 
 
1304
#ifdef SFL_VIDEO
 
1305
static void
 
1306
append_video_input_to_submenu(GtkWidget *submenu, const gchar *device)
 
1307
{
 
1308
    GtkWidget *item = gtk_image_menu_item_new_with_mnemonic(_(device));
 
1309
    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
 
1310
    g_signal_connect(G_OBJECT(item), "activate",
 
1311
            G_CALLBACK(call_switch_video_input), (gpointer) device);
 
1312
    gtk_widget_show(item);
 
1313
}
 
1314
#endif
 
1315
 
1211
1316
void
1212
1317
show_popup_menu(GtkWidget *my_widget, GdkEventButton *event, SFLPhoneClient *client)
1213
1318
{
1214
1319
    // TODO update the selection to make sure the call under the mouse is the call selected
1215
1320
    gboolean pickup = FALSE, hangup = FALSE, hold = FALSE, copy = FALSE, record = FALSE, im = FALSE;
 
1321
#ifdef SFL_VIDEO
 
1322
    gboolean video_sources = FALSE;
 
1323
#endif
1216
1324
    gboolean accounts = FALSE;
1217
1325
 
1218
1326
    // conference type boolean
1250
1358
                    hold = TRUE;
1251
1359
                    record = TRUE;
1252
1360
                    im = TRUE;
 
1361
#ifdef SFL_VIDEO
 
1362
                    video_sources = is_video_call(selectedCall);
 
1363
#endif
1253
1364
                    break;
1254
1365
                case CALL_STATE_BUSY:
1255
1366
                case CALL_STATE_FAILURE:
1287
1398
    }
1288
1399
 
1289
1400
    GtkWidget *menu = gtk_menu_new();
 
1401
    gtk_menu_set_accel_group(GTK_MENU(menu), get_accel_group());
1290
1402
 
1291
1403
    if (calltab_get_selected_type(current_calls_tab) == A_CALL) {
1292
1404
        g_debug("Build call menu");
1293
1405
        if (copy) {
1294
 
            GtkWidget *menu_items = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY,
1295
 
                                    get_accel_group());
1296
 
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
1297
 
            g_signal_connect(G_OBJECT(menu_items), "activate",
 
1406
            GtkWidget *copy_item = gtk_menu_item_new_with_mnemonic(_("_Copy"));
 
1407
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), copy_item);
 
1408
            g_signal_connect(G_OBJECT(copy_item), "activate",
1298
1409
                             G_CALLBACK(edit_copy),
1299
1410
                             NULL);
1300
 
            gtk_widget_show(menu_items);
 
1411
            gtk_widget_show(copy_item);
1301
1412
        }
1302
1413
 
1303
 
        GtkWidget *paste = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE,
1304
 
                           get_accel_group());
 
1414
        GtkWidget *paste = gtk_menu_item_new_with_mnemonic(_("_Paste"));
1305
1415
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), paste);
1306
1416
        g_signal_connect(G_OBJECT(paste), "activate", G_CALLBACK(edit_paste),
1307
1417
                         client);
1314
1424
        }
1315
1425
 
1316
1426
        if (pickup) {
1317
 
            GtkWidget *menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Pick up"));
 
1427
            GtkWidget *pickup_item = gtk_image_menu_item_new_with_mnemonic(_("_Pick up"));
1318
1428
            GtkWidget *image = gtk_image_new_from_file(ICONS_DIR "/icon_accept.svg");
1319
 
            gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
1320
 
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
1321
 
            g_signal_connect(G_OBJECT(menu_items), "activate",
 
1429
            gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(pickup_item), image);
 
1430
            gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(pickup_item), TRUE);
 
1431
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), pickup_item);
 
1432
            g_signal_connect(G_OBJECT(pickup_item), "activate",
1322
1433
                             G_CALLBACK(call_pick_up),
1323
1434
                             client);
1324
 
            gtk_widget_show(menu_items);
 
1435
            gtk_widget_show(pickup_item);
1325
1436
        }
1326
1437
 
1327
1438
        if (hangup) {
1348
1459
 
1349
1460
        if (record) {
1350
1461
            GtkWidget *menu_items = gtk_image_menu_item_new_with_mnemonic(_("_Record"));
1351
 
            GtkWidget *image = gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD,
 
1462
            GtkWidget *image = gtk_image_new_from_stock(GTK_STOCK_RECORD,
1352
1463
                               GTK_ICON_SIZE_MENU);
1353
1464
            gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_items), image);
1354
1465
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
1377
1488
                gtk_widget_show(menu_items);
1378
1489
            }
1379
1490
        }
 
1491
 
 
1492
#ifdef SFL_VIDEO
 
1493
        if (video_sources) {
 
1494
            GtkWidget *video_sep, *video_item, *video_menu;
 
1495
 
 
1496
            video_sep = gtk_separator_menu_item_new();
 
1497
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), video_sep);
 
1498
            gtk_widget_show(video_sep);
 
1499
 
 
1500
            /* Add a video sources menu */
 
1501
            video_item = gtk_image_menu_item_new_with_mnemonic(_("Video sources"));
 
1502
            gtk_menu_shell_append(GTK_MENU_SHELL(menu), video_item);
 
1503
            gtk_widget_show(video_item);
 
1504
 
 
1505
            video_menu = gtk_menu_new();
 
1506
            gtk_menu_item_set_submenu(GTK_MENU_ITEM(video_item), video_menu);
 
1507
 
 
1508
            /* Append sources to the submenu */
 
1509
            gchar **video_list = dbus_video_get_device_list();
 
1510
            while (*video_list) {
 
1511
                append_video_input_to_submenu(video_menu, *video_list);
 
1512
                //g_free(*video_list);
 
1513
                video_list++;
 
1514
            }
 
1515
            /* Add the special X11 device */
 
1516
            append_video_input_to_submenu(video_menu, _("Screen"));
 
1517
            append_video_input_to_submenu(video_menu, _("Choose file..."));
 
1518
        }
 
1519
#endif
1380
1520
    } else {
1381
1521
        g_debug("Build conf menus");
1382
1522
 
1639
1779
    holdMenu_ = get_widget(ui, "/MenuBar/CallMenu/OnHoldMenu");
1640
1780
    recordAction_ = get_action(ui, "/MenuBar/CallMenu/Record");
1641
1781
    imAction_ = get_action(ui, "/MenuBar/CallMenu/InstantMessaging");
 
1782
#ifdef SFL_VIDEO
 
1783
    screenshareAction_ = get_action(ui, "/MenuBar/CallMenu/ScreenSharing");
 
1784
#endif
1642
1785
    copyAction_ = get_action(ui, "/MenuBar/EditMenu/Copy");
1643
1786
    pasteAction_ = get_action(ui, "/MenuBar/EditMenu/Paste");
1644
1787
    volumeToggle_ = get_action(ui, "/MenuBar/ViewMenu/VolumeControls");
1672
1815
    hangUpWidget_ = get_widget(ui, "/ToolbarActions/HangUpToolbar");
1673
1816
    recordWidget_ = get_widget(ui, "/ToolbarActions/RecordToolbar");
1674
1817
    imToolbar_ = get_widget(ui, "/ToolbarActions/InstantMessagingToolbar");
 
1818
    screenshareToolbar_ = get_widget(ui, "/ToolbarActions/ScreenSharingToolbar");
 
1819
/* Hide this widget if video support is disabled */
 
1820
#ifndef SFL_VIDEO
 
1821
    remove_from_toolbar(client->toolbar, screenshareToolbar_);
 
1822
#endif
1675
1823
    historyButton_ = get_widget(ui, "/ToolbarActions/HistoryToolbar");
1676
1824
    if (addrbook)
1677
1825
        contactButton_ = get_widget(ui, "/ToolbarActions/AddressbookToolbar");