Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkprefs.c

pidgin/gtkprefs.c

branch
vv
changeset 26337
ec2fc1bc9024
parent 25911
f22097dc8413
parent 26336
46202497d8c3
child 26461
3895e7fa5c1c
equal deleted inserted replaced
26044:133e5eca834c 26337:ec2fc1bc9024
26 */ 26 */
27 #include "internal.h" 27 #include "internal.h"
28 #include "pidgin.h" 28 #include "pidgin.h"
29 29
30 #include "debug.h" 30 #include "debug.h"
31 #ifdef USE_VV
32 #include "mediamanager.h"
33 #endif
31 #include "notify.h" 34 #include "notify.h"
32 #include "prefs.h" 35 #include "prefs.h"
33 #include "proxy.h" 36 #include "proxy.h"
34 #include "prpl.h" 37 #include "prpl.h"
35 #include "request.h" 38 #include "request.h"
143 gtk_widget_show(entry); 146 gtk_widget_show(entry);
144 147
145 return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL); 148 return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL);
146 } 149 }
147 150
151 GtkWidget *
152 pidgin_prefs_labeled_password(GtkWidget *page, const gchar *title,
153 const char *key, GtkSizeGroup *sg)
154 {
155 GtkWidget *entry;
156 const gchar *value;
157
158 value = purple_prefs_get_string(key);
159
160 entry = gtk_entry_new();
161 gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
162 gtk_entry_set_text(GTK_ENTRY(entry), value);
163 g_signal_connect(G_OBJECT(entry), "changed",
164 G_CALLBACK(entry_set), (char*)key);
165 gtk_widget_show(entry);
166
167 return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL);
168 }
169
170
148 static void 171 static void
149 dropdown_set(GObject *w, const char *key) 172 dropdown_set(GObject *w, const char *key)
150 { 173 {
151 const char *str_value; 174 const char *str_value;
152 int int_value; 175 int int_value;
154 177
155 type = GPOINTER_TO_INT(g_object_get_data(w, "type")); 178 type = GPOINTER_TO_INT(g_object_get_data(w, "type"));
156 179
157 if (type == PURPLE_PREF_INT) { 180 if (type == PURPLE_PREF_INT) {
158 int_value = GPOINTER_TO_INT(g_object_get_data(w, "value")); 181 int_value = GPOINTER_TO_INT(g_object_get_data(w, "value"));
159
160 purple_prefs_set_int(key, int_value); 182 purple_prefs_set_int(key, int_value);
161 } 183 }
162 else if (type == PURPLE_PREF_STRING) { 184 else if (type == PURPLE_PREF_STRING) {
163 str_value = (const char *)g_object_get_data(w, "value"); 185 str_value = (const char *)g_object_get_data(w, "value");
164
165 purple_prefs_set_string(key, str_value); 186 purple_prefs_set_string(key, str_value);
166 } 187 }
167 else if (type == PURPLE_PREF_BOOLEAN) { 188 else if (type == PURPLE_PREF_BOOLEAN) {
168 purple_prefs_set_bool(key, 189 purple_prefs_set_bool(key,
169 GPOINTER_TO_INT(g_object_get_data(w, "value"))); 190 GPOINTER_TO_INT(g_object_get_data(w, "value")));
1208 _("Always"), "always", 1229 _("Always"), "always",
1209 _("On unread messages"), "pending", 1230 _("On unread messages"), "pending",
1210 _("Never"), "never", 1231 _("Never"), "never",
1211 NULL); 1232 NULL);
1212 gtk_size_group_add_widget(sg, label); 1233 gtk_size_group_add_widget(sg, label);
1213 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); 1234 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1214 1235
1215 vbox = pidgin_make_frame(ret, _("Conversation Window Hiding")); 1236 vbox = pidgin_make_frame(ret, _("Conversation Window Hiding"));
1216 label = pidgin_prefs_dropdown(vbox, _("_Hide new IM conversations:"), 1237 label = pidgin_prefs_dropdown(vbox, _("_Hide new IM conversations:"),
1217 PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/conversations/im/hide_new", 1238 PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/conversations/im/hide_new",
1218 _("Never"), "never", 1239 _("Never"), "never",
1219 _("When away"), "away", 1240 _("When away"), "away",
1220 _("Always"), "always", 1241 _("Always"), "always",
1221 NULL); 1242 NULL);
1222 gtk_size_group_add_widget(sg, label); 1243 gtk_size_group_add_widget(sg, label);
1223 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); 1244 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1224 1245
1225 1246
1226 /* All the tab options! */ 1247 /* All the tab options! */
1227 vbox = pidgin_make_frame(ret, _("Tabs")); 1248 vbox = pidgin_make_frame(ret, _("Tabs"));
1228 1249
1253 _("Left Vertical"), GTK_POS_LEFT|8, 1274 _("Left Vertical"), GTK_POS_LEFT|8,
1254 _("Right Vertical"), GTK_POS_RIGHT|8, 1275 _("Right Vertical"), GTK_POS_RIGHT|8,
1255 #endif 1276 #endif
1256 NULL); 1277 NULL);
1257 gtk_size_group_add_widget(sg, label); 1278 gtk_size_group_add_widget(sg, label);
1258 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); 1279 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1259 1280
1260 names = pidgin_conv_placement_get_options(); 1281 names = pidgin_conv_placement_get_options();
1261 label = pidgin_prefs_dropdown_from_list(vbox2, _("N_ew conversations:"), 1282 label = pidgin_prefs_dropdown_from_list(vbox2, _("N_ew conversations:"),
1262 PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/conversations/placement", names); 1283 PURPLE_PREF_STRING, PIDGIN_PREFS_ROOT "/conversations/placement", names);
1263 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); 1284 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1404 * and a green background when the IP address is valid. 1425 * and a green background when the IP address is valid.
1405 */ 1426 */
1406 purple_network_set_public_ip(gtk_entry_get_text(entry)); 1427 purple_network_set_public_ip(gtk_entry_get_text(entry));
1407 } 1428 }
1408 1429
1430 static gboolean network_stun_server_changed_cb(GtkWidget *widget,
1431 GdkEventFocus *event, gpointer data)
1432 {
1433 GtkEntry *entry = GTK_ENTRY(widget);
1434 purple_prefs_set_string("/purple/network/stun_server",
1435 gtk_entry_get_text(entry));
1436 purple_network_set_stun_server(gtk_entry_get_text(entry));
1437
1438 return FALSE;
1439 }
1440
1441 static gboolean network_turn_server_changed_cb(GtkWidget *widget,
1442 GdkEventFocus *event, gpointer data)
1443 {
1444 GtkEntry *entry = GTK_ENTRY(widget);
1445 purple_prefs_set_string("/purple/network/turn_server",
1446 gtk_entry_get_text(entry));
1447 purple_network_set_turn_server(gtk_entry_get_text(entry));
1448
1449 return FALSE;
1450 }
1451
1409 static void 1452 static void
1410 proxy_changed_cb(const char *name, PurplePrefType type, 1453 proxy_changed_cb(const char *name, PurplePrefType type,
1411 gconstpointer value, gpointer data) 1454 gconstpointer value, gpointer data)
1412 { 1455 {
1413 GtkWidget *frame = data; 1456 GtkWidget *frame = data;
1469 ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE); 1512 ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
1470 gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER); 1513 gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
1471 1514
1472 vbox = pidgin_make_frame (ret, _("IP Address")); 1515 vbox = pidgin_make_frame (ret, _("IP Address"));
1473 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); 1516 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1474 pidgin_prefs_labeled_entry(vbox,_("ST_UN server:"), 1517
1475 "/purple/network/stun_server", sg); 1518 entry = gtk_entry_new();
1519 gtk_entry_set_text(GTK_ENTRY(entry), purple_prefs_get_string(
1520 "/purple/network/stun_server"));
1521 g_signal_connect(G_OBJECT(entry), "focus-out-event",
1522 G_CALLBACK(network_stun_server_changed_cb), NULL);
1523 gtk_widget_show(entry);
1524
1525 pidgin_add_widget_to_vbox(GTK_BOX(vbox), "ST_UN server:",
1526 sg, entry, TRUE, NULL);
1476 1527
1477 hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); 1528 hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
1478 gtk_container_add(GTK_CONTAINER(vbox), hbox); 1529 gtk_container_add(GTK_CONTAINER(vbox), hbox);
1479 1530
1480 label = gtk_label_new(NULL); 1531 label = gtk_label_new(NULL);
1547 "/purple/network/ports_range_end", 0, 65535, sg); 1598 "/purple/network/ports_range_end", 0, 65535, sg);
1548 if (!purple_prefs_get_bool("/purple/network/ports_range_use")) 1599 if (!purple_prefs_get_bool("/purple/network/ports_range_use"))
1549 gtk_widget_set_sensitive(GTK_WIDGET(spin_button), FALSE); 1600 gtk_widget_set_sensitive(GTK_WIDGET(spin_button), FALSE);
1550 g_signal_connect(G_OBJECT(ports_checkbox), "clicked", 1601 g_signal_connect(G_OBJECT(ports_checkbox), "clicked",
1551 G_CALLBACK(pidgin_toggle_sensitive), spin_button); 1602 G_CALLBACK(pidgin_toggle_sensitive), spin_button);
1603
1604 g_object_unref(sg);
1605
1606 /* TURN server */
1607 vbox = pidgin_make_frame(ret, _("Relay Server (TURN)"));
1608 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1609
1610 entry = gtk_entry_new();
1611 gtk_entry_set_text(GTK_ENTRY(entry), purple_prefs_get_string(
1612 "/purple/network/turn_server"));
1613 g_signal_connect(G_OBJECT(entry), "focus-out-event",
1614 G_CALLBACK(network_turn_server_changed_cb), NULL);
1615 gtk_widget_show(entry);
1616
1617 hbox = pidgin_add_widget_to_vbox(GTK_BOX(vbox), "_TURN server:",
1618 sg, entry, TRUE, NULL);
1619
1620 pidgin_prefs_labeled_spin_button(hbox, _("_Port:"),
1621 "/purple/network/turn_port", 0, 65535, NULL);
1622 hbox = pidgin_prefs_labeled_entry(vbox, "_Username:",
1623 "/purple/network/turn_username", sg);
1624 pidgin_prefs_labeled_password(hbox, "_Password:",
1625 "/purple/network/turn_password", NULL);
1552 1626
1553 if (purple_running_gnome()) { 1627 if (purple_running_gnome()) {
1554 vbox = pidgin_make_frame(ret, _("Proxy Server & Browser")); 1628 vbox = pidgin_make_frame(ret, _("Proxy Server & Browser"));
1555 prefs_proxy_frame = gtk_vbox_new(FALSE, 0); 1629 prefs_proxy_frame = gtk_vbox_new(FALSE, 0);
1556 1630
2324 g_object_unref(sg); 2398 g_object_unref(sg);
2325 2399
2326 return ret; 2400 return ret;
2327 } 2401 }
2328 2402
2403 #ifdef USE_VV
2404
2405 /* get a GList of pairs name / device */
2406 static GList *
2407 get_device_items(const gchar *plugin)
2408 {
2409 GList *ret = NULL;
2410 GList *devices = purple_media_get_devices(plugin);
2411 GstElement *element = gst_element_factory_make(plugin, NULL);
2412
2413 if (element == NULL)
2414 return NULL;
2415
2416 for(; devices ; devices = g_list_delete_link(devices, devices)) {
2417 gchar *name;
2418 g_object_set(G_OBJECT(element), "device", devices->data, NULL);
2419 g_object_get(G_OBJECT(element), "device-name", &name, NULL);
2420 ret = g_list_append(ret, name);
2421 ret = g_list_append(ret, devices->data);
2422 }
2423
2424 gst_object_unref(element);
2425 return ret;
2426 }
2427
2428 /*
2429 * Test functions to run video preview
2430 */
2431 static gboolean
2432 preview_video_bus_call(GstBus *bus, GstMessage *msg, gpointer pipeline)
2433 {
2434 switch(GST_MESSAGE_TYPE(msg)) {
2435 case GST_MESSAGE_EOS:
2436 purple_debug_info("preview-video", "End of Stream\n");
2437 break;
2438 case GST_MESSAGE_ERROR: {
2439 gchar *debug = NULL;
2440 GError *err = NULL;
2441
2442 gst_message_parse_error(msg, &err, &debug);
2443
2444 purple_debug_error("preview-video", "Error: %s\n", err->message);
2445 g_error_free(err);
2446
2447 if (debug) {
2448 purple_debug_error("preview-video", "details: %s\n", debug);
2449 g_free (debug);
2450 }
2451 break;
2452 }
2453 default:
2454 return TRUE;
2455 }
2456
2457 gst_element_set_state(pipeline, GST_STATE_NULL);
2458 gst_object_unref(GST_PIPELINE(pipeline));
2459 return FALSE;
2460 }
2461
2462 static void
2463 preview_button_clicked(GtkWidget *widget, gpointer *data)
2464 {
2465 const char *plugin = purple_prefs_get_string("/purple/media/video/plugin");
2466 const char *device = purple_prefs_get_string("/purple/media/video/device");
2467 GstBus *bus;
2468
2469 /* create a preview window... */
2470 GstElement *pipeline = NULL;
2471 GError *p_err = NULL;
2472
2473 gchar *test_pipeline_str = NULL;
2474
2475 if (strlen(device) > 0)
2476 test_pipeline_str = g_strdup_printf("%s device=\"%s\" !" \
2477 " ffmpegcolorspace !" \
2478 " autovideosink",
2479 plugin, device);
2480 else
2481 test_pipeline_str = g_strdup_printf("%s ! ffmpegcolorspace !" \
2482 " autovideosink", plugin);
2483
2484 pipeline = gst_parse_launch (test_pipeline_str, &p_err);
2485
2486 g_free(test_pipeline_str);
2487
2488 if (pipeline == NULL) {
2489 purple_debug_error("gtkprefs",
2490 "Error starting preview: %s\n", p_err->message);
2491 g_error_free(p_err);
2492 return;
2493 }
2494
2495 bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
2496 gst_bus_add_watch(bus, preview_video_bus_call, pipeline);
2497 gst_object_unref(bus);
2498
2499 gst_element_set_state(pipeline, GST_STATE_PLAYING);
2500 }
2501
2502 static void
2503 media_plugin_changed_cb(const gchar *name, PurplePrefType type,
2504 gconstpointer value, gpointer data)
2505 {
2506 GtkWidget *hbox = data;
2507 GtkWidget *dd = NULL;
2508 GtkWidget *preview_button = NULL;
2509 const char *plugin = value;
2510 const char *device = purple_prefs_get_string("/purple/media/video/device");
2511 GList *video_items = get_device_items(plugin);
2512 GList *list;
2513
2514 if (video_items == NULL) {
2515 video_items = g_list_prepend(video_items, g_strdup(""));
2516 video_items = g_list_prepend(video_items, g_strdup("Default"));
2517 }
2518
2519 if (g_list_find(video_items, device) == NULL)
2520 {
2521 purple_prefs_set_string("/purple/media/video/device",
2522 g_list_next(video_items)->data);
2523 }
2524
2525 list = gtk_container_get_children(GTK_CONTAINER(hbox));
2526
2527 while (list) {
2528 gtk_widget_destroy(list->data);
2529 list = g_list_delete_link(list, list);
2530 }
2531
2532 dd = pidgin_prefs_dropdown_from_list(hbox, _("_Device:"), PURPLE_PREF_STRING,
2533 "/purple/media/video/device",
2534 video_items);
2535
2536 gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5);
2537
2538 preview_button = gtk_button_new_with_mnemonic(_("_Preview"));
2539 g_signal_connect(G_OBJECT(preview_button), "clicked",
2540 G_CALLBACK(preview_button_clicked), NULL);
2541
2542 gtk_container_add(GTK_CONTAINER(hbox), preview_button);
2543
2544 gtk_widget_show_all(hbox);
2545 }
2546
2547 static void
2548 prefs_media_input_volume_changed(GtkRange *range)
2549 {
2550 double val = (double)gtk_range_get_value(GTK_RANGE(range));
2551 GList *medias = purple_media_manager_get_media(purple_media_manager_get());
2552 purple_prefs_set_int("/purple/media/audio/volume/input", val);
2553
2554 val /= 10.0;
2555 for (; medias; medias = g_list_next(medias)) {
2556 PurpleMedia *media = PURPLE_MEDIA(medias->data);
2557 purple_media_set_input_volume(media, NULL, val);
2558 }
2559 }
2560
2561 static void
2562 prefs_media_output_volume_changed(GtkRange *range)
2563 {
2564 double val = (double)gtk_range_get_value(GTK_RANGE(range));
2565 GList *medias = purple_media_manager_get_media(purple_media_manager_get());
2566 purple_prefs_set_int("/purple/media/audio/volume/output", val);
2567
2568 val /= 10.0;
2569 for (; medias; medias = g_list_next(medias)) {
2570 PurpleMedia *media = PURPLE_MEDIA(medias->data);
2571 purple_media_set_output_volume(media, NULL, NULL, val);
2572 }
2573 }
2574
2575 static GtkWidget *
2576 media_page()
2577 {
2578 GtkWidget *ret;
2579 GtkWidget *vbox;
2580 GtkWidget *hbox;
2581 GtkWidget *dd;
2582 GtkWidget *preview_button;
2583 GtkWidget *sw;
2584 GtkSizeGroup *sg, *sg2;
2585 const char *plugin = purple_prefs_get_string("/purple/media/video/plugin");
2586 const char *device = purple_prefs_get_string("/purple/media/video/device");
2587 GList *video_items = get_device_items(plugin);
2588 GList *audio_items = get_device_items("alsasrc");
2589
2590 if (video_items == NULL) {
2591 video_items = g_list_prepend(video_items, "");
2592 video_items = g_list_prepend(video_items, "Default");
2593 }
2594
2595 if (g_list_find(video_items, device) == NULL)
2596 {
2597 purple_prefs_set_string("/purple/media/video/device",
2598 g_list_next(video_items)->data);
2599 }
2600
2601 ret = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);
2602 gtk_container_set_border_width (GTK_CONTAINER (ret), PIDGIN_HIG_BORDER);
2603
2604 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2605 sg2 = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2606
2607 vbox = pidgin_make_frame (ret, _("Video Input"));
2608 gtk_size_group_add_widget(sg2, vbox);
2609
2610 hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
2611 dd = pidgin_prefs_dropdown(vbox, _("_Plugin:"), PURPLE_PREF_STRING,
2612 "/purple/media/video/plugin",
2613 _("Default"), "gconfvideosrc",
2614 _("Video4Linux"), "v4lsrc",
2615 _("Video4Linux2"), "v4l2src",
2616 _("Video Test Source"), "videotestsrc",
2617 NULL);
2618
2619 gtk_size_group_add_widget(sg, dd);
2620 gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5);
2621
2622 hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
2623 dd = pidgin_prefs_dropdown_from_list(hbox, _("Device:"), PURPLE_PREF_STRING,
2624 "/purple/media/video/device",
2625 video_items);
2626
2627 purple_prefs_connect_callback(prefs, "/purple/media/video/plugin",
2628 media_plugin_changed_cb, hbox);
2629
2630 g_signal_connect_swapped(hbox, "destroy",
2631 G_CALLBACK(purple_prefs_disconnect_by_handle), hbox);
2632
2633 gtk_size_group_add_widget(sg, dd);
2634 gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5);
2635
2636 preview_button = gtk_button_new_with_mnemonic(_("_Preview"));
2637 g_signal_connect(G_OBJECT(preview_button), "clicked",
2638 G_CALLBACK(preview_button_clicked), NULL);
2639
2640 gtk_container_add(GTK_CONTAINER(hbox), preview_button);
2641 gtk_container_add(GTK_CONTAINER(vbox), hbox);
2642
2643 vbox = pidgin_make_frame (ret, _("Audio Input"));
2644 gtk_size_group_add_widget(sg2, vbox);
2645 dd = pidgin_prefs_dropdown_from_list(vbox, _("Device:"), PURPLE_PREF_STRING,
2646 "/purple/media/audio/device",
2647 audio_items);
2648
2649 gtk_size_group_add_widget(sg, dd);
2650 gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5);
2651
2652 hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
2653 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2654
2655 /* Input Volume */
2656 sw = gtk_hscale_new_with_range(0.0, 100.0, 5.0);
2657 gtk_range_set_increments(GTK_RANGE(sw), 5.0, 25.0);
2658 gtk_range_set_value(GTK_RANGE(sw),
2659 purple_prefs_get_int("/purple/media/audio/volume/input"));
2660 g_signal_connect (G_OBJECT (sw), "format-value",
2661 G_CALLBACK (prefs_sound_volume_format),
2662 NULL);
2663 g_signal_connect (G_OBJECT (sw), "value-changed",
2664 G_CALLBACK (prefs_media_input_volume_changed),
2665 NULL);
2666 pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Volume:"), sg, sw, TRUE, NULL);
2667
2668 vbox = pidgin_make_frame (ret, _("Audio Output"));
2669 gtk_size_group_add_widget(sg2, vbox);
2670
2671 /* Output Volume */
2672 sw = gtk_hscale_new_with_range(0.0, 100.0, 5.0);
2673 gtk_range_set_increments(GTK_RANGE(sw), 5.0, 25.0);
2674 gtk_range_set_value(GTK_RANGE(sw),
2675 purple_prefs_get_int("/purple/media/audio/volume/output"));
2676 g_signal_connect (G_OBJECT (sw), "format-value",
2677 G_CALLBACK (prefs_sound_volume_format),
2678 NULL);
2679 g_signal_connect (G_OBJECT (sw), "value-changed",
2680 G_CALLBACK (prefs_media_output_volume_changed),
2681 NULL);
2682 pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Volume:"), sg, sw, TRUE, NULL);
2683
2684 gtk_widget_show_all(ret);
2685
2686 return ret;
2687 }
2688
2689 #endif /* USE_VV */
2329 2690
2330 static void 2691 static void
2331 set_idle_away(PurpleSavedStatus *status) 2692 set_idle_away(PurpleSavedStatus *status)
2332 { 2693 {
2333 purple_prefs_set_int("/purple/savedstatus/idleaway", purple_savedstatus_get_creation_time(status)); 2694 purple_prefs_set_int("/purple/savedstatus/idleaway", purple_savedstatus_get_creation_time(status));
2449 static void prefs_notebook_init(void) { 2810 static void prefs_notebook_init(void) {
2450 prefs_notebook_add_page(_("Interface"), interface_page(), notebook_page++); 2811 prefs_notebook_add_page(_("Interface"), interface_page(), notebook_page++);
2451 prefs_notebook_add_page(_("Conversations"), conv_page(), notebook_page++); 2812 prefs_notebook_add_page(_("Conversations"), conv_page(), notebook_page++);
2452 prefs_notebook_add_page(_("Smiley Themes"), theme_page(), notebook_page++); 2813 prefs_notebook_add_page(_("Smiley Themes"), theme_page(), notebook_page++);
2453 prefs_notebook_add_page(_("Sounds"), sound_page(), notebook_page++); 2814 prefs_notebook_add_page(_("Sounds"), sound_page(), notebook_page++);
2815
2816 #ifdef USE_VV
2817 prefs_notebook_add_page(_("Media"), media_page(), notebook_page++);
2818 #endif
2454 prefs_notebook_add_page(_("Network"), network_page(), notebook_page++); 2819 prefs_notebook_add_page(_("Network"), network_page(), notebook_page++);
2455 #ifndef _WIN32 2820 #ifndef _WIN32
2456 /* We use the registered default browser in windows */ 2821 /* We use the registered default browser in windows */
2457 /* if the user is running gnome 2.x or Mac OS X, hide the browsers tab */ 2822 /* if the user is running gnome 2.x or Mac OS X, hide the browsers tab */
2458 if ((purple_running_gnome() == FALSE) && (purple_running_osx() == FALSE)) { 2823 if ((purple_running_gnome() == FALSE) && (purple_running_osx() == FALSE)) {
2584 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/smileys/theme", "Default"); 2949 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/smileys/theme", "Default");
2585 2950
2586 /* Smiley Callbacks */ 2951 /* Smiley Callbacks */
2587 purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/smileys/theme", 2952 purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/smileys/theme",
2588 smiley_theme_pref_cb, NULL); 2953 smiley_theme_pref_cb, NULL);
2954
2955 #ifdef USE_VV
2956 purple_prefs_add_none("/purple/media");
2957 purple_prefs_add_none("/purple/media/video");
2958 purple_prefs_add_string("/purple/media/video/plugin", "gconfvideosrc");
2959 purple_prefs_add_string("/purple/media/video/device", "");
2960 purple_prefs_add_none("/purple/media/audio");
2961 purple_prefs_add_string("/purple/media/audio/device", "");
2962 purple_prefs_add_none("/purple/media/audio/volume");
2963 purple_prefs_add_int("/purple/media/audio/volume/input", 10);
2964 purple_prefs_add_int("/purple/media/audio/volume/output", 10);
2965 #endif /* USE_VV */
2589 2966
2590 pidgin_prefs_update_old(); 2967 pidgin_prefs_update_old();
2591 } 2968 }
2592 2969
2593 void pidgin_prefs_update_old() 2970 void pidgin_prefs_update_old()

Mercurial Repository: pidgin3

mercurial