static void
statusicon_set_inacall (StatusIcon *statusicon,
bool inacall)
{
g_return_if_fail (statusicon != NULL);
/* Update the status icon */
if (inacall)
gtk_status_icon_set_from_icon_name (GTK_STATUS_ICON (statusicon), "user-inacall");
else
statusicon_set_status (statusicon, statusicon->priv->status);
}
void
hippo_ui_get_screen_info(HippoUI *ui,
HippoRectangle *monitor_rect_p,
HippoRectangle *tray_icon_rect_p,
HippoOrientation *tray_icon_orientation_p)
{
GtkOrientation orientation;
GdkScreen *screen;
GdkRectangle icon_rect;
GdkRectangle monitor;
int monitor_num;
gtk_status_icon_get_geometry(GTK_STATUS_ICON(ui->icon),
&screen,
&icon_rect,
&orientation);
if (monitor_rect_p) {
HippoRectangle work_area;
monitor_num = gdk_screen_get_monitor_at_point(screen,
icon_rect.x + icon_rect.width / 2,
icon_rect.y + icon_rect.height / 2);
if (monitor_num < 0)
monitor_num = 0;
gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor);
monitor_rect_p->x = monitor.x;
monitor_rect_p->y = monitor.y;
monitor_rect_p->width = monitor.width;
monitor_rect_p->height = monitor.height;
screen_get_work_area(screen, &work_area);
hippo_rectangle_intersect(monitor_rect_p, &work_area, monitor_rect_p);
}
if (tray_icon_rect_p) {
tray_icon_rect_p->x = icon_rect.x;
tray_icon_rect_p->y = icon_rect.y;
tray_icon_rect_p->width = icon_rect.width;
tray_icon_rect_p->height = icon_rect.height;
}
if (tray_icon_orientation_p) {
if (orientation == GTK_ORIENTATION_VERTICAL)
*tray_icon_orientation_p = HIPPO_ORIENTATION_VERTICAL;
else
*tray_icon_orientation_p = HIPPO_ORIENTATION_HORIZONTAL;
}
}
/*
Read data and update tooltip
*/
gboolean
temp_notifier_timeout_func (temp_notifier_s *core)
{
FILE *file;
char string[50];
char temperature[6];
int i = 0, j = 0;
/* Read CPU0's temperature */
file = fopen (core->thermal_file_cpu0, "r");
if (file != NULL)
{
fread (&string, sizeof (string), 1, file);
snprintf (temperature, 3, "%c%c\0", string[25], string[26]);
fclose (file);
core->cpu0_temp = atoi (temperature);
/* Check temperature */
i = temp_notifier_check_temp (core->cpu0_temp, core->critical_temp);
}
else
core->cpu0_temp = -1;
/* Read CPU0's temperature */
file = fopen (core->thermal_file_cpu1, "r");
if (file != NULL)
{
fread (&string, sizeof (string), 1, file);
snprintf (temperature, 3, "%c%c\0", string[25], string[26]);
fclose (file);
core->cpu1_temp = atoi (temperature);
/* Check temperature */
j = temp_notifier_check_temp (core->cpu1_temp, core->critical_temp);
}
else
core->cpu1_temp = -1;
/* Check GtkStatusIcon */
if ((i == -1) || (j == -1))
gtk_status_icon_set_blinking (GTK_STATUS_ICON(core->icon), TRUE);
else
gtk_status_icon_set_blinking (GTK_STATUS_ICON(core->icon), FALSE);
/* Update GtkTooltip */
if ((core->cpu0_temp == -1) && (core->cpu1_temp == -1))
gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON(core->icon), g_strdup_printf ("- CPU1: ERROR\n- CPU2: ERROR"));
else if (core->cpu0_temp == -1)
gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON(core->icon), g_strdup_printf ("- CPU1: ERROR\n- CPU2: %d C", core->cpu1_temp));
else if (core->cpu1_temp == -1)
gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON(core->icon), g_strdup_printf ("- CPU1: %d C\n- CPU2: ERROR", core->cpu0_temp));
else
gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON(core->icon), g_strdup_printf ("- CPU1: %d C\n- CPU2: %d C", core->cpu0_temp, core->cpu1_temp));
return TRUE;
}
static void _linphone_status_icon_impl_enable_blinking(LinphoneStatusIcon *si, gboolean val) {
GtkStatusIcon *icon = GTK_STATUS_ICON(si->data);
guint tout;
tout=(unsigned)GPOINTER_TO_INT(g_object_get_data(G_OBJECT(icon),"timeout"));
if (val && tout==0) {
tout=g_timeout_add(500,(GSourceFunc)_linphone_status_icon_impl_gtk_do_icon_blink_cb,icon);
g_object_set_data(G_OBJECT(icon),"timeout",GINT_TO_POINTER(tout));
} else if (!val && tout!=0) {
GdkPixbuf *normal_icon=g_object_get_data(G_OBJECT(icon),"icon");
g_source_remove(tout);
g_object_set_data(G_OBJECT(icon),"timeout",NULL);
gtk_status_icon_set_from_pixbuf(icon,normal_icon);
}
}
static void
statusicon_on_notification_added (boost::shared_ptr<Ekiga::Notification> notification,
gpointer data)
{
StatusIcon *self = STATUSICON (data);
GdkPixbuf* pixbuf = gtk_widget_render_icon_pixbuf (self->priv->chat_window,
GTK_STOCK_DIALOG_WARNING,
GTK_ICON_SIZE_MENU);
gchar *current_tooltip = gtk_status_icon_get_tooltip_text (GTK_STATUS_ICON (self));
gchar *tooltip = NULL;
if (current_tooltip != NULL)
tooltip = g_strdup_printf ("%s\n%s", current_tooltip, notification->get_title ().c_str ());
else
tooltip = g_strdup (notification->get_title ().c_str ());
gtk_status_icon_set_from_pixbuf (GTK_STATUS_ICON (self), pixbuf);
gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON (self), tooltip);
g_object_unref (pixbuf);
g_free (current_tooltip);
g_free (tooltip);
}
GtkStatusIcon *init_notification(void)
{
notify_init("bluetooth-manager");
statusicon = gtk_status_icon_new_from_icon_name(icon_name);
gtk_status_icon_set_title (GTK_STATUS_ICON (statusicon),
_("Bluetooth"));
gtk_status_icon_set_tooltip_markup(statusicon, tooltip);
/* XXX: Make sure the status icon is actually shown */
gtk_status_icon_set_visible(statusicon, FALSE);
gtk_status_icon_set_visible(statusicon, TRUE);
return statusicon;
}
void qq_tray_stop_blinking_for(QQTray *tray, const gchar *uin)
{
if(tray == NULL || uin == NULL){
return;
}
QQTrayPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(tray, qq_tray_get_type()
, QQTrayPriv);
gchar *tmpuin = NULL;
g_queue_clear(priv -> tmp_queue);
while(!g_queue_is_empty(priv -> blinking_queue)){
tmpuin = g_queue_pop_tail(priv -> blinking_queue);
if(g_strcmp0(tmpuin, uin) == 0){
//remove it
g_free(tmpuin);
break;
}
g_queue_push_head(priv -> tmp_queue, tmpuin);
}
while(!g_queue_is_empty(priv -> tmp_queue)){
g_queue_push_tail(priv -> blinking_queue
, g_queue_pop_head(priv -> tmp_queue));
}
GdkPixbuf *pb;
if(g_queue_is_empty(priv -> blinking_queue)){
// no more blinking
gtk_status_icon_set_blinking(GTK_STATUS_ICON(tray), FALSE);
pb = gdk_pixbuf_new_from_file(IMGDIR"/webqq_icon.png", NULL);
gtk_status_icon_set_from_pixbuf(GTK_STATUS_ICON(tray), pb);
g_object_unref(pb);
}else{
qq_tray_blinking(tray, g_queue_peek_tail(priv -> blinking_queue));
}
}
static void
xmr_tray_icon_init(XmrTrayIcon *tray)
{
XmrTrayIconPrivate *priv;
tray->priv = G_TYPE_INSTANCE_GET_PRIVATE(tray, XMR_TYPE_TRAY_ICON, XmrTrayIconPrivate);
priv = tray->priv;
priv->popup_menu = NULL;
priv->main_window = NULL;
gtk_status_icon_set_tooltip_markup(GTK_STATUS_ICON(tray), "<b>xmradio</b>");
g_signal_connect(tray, "popup-menu", G_CALLBACK(on_tray_popup_menu), NULL);
g_signal_connect(tray, "activate", G_CALLBACK(on_tray_activate), NULL);
}
static gboolean
statusicon_blink_cb (gpointer data)
{
StatusIcon *statusicon = STATUSICON (data);
g_return_val_if_fail (data != NULL, false);
if (statusicon->priv->blinking)
gtk_status_icon_set_from_icon_name (GTK_STATUS_ICON (statusicon), "im-message");
else
statusicon_set_status (statusicon, statusicon->priv->status);
statusicon->priv->blinking = !statusicon->priv->blinking;
return true;
}
static void
sensor_added(IsManager *manager,
IsSensor *sensor,
IsIndicator *self)
{
/* if a sensor has been added and we haven't yet got any enabled sensors
to display (and hence no primary sensor), change our text to show
this */
if (!self->priv->menu_items)
{
is_indicator_set_label(self, _("No active sensors"));
#if !HAVE_APPINDICATOR
gtk_status_icon_set_from_stock(GTK_STATUS_ICON(self),
GTK_STOCK_DIALOG_WARNING);
#endif
}
}
GtkStatusIcon *init_notification(void)
{
notify_init("bluetooth-manager");
icon_enabled = g_themed_icon_new_with_default_fallbacks (ACTIVE_ICON_NAME"-symbolic");
icon_disabled = g_themed_icon_new_with_default_fallbacks (DISABLE_ICON_NAME"-symbolic");
statusicon = gtk_status_icon_new_from_gicon(bt_enabled ? icon_enabled : icon_disabled);
gtk_status_icon_set_title (GTK_STATUS_ICON (statusicon),
_("Bluetooth"));
gtk_status_icon_set_tooltip_markup(statusicon, tooltip);
/* XXX: Make sure the status icon is actually shown */
gtk_status_icon_set_visible(statusicon, FALSE);
gtk_status_icon_set_visible(statusicon, TRUE);
return statusicon;
}
HippoStatusIcon*
hippo_status_icon_new(HippoDataCache *cache)
{
HippoConnection *connection = hippo_data_cache_get_connection(cache);
HippoStatusIcon *icon;
icon = g_object_new(HIPPO_TYPE_STATUS_ICON,
"icon-name", get_icon_name(connection),
NULL);
icon->cache = cache;
g_object_ref(icon->cache);
g_signal_connect(connection, "state-changed",
G_CALLBACK(on_state_changed), icon);
gtk_status_icon_set_tooltip(GTK_STATUS_ICON(icon),
hippo_connection_get_tooltip(connection));
return HIPPO_STATUS_ICON(icon);
}
static void
statusicon_activated_cb (G_GNUC_UNUSED GtkStatusIcon *icon,
gpointer data)
{
StatusIcon *self = STATUSICON (data);
// No unread messages => signal the gtk+ frontend
// (should hide/present the main window)
if (!self->priv->unread_messages) {
g_signal_emit (self, signals, 0, NULL);
}
else {
// Unread messages => show chat window
gtk_window_present (GTK_WINDOW (self->priv->chat_window));
}
// Remove warnings from statusicon
statusicon_set_status (STATUSICON (data), STATUSICON (data)->priv->status);
gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON (self), NULL);
}
int main (int argc, char *argv[])
{
char *cwd;
char *glade_path;
struct s_gui_data data;
config_args args;
args.config_path = NULL;
monconf_parse_cli_args(&args, argc, argv);
monconf_prepare_config_directory();
monconf *conf = monconf_create();
monconf_read_config(conf, args.config_path);
monconf_load_available_actions(conf);
data.rstart.active = 0;
data.lstart.active = 0;
gtk_init (&argc, &argv);
data.builder = gtk_builder_new ();
glade_path = monconf_resolve_path("ui-glade/monarqui_gui.glade");
gtk_builder_add_from_file (data.builder, glade_path, NULL);
g_free(glade_path);
data.builder = GTK_BUILDER(data.builder);
data.windowMain = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowMain"));
data.windowEntry = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowEntry"));
data.windowConfig = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowConfig"));
data.windowAction = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowAction"));
data.action_mainExit = GTK_ACTION(gtk_builder_get_object(data.builder, "action_mainExit"));
data.action_configOpen = GTK_ACTION(gtk_builder_get_object(data.builder, "action_configOpen"));
data.action_configClose = GTK_ACTION(gtk_builder_get_object(data.builder, "action_configClose"));
data.action_startPause = GTK_ACTION(gtk_builder_get_object(data.builder, "action_startPause"));
data.action_entryAdd = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryAdd"));
data.action_entryModify = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryModify"));
data.action_entryDuplicate = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryDuplicate"));
data.action_entryDelete = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryDelete"));
data.action_actionAdd = GTK_ACTION(gtk_builder_get_object(data.builder, "action_actionAdd"));
data.action_actionModify = GTK_ACTION(gtk_builder_get_object(data.builder, "action_actionModify"));
data.action_actionDelete = GTK_ACTION(gtk_builder_get_object(data.builder, "action_actionDelete"));
data.action_saveConfig = GTK_ACTION(gtk_builder_get_object(data.builder, "action_saveConfig"));
data.action_toggleApplication = GTK_ACTION(gtk_builder_get_object(data.builder, "action_toggleApplication"));
data.action_systrayPopup = GTK_ACTION(gtk_builder_get_object(data.builder, "action_systrayPopup"));
data.image_startStop = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_startStop"));
data.systrayIcon = GTK_STATUS_ICON(gtk_builder_get_object(data.builder,"systrayIcon"));
data.args = &args;
data.conf = conf;
data.treeviewActions = GTK_TREE_VIEW(gtk_builder_get_object(data.builder,"treeviewActions"));
data.treeviewEntries = GTK_TREE_VIEW(gtk_builder_get_object(data.builder,"treeviewEntries"));
data.treeviewEntryActions = GTK_TREE_VIEW(gtk_builder_get_object(data.builder,"treeviewEntryActions"));
data.listStoreActions = GTK_LIST_STORE(gtk_builder_get_object(data.builder,"listStoreActions"));
data.listStoreEntries = GTK_LIST_STORE(gtk_builder_get_object(data.builder,"listStoreEntries"));
data.listStoreEntryActions = GTK_LIST_STORE(gtk_builder_get_object(data.builder,"listStoreEntryActions"));
data.image_started = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_started"));
data.image_started_event = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_started_event"));
data.image_stopped = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_stopped"));
data.logged_event = FALSE;
data.textbufferLog = GTK_TEXT_BUFFER(gtk_builder_get_object(data.builder, "textbufferLog"));
data.systrayMenu = GTK_MENU(gtk_menu_new());
data.systrayMenuItem_startStop = GTK_MENU_ITEM(gtk_menu_item_new_with_label("Start"));
data.systrayMenuItem_quit = GTK_MENU_ITEM(gtk_menu_item_new_with_label("Quit"));
gtk_menu_shell_append(GTK_MENU_SHELL(data.systrayMenu), GTK_WIDGET(data.systrayMenuItem_startStop));
gtk_menu_shell_append(GTK_MENU_SHELL(data.systrayMenu), GTK_WIDGET(data.systrayMenuItem_quit));
gtk_action_set_label(data.action_startPause, "Start");
gtk_builder_connect_signals (data.builder, (gpointer)&data);
gtk_image_set_from_icon_name(data.image_startStop, ICON_NAME_START, GTK_ICON_SIZE_BUTTON);
gtk_status_icon_set_from_pixbuf(data.systrayIcon, gtk_image_get_pixbuf(data.image_stopped));
populate_entries(&data);
populate_actions(&data);
gtk_widget_show (data.windowMain);
gtk_main ();
g_object_unref (G_OBJECT (data.builder));
free(args.config_path);
return 0;
}
int
main (int argc, char *argv[])
{
signal_user_data_t *ud;
GValue *preset;
GError *error = NULL;
GOptionContext *context;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!g_thread_supported())
g_thread_init(NULL);
context = g_option_context_new ("- Rip and encode DVD or MPEG file");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#if !defined(_WIN32)
g_option_context_add_group (context, gst_init_get_option_group ());
#endif
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free(context);
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_set_locale ();
gtk_init (&argc, &argv);
gtk_rc_parse_string(hud_rcstyle);
g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON));
g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL);
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_register_transforms();
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->settings = ghb_settings_new();
ud->builder = create_builder_or_die (BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes (ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
GtkWidget *widget;
#if defined(_NO_UPDATE_CHECK)
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
widget = GHB_WIDGET(ud->builder, "preview_hud");
gtk_widget_set_name(widget, "preview_hud");
widget = GHB_WIDGET(ud->builder, "preview_window");
gtk_widget_set_name(widget, "preview_window");
// Set up the "hud" control overlay for the preview window
GtkWidget *draw, *hud, *blender, *align;
align = GHB_WIDGET(ud->builder, "preview_window_alignment");
draw = GHB_WIDGET(ud->builder, "preview_image_align");
hud = GHB_WIDGET(ud->builder, "preview_hud");
// Set up compositing for hud
blender = ghb_compositor_new();
gtk_container_add(GTK_CONTAINER(align), blender);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85);
gtk_widget_show(blender);
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer (textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full (ud->builder, MyConnect, ud);
// Load all internal settings
ghb_settings_init(ud);
// Load the presets files
ghb_presets_load(ud);
ghb_prefs_load(ud);
ghb_prefs_to_ui(ud);
gint logLevel;
logLevel = ghb_settings_get_int(ud->settings, "LoggingLevel");
ghb_backend_init(logLevel);
if (ghb_settings_get_boolean(ud->settings, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
gchar *source = ghb_settings_get_string(ud->settings, "default_source");
ghb_dvd_set_current(source, ud);
g_free(source);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_parse_options(ud, "");
// Populate the presets tree view
ghb_presets_list_init(ud, NULL, 0);
// Get the first preset name
if (arg_preset != NULL)
{
preset = ghb_parse_preset_path(arg_preset);
if (preset)
{
ghb_select_preset(ud->builder, preset);
ghb_value_free(preset);
}
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies (ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_settings_set_string(ud->settings, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add (500, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si,
ghb_settings_get_boolean(ud->settings, "show_status"));
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_status_icon_set_has_tooltip(si, TRUE);
g_signal_connect(si, "query-tooltip",
status_icon_query_tooltip_cb, ud);
#else
gtk_status_icon_set_tooltip(si, "HandBrake");
#endif
// Ugly hack to keep subtitle table from bouncing around as I change
// which set of controls are visible
GtkRequisition req;
gint height;
widget = GHB_WIDGET(ud->builder, "SrtCodeset");
gtk_widget_size_request( widget, &req );
height = req.height;
widget = GHB_WIDGET(ud->builder, "srt_code_label");
gtk_widget_size_request( widget, &req );
height += req.height;
widget = GHB_WIDGET(ud->builder, "subtitle_table");
gtk_widget_set_size_request(widget, -1, height);
// Everything should be go-to-go. Lets rock!
gtk_main ();
gtk_status_icon_set_visible(si, FALSE);
ghb_backend_close();
if (ud->queue)
ghb_value_free(ud->queue);
ghb_value_free(ud->settings);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
#if !defined(_WIN32)
notify_uninit();
#endif
g_free(ud);
return 0;
}
SetIconText(GtkStatusIcon *tray_icon, const char *text, const char *color) {
// build background from image
GdkPixbuf* special_icon = gdk_pixbuf_new_from_file("message-mail-new.png", NULL); // GError **error);
GdkPixbuf *dest = gdk_pixbuf_copy(special_icon);
int w=gdk_pixbuf_get_width(special_icon);
int h=gdk_pixbuf_get_height(special_icon);
// prepare colors/alpha
GdkColormap* cmap=gdk_screen_get_system_colormap(gdk_screen_get_default());
int screen_depth=24;
GdkVisual* visual = gdk_colormap_get_visual(cmap);
screen_depth = visual->depth;
GdkColor fore = { 0, 0, 0, 0 };
GdkColor alpha = { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
gdk_color_parse(color, &fore);
if(fore.red==alpha.red && fore.green==alpha.green && fore.blue==alpha.blue) {
alpha.red=0; // make sure alpha is different from fore
}
gdk_colormap_alloc_color (cmap, &fore, TRUE, TRUE);
gdk_colormap_alloc_color (cmap, &alpha, TRUE, TRUE);
// build pixmap with rectangle
GdkPixmap *pm = gdk_pixmap_new (NULL, w, h, screen_depth);
cairo_t *cr = gdk_cairo_create(pm);
gdk_cairo_set_source_color(cr, &alpha);
/* void gdk_cairo_set_source_color (cairo_t *cr, */
/* const GdkColor *color); */
cairo_rectangle(cr, 0, 0, w, h);
/* void cairo_rectangle (cairo_t *cr, */
/* double x, */
/* double y, */
/* double width, */
/* double height); */
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_fill(cr);
// build text
GtkWidget *scratch = gtk_window_new(GTK_WINDOW_TOPLEVEL);
PangoLayout *layout = gtk_widget_create_pango_layout(scratch, NULL);
gtk_widget_destroy(scratch);
PangoFontDescription *fnt = pango_font_description_from_string("Sans 18");
pango_font_description_set_weight (fnt,PANGO_WEIGHT_SEMIBOLD);
pango_layout_set_spacing (layout,0);
pango_layout_set_font_description (layout, fnt);
pango_layout_set_text (layout, (gchar *)text,-1);
int tw=0;
int th=0;
int sz;
int border=4;
pango_layout_get_pixel_size(layout, &tw, &th);
while( (tw>w - border || th > h - border)) //fit text to the icon by decreasing font size
{
sz=pango_font_description_get_size (fnt);
if(sz<MIN_FONT_SIZE) {
sz=MIN_FONT_SIZE;
break;
}
sz-=PANGO_SCALE;
pango_font_description_set_size (fnt,sz);
pango_layout_set_font_description (layout, fnt);
pango_layout_get_pixel_size(layout, &tw, &th);
}
pango_font_description_free (fnt);
// center text
int px, py;
px=(w-tw)/2;
py=(h-th)/2;
// draw text on pixmap
gdk_cairo_set_source_color(cr, &fore);
cairo_move_to (cr, px, py);
pango_cairo_show_layout (cr, layout);
cairo_destroy(cr);
g_object_unref (layout);
GdkPixbuf *buf = gdk_pixbuf_get_from_drawable (NULL, pm, NULL, 0, 0, 0, 0, w, h);
g_object_unref (pm);
GdkPixbuf *alpha_buf = gdk_pixbuf_add_alpha(buf, TRUE, (guchar)alpha.red, (guchar)alpha.green, (guchar)alpha.blue);
g_object_unref (buf);
//merge the rendered text on top
gdk_pixbuf_composite(alpha_buf,dest,0,0,w,h,0,0,1,1,GDK_INTERP_NEAREST,255);
g_object_unref(alpha_buf);
/* gdk_pixbuf_composite(buf,dest,0,0,w,h,0,0,1,1,GDK_INTERP_NEAREST,255); */
/* g_object_unref(buf); */
gtk_status_icon_set_from_pixbuf(GTK_STATUS_ICON(tray_icon), GDK_PIXBUF(dest));
}
/*
* Function: init_interface
*
* Creates the GUI according to 'arguments' structure.
*/
void init_interface(app_elems * interface, args * arguments, int source)
{
interface->askedforkill = FALSE;
GdkPixbuf *pixbuf;
GError *error = NULL;
int i, size = 10;
/* Heading label text (sub-program command line) */
for (i = 0; arguments->program[i] != NULL; i++) {
size += strlen(arguments->program[i]) + 1;
}
char command[size];
command[0] = '\0';
for (i = 0; arguments->program[i] != NULL; i++) {
strcat(command, arguments->program[i]);
strncat(command, " ", size);
}
/* Main window */
interface->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(interface->window), arguments->title);
gtk_window_set_default_size(GTK_WINDOW(interface->window),
arguments->width, arguments->height);
gtk_container_set_border_width(GTK_CONTAINER(interface->window), 10);
g_signal_connect(G_OBJECT(interface->window), "destroy",
G_CALLBACK(cb_close_or_reduce), interface);
/* Notification icon */
interface->icon = gtk_status_icon_new_from_file(arguments->iconpath);
pixbuf = gdk_pixbuf_new_from_file(arguments->iconpath, &error);
if (pixbuf == NULL) {
fprintf(stderr, _("Can't find specified icon\n"));
} else {
gtk_window_set_icon(GTK_WINDOW(interface->window), pixbuf);
}
gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(interface->icon),
arguments->tooltip);
gtk_status_icon_set_visible(GTK_STATUS_ICON(interface->icon), TRUE);
g_signal_connect(GTK_STATUS_ICON(interface->icon), "activate",
G_CALLBACK(cb_toggle_display), interface);
/* Body */
/* To compile with GTK+2.0, replace by:
GtkWidget *vb1 = gtk_vbox_new(FALSE, VPADDING);
GtkWidget *hb1 = gtk_hbox_new(FALSE, HPADDING);
*/
GtkWidget *vb1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, VPADDING);
GtkWidget *hb1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, HPADDING);
/* Quit button */
GtkWidget *b1 = gtk_button_new_with_mnemonic(_("_Hide"));
gtk_button_set_image(GTK_BUTTON(b1),
gtk_image_new_from_stock(GTK_STOCK_QUIT,
GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(b1), "clicked",
G_CALLBACK(cb_close_or_reduce), interface);
interface->quitbutton = b1;
/* Kill button */
GtkWidget *b2 = gtk_button_new_with_mnemonic(_("_Stop (SIGINT)"));
gtk_button_set_image(GTK_BUTTON(b2),
gtk_image_new_from_stock(GTK_STOCK_STOP,
GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(b2), "clicked", G_CALLBACK(cb_kill_child),
interface);
interface->killbutton = b2;
//STDOUT & STDERR Scrolling TextView
GtkWidget *stdout_child = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(stdout_child), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stdout_child), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stdout_child),
GTK_WRAP_CHAR);
gtk_widget_modify_font(stdout_child,
pango_font_description_from_string
("monospace"));
add_textview_refresher(GTK_TEXT_VIEW(stdout_child), source);
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll), stdout_child);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* Heading label */
GtkWidget *command_line = gtk_label_new(command);
gtk_label_set_line_wrap(GTK_LABEL(command_line), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(command_line), GTK_WRAP_CHAR);
gtk_widget_modify_font(command_line,
pango_font_description_from_string("bold"));
/* Line break checkbox */
GtkWidget *ch1 = gtk_check_button_new_with_mnemonic(_("_Line breaks"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ch1), TRUE);
g_signal_connect(G_OBJECT(ch1), "toggled",
G_CALLBACK(cb_toggle_line_break), stdout_child);
/* Link all widgets together */
gtk_box_pack_end(GTK_BOX(hb1), b1, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hb1), b2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hb1), ch1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vb1), command_line, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vb1), scroll, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vb1), hb1, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(interface->window), vb1);
}
int
main (int argc, char *argv[])
{
signal_user_data_t *ud;
GValue *preset;
GError *error = NULL;
GOptionContext *context;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (!g_thread_supported())
g_thread_init(NULL);
context = g_option_context_new ("- Transcode media formats");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#if defined(_ENABLE_GST)
g_option_context_add_group (context, gst_init_get_option_group ());
#endif
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free(context);
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_init (&argc, &argv);
gtk_rc_parse_string(hud_rcstyle);
g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON));
g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL);
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_register_transforms();
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->settings = ghb_settings_new();
ud->builder = create_builder_or_die (BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes (ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
GtkWidget *widget;
#if defined(_NO_UPDATE_CHECK)
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
widget = GHB_WIDGET(ud->builder, "preview_hud");
gtk_widget_set_name(widget, "preview_hud");
widget = GHB_WIDGET(ud->builder, "preview_window");
gtk_widget_set_name(widget, "preview_window");
// Set up the "hud" control overlay for the preview window
GtkWidget *draw, *hud, *blender, *align;
align = GHB_WIDGET(ud->builder, "preview_window_alignment");
draw = GHB_WIDGET(ud->builder, "preview_image_align");
hud = GHB_WIDGET(ud->builder, "preview_hud");
// Set up compositing for hud
blender = ghb_compositor_new();
gtk_container_add(GTK_CONTAINER(align), blender);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1);
ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85);
gtk_widget_show(blender);
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer (textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full (ud->builder, MyConnect, ud);
// Load all internal settings
ghb_settings_init(ud);
// Load the presets files
ghb_presets_load(ud);
ghb_prefs_load(ud);
ghb_prefs_to_ui(ud);
gint logLevel;
logLevel = ghb_settings_get_int(ud->settings, "LoggingLevel");
ghb_backend_init(logLevel);
if (ghb_settings_get_boolean(ud->settings, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
gchar *source = ghb_settings_get_string(ud->settings, "default_source");
ghb_dvd_set_current(source, ud);
g_free(source);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_parse_options(ud, "");
// Populate the presets tree view
ghb_presets_list_init(ud, NULL, 0);
// Get the first preset name
if (arg_preset != NULL)
{
preset = ghb_parse_preset_path(arg_preset);
if (preset)
{
ghb_select_preset(ud->builder, preset);
ghb_value_free(preset);
}
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies (ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_settings_set_string(ud->settings, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add (500, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);
#if defined(_USE_APP_IND)
GtkUIManager * uim = GTK_UI_MANAGER(GHB_OBJECT(ud->builder, "uimanager1"));
GtkMenu *ai_menu = GTK_MENU(gtk_ui_manager_get_widget(uim, "/ui/tray_menu"));
ud->ai = app_indicator_new("HandBrake", "hb-icon", APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_menu( ud->ai, ai_menu );
app_indicator_set_label( ud->ai, "", "99.99%");
if (ghb_settings_get_boolean(ud->settings, "show_status"))
{
app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_ACTIVE );
}
else
{
app_indicator_set_status( ud->ai, APP_INDICATOR_STATUS_PASSIVE );
}
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si, FALSE );
#else
GtkStatusIcon *si;
si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));
gtk_status_icon_set_visible(si,
ghb_settings_get_boolean(ud->settings, "show_status"));
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_status_icon_set_has_tooltip(si, TRUE);
g_signal_connect(si, "query-tooltip",
status_icon_query_tooltip_cb, ud);
#else
gtk_status_icon_set_tooltip(si, "HandBrake");
#endif
#endif
// Ugly hack to keep subtitle table from bouncing around as I change
// which set of controls are visible
GtkRequisition req;
gint width, height;
widget = GHB_WIDGET(ud->builder, "SrtCodeset");
gtk_widget_size_request( widget, &req );
height = req.height;
widget = GHB_WIDGET(ud->builder, "srt_code_label");
gtk_widget_size_request( widget, &req );
height += req.height;
widget = GHB_WIDGET(ud->builder, "subtitle_table");
gtk_widget_set_size_request(widget, -1, height);
widget = GHB_WIDGET (ud->builder, "hb_window");
GdkGeometry geo = {
-1, -1, 1024, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
};
GdkWindowHints geo_mask;
geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
gtk_window_set_geometry_hints( GTK_WINDOW(widget), widget, &geo, geo_mask);
width = ghb_settings_get_int(ud->settings, "window_width");
height = ghb_settings_get_int(ud->settings, "window_height");
gtk_window_resize(GTK_WINDOW(widget), width, height);
gtk_widget_show(widget);
/*
* Filter objects in GtkBuilder xml
* Unfortunately, GtkFilter is poorly supported by GtkBuilder,
* so a lot of the setup must happen in code.
SourceFilterAll
SourceFilterVideo
SourceFilterTS
SourceFilterMPG
SourceFilterEVO
SourceFilterVOB
SourceFilterMKV
SourceFilterMP4
SourceFilterAVI
SourceFilterMOV
SourceFilterOGG
SourceFilterFLV
SourceFilterWMV
*/
// Add filters to source chooser
GtkFileFilter *filter;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_filter_set_name(filter, "All");
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));
gtk_file_filter_set_name(filter, "Video");
gtk_file_filter_add_mime_type(filter, "video/*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));
gtk_file_filter_set_name(filter, "TS");
gtk_file_filter_add_pattern(filter, "*.ts");
gtk_file_filter_add_pattern(filter, "*.TS");
gtk_file_filter_add_pattern(filter, "*.m2ts");
gtk_file_filter_add_pattern(filter, "*.M2TS");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));
gtk_file_filter_set_name(filter, "MPG");
gtk_file_filter_add_pattern(filter, "*.mpg");
gtk_file_filter_add_pattern(filter, "*.MPG");
gtk_file_filter_add_pattern(filter, "*.mepg");
gtk_file_filter_add_pattern(filter, "*.MEPG");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));
gtk_file_filter_set_name(filter, "EVO");
gtk_file_filter_add_pattern(filter, "*.evo");
gtk_file_filter_add_pattern(filter, "*.EVO");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));
gtk_file_filter_set_name(filter, "VOB");
gtk_file_filter_add_pattern(filter, "*.vob");
gtk_file_filter_add_pattern(filter, "*.VOB");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV"));
gtk_file_filter_set_name(filter, "MKV");
gtk_file_filter_add_pattern(filter, "*.mkv");
gtk_file_filter_add_pattern(filter, "*.MKV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4"));
gtk_file_filter_set_name(filter, "MP4");
gtk_file_filter_add_pattern(filter, "*.mp4");
gtk_file_filter_add_pattern(filter, "*.MP4");
gtk_file_filter_add_pattern(filter, "*.m4v");
gtk_file_filter_add_pattern(filter, "*.M4V");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV"));
gtk_file_filter_set_name(filter, "MOV");
gtk_file_filter_add_pattern(filter, "*.mov");
gtk_file_filter_add_pattern(filter, "*.MOV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI"));
gtk_file_filter_set_name(filter, "AVI");
gtk_file_filter_add_pattern(filter, "*.avi");
gtk_file_filter_add_pattern(filter, "*.AVI");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG"));
gtk_file_filter_set_name(filter, "OGG");
gtk_file_filter_add_pattern(filter, "*.ogg");
gtk_file_filter_add_pattern(filter, "*.OGG");
gtk_file_filter_add_pattern(filter, "*.ogv");
gtk_file_filter_add_pattern(filter, "*.OGV");
gtk_file_filter_add_pattern(filter, "*.ogm");
gtk_file_filter_add_pattern(filter, "*.OGM");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV"));
gtk_file_filter_set_name(filter, "FLV");
gtk_file_filter_add_pattern(filter, "*.flv");
gtk_file_filter_add_pattern(filter, "*.FLV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV"));
gtk_file_filter_set_name(filter, "WMV");
gtk_file_filter_add_pattern(filter, "*.wmv");
gtk_file_filter_add_pattern(filter, "*.WMV");
gtk_file_chooser_add_filter(chooser, filter);
// Gtk has a really stupid bug. If the file chooser is showing
// hidden files AND there is no filter set, it will not select
// the filename when gtk_file_chooser_set_filename is called.
// So add a completely unnessary filter to prevent this behavior.
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_chooser_set_filter(chooser, filter);
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string ("monospace 10");
textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "activity_view"));
gtk_widget_modify_font(GTK_WIDGET(textview), font_desc);
pango_font_description_free (font_desc);
// Everything should be go-to-go. Lets rock!
gtk_main ();
gtk_status_icon_set_visible(si, FALSE);
ghb_backend_close();
if (ud->queue)
ghb_value_free(ud->queue);
ghb_value_free(ud->settings);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
#if !defined(_WIN32)
notify_uninit();
#endif
g_free(ud);
return 0;
}
void cgraphics_status_icon_set_tooltip(status_icon_t * status, const char * tooltip)
{
gtk_status_icon_set_tooltip(GTK_STATUS_ICON(status), tooltip);
}
void cgraphics_status_icon_set_icon(status_icon_t * status, image_t * icon)
{
gtk_status_icon_set_from_pixbuf(GTK_STATUS_ICON(status->native), (GdkPixbuf*)icon->native);
}
static void _linphone_status_icon_impl_gtk_uninit(LinphoneStatusIcon *si) {
GtkStatusIcon *icon = GTK_STATUS_ICON(si->data);
gtk_status_icon_set_visible(icon, FALSE);
}
void xmr_tray_icon_set_tooltips(XmrTrayIcon *tray, const gchar *text)
{
g_return_if_fail(tray != NULL && text != NULL);
gtk_status_icon_set_tooltip_markup(GTK_STATUS_ICON(tray), text);
}
void
hippo_ui_show(HippoUI *ui)
{
gtk_status_icon_set_visible(GTK_STATUS_ICON(ui->icon), TRUE);
}
static void
update_sensor_menu_item_label(IsIndicator *self,
IsSensor *sensor,
GtkMenuItem *menu_item)
{
gchar *text;
text = g_strdup_printf("%s %2.*f%s",
is_sensor_get_label(sensor),
is_sensor_get_digits(sensor),
is_sensor_get_value(sensor),
is_sensor_get_units(sensor));
gtk_menu_item_set_label(menu_item, text);
g_free(text);
text = NULL;
#if HAVE_APPINDICATOR
if (sensor == self->priv->primary)
{
IsIndicatorPrivate *priv = self->priv;
gboolean connected;
g_object_get(self, "connected", &connected, NULL);
/* using fallback so just set icon */
if (!connected)
{
app_indicator_set_icon_full(APP_INDICATOR(self), PACKAGE,
is_sensor_get_label(sensor));
return;
}
if (priv->display_flags & IS_INDICATOR_DISPLAY_VALUE)
{
text = g_strdup_printf("%2.*f%s",
is_sensor_get_digits(sensor),
is_sensor_get_value(sensor),
is_sensor_get_units(sensor));
}
if (priv->display_flags & IS_INDICATOR_DISPLAY_LABEL)
{
/* join label to existing text - if text is NULL this
will just show label */
text = g_strjoin(" ",
is_sensor_get_label(sensor),
text, NULL);
}
if (priv->display_flags & IS_INDICATOR_DISPLAY_ICON)
{
app_indicator_set_icon_full(APP_INDICATOR(self),
is_sensor_get_icon_path(sensor),
is_sensor_get_label(sensor));
}
else
{
/* set to a 1x1 transparent icon for no icon */
app_indicator_set_icon_full(APP_INDICATOR(self), "indicator-sensors-no-icon",
is_sensor_get_label(sensor));
}
app_indicator_set_label(APP_INDICATOR(self), text, text);
g_free(text);
app_indicator_set_status(APP_INDICATOR(self),
is_sensor_get_alarmed(sensor) ?
APP_INDICATOR_STATUS_ATTENTION :
APP_INDICATOR_STATUS_ACTIVE);
}
#else
gtk_status_icon_set_from_icon_name(GTK_STATUS_ICON(self), PACKAGE);
#endif
}
int main(int argc, char **argv)
{
int o;
char *name = "Master";
char *iname = "Capture";
int showinput = 0;
bindtextdomain("tray_mixer", LOCALE_DIR);
textdomain("tray_mixer");
while ((o = getopt(argc, argv, "e:Ii:")) >= 0) {
switch (o) {
case 'e':
name = optarg;
break;
case 'i':
iname = optarg;
/* fall through */
case 'I':
showinput = 1;
break;
}
}
gtk_init(&argc, &argv);
mixer_init(name, iname);
icon = gtk_status_icon_new_from_file(ICON_PATH "speaker.png");
g_signal_connect(G_OBJECT(icon), "activate", G_CALLBACK(click), NULL);
item = gtk_menu_item_new_with_label(_("Quit"));
menu = gtk_menu_new();
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(icon), "popup-menu", G_CALLBACK(popup), NULL);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(quit), NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(window),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_default_size(GTK_WINDOW(window), 60, 140);
hbox = gtk_hbox_new(TRUE, 5);
gtk_container_add(GTK_CONTAINER(window), hbox);
add_channel(&ch[0]);
if (showinput)
add_channel(&ch[1]);
gtk_status_icon_set_visible(GTK_STATUS_ICON(icon), TRUE);
gtk_main();
return 0;
}
static void qq_tray_init(QQTray *tray)
{
gtk_status_icon_set_tooltip_markup(GTK_STATUS_ICON(tray), "<b>GtkQQ</b>");
QQTrayPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(tray, qq_tray_get_type()
, QQTrayPriv);
priv -> blinking_queue = g_queue_new();
priv -> tmp_queue = g_queue_new();
priv -> popupmenu = gtk_menu_new();
GtkWidget *menuitem;
menuitem = gtk_check_menu_item_new_with_label("Mute");
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
GtkWidget *img;
GdkPixbuf *pb;
#define STATUS_ITEM(x,y) \
menuitem = gtk_image_menu_item_new();\
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);\
pb = gdk_pixbuf_new_from_file_at_size(IMGDIR"/status/"x".png"\
, 12, 12, NULL);\
img = gtk_image_new_from_pixbuf(pb);\
g_object_unref(pb);\
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), img);\
gtk_menu_item_set_label(GTK_MENU_ITEM(menuitem), y);\
g_signal_connect(G_OBJECT(menuitem), "activate"\
, G_CALLBACK(qq_tray_status_menu_item_activate), x);
STATUS_ITEM("online", "Online");
STATUS_ITEM("hidden", "Hidden");
STATUS_ITEM("away", "Away");
STATUS_ITEM("busy", "Busy");
STATUS_ITEM("callme", "Call Me");
STATUS_ITEM("silent", "Silent");
#undef STATUS_ITEM
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
menuitem = gtk_menu_item_new_with_label("Personal Setting");
g_signal_connect(G_OBJECT(menuitem), "activate"
, G_CALLBACK(qq_tray_personal_setting_menu_item_activate)
, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
menuitem = gtk_menu_item_new_with_label("System Setting");
g_signal_connect(G_OBJECT(menuitem), "activate"
, G_CALLBACK(qq_tray_system_setting_menu_item_activate)
, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate"
, G_CALLBACK(qq_tray_about_menu_item_activate)
, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
gtk_menu_item_set_label(GTK_MENU_ITEM(menuitem), "About GtkQQ");
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
g_signal_connect(G_OBJECT(menuitem), "activate"
, G_CALLBACK(qq_tray_quit_menu_item_activate)
, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(priv -> popupmenu), menuitem);
gtk_menu_item_set_label(GTK_MENU_ITEM(menuitem), "Quit");
gtk_widget_show_all(priv -> popupmenu);
g_signal_connect(G_OBJECT(tray), "popup-menu"
, G_CALLBACK(qq_tray_popup_menu), tray);
g_signal_connect(G_OBJECT(tray), "button-press-event"
, G_CALLBACK(qq_tray_button_press), tray);
g_signal_connect(G_OBJECT(tray), "query-tooltip"
, G_CALLBACK(qq_tray_on_show_tooltip), tray);
}
void tray_on_menu(GtkWidget *widget,guint button,
guint32 activate_time,gpointer data)
{
gtk_menu_popup(GTK_MENU(data),NULL,NULL,gtk_status_icon_position_menu,GTK_STATUS_ICON(widget),button,activate_time);
}
void cgraphics_status_icon_set_visible(status_icon_t * status, int visible)
{
gtk_status_icon_set_visible(GTK_STATUS_ICON(status), visible? TRUE : FALSE);
}
