static void init_app_indicator (DrWright *dr) { GtkWidget *indicator_menu; dr->indicator = app_indicator_new_with_path ("typing-break-indicator", TYPING_MONITOR_ACTIVE_ICON, APP_INDICATOR_CATEGORY_APPLICATION_STATUS, IMAGEDIR); if (dr->enabled) { app_indicator_set_status (dr->indicator, APP_INDICATOR_STATUS_ACTIVE); } else { app_indicator_set_status (dr->indicator, APP_INDICATOR_STATUS_PASSIVE); } indicator_menu = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop"); app_indicator_set_menu (dr->indicator, GTK_MENU (indicator_menu)); app_indicator_set_attention_icon (dr->indicator, TYPING_MONITOR_ATTENTION_ICON); update_status (dr); update_app_indicator (dr); }
gboolean tray_appindicator_create(gpointer data) { if (is_exist_tray_appindicator()) return FALSE; if (tray_appindicator) { if (app_indicator_get_status (tray_appindicator) != APP_INDICATOR_STATUS_ACTIVE) { app_indicator_set_status (tray_appindicator, APP_INDICATOR_STATUS_ACTIVE); destroy_other_tray(); } } else { destroy_other_tray(); if (!tray_appindicator_load_icon(HIME_TRAY_PNG, HIME_TRAY_PNG, iconame, icondir)) return FALSE; tray_appindicator = app_indicator_new_with_path ("hime", iconame, APP_INDICATOR_CATEGORY_APPLICATION_STATUS, icondir); if(tray_appindicator == NULL) return TRUE; app_indicator_set_status (tray_appindicator, APP_INDICATOR_STATUS_ACTIVE); GtkWidget *menu = NULL; menu = create_tray_menu(mitems); app_indicator_set_secondary_activate_target(tray_appindicator, mitems[0].item); app_indicator_set_menu (tray_appindicator, GTK_MENU (menu)); } load_tray_appindicator(); return FALSE; }
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 QAppIndicator::onShown(bool _visible) { if (_visible) { app_indicator_set_status(m_appIndicator, APP_INDICATOR_STATUS_ACTIVE); } else { app_indicator_set_status(m_appIndicator, APP_INDICATOR_STATUS_PASSIVE); } }
void MainWindow::createSystemTray() { #ifdef UBUNTU_UNITY AppIndicator *indicator = app_indicator_new("Shadowsocks-Qt5", "shadowsocks-qt5", APP_INDICATOR_CATEGORY_OTHER); GtkWidget *menu = gtk_menu_new(); showItem = gtk_check_menu_item_new_with_label(tr("Show").toLocal8Bit().constData()); gtk_check_menu_item_set_active((GtkCheckMenuItem*)showItem, true); gtk_menu_shell_append(GTK_MENU_SHELL(menu), showItem); g_signal_connect(showItem, "toggled", G_CALLBACK(onShow), qApp); gtk_widget_show(showItem); GtkWidget *exitItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), exitItem); g_signal_connect(exitItem, "activate", G_CALLBACK(onQuit), qApp); gtk_widget_show(exitItem); app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu(indicator, GTK_MENU(menu)); #else //desktop systray systrayMenu = new QMenu(this); systrayMenu->addAction(tr("Show"), this, SLOT(showWindow())); systrayMenu->addAction(QIcon::fromTheme("application-exit", QIcon::fromTheme("exit")), tr("Quit"), qApp, SLOT(exit())); systray->setIcon(QIcon(":/icons/icons/shadowsocks-qt5.png")); systray->setToolTip(QString("Shadowsocks-Qt5")); systray->setContextMenu(systrayMenu); connect(systray, &QSystemTrayIcon::activated, this, &MainWindow::onSystrayActivated); systray->show(); #endif }
void create_indicator(void *handle) { app_indicator_new_fun app_indicator_new; app_indicator_set_status_fun app_indicator_set_status; app_indicator_set_menu_fun app_indicator_set_menu; app_indicator_new = dlsym(handle, "app_indicator_new"); app_indicator_set_status = dlsym(handle, "app_indicator_set_status"); app_indicator_set_menu = dlsym(handle, "app_indicator_set_menu"); // write icon to temp file, otherwise imposible to set in libappindicator int fd = -1; memset(tmpIconNameBuf, 0, sizeof(tmpIconNameBuf)); strncpy(tmpIconNameBuf,"/tmp/storageguiicon-XXXXXX",26); fd = mkstemp(tmpIconNameBuf); if (fd > 0) { if(write(fd, icon, iconSize) == -1) { fprintf(stderr, "Failed to write icon data into temp file\n"); } } else { fprintf(stderr, "Failed to create temp file for icon\n"); } AppIndicator *indicator = app_indicator_new (menu_title, tmpIconNameBuf, APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu (indicator, GTK_MENU (menu)); }
static void activate_clicked_cb (GtkWidget *widget, gpointer data) { AppIndicator * ci = APP_INDICATOR(data); if (active) { app_indicator_set_status (ci, APP_INDICATOR_STATUS_ATTENTION); gtk_menu_item_set_label(GTK_MENU_ITEM(widget), "I'm okay now"); active = FALSE; } else { app_indicator_set_status (ci, APP_INDICATOR_STATUS_ACTIVE); gtk_menu_item_set_label(GTK_MENU_ITEM(widget), "Get Attention"); active = TRUE; } }
static gboolean indicator_load(PurplePlugin *plugin) { indicator_docklet_init(plugin, &ui_ops); AppIndicator *indicator = app_indicator_new_with_path("pidgin", PIDGIN_STOCK_TRAY_AVAILABLE, APP_INDICATOR_CATEGORY_APPLICATION_STATUS, DATADIR G_DIR_SEPARATOR_S "pixmaps" G_DIR_SEPARATOR_S "pidgin" G_DIR_SEPARATOR_S "tray"); sIndicator = indicator; app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); indicator_update_icon(purple_savedstatus_get_type(purple_savedstatus_get_current()), FALSE, FALSE); void *plugins_handle = purple_plugins_get_handle(); purple_signal_connect(plugins_handle, "plugin-load", plugin->handle, PURPLE_CALLBACK(indicator_build_menu), indicator); purple_signal_connect(plugins_handle, "plugin-unload", plugin->handle, PURPLE_CALLBACK(indicator_build_menu), indicator); indicator_build_menu(NULL, indicator); plugin->extra = indicator; pidgin_blist_visibility_manager_add(); return TRUE; }
int main (int argc, char **argv) { gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); //connect destroy signal on quit g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); //Indicator creation indicator = app_indicator_new ("ramfs-applet", "", APP_INDICATOR_CATEGORY_SYSTEM_SERVICES); app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE); set_indicating_menu_items(0,0); g_timeout_add_seconds(1,read_statistics,NULL); gtk_main (); return 0; }
static void create_iijmio_indicator(GtkUIManager *ui) { AppIndicator *indicator; GtkWidget *indicator_menu; GtkIconTheme *theme; gchar *current_dir; gchar *theme_path; indicator = app_indicator_new("iijmio-indicator-client", INDICATOR_ICON, APP_INDICATOR_CATEGORY_APPLICATION_STATUS); indicator_menu = gtk_ui_manager_get_widget (ui, "/ui/IndicatorPopup"); current_dir = g_get_current_dir(); g_print("%s current_dir:%s\n", G_STRFUNC, current_dir); theme_path = g_build_path(G_DIR_SEPARATOR_S, current_dir, "data", NULL); g_print("%s path:%s\n", G_STRFUNC, theme_path); app_indicator_set_icon_theme_path(indicator, theme_path); g_free(current_dir); g_free(theme_path); app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_attention_icon(indicator, INDICATOR_ATTENTION_ICON); app_indicator_set_menu(indicator, GTK_MENU(indicator_menu)); gtk_widget_show_all(indicator_menu); }
void Main_window::show_tray_icon(bool show) { #if HAVE_APP_INDICATOR if(this->gui->use_appindicator) { app_indicator_set_status(this->gui->appindicator, show ? APP_INDICATOR_STATUS_ACTIVE : APP_INDICATOR_STATUS_PASSIVE); show = false; } #endif if(show) { if(this->gui->tray) this->gui->tray->set_visible(true); else { // Создаем иконку в трее this->gui->tray = Gtk::StatusIcon::create(APP_UNIX_NAME); // Обработчик нажатия левой кнопки мыши по значку в трее this->gui->tray->signal_activate().connect(sigc::mem_fun(*this, &Main_window::on_tray_activated)); // Обработчик нажатия правой кнопки мыши по значку в трее this->gui->tray->signal_popup_menu().connect(sigc::mem_fun(*this, &Main_window::on_tray_popup_menu)); } } else { if(this->gui->tray) this->gui->tray->set_visible(false); } }
void init_app_indicator(int argc, char **argv) { GtkWidget *window; GError *error = NULL; gtk_init (&argc, &argv); /* main window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); /* Indicator */ indicator = app_indicator_new ("pa-device-switcher-indicator", "indicator-messages", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); menu = gtk_menu_new(); app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_attention_icon (indicator, "indicator-messages-new"); app_indicator_set_menu (indicator, GTK_MENU (menu)); }
void MainWindow::toggleTrayIcon(bool visible) { #ifdef USE_LIBAPPINDICATOR if(unityDesktop) app_indicator_set_status(indicator, visible ? APP_INDICATOR_STATUS_ACTIVE : APP_INDICATOR_STATUS_PASSIVE); else #endif // USE_LIBAPPINDICATOR trayIcon->setVisible(visible); }
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 */ }
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 */ }
UnitySystemTray::UnitySystemTray(const QString & name, const QString & icon) { p = new UnitySystemTrayPrivate; p->menu = gtk_menu_new(); p->indicator = app_indicator_new(name.toUtf8(), icon.toUtf8(), APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_status(p->indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu(p->indicator, GTK_MENU(p->menu)); }
void create_app_indicator(gint create) { /* Create the menu */ indicator_menu = create_tray_menu(indicator_menu, 2); /* check if we need to create the indicator or just refresh the menu */ if(create == 1) { indicator = app_indicator_new("clipit", "clipit-trayicon", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_attention_icon (indicator, "clipit-trayicon"); } app_indicator_set_menu (indicator, GTK_MENU (indicator_menu)); }
int nativeLoop(void) { gtk_init(0, NULL); global_app_indicator = app_indicator_new("systray", "", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_status(global_app_indicator, APP_INDICATOR_STATUS_ACTIVE); global_tray_menu = gtk_menu_new(); app_indicator_set_menu(global_app_indicator, GTK_MENU(global_tray_menu)); systray_ready(); gtk_main(); systray_on_exit(); return 0; }
static void indicator_init () { /* TODO: set actual icon */ Indicator = app_indicator_new ( "indi-player", "/usr/share/pixmaps/gnome-xterm.png", APP_INDICATOR_CATEGORY_APPLICATION_STATUS ); app_indicator_set_attention_icon (Indicator, "indicator-sound"); app_indicator_set_status (Indicator, APP_INDICATOR_STATUS_ACTIVE); //app_indicator_set_label (Indicator, "indi player", NULL); }
static void update_app_indicator (DrWright *dr) { AppIndicatorStatus new_status; if (!dr->enabled) { app_indicator_set_status (dr->indicator, APP_INDICATOR_STATUS_PASSIVE); return; } switch (dr->state) { case STATE_WARN: case STATE_BREAK_SETUP: case STATE_BREAK: new_status = APP_INDICATOR_STATUS_ATTENTION; break; default: new_status = APP_INDICATOR_STATUS_ACTIVE; } app_indicator_set_status (dr->indicator, new_status); }
static gboolean update_status (DrWright *dr) { gint min; gchar *str; #ifdef HAVE_APP_INDICATOR GtkWidget *item; #endif /* HAVE_APP_INDICATOR */ if (!dr->enabled) { #ifdef HAVE_APP_INDICATOR app_indicator_set_status (dr->indicator, APP_INDICATOR_STATUS_PASSIVE); #else gtk_status_icon_set_tooltip_text (dr->icon, _("Disabled")); #endif /* HAVE_APP_INDICATOR */ return TRUE; } min = get_time_left (dr); if (min >= 1) { #ifdef HAVE_APP_INDICATOR str = g_strdup_printf (_("Take a break now (next in %dm)"), min); #else str = g_strdup_printf (ngettext("%d minute until the next break", "%d minutes until the next break", min), min); #endif /* HAVE_APP_INDICATOR */ } else { #ifdef HAVE_APP_INDICATOR str = g_strdup_printf (_("Take a break now (next in less than one minute)")); #else str = g_strdup_printf (_("Less than one minute until the next break")); #endif /* HAVE_APP_INDICATOR */ } #ifdef HAVE_APP_INDICATOR item = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop/TakeABreak"); gtk_menu_item_set_label (GTK_MENU_ITEM (item), str); #else gtk_status_icon_set_tooltip_text (dr->icon, str); #endif /* HAVE_APP_INDICATOR */ g_free (str); return TRUE; }
void *run_indicator(void *arg) { AppIndicator *indicator; char icon[256]; force = (int *)arg; strcpy(icon, pathname); strcat(icon, "/clock_ind.png"); indicator = app_indicator_new("uManage-client", icon, APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_attention_icon(indicator, "indicator-messages-new"); build_menu(indicator); gtk_main (); return arg; }
void StatusNotifier::createAppIndicator() { AppIndicator *indicator = app_indicator_new("Shadowsocks-Qt5", "shadowsocks-qt5", APP_INDICATOR_CATEGORY_OTHER); GtkWidget *menu = gtk_menu_new(); minimiseRestoreGtkItem = gtk_menu_item_new_with_label(tr("Minimise").toLocal8Bit().constData()); gtk_menu_shell_append(GTK_MENU_SHELL(menu), minimiseRestoreGtkItem); g_signal_connect(minimiseRestoreGtkItem, "activate", G_CALLBACK(onAppIndicatorActivated), &window); gtk_widget_show(minimiseRestoreGtkItem); GtkWidget *exitItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), exitItem); g_signal_connect(exitItem, "activate", G_CALLBACK(onQuit), &window); gtk_widget_show(exitItem); app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu(indicator, GTK_MENU(menu)); }
static void remmina_icon_destroy(void) { if (remmina_icon.icon) { #ifdef HAVE_LIBAPPINDICATOR app_indicator_set_status (remmina_icon.icon, APP_INDICATOR_STATUS_PASSIVE); #else gtk_status_icon_set_visible(remmina_icon.icon, FALSE); #endif remmina_widget_pool_hold(FALSE); } if (remmina_icon.avahi) { remmina_avahi_free(remmina_icon.avahi); remmina_icon.avahi = NULL; } if (remmina_icon.autostart_file) { g_free(remmina_icon.autostart_file); remmina_icon.autostart_file = NULL; } }
static void is_indicator_constructed(GObject *object) { IsIndicator *self = IS_INDICATOR(object); GtkActionGroup *action_group; GtkUIManager *ui_manager; GError *error = NULL; GtkWidget *menu; action_group = gtk_action_group_new("AppActions"); gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions(action_group, entries, n_entries, self); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); if (!gtk_ui_manager_add_ui_from_string(ui_manager, ui_info, -1, &error)) { g_error("Failed to build menus: %s\n", error->message); } menu = gtk_ui_manager_get_widget(ui_manager, "/ui/Indicator"); /* manually add separator since specifying it in the ui description means it gets optimised out (since there is no menu item above it) but if we manually add it and show the whole menu then all is good... */ gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); gtk_widget_show_all(menu); is_indicator_set_label(self, _("No Sensors")); is_indicator_set_menu(self, GTK_MENU(menu)); #if HAVE_APPINDICATOR app_indicator_set_status(APP_INDICATOR(self), APP_INDICATOR_STATUS_ACTIVE); #endif fake_add_enable_sensors(IS_INDICATOR(object)); }
PocketvoxIndicator* pocketvox_indicator_new() { PocketvoxIndicator *indicator = (PocketvoxIndicator *)g_object_new(TYPE_POCKETVOX_INDICATOR, NULL); indicator->priv = G_TYPE_INSTANCE_GET_PRIVATE (indicator, TYPE_POCKETVOX_INDICATOR, PocketvoxIndicatorPrivate); PocketvoxIndicatorPrivate *priv = indicator->priv; app_indicator_set_status(priv->applet, APP_INDICATOR_STATUS_ACTIVE); GtkWidget* stateItem = gtk_menu_item_new_with_label(_("Stop")); priv->modulesItem = gtk_menu_item_new_with_label(_("Modules")); GtkWidget* separatorItem0 = gtk_separator_menu_item_new(); GtkWidget* separatorItem1 = gtk_separator_menu_item_new(); GtkWidget* quitItem = gtk_menu_item_new_with_label(_("Quit")); priv->appsItem = gtk_menu_item_new_with_label(_("Apps")); gtk_menu_item_set_submenu((GtkMenuItem *)priv->modulesItem, priv->modulesMenu); gtk_menu_item_set_submenu((GtkMenuItem *)priv->appsItem, priv->appsMenu); gtk_menu_attach((GtkMenu *)priv->menu, stateItem, 0, 1, 0, 1); gtk_menu_attach((GtkMenu *)priv->menu, separatorItem0, 0, 1, 1, 2); gtk_menu_attach((GtkMenu *)priv->menu, priv->modulesItem, 0, 1, 2, 3); gtk_menu_attach((GtkMenu *)priv->menu, priv->appsItem, 0, 1, 3, 4); gtk_menu_attach((GtkMenu *)priv->menu, separatorItem1, 0, 1, 4, 5); gtk_menu_attach((GtkMenu *)priv->menu, quitItem, 0, 1, 5, 6); gtk_widget_show_all(priv->menu); gtk_widget_hide(priv->appsItem); gtk_widget_hide(priv->modulesItem); g_signal_connect(stateItem, "activate", G_CALLBACK(pocketvox_indicator_state_changed), indicator); g_signal_connect(quitItem, "activate", G_CALLBACK(pocketvox_indicator_quit), indicator); app_indicator_set_menu(priv->applet, (GtkMenu *)priv->menu); return indicator; }
void startup(GApplication *app, gpointer user_data) { GtkMenu *tray_menu; GtkWindow *window; gchar *theme_path; /* set ui */ builder = gtk_builder_new(); gtk_builder_add_from_resource(builder, "/ui/calendar.glade", NULL); gtk_builder_connect_signals(builder, NULL); window = GTK_WINDOW(gtk_builder_get_object(builder, "window")); tray_menu = GTK_MENU(gtk_builder_get_object(builder, "tray_menu")); /* set gtkapplication window */ gtk_application_add_window(GTK_APPLICATION(app), window); /* initialize our time */ time_gen(); mytime = today; /* prepare appindicator */ theme_path = g_build_filename(DATADIR, "icons", "hicolor", "256x256", NULL); indicator = app_indicator_new_with_path("Acal", "persian-calendar-1", APP_INDICATOR_CATEGORY_APPLICATION_STATUS, theme_path); app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu(indicator, tray_menu); /* show initial tray & prepare cal */ update_tray(); cal_gen(); /* add timer to update tray */ g_timeout_add_seconds(3, check_update_tray, (gpointer)indicator); }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); mainWindow = this; // Start device manager KbManager::init(CKB_VERSION_STR); connect(KbManager::kbManager(), SIGNAL(kbConnected(Kb*)), this, SLOT(addDevice(Kb*))); connect(KbManager::kbManager(), SIGNAL(kbDisconnected(Kb*)), this, SLOT(removeDevice(Kb*))); connect(KbManager::kbManager(), SIGNAL(versionUpdated()), this, SLOT(updateVersion())); connect(KbManager::scanTimer(), SIGNAL(timeout()), this, SLOT(timerTick())); // Set up tray icon restoreAction = new QAction(tr("Restore"), this); closeAction = new QAction(tr("Quit ckb"), this); #ifdef USE_LIBAPPINDICATOR QString desktop = std::getenv("XDG_CURRENT_DESKTOP"); unityDesktop = (desktop.toLower() == "unity"); if(unityDesktop){ trayIcon = 0; indicatorMenu = gtk_menu_new(); indicatorMenuRestoreItem = gtk_menu_item_new_with_label("Restore"); indicatorMenuQuitItem = gtk_menu_item_new_with_label("Quit ckb"); gtk_menu_shell_append(GTK_MENU_SHELL(indicatorMenu), indicatorMenuRestoreItem); gtk_menu_shell_append(GTK_MENU_SHELL(indicatorMenu), indicatorMenuQuitItem); g_signal_connect(indicatorMenuQuitItem, "activate", G_CALLBACK(quitIndicator), this); g_signal_connect(indicatorMenuRestoreItem, "activate", G_CALLBACK(restoreIndicator), this); gtk_widget_show(indicatorMenuRestoreItem); gtk_widget_show(indicatorMenuQuitItem); indicator = app_indicator_new("ckb", "indicator-messages", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu(indicator, GTK_MENU(indicatorMenu)); app_indicator_set_icon(indicator, "ckb"); } else #endif // USE_LIBAPPINDICATOR { trayIconMenu = new QMenu(this); trayIconMenu->addAction(restoreAction); trayIconMenu->addAction(closeAction); trayIcon = new QSystemTrayIcon(QIcon(":/img/ckb-logo.png"), this); trayIcon->setContextMenu(trayIconMenu); connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(iconClicked(QSystemTrayIcon::ActivationReason))); } toggleTrayIcon(!CkbSettings::get("Program/SuppressTrayIcon").toBool()); #ifdef Q_OS_MACX // Make a custom "Close" menu action for OSX, as the default one brings up the "still running" popup unnecessarily QMenuBar* menuBar = new QMenuBar(this); setMenuBar(menuBar); this->menuBar()->addMenu("ckb")->addAction(closeAction); #else // On linux, add a handler for Ctrl+Q new QShortcut(QKeySequence("Ctrl+Q"), this, SLOT(quitApp())); #endif connect(ui->actionExit, SIGNAL(triggered()), this, SLOT(quitApp())); connect(closeAction, SIGNAL(triggered()), this, SLOT(quitApp())); connect(restoreAction, SIGNAL(triggered()), this, SLOT(showWindow())); connect(qApp, SIGNAL(applicationStateChanged(Qt::ApplicationState)), this, SLOT(stateChange(Qt::ApplicationState))); connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(cleanup())); ui->tabWidget->addTab(settingsWidget = new SettingsWidget(this), configLabel); settingsWidget->setVersion("ckb " CKB_VERSION_STR); }
void create_tray_icon (void) { dpy = XOpenDisplay(NULL); gxneur_config_read_str("show_in_the_tray", &show_in_the_tray); gxneur_config_read_str("rendering_engine", &rendering_engine); gxneur_config_add_notify("show_in_the_tray", show_in_the_tray_callback, NULL); gxneur_config_add_notify("rendering_engine", rendering_engine_callback, NULL); if (arg_show_in_the_tray) g_free(show_in_the_tray), show_in_the_tray = g_strdup(arg_show_in_the_tray); if (arg_rendering_engine) g_free(rendering_engine), rendering_engine = g_strdup(arg_rendering_engine); if (!show_in_the_tray) show_in_the_tray = g_strdup(DEFAULT_SHOW_IN_THE_TRAY); if (!rendering_engine) rendering_engine = g_strdup(DEFAULT_RENDERING_ENGINE); tray = g_new0(struct _tray_icon, 1); #ifdef HAVE_APP_INDICATOR tray->app_indicator = NULL; #endif tray->status_icon = NULL; tray->tray_icon = NULL; // Init pixbuf array for (int i = 0; i < MAX_LAYOUTS; i++) { tray->images[i] = NULL; } // Load images names for (int i = 0; i < xconfig->handle->total_languages; i++) { char *layout_name = strdup(xconfig->handle->languages[i].dir); tray->images[i] = g_strdup_printf("%s-%s", PACKAGE, layout_name); free(layout_name); } tray->menu = create_menu(tray, xconfig->manual_mode); int tray_icon_created = 0; int tray_icon_failed = 0; if (strcasecmp(rendering_engine, "AppIndicator") == 0) { #ifdef HAVE_APP_INDICATOR // App indicator tray->app_indicator = app_indicator_new ("X Neural Switcher", PACKAGE, APP_INDICATOR_CATEGORY_APPLICATION_STATUS); if (tray->app_indicator) { app_indicator_set_status (tray->app_indicator, APP_INDICATOR_STATUS_ACTIVE); app_indicator_set_menu (tray->app_indicator, tray->menu); tray_icon_created = 1; tray_icon_failed = 0; } else { tray_icon_failed = 1; } #else tray_icon_failed = 1; #endif } gint kbd_gr = get_active_kbd_group(dpy); // Tray icon if (strcasecmp(rendering_engine, "Built-in") == 0 /*|| tray_icon_failed*/) { tray->tray_icon = _gtk_tray_icon_new(_("X Neural Switcher")); if (tray->tray_icon) { g_signal_connect(G_OBJECT(tray->tray_icon), "button_press_event", G_CALLBACK(tray_icon_press), NULL); tray->evbox = gtk_event_box_new(); gtk_event_box_set_visible_window(GTK_EVENT_BOX(tray->evbox), 0); if (strcasecmp(show_in_the_tray, "Text") == 0) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].dir); for (unsigned int i=0; i < strlen(layout_name); i++) layout_name[i] = toupper(layout_name[i]); tray->image = gtk_label_new ((const gchar *)layout_name); gtk_label_set_justify (GTK_LABEL(tray->image), GTK_JUSTIFY_CENTER); free(layout_name); } else { tray->image = gtk_image_new_from_icon_name(tray->images[kbd_gr], GTK_ICON_SIZE_LARGE_TOOLBAR); } gtk_container_add(GTK_CONTAINER(tray->evbox), tray->image); gtk_container_add(GTK_CONTAINER(tray->tray_icon), tray->evbox); gtk_widget_show_all(GTK_WIDGET(tray->tray_icon)); tray_icon_created = 1; tray_icon_failed = 0; } else { tray_icon_failed = 1; } } // Status Icon if (tray_icon_failed || !tray_icon_created || strcasecmp(rendering_engine, "StatusIcon") == 0 ) { tray->status_icon = gtk_status_icon_new(); g_signal_connect(G_OBJECT(tray->status_icon), "activate", G_CALLBACK(status_icon_on_click), NULL); g_signal_connect(G_OBJECT(tray->status_icon), "popup-menu", G_CALLBACK(status_icon_on_menu), NULL); gtk_status_icon_set_from_icon_name(tray->status_icon, PACKAGE); gtk_status_icon_set_tooltip_text(tray->status_icon, "X Neural Switcher"); gtk_status_icon_set_visible(tray->status_icon, TRUE); if (strcasecmp(show_in_the_tray, "Text") == 0) { char *layout_name = strdup(xconfig->handle->languages[kbd_gr].dir); for (unsigned int i=0; i < strlen(layout_name); i++) layout_name[i] = toupper(layout_name[i]); GdkPixbuf *pb = text_to_gtk_pixbuf (layout_name); free(layout_name); pb = gdk_pixbuf_add_alpha(pb, TRUE, 255, 255, 255); gtk_status_icon_set_from_pixbuf(tray->status_icon, pb); g_object_unref(pb); } else { gtk_status_icon_set_from_icon_name(tray->status_icon, tray->images[kbd_gr]); } } force_update = TRUE; g_timeout_add(1000, clock_check, 0); }
// runs in main thread, should always return FALSE to prevent gtk to execute it again gboolean do_quit(gpointer data) { // app indicator doesn't provide a way to remove it, hide it as a workaround app_indicator_set_status(global_app_indicator, APP_INDICATOR_STATUS_PASSIVE); gtk_main_quit(); return FALSE; }