static gboolean
ipnl_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer tray_icon)
{
DBG_PRINT("Info panel window-state-event: [%08X] -> %08X\n", event->changed_mask,
event->new_window_state);
if(event->changed_mask & GDK_WINDOW_STATE_ICONIFIED &&
(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED ||
event->new_window_state & (GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_MAXIMIZED) )){
gtk_widget_hide (GTK_WIDGET(widget));
gtk_status_icon_set_visible(GTK_STATUS_ICON(tray_icon), TRUE);
DBG_PRINT(">>Info panel window-state-event: Iconified: %08X\n", event->new_window_state);
}
else if(event->changed_mask & GDK_WINDOW_STATE_WITHDRAWN &&
(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED ||
event->new_window_state & (GDK_WINDOW_STATE_ICONIFIED |
GDK_WINDOW_STATE_MAXIMIZED))) {
//gtk_status_icon_set_visible(GTK_STATUS_ICON(tray_icon), FALSE);
//gtk_widget_show_all (GTK_WIDGET(widget));
DBG_PRINT(">>Info panel window-state-event: Withdrawn: %08X\n", event->new_window_state);
}
return FALSE;
}
void create_status_icon()
{
tray_icon = gtk_status_icon_new();
g_signal_connect(G_OBJECT(tray_icon), "popup-menu", G_CALLBACK(status_icon_activate), NULL);
g_signal_connect(G_OBJECT(tray_icon), "activate", G_CALLBACK(_tray_callback), GINT_TO_POINTER(-1));
gtk_status_icon_set_tooltip_text(tray_icon, tray_name);
gtk_status_icon_set_visible(tray_icon, TRUE);
}
static void
status_icon_activate_cb (GtkStatusIcon *icon,
NemoProgressUIHandler *self)
{
self->priv->should_show_status_icon = FALSE;
gtk_status_icon_set_visible (icon, FALSE);
gtk_window_present (GTK_WINDOW (self->priv->progress_window));
}
static GtkStatusIcon *create_icon() {
GtkStatusIcon *icon;
icon = gtk_status_icon_new();
gtk_status_icon_set_from_icon_name(icon,GTK_STOCK_INDEX);
gtk_status_icon_set_visible(icon,TRUE);
gtk_status_icon_set_tooltip(icon,"Click here for the Fluxbox menu");
return icon;
}
void notification_trayicon_destroy(void)
{
if(trayicon) {
gtk_status_icon_set_visible(trayicon, FALSE);
g_object_unref(trayicon);
trayicon = NULL;
}
}
static void
progress_ui_handler_hide_status (NemoProgressUIHandler *self)
{
if (self->priv->status_icon != NULL) {
self->priv->should_show_status_icon = FALSE;
gtk_status_icon_set_visible (self->priv->status_icon, FALSE);
}
}
int main(int argc, char *argv[])
{
GtkWidget *item;
GtkMenuShell *menu;
gtk_init(&argc, &argv);
/* Status icon */
status_icon = gtk_status_icon_new_from_icon_name(LOGO_ICON);
gtk_status_icon_set_visible(status_icon, TRUE);
g_signal_connect(G_OBJECT(status_icon), "button_press_event",
G_CALLBACK(status_icon_on_button_press), NULL);
/* App menu */
app_menu = gtk_menu_new();
menu = GTK_MENU_SHELL(app_menu);
/* Story items */
for (guint i = 0; i < MAX_STORIES; i++) {
menu_init_item(&stories[i]);
}
/* Settings menu */
settings_menu = gtk_menu_new();
menu = GTK_MENU_SHELL(settings_menu);
/* Refresh */
item = gtk_menu_item_new_with_mnemonic(_("_Refresh"));
gpointer immediate = GINT_TO_POINTER(FALSE);
g_signal_connect(item, "activate", G_CALLBACK(refresh_stories), immediate);
gtk_menu_shell_append(menu, item);
gtk_menu_shell_append(menu, gtk_separator_menu_item_new());
/* About */
item = gtk_menu_item_new_with_mnemonic(_("_About"));
g_signal_connect(item, "activate", G_CALLBACK(menu_on_about), NULL);
gtk_menu_shell_append(menu, item);
/* Quit */
item = gtk_menu_item_new_with_mnemonic(_("_Quit"));
g_signal_connect(item, "activate", G_CALLBACK(gtk_main_quit), NULL);
gtk_menu_shell_append(menu, item);
gtk_widget_show_all(app_menu);
gtk_widget_show_all(settings_menu);
if (!(gmulticurl = gmulticurl_new()))
g_warning("gmulticurl init error");
gtk_main();
if (gmulticurl_cleanup(gmulticurl))
g_warning("gmulticurl init error");
return 0;
}
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;
}
void systray_create(menu_infos_t* mis)
{
mis->icon = ui_statusicon();
systray_menu_create(mis);
g_signal_connect(mis->icon, "button-press-event", G_CALLBACK(systray_click_cb), mis);
g_signal_connect(mis->icon, "scroll-event", G_CALLBACK(systray_scroll_cb), mis);
gtk_status_icon_set_tooltip_text(mis->icon, "connecting to server...");
gtk_status_icon_set_visible(mis->icon, TRUE);
}
void destroy_tray_double()
{
if (icon_main == NULL || icon_state == NULL)
return;
// Workaround: to release the space on notification area
gtk_status_icon_set_visible(icon_main, FALSE);
gtk_status_icon_set_visible(icon_state, FALSE);
g_object_unref(icon_main); icon_main = NULL;
g_object_unref(icon_state); icon_state = NULL;
if (tray_menu) {
gtk_widget_destroy(tray_menu);
tray_menu = NULL;
}
if (tray_menu_state) {
gtk_widget_destroy(tray_menu_state);
tray_menu_state = NULL;
}
}
static void _linphone_status_icon_impl_gtk_start(LinphoneStatusIcon *si) {
GtkStatusIcon *icon = GTK_STATUS_ICON(si->data);
#if GTK_CHECK_VERSION(2,20,2)
char *name = g_strdup_printf("%s - %s", si->params->title, si->params->desc);
gtk_status_icon_set_name(icon, name);
g_free(name);
#endif
gtk_status_icon_set_visible(icon,TRUE);
}
static void
visible_toggle_toggled (GtkToggleButton *toggle)
{
GSList *l;
for (l = icons; l; l = l->next)
gtk_status_icon_set_visible (GTK_STATUS_ICON (l->data),
gtk_toggle_button_get_active (toggle));
}
gint
yad_notification_run ()
{
GIOChannel *channel = NULL;
status_icon = gtk_status_icon_new ();
g_signal_connect (status_icon, "size-changed", G_CALLBACK (icon_size_changed_cb), NULL);
if (options.data.dialog_text)
{
if (!options.data.no_markup)
gtk_status_icon_set_tooltip_markup (status_icon, options.data.dialog_text);
else
gtk_status_icon_set_tooltip_text (status_icon, options.data.dialog_text);
}
else
gtk_status_icon_set_tooltip_text (status_icon, _("Yad notification"));
if (options.data.dialog_image)
icon = g_strdup (options.data.dialog_image);
if (options.common_data.command)
action = g_strdup (options.common_data.command);
set_icon ();
g_signal_connect (status_icon, "activate", G_CALLBACK (activate_cb), NULL);
g_signal_connect (status_icon, "popup_menu", G_CALLBACK (popup_menu_cb), NULL);
if (options.notification_data.menu)
parse_menu_str (options.notification_data.menu);
/* quit on middle click (like press Esc) */
if (options.notification_data.middle)
g_signal_connect (status_icon, "button-press-event", G_CALLBACK (middle_quit_cb), NULL);
if (options.common_data.listen)
{
channel = g_io_channel_unix_new (0);
if (channel)
{
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, NULL);
}
}
/* Show icon and wait */
gtk_status_icon_set_visible (status_icon, !options.notification_data.hidden);
if (options.data.timeout > 0)
g_timeout_add_seconds (options.data.timeout, (GSourceFunc) timeout_cb, NULL);
gtk_main ();
return exit_code;
}
NS_IMETHODIMP Icon::Init(nsIDOMWindow *aWindow, const nsString& aTitle)
{
nsresult rv;
nsCOMPtr<nsIBaseWindow> baseWindow;
rv = GetBaseWindow(aWindow, getter_AddRefs(baseWindow));
NS_ENSURE_SUCCESS(rv, rv);
nativeWindow native = 0;
rv = baseWindow->GetParentNativeWindow(&native);
NS_ENSURE_SUCCESS(rv, rv);
// Get the window
mGdkWindow = gdk_window_get_toplevel(reinterpret_cast<GdkWindow*>(native));
if (!mGdkWindow) {
return NS_ERROR_UNEXPECTED;
}
// Get the widget and gtk window
GtkWidget *widget;
gdk_window_get_user_data(mGdkWindow, reinterpret_cast<gpointer*>(&widget));
widget = gtk_widget_get_toplevel(widget);
mGtkWindow = reinterpret_cast<GtkWindow*>(widget);
// Set up tray icon
mStatusIcon = gtk_status_icon_new();
// Get the window icon and set it
GdkPixbuf *buf = gtk_window_get_icon(mGtkWindow);
if (buf) {
gtk_status_icon_set_from_pixbuf(mStatusIcon, buf);
} else {
const gchar *iconname = gtk_window_get_icon_name(mGtkWindow);
if (iconname)
gtk_status_icon_set_from_icon_name(mStatusIcon, iconname);
}
// Get and set the title
if (aTitle.IsEmpty()) {
gtk_status_icon_set_tooltip_text(mStatusIcon, gtk_window_get_title(mGtkWindow));
gtk_widget_add_events(widget, GDK_PROPERTY_CHANGE_MASK);
propertyEventId = g_signal_connect(mGtkWindow, "property-notify-event", G_CALLBACK(gtkPropertyEvent), this);
}
else {
NS_ConvertUTF16toUTF8 titleUTF8(aTitle);
gtk_status_icon_set_tooltip_text(mStatusIcon, reinterpret_cast<const char*>(titleUTF8.get()));
propertyEventId = 0;
}
// Add signals
g_signal_connect(G_OBJECT(mStatusIcon), "button-press-event", G_CALLBACK(gtkButtonEvent), this);
g_signal_connect(G_OBJECT(mStatusIcon), "button-release-event", G_CALLBACK(gtkButtonEvent), this);
// Make visible
gtk_status_icon_set_visible(mStatusIcon, 1);
return NS_OK;
}
/**
* Creates the tray icon and connects the signals 'scroll_event'
* and 'size-changed'.
*
* @return the newly created tray icon
*/
GtkStatusIcon *create_tray_icon() {
tray_icon = gtk_status_icon_new();
/* catch scroll-wheel events */
g_signal_connect ((gpointer) tray_icon, "scroll_event", G_CALLBACK (on_scroll), NULL);
g_signal_connect ((gpointer) tray_icon, "size-changed", G_CALLBACK (tray_icon_resized), NULL);
gtk_status_icon_set_visible(tray_icon, TRUE);
return tray_icon;
}
void show_icon(void)
{
#ifdef HAVE_APP_INDICATOR
if (indicator != NULL)
app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE);
#else
if (statusicon != NULL)
gtk_status_icon_set_visible(statusicon, TRUE);
#endif /* HAVE_APP_INDICATOR */
}
void hide_icon(void)
{
#ifdef HAVE_APP_INDICATOR
if (indicator != NULL)
app_indicator_set_status(indicator, APP_INDICATOR_STATUS_PASSIVE);
#else
if (statusicon != NULL)
gtk_status_icon_set_visible(statusicon, FALSE);
#endif /* HAVE_APP_INDICATOR */
}
static gboolean
status_icon_button_release_cb (GtkStatusIcon *icon,
GdkEvent *event,
NemoProgressUIHandler *self)
{
self->priv->should_show_status_icon = FALSE;
gtk_status_icon_set_visible (icon, FALSE);
gtk_window_present (GTK_WINDOW (self->priv->progress_window));
return FALSE;
}
static void
update_status_icon_and_window (void)
{
char *tooltip;
tooltip = g_strdup_printf (ngettext ("%'d file operation active",
"%'d file operations active",
n_progress_ops),
n_progress_ops);
gtk_status_icon_set_tooltip_text (status_icon, tooltip);
g_free (tooltip);
if (n_progress_ops == 0) {
gtk_status_icon_set_visible (status_icon, FALSE);
gtk_widget_hide (get_progress_window ());
} else {
gtk_status_icon_set_visible (status_icon, TRUE);
}
}
void remmina_icon_init(void)
{
if (!remmina_icon.icon && !remmina_pref.disable_tray_icon)
{
#ifdef HAVE_LIBAPPINDICATOR
remmina_icon.icon = app_indicator_new ("remmina-icon", "remmina", APP_INDICATOR_CATEGORY_OTHER);
app_indicator_set_icon_theme_path (remmina_icon.icon, REMMINA_DATADIR G_DIR_SEPARATOR_S "icons");
app_indicator_set_status (remmina_icon.icon, APP_INDICATOR_STATUS_ACTIVE);
app_indicator_set_title (remmina_icon.icon, "Remmina");
remmina_icon_populate_menu ();
#else
remmina_icon.icon = gtk_status_icon_new_from_icon_name("remmina");
gtk_status_icon_set_title(remmina_icon.icon, _("Remmina Remote Desktop Client"));
gtk_status_icon_set_tooltip_text(remmina_icon.icon, _("Remmina Remote Desktop Client"));
g_signal_connect(G_OBJECT(remmina_icon.icon), "popup-menu", G_CALLBACK(remmina_icon_on_popup_menu), NULL);
g_signal_connect(G_OBJECT(remmina_icon.icon), "activate", G_CALLBACK(remmina_icon_on_activate), NULL);
#endif
remmina_widget_pool_hold(TRUE);
}
else
if (remmina_icon.icon)
{
#ifdef HAVE_LIBAPPINDICATOR
app_indicator_set_status (remmina_icon.icon, remmina_pref.disable_tray_icon ?
APP_INDICATOR_STATUS_PASSIVE : APP_INDICATOR_STATUS_ACTIVE);
#else
gtk_status_icon_set_visible(remmina_icon.icon, !remmina_pref.disable_tray_icon);
#endif
remmina_widget_pool_hold(!remmina_pref.disable_tray_icon);
}
if (!remmina_icon.avahi)
{
remmina_icon.avahi = remmina_avahi_new();
}
if (remmina_icon.avahi)
{
if (remmina_pref.applet_enable_avahi)
{
if (!remmina_icon.avahi->started)
remmina_avahi_start(remmina_icon.avahi);
}
else
{
remmina_avahi_stop(remmina_icon.avahi);
}
}
if (!remmina_icon.autostart_file)
{
remmina_icon.autostart_file = g_strdup_printf("%s/.config/autostart/remmina-applet.desktop", g_get_home_dir());
remmina_icon_create_autostart_file();
}
}
void
enable_systray_changed_cb (GtkComboBox *widget, gpointer user_data) {
GUI *appGUI = (GUI *)user_data;
if (!appGUI->opt->callback_active) return;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(appGUI->opt->enable_systray_checkbutton)) == TRUE) {
config.enable_systray = 1;
gtk_widget_set_sensitive(appGUI->opt->start_minimised_checkbutton, TRUE);
gtk_status_icon_set_visible(appGUI->osmo_trayicon, TRUE);
if (gtk_status_icon_is_embedded(appGUI->osmo_trayicon) == FALSE) {
appGUI->no_tray = TRUE;
}
} else {
config.enable_systray = 0;
gtk_status_icon_set_visible(appGUI->osmo_trayicon, FALSE);
gtk_widget_set_sensitive(appGUI->opt->start_minimised_checkbutton, FALSE);
}
}
static void create_tray_icon (void)
{
GtkStatusIcon *tray_icon = gtk_status_icon_new ();
gtk_status_icon_set_tooltip_text (tray_icon, "cbatticon");
gtk_status_icon_set_visible (tray_icon, TRUE);
update_tray_icon (tray_icon);
g_timeout_add_seconds (configuration.update_interval, (GSourceFunc)update_tray_icon, (gpointer)tray_icon);
g_signal_connect (G_OBJECT (tray_icon), "activate", G_CALLBACK (tray_icon_on_click), NULL);
}
static void ui_create_status_icon(KIM * im)
{
GtkStatusIcon *trayIcon;
trayIcon = gtk_status_icon_new_from_file("/home/auv/right.png");
gtk_status_icon_set_visible(trayIcon, TRUE);
gtk_status_icon_set_blinking(trayIcon, TRUE);
gtk_status_icon_set_tooltip(trayIcon, "auv is a good v!");
g_signal_connect(trayIcon, "popup-menu", G_CALLBACK(status_icon_popup_menu_cb), NULL);
}
static void si_enable(gboolean enable)
{
static GtkStatusIcon *si_applet = NULL;
if (enable && ! si_applet)
{
GtkWidget *si_smenu;
si_applet = si_create();
if (si_applet == NULL)
{
g_warning("StatusIcon plugin: unable to create a status icon.\n");
return;
}
g_object_set_data(G_OBJECT(si_applet), "timer_id", GINT_TO_POINTER(0));
g_object_set_data(G_OBJECT(si_applet), "timer_active", GINT_TO_POINTER(0));
g_object_set_data(G_OBJECT(si_applet), "popup_active", GINT_TO_POINTER(0));
g_signal_connect(G_OBJECT(si_applet), "button-press-event", G_CALLBACK(si_cb_btpress), NULL);
g_signal_connect(G_OBJECT(si_applet), "scroll-event", G_CALLBACK(si_cb_btscroll), NULL);
g_signal_connect(G_OBJECT(si_applet), "query-tooltip", G_CALLBACK(si_cb_tooltip), NULL);
gtk_status_icon_set_has_tooltip(si_applet, TRUE);
gtk_status_icon_set_visible(si_applet, TRUE);
/* small menu that can be used in place of the audacious standard one */
si_smenu = si_smallmenu_create();
g_object_set_data(G_OBJECT(si_applet), "smenu", si_smenu);
hook_associate("title change", si_popup_reshow, si_applet);
hook_associate("window close", si_window_close, NULL);
}
if (! enable && si_applet)
{
/* Prevent accidentally hiding of the interface
* by disabling the plugin while Audacious is closed to the tray. */
extern GeneralPlugin _aud_plugin_self;
PluginHandle *si = aud_plugin_by_header(&_aud_plugin_self);
if (! aud_plugin_get_enabled(si) && ! aud_interface_is_shown())
aud_interface_show(TRUE);
GtkWidget *si_smenu = g_object_get_data(G_OBJECT(si_applet), "smenu");
si_popup_timer_stop(si_applet); /* just in case the timer is active */
gtk_widget_destroy(si_smenu);
g_object_unref(si_applet);
si_applet = NULL;
hook_dissociate("title change", si_popup_reshow);
hook_dissociate("window close", si_window_close);
}
}
static void
gui_update()
{
ENTER;
DBG("group=%d name=%s flag=%p\n", cur_group, group[cur_group].name,
group[cur_group].flag);
gtk_status_icon_set_from_pixbuf(icon, group[cur_group].flag);
if (hide_default)
gtk_status_icon_set_visible(icon, cur_group);
RET();
}
void tray_icon_create(void)
{
GtkStatusIcon *tray_icon;
tray_icon = gtk_status_icon_new_from_stock(GTK_STOCK_CDROM);
gtk_status_icon_set_visible(tray_icon, TRUE);
g_signal_connect((gpointer) tray_icon, "activate",
G_CALLBACK(on_activate), NULL);
g_signal_connect((gpointer) tray_icon, "popup-menu",
G_CALLBACK(on_popup), NULL);
}
static GtkStatusIcon *create_tray_icon() {
GtkStatusIcon *tray_icon;
tray_icon = gtk_status_icon_new();
g_signal_connect(G_OBJECT(tray_icon), "activate", G_CALLBACK(tray_icon_on_click), NULL);
g_signal_connect(G_OBJECT(tray_icon), "popup-menu",G_CALLBACK(tray_icon_on_menu), NULL);
gtk_status_icon_set_from_icon_name(tray_icon, GTK_STOCK_REFRESH);
gtk_status_icon_set_tooltip(tray_icon, "Fan control");
gtk_status_icon_set_visible(tray_icon, TRUE);
return tray_icon;
}
static void
progress_ui_handler_hide_notification_or_status (NautilusProgressUIHandler *self)
{
if (self->priv->status_icon != NULL) {
gtk_status_icon_set_visible (self->priv->status_icon, FALSE);
}
if (self->priv->progress_notification != NULL) {
notify_notification_close (self->priv->progress_notification, NULL);
g_clear_object (&self->priv->progress_notification);
}
}
Icon::~Icon()
{
Restore();
if (mStatusIcon) {
gtk_status_icon_set_visible(mStatusIcon, 0);
g_object_unref(mStatusIcon);
}
if (propertyEventId) {
g_signal_handler_disconnect(mGtkWindow, propertyEventId);
}
}
void dockicon(struttura *str)
{
gtk_status_icon_set_visible(str->tray_icon, TRUE);
gtk_widget_hide(str->window);
/* if(str->ins.on)
{
str->ins.on=0;
printf("il vettore di numeri associato è %s \n",str->ins.key_numbers);
}
else
ins(str);*/
}
