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;
}
