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 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::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
}
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);
}
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 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 set_indicating_menu_items(long ramfs, long mem)
{
char ramfs_text[100];
sprintf(ramfs_text,"ramfs size: %ld MB",ramfs/1024);
char mem_text[100];
sprintf(mem_text,"free RAM: %ld MB", mem/1024);
indicator_menu = gtk_menu_new();
ramfs_item = gtk_menu_item_new_with_label ((const char*)ramfs_text);
freemem_item = gtk_menu_item_new_with_label ((const char*)mem_text);
quit_item = gtk_menu_item_new_with_label ("Quit");
//add menu item to menu
gtk_menu_append(GTK_MENU(indicator_menu),ramfs_item);
gtk_menu_append(GTK_MENU(indicator_menu),freemem_item);
gtk_menu_append(GTK_MENU(indicator_menu),quit_item);
g_signal_connect (G_OBJECT (quit_item),
"activate",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_show (freemem_item);
gtk_widget_show (ramfs_item);
gtk_widget_show (quit_item);
app_indicator_set_menu (indicator, GTK_MENU (indicator_menu));
}
static void
indicator_build_menu(PurplePlugin *plugin, AppIndicator *indicator) {
GtkMenu *menu = GTK_MENU(docklet_menu());
GList *items = gtk_container_get_children(GTK_CONTAINER(menu));
app_indicator_set_menu(indicator, menu);
app_indicator_set_secondary_activate_target(indicator, GTK_WIDGET(items->data));
}
static void menu_init ()
{
Menu = gtk_menu_new ();
gchar *xdg_music_path = (gchar*)g_get_user_special_dir (G_USER_DIRECTORY_MUSIC);
if (!xdg_music_path)
return;
GtkWidget* item = path_to_menu (xdg_music_path);
gtk_menu_append (Menu, item);
gtk_widget_show_all (item);
/* Line */
item = gtk_separator_menu_item_new ();
gtk_menu_append (Menu, item);
gtk_widget_show_all (item);
/* Shuffle */
item = gtk_check_menu_item_new_with_label ("Shuffle");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (call_shuffle), NULL);
gtk_widget_show_all (item);
/* Play/pause */
item = gtk_menu_item_new_with_label ("Play/Pause");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (play_or_pause), NULL);
gtk_widget_show_all (item);
/* Stop */
item = gtk_menu_item_new_with_label ("Stop");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (stop), NULL);
gtk_widget_show_all (item);
/* Previous */
item = gtk_menu_item_new_with_label ("Prev track");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (prev_track), NULL);
gtk_widget_show_all (item);
/* Next */
item = gtk_menu_item_new_with_label ("Next track");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (next_track), NULL);
gtk_widget_show_all (item);
/* Quit */
item = gtk_menu_item_new_with_label ("Quit");
gtk_menu_append (Menu, item);
g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (quit), NULL);
gtk_widget_show_all (item);
app_indicator_set_menu (Indicator, GTK_MENU (Menu));
}
void build_menu(AppIndicator *indicator) {
app_indicator_set_menu(indicator, GTK_MENU(umenu_Indicator_Menu));
gtk_widget_show_all((GtkWidget*)umenu_Indicator_Menu);
g_signal_connect(umenu_Menu_Quit, "activate", G_CALLBACK(activate_quit), NULL);
g_signal_connect(umenu_Menu_Opts, "activate", G_CALLBACK(activate_options), NULL);
g_signal_connect(umenu_Menu_Refresh, "activate", G_CALLBACK(activate_refresh), NULL);
g_signal_connect(umenu_Menu_About, "activate", G_CALLBACK(activate_about), NULL);
g_signal_connect(umenu_Menu_Pause, "toggled", G_CALLBACK(activate_pause), NULL);
g_signal_connect(umenu_Menu_Jiggle, "toggled", G_CALLBACK(activate_jiggle), NULL);
}
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));
}
void QAppIndicator::onMenuSet(QAppIndicatorMenu *_menu)
{
if (m_menu)
{
delete m_menu;
}
m_menu = _menu;
app_indicator_set_menu(m_appIndicator, GTK_MENU(_menu->m_menu));
_menu->setParent(this);
}
static void
is_indicator_set_menu(IsIndicator *self,
GtkMenu *menu)
{
#if HAVE_APPINDICATOR
app_indicator_set_menu(APP_INDICATOR(self), menu);
#else
g_object_set_data_full(G_OBJECT(self), "indicator-menu", menu,
(GDestroyNotify)gtk_widget_destroy);
g_signal_connect(self, "popup-menu", G_CALLBACK(popup_menu), self);
#endif
}
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;
}
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));
}
void
remmina_icon_populate_menu (void)
{
GtkWidget *menu;
GtkWidget *menuitem;
menu = remmina_applet_menu_new ();
app_indicator_set_menu (remmina_icon.icon, GTK_MENU (menu));
remmina_applet_menu_set_hide_count (REMMINA_APPLET_MENU (menu), remmina_pref.applet_hide_count);
remmina_applet_menu_populate (REMMINA_APPLET_MENU (menu));
remmina_icon_populate_extra_menu_item (menu);
menuitem = gtk_separator_menu_item_new ();
gtk_widget_show(menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
remmina_icon_populate_additional_menu_item (menu);
}
void fill_app_indicator(pa_devicelist_t *input, pa_devicelist_t *output) {
gtk_widget_destroy(menu);
GtkWidget *menu_items[3];
menu = gtk_menu_new();
create_list_for_type(input);
add_separator_to_menu();
create_list_for_type(output);
add_separator_to_menu();
GtkWidget *btn_quit = gtk_menu_item_new_with_label("Quit");
gtk_menu_append(GTK_MENU_SHELL (menu),btn_quit);
gtk_widget_show(btn_quit);
g_signal_connect (btn_quit, "activate",
G_CALLBACK (gtk_main_quit), NULL);
app_indicator_set_menu (indicator, GTK_MENU (menu));
}
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);
}
int
main (int argc, char ** argv)
{
GtkWidget *menu = NULL;
AppIndicator *ci = NULL;
gtk_init (&argc, &argv);
ci = app_indicator_new ("example-simple-client",
"indicator-messages",
APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
g_assert (IS_APP_INDICATOR (ci));
g_assert (G_IS_OBJECT (ci));
app_indicator_set_status (ci, APP_INDICATOR_STATUS_ACTIVE);
app_indicator_set_attention_icon_full(ci, "indicator-messages-new", "System Messages Icon Highlighted");
app_indicator_set_label (ci, "1%", "100%");
app_indicator_set_title (ci, "Test Inidcator");
g_signal_connect (ci, "act",
G_CALLBACK (scroll_event_cb), NULL);
g_timeout_add_seconds(1, percent_change, ci);
menu = gtk_menu_new ();
GtkWidget *item = gtk_check_menu_item_new_with_label ("1");
g_signal_connect (item, "activate",
G_CALLBACK (item_clicked_cb), "1");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_radio_menu_item_new_with_label (NULL, "2");
g_signal_connect (item, "activate",
G_CALLBACK (item_clicked_cb), "2");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
item = gtk_menu_item_new_with_label ("3");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
append_submenu (item);
gtk_widget_show (item);
GtkWidget *toggle_item = gtk_menu_item_new_with_label ("Toggle 3");
g_signal_connect (toggle_item, "activate",
G_CALLBACK (toggle_sensitivity_cb), item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), toggle_item);
gtk_widget_show(toggle_item);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, NULL);
g_signal_connect (item, "activate",
G_CALLBACK (image_clicked_cb), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show(item);
item = gtk_menu_item_new_with_label ("Get Attention");
g_signal_connect (item, "activate",
G_CALLBACK (activate_clicked_cb), ci);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show(item);
app_indicator_set_secondary_activate_target(ci, item);
item = gtk_menu_item_new_with_label ("Show label");
label_toggle_cb(item, ci);
g_signal_connect (item, "activate",
G_CALLBACK (label_toggle_cb), ci);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show(item);
item = gtk_check_menu_item_new_with_label ("Set Local Icon");
g_signal_connect (item, "activate",
G_CALLBACK (local_icon_toggle_cb), ci);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show(item);
app_indicator_set_menu (ci, GTK_MENU (menu));
mainloop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(mainloop);
return 0;
}
int main (int argc, char **argv)
{
/**********************************************************************************/
/* DAEMON SETUP */
/* Our process ID and Session ID */
pid_t pid, sid;
/* Fork off the parent process */
pid = fork();
if (pid < 0)
exit(EXIT_FAILURE);
/* If we got a good PID, then
we can exit the parent process. */
if (pid > 0)
exit(EXIT_SUCCESS);
/* Change the file mode mask */
umask(0);
/* Open any logs here */
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0)
exit(EXIT_FAILURE);
/* Change the current working directory */
if ((chdir("/")) < 0)
exit(EXIT_FAILURE);
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/**********************************************************************************/
/* PROGRAM */
/* define variables gtk*/
GtkWidget *window;
GtkWidget *indicator_menu;
GtkActionGroup *action_group;
GtkUIManager *uim;
GError *error = NULL;
AppIndicator *indicator;
/* define custum variables */
int status = atoi(argv[1]);
/* gtk init with no args */
gtk_init (0, NULL);
/* main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Gnus Indicator");
g_signal_connect (G_OBJECT (window),
"destroy",
G_CALLBACK (gtk_main_quit),
NULL);
/* Menus */
action_group = gtk_action_group_new ("AppActions");
gtk_action_group_add_actions (action_group, entries, n_entries, window);
uim = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (uim, action_group, 0);
if (!gtk_ui_manager_add_ui_from_string (uim, ui_info, -1, &error))
{
g_message ("Failed to build menus: %s\n", error->message);
g_error_free (error);
error = NULL;
}
/* Indicator */
indicator_menu = gtk_ui_manager_get_widget (uim, "/ui/IndicatorPopup");
indicator = app_indicator_new ("example-simple-client",
"/usr/share/pixmaps/gnome-gnus.png",
APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_attention_icon(indicator, "/usr/share/pixmaps/gnome-gnus-new.png");
app_indicator_set_menu (indicator, GTK_MENU (indicator_menu));
/* set status */
if(status == 0)
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE);
else if(status == 1)
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ATTENTION);
else
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_PASSIVE);
gtk_main();
return 0;
}
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);
}
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);
}
Main_window::Main_window(const Main_window_settings& settings)
:
m::gtk::Window("", settings.window, 800, 600, 0),
gui(new Gui)
{
Client_settings& client_settings = get_client_settings();
Main_window_settings& main_window_settings = client_settings.gui.main_window;
// Заголовок окна -->
this->gui->orig_window_title = APP_NAME;
if(get_application().get_config_dir_path() != get_default_config_dir_path())
this->gui->orig_window_title = " (" + get_application().get_config_dir_path() + ")";
Gtk::Window::set_title(this->gui->orig_window_title);
// Заголовок окна <--
// Трей
show_tray_icon(client_settings.gui.show_tray_icon);
// Меню -->
this->gui->ui_manager = Gtk::UIManager::create();
Glib::RefPtr<Gtk::ActionGroup> action_group = Gtk::ActionGroup::create();
action_group->add(
app_icons::create_action("app", app_icons::ICON_APP, APP_NAME),
sigc::mem_fun(*this, &Main_window::on_tray_activated)
);
action_group->add(Gtk::Action::create("file", _("_File")));
action_group->add(
Gtk::Action::create("create", Gtk::Stock::NEW, _("_Create")),
sigc::mem_fun(*this, &Main_window::on_create_callback)
);
action_group->add(
Gtk::Action::create("open", Gtk::Stock::OPEN, _("_Open a torrent")),
sigc::mem_fun(*this, &Main_window::on_open_callback)
);
action_group->add(
Gtk::Action::create("open_magnet", Gtk::Stock::JUMP_TO, _("_Open a magnet link")),
sigc::mem_fun(*this, &Main_window::on_open_magnet_callback)
);
action_group->add(
Gtk::Action::create("quit", Gtk::Stock::QUIT, _("_Quit")),
sigc::mem_fun(get_application(), &Application::close
));
action_group->add(Gtk::Action::create("edit", _("_Edit")));
action_group->add(
app_icons::create_action("statistics", app_icons::ICON_STATISTICS, _("_Statistics")),
sigc::mem_fun(*this, &Main_window::on_show_statistics_callback)
);
action_group->add(
Gtk::Action::create("preferences", Gtk::Stock::PREFERENCES, _("_Preferences")),
sigc::mem_fun(*this, &Main_window::on_show_settings_window_callback)
);
action_group->add(Gtk::Action::create("view", _("_View")));
// Toolbar -->
action_group->add(Gtk::Action::create("toolbar", _("_Toolbar")));
this->gui->menu_show_toolbar_action = Gtk::ToggleAction::create(
"toolbar/show", _Q("'Show ...' toggle|_Show"), "",
get_client_settings().gui.show_toolbar
);
action_group->add(
this->gui->menu_show_toolbar_action,
sigc::mem_fun(*this, &Main_window::on_show_toolbar_toggled_callback)
);
// Стиль панели инструментов -->
{
Gtk::RadioButtonGroup radio_group;
std::map< m::gtk::toolbar::Style, Glib::RefPtr<Gtk::RadioAction> > toolbar_style_buttons;
action_group->add(Gtk::Action::create("toolbar/style", _("Toolbar _style")));
action_group->add(
toolbar_style_buttons[m::gtk::toolbar::DEFAULT] = Gtk::RadioAction::create(
radio_group, "toolbar/style/default", _("_Desktop default")
),
sigc::bind<m::gtk::toolbar::Style>(
sigc::mem_fun(*this, &Main_window::change_toolbar_style),
m::gtk::toolbar::DEFAULT
)
);
action_group->add(
toolbar_style_buttons[m::gtk::toolbar::ICONS] = Gtk::RadioAction::create(
radio_group, "toolbar/style/icons", _("_Icons")
),
sigc::bind<m::gtk::toolbar::Style>(
sigc::mem_fun(*this, &Main_window::change_toolbar_style),
m::gtk::toolbar::ICONS
)
);
action_group->add(
toolbar_style_buttons[m::gtk::toolbar::TEXT] = Gtk::RadioAction::create(
radio_group, "toolbar/style/text", _("_Text")
),
sigc::bind<m::gtk::toolbar::Style>(
sigc::mem_fun(*this, &Main_window::change_toolbar_style),
m::gtk::toolbar::TEXT
)
);
action_group->add(
toolbar_style_buttons[m::gtk::toolbar::BOTH] = Gtk::RadioAction::create(
radio_group, "toolbar/style/both", _("_Both")
),
sigc::bind<m::gtk::toolbar::Style>(
sigc::mem_fun(*this, &Main_window::change_toolbar_style),
m::gtk::toolbar::BOTH
)
);
action_group->add(
toolbar_style_buttons[m::gtk::toolbar::BOTH_HORIZ] = Gtk::RadioAction::create(
radio_group, "toolbar/style/both_horiz", _("Both _horizontal")
),
sigc::bind<m::gtk::toolbar::Style>(
sigc::mem_fun(*this, &Main_window::change_toolbar_style),
m::gtk::toolbar::BOTH_HORIZ
)
);
toolbar_style_buttons[get_client_settings().gui.toolbar_style]->set_active();
}
// Стиль панели инструментов <--
// Toolbar <--
// Categories <--
{
Glib::RefPtr<Gtk::ToggleAction> action;
action_group->add(Gtk::Action::create("categories", _("_Categories")));
action = Gtk::ToggleAction::create(
"categories/show", _Q("'Show ...' toggle|_Show"), "",
get_client_settings().gui.main_window.torrents_viewport.categories_view->visible
);
action_group->add(
action,
sigc::bind< Glib::RefPtr<Gtk::ToggleAction> >(
sigc::mem_fun(*this->gui, &Main_window::Gui::on_show_categories_toggle_cb), action)
);
action = Gtk::ToggleAction::create(
"categories/show_names", _("Show _names"), "",
get_client_settings().gui.main_window.torrents_viewport.categories_view->show_names
);
action_group->add(
action,
sigc::bind< Glib::RefPtr<Gtk::ToggleAction> >(
sigc::mem_fun(*this->gui, &Main_window::Gui::on_show_categories_names_toggle_cb), action)
);
action = Gtk::ToggleAction::create(
"categories/show_counters", _("Show _counters"), "",
get_client_settings().gui.main_window.torrents_viewport.categories_view->show_counters
);
action_group->add(
action,
sigc::bind< Glib::RefPtr<Gtk::ToggleAction> >(
sigc::mem_fun(*this->gui, &Main_window::Gui::on_show_categories_counters_toggle_cb), action)
);
}
// Categories <--
// Torrents -->
action_group->add(Gtk::Action::create("torrents", _("_Torrents")));
action_group->add(Gtk::Action::create("resume", Gtk::Stock::MEDIA_PLAY, _("_Resume")));
action_group->add(
app_icons::create_action("resume/all", app_icons::ICON_DOWNLOAD_AND_UPLOAD, _("_All")),
sigc::bind<Torrents_group>(
sigc::mem_fun(*this, &Main_window::on_resume_torrents_callback),
ALL
)
);
action_group->add(
app_icons::create_action("resume/downloads", app_icons::ICON_DOWNLOAD, _("_Downloads")),
sigc::bind<Torrents_group>(
sigc::mem_fun(*this, &Main_window::on_resume_torrents_callback),
DOWNLOADS
)
);
action_group->add(
app_icons::create_action("resume/uploads", app_icons::ICON_UPLOAD, _("_Uploads")),
sigc::bind<Torrents_group>(
sigc::mem_fun(*this, &Main_window::on_resume_torrents_callback),
UPLOADS
)
);
action_group->add(Gtk::Action::create("pause", Gtk::Stock::MEDIA_PAUSE, _("_Pause")));
action_group->add(
app_icons::create_action("pause/all", app_icons::ICON_DOWNLOAD_AND_UPLOAD, _("_All")),
sigc::bind<Torrents_group>(
sigc::mem_fun(*this, &Main_window::on_pause_torrents_callback),
ALL
)
);
action_group->add(
app_icons::create_action("pause/downloads", app_icons::ICON_DOWNLOAD, _("_Downloads")),
sigc::bind<Torrents_group>(
sigc::mem_fun(*this, &Main_window::on_pause_torrents_callback),
DOWNLOADS
)
);
action_group->add(
app_icons::create_action("pause/uploads", app_icons::ICON_UPLOAD, _("_Uploads")),
sigc::bind<Torrents_group>(
sigc::mem_fun(*this, &Main_window::on_pause_torrents_callback),
UPLOADS
)
);
// Temporary -->
gui->resume_temporary = Gtk::Action::create(
"resume_temporary", Gtk::Stock::MEDIA_PLAY, _("R_esume temporary"));
action_group->add(gui->resume_temporary);
action_group->add(
app_icons::create_action("resume_temporary/all", app_icons::ICON_DOWNLOAD_AND_UPLOAD, _("_All")),
sigc::bind< std::pair<Temporary_action,Torrents_group> >(
sigc::mem_fun(*this, &Main_window::on_temporary_process_torrents_cb),
std::pair<Temporary_action,Torrents_group>( TEMPORARY_ACTION_RESUME, ALL )
)
);
action_group->add(
app_icons::create_action("resume_temporary/downloads", app_icons::ICON_DOWNLOAD, _("_Downloads")),
sigc::bind< std::pair<Temporary_action,Torrents_group> >(
sigc::mem_fun(*this, &Main_window::on_temporary_process_torrents_cb),
std::pair<Temporary_action,Torrents_group>( TEMPORARY_ACTION_RESUME, DOWNLOADS )
)
);
action_group->add(
app_icons::create_action("resume_temporary/uploads", app_icons::ICON_UPLOAD, _("_Uploads")),
sigc::bind< std::pair<Temporary_action,Torrents_group> >(
sigc::mem_fun(*this, &Main_window::on_temporary_process_torrents_cb),
std::pair<Temporary_action,Torrents_group>( TEMPORARY_ACTION_RESUME, UPLOADS )
)
);
gui->pause_temporary = Gtk::Action::create(
"pause_temporary", Gtk::Stock::MEDIA_PAUSE, _("P_ause temporary"));
action_group->add(gui->pause_temporary);
action_group->add(
app_icons::create_action("pause_temporary/all", app_icons::ICON_DOWNLOAD_AND_UPLOAD, _("_All")),
sigc::bind< std::pair<Temporary_action,Torrents_group> >(
sigc::mem_fun(*this, &Main_window::on_temporary_process_torrents_cb),
std::pair<Temporary_action,Torrents_group>( TEMPORARY_ACTION_PAUSE, ALL )
)
);
action_group->add(
app_icons::create_action("pause_temporary/downloads", app_icons::ICON_DOWNLOAD, _("_Downloads")),
sigc::bind< std::pair<Temporary_action,Torrents_group> >(
sigc::mem_fun(*this, &Main_window::on_temporary_process_torrents_cb),
std::pair<Temporary_action,Torrents_group>( TEMPORARY_ACTION_PAUSE, DOWNLOADS )
)
);
action_group->add(
app_icons::create_action("pause_temporary/uploads", app_icons::ICON_UPLOAD, _("_Uploads")),
sigc::bind< std::pair<Temporary_action,Torrents_group> >(
sigc::mem_fun(*this, &Main_window::on_temporary_process_torrents_cb),
std::pair<Temporary_action,Torrents_group>( TEMPORARY_ACTION_PAUSE, UPLOADS )
)
);
gui->complete_temporary_action = Gtk::Action::create(
"complete_temporary_action", Gtk::Stock::APPLY, _("C_omplete pending temporary action"));
action_group->add(
gui->complete_temporary_action,
sigc::bind<bool>( sigc::mem_fun(*this, &Main_window::on_interrupt_temporary_action_cb), true )
);
gui->cancel_temporary_action = Gtk::Action::create(
"cancel_temporary_action", Gtk::Stock::STOP, _("_Cancel pending temporary action"));
action_group->add(
gui->cancel_temporary_action,
sigc::bind<bool>( sigc::mem_fun(*this, &Main_window::on_interrupt_temporary_action_cb), false )
);
// Temporary <--
// Torrents <--
action_group->add(
app_icons::create_action("set_upload_rate_limit", app_icons::ICON_UPLOAD, _("Set _upload rate limit")),
sigc::bind<Traffic_type>(
sigc::mem_fun(*this, &Main_window::on_change_rate_limit_callback),
UPLOAD
)
);
action_group->add(
app_icons::create_action("set_download_rate_limit",
app_icons::ICON_DOWNLOAD, _("Set _download rate limit")),
sigc::bind<Traffic_type>(
sigc::mem_fun(*this, &Main_window::on_change_rate_limit_callback),
DOWNLOAD
)
);
action_group->add(Gtk::Action::create("help", _("_Help")));
action_group->add(
Gtk::Action::create("about", Gtk::Stock::ABOUT, _("_About")),
sigc::mem_fun(*this, &Main_window::on_show_about_dialog_callback)
);
this->gui->ui_manager->insert_action_group(action_group);
Glib::ustring ui_info =
"<ui>"
" <menubar name='menu_bar'>"
" <menu action='file'>"
" <menuitem action='create'/>"
" <menuitem action='open'/>"
" <menuitem action='open_magnet'/>"
" <menuitem action='quit'/>"
" </menu>"
" <menu action='edit'>"
" <menuitem action='statistics'/>"
" <menuitem action='preferences'/>"
" </menu>"
" <menu action='view'>"
" <menu action='toolbar'>"
" <menuitem action='toolbar/show'/>"
" <menu action='toolbar/style'>"
" <menuitem action='toolbar/style/default'/>"
" <menuitem action='toolbar/style/icons'/>"
" <menuitem action='toolbar/style/text'/>"
" <menuitem action='toolbar/style/both'/>"
" <menuitem action='toolbar/style/both_horiz'/>"
" </menu>"
" </menu>"
" <menu action='categories'>"
" <menuitem action='categories/show'/>"
" <menuitem action='categories/show_names'/>"
" <menuitem action='categories/show_counters'/>"
" </menu>"
" </menu>"
" <menu action='torrents'>"
" <menu action='resume'>"
" <menuitem action='resume/all'/>"
" <menuitem action='resume/uploads'/>"
" <menuitem action='resume/downloads'/>"
" </menu>"
" <menu action='pause'>"
" <menuitem action='pause/all'/>"
" <menuitem action='pause/uploads'/>"
" <menuitem action='pause/downloads'/>"
" </menu>"
" <separator/>"
" <menu action='resume_temporary'>"
" <menuitem action='resume_temporary/all'/>"
" <menuitem action='resume_temporary/uploads'/>"
" <menuitem action='resume_temporary/downloads'/>"
" </menu>"
" <menu action='pause_temporary'>"
" <menuitem action='pause_temporary/all'/>"
" <menuitem action='pause_temporary/uploads'/>"
" <menuitem action='pause_temporary/downloads'/>"
" </menu>"
" <menuitem action='complete_temporary_action'/>"
" <menuitem action='cancel_temporary_action'/>"
" </menu>"
" <menu action='help'>"
" <menuitem action='about'/>"
" </menu>"
" </menubar>"
" <popup name='appindicator'>"
" <menuitem action='app'/>"
" <separator/>"
" <menuitem action='open'/>"
" <menuitem action='open_magnet'/>"
" <separator/>"
" <menu action='resume'>"
" <menuitem action='resume/all'/>"
" <menuitem action='resume/uploads'/>"
" <menuitem action='resume/downloads'/>"
" </menu>"
" <menu action='pause'>"
" <menuitem action='pause/all'/>"
" <menuitem action='pause/uploads'/>"
" <menuitem action='pause/downloads'/>"
" </menu>"
" <separator/>"
" <menu action='resume_temporary'>"
" <menuitem action='resume_temporary/all'/>"
" <menuitem action='resume_temporary/uploads'/>"
" <menuitem action='resume_temporary/downloads'/>"
" </menu>"
" <menu action='pause_temporary'>"
" <menuitem action='pause_temporary/all'/>"
" <menuitem action='pause_temporary/uploads'/>"
" <menuitem action='pause_temporary/downloads'/>"
" </menu>"
" <menuitem action='complete_temporary_action'/>"
" <menuitem action='cancel_temporary_action'/>"
" <separator/>"
" <menuitem action='set_upload_rate_limit'/>"
" <menuitem action='set_download_rate_limit'/>"
" <separator/>"
" <menuitem action='quit'/>"
" </popup>"
" <popup name='tray_popup_menu'>"
" <menuitem action='open'/>"
" <menuitem action='open_magnet'/>"
" <separator/>"
" <menu action='resume'>"
" <menuitem action='resume/all'/>"
" <menuitem action='resume/uploads'/>"
" <menuitem action='resume/downloads'/>"
" </menu>"
" <menu action='pause'>"
" <menuitem action='pause/all'/>"
" <menuitem action='pause/uploads'/>"
" <menuitem action='pause/downloads'/>"
" </menu>"
" <separator/>"
" <menu action='resume_temporary'>"
" <menuitem action='resume_temporary/all'/>"
" <menuitem action='resume_temporary/uploads'/>"
" <menuitem action='resume_temporary/downloads'/>"
" </menu>"
" <menu action='pause_temporary'>"
" <menuitem action='pause_temporary/all'/>"
" <menuitem action='pause_temporary/uploads'/>"
" <menuitem action='pause_temporary/downloads'/>"
" </menu>"
" <menuitem action='complete_temporary_action'/>"
" <menuitem action='cancel_temporary_action'/>"
" <separator/>"
" <menuitem action='set_upload_rate_limit'/>"
" <menuitem action='set_download_rate_limit'/>"
" <separator/>"
" <menuitem action='quit'/>"
" </popup>"
"</ui>";
this->gui->ui_manager->add_ui_from_string(ui_info);
this->add_accel_group(this->gui->ui_manager->get_accel_group());
// Меню <--
Gtk::VBox* main_vbox = Gtk::manage(new Gtk::VBox());
this->add(*main_vbox);
// Панель меню -->
Gtk::Widget* menu_bar = this->gui->ui_manager->get_widget("/menu_bar");
main_vbox->pack_start(*menu_bar, false, true);
// Панель меню <--
// Панель инструментов
main_vbox->pack_start(this->gui->toolbar, false, false);
// Список торрентов -->
this->gui->torrents_viewport = Gtk::manage(new Torrents_viewport(main_window_settings.torrents_viewport));
main_vbox->pack_start(*this->gui->torrents_viewport, true, true);
// Настройки отдельных виджетов
this->gui->torrents_viewport->get_log_view().set_max_lines(client_settings.gui.max_log_lines);
// Список торрентов <--
// status bar -->
{
Gtk::Alignment* alignment = Gtk::manage(new Gtk::Alignment());
alignment->property_top_padding() = m::gtk::VBOX_SPACING / 2;
main_vbox->pack_start(*alignment, false, false);
alignment->add(this->gui->status_bar);
this->gui->status_bar.push("");
}
// status bar <--
// AppIndicator -->
#if HAVE_APP_INDICATOR
{
app_indicator_set_menu(this->gui->appindicator, GTK_MENU(
gtk_ui_manager_get_widget(this->gui->ui_manager->gobj(), "/ui/appindicator")));
g_signal_connect(G_OBJECT(this->gui->appindicator), APP_INDICATOR_SIGNAL_CONNECTION_CHANGED,
G_CALLBACK(&Main_window::on_appindicator_connection_changed), this);
}
#endif
// AppIndicator <--
// Панель инструментов -->
{
// Заполнять ее лучше в самом конце, когда уже созданы все необходимые
// виджеты.
Gtk::ToolButton* button;
button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::NEW));
button->set_label(_("Create"));
button->set_tooltip_text(_("Create a new torrent"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::mem_fun(*this, &Main_window::on_create_callback)
);
button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::OPEN));
button->set_label(_("Open"));
button->set_tooltip_text(_("Open a torrent"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::mem_fun(*this, &Main_window::on_open_callback)
);
button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::JUMP_TO));
button->set_label(_("Magnet link"));
button->set_tooltip_text(_("Open a magnet link"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::mem_fun(*this, &Main_window::on_open_magnet_callback)
);
this->gui->toolbar.append(
*Gtk::manage(new Gtk::SeparatorToolItem())
);
button = this->gui->toolbar_resume_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::MEDIA_PLAY));
button->set_label(_("Resume"));
button->set_tooltip_text(_("Resume torrent(s)"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::bind<Torrent_process_action>(
sigc::mem_fun(*this->gui->torrents_viewport, &Torrents_viewport::process_torrents),
RESUME
)
);
button = this->gui->toolbar_pause_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::MEDIA_PAUSE));
button->set_label(_("Pause"));
button->set_tooltip_text(_("Pause torrent(s)"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::bind<Torrent_process_action>(
sigc::mem_fun(*this->gui->torrents_viewport, &Torrents_viewport::process_torrents),
PAUSE
)
);
button = this->gui->toolbar_remove_button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::REMOVE));
button->set_label(_("Remove"));
button->set_tooltip_text(_("Remove torrent(s)"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::bind<Torrent_process_action>(
sigc::mem_fun(*this->gui->torrents_viewport, &Torrents_viewport::process_torrents),
REMOVE
)
);
this->gui->toolbar.append(
*Gtk::manage(new Gtk::SeparatorToolItem())
);
button = Gtk::manage(new Gtk::ToolButton());
button->set_label(_("Statistics"));
app_icons::set_for_tool_button(*button, app_icons::ICON_STATISTICS);
button->set_tooltip_text(_("Statistics"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::mem_fun(*this, &Main_window::on_show_statistics_callback)
);
button = Gtk::manage(new Gtk::ToolButton(Gtk::Stock::PREFERENCES));
button->set_label(_("Preferences"));
button->set_tooltip_text(_("Preferences"));
button->set_is_important();
this->gui->toolbar.append(
*button,
sigc::mem_fun(*this, &Main_window::on_show_settings_window_callback)
);
this->gui->toolbar.show_all_children();
if(get_client_settings().gui.show_toolbar)
this->gui->toolbar.show();
this->gui->toolbar.set_no_show_all();
}
// Панель инструментов <--
// Устанавливаем интервал обновления GUI
this->set_gui_update_interval(client_settings.gui.update_interval);
// Обновление доступных в данный момент кнопок -->
this->on_torrent_process_actions_changed_callback(0);
gui->torrent_process_actions_changed_connection =
this->gui->torrents_viewport->signal_torrent_process_actions_changed().connect(
sigc::mem_fun(*this, &Main_window::on_torrent_process_actions_changed_callback)
);
// Обновление доступных в данный момент кнопок <--
// Автоматическое сохранение настроек
gui->autosave_settings_connection = Glib::signal_timeout().connect(
sigc::mem_fun(*this, &Main_window::on_save_settings_timeout), SAVE_SETTINGS_INTERVAL
);
// Обработчик сигнала на изменение состояния окна
this->signal_window_state_event().connect(sigc::mem_fun(
*this, &Main_window::on_window_state_changed_callback
));
// Закрытие окна
this->signal_delete_event().connect(sigc::mem_fun(*this, &Main_window::on_close_callback));
if(client_settings.gui.show_tray_icon && client_settings.gui.hide_app_to_tray_at_startup)
this->show_all_children();
else
this->show_all();
// В gtkmm 2.16.0 (Ubuntu 9.04) есть небольшая бага, из-за которой
// this->show_all() отображает даже элементы меню, для которых была
// выполнена Gtk::Action::set_visible(false).
// Поэтому скрываем элементы меню в самый последний момент.
COMPATIBILITY
gui->complete_temporary_action->set_visible(true);
gui->cancel_temporary_action->set_visible(true);
}
int
main (int argc, char **argv)
{
GError *error = NULL;
gboolean no_daemon = FALSE;
gboolean debug = FALSE;
GOptionContext *context;
GOptionEntry entries[] = {
{"no-daemon", 0, 0, G_OPTION_ARG_NONE, &no_daemon, N_("Do not daemonize"), NULL},
{"debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Log debugging message"), NULL},
{NULL}
};
context = g_option_context_new ("- dasom daemon");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error != NULL)
{
g_warning ("%s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, DASOM_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (no_daemon == FALSE)
{
openlog (g_get_prgname (), LOG_PID | LOG_PERROR, LOG_DAEMON);
syslog_initialized = TRUE;
g_log_set_default_handler ((GLogFunc) dasom_log_default_handler, &debug);
if (daemon (0, 0) != 0)
{
g_critical ("Couldn't daemonize.");
return EXIT_FAILURE;
}
}
gtk_init (&argc, &argv);
AppIndicator *indicator;
GtkWidget *menu_shell;
GtkWidget *about_menu;
GtkWidget *exit_menu;
DasomAgent *agent;
menu_shell = gtk_menu_new ();
about_menu = gtk_menu_item_new_with_label (_("About"));
exit_menu = gtk_menu_item_new_with_label (_("Exit"));
gtk_widget_show_all (about_menu);
gtk_widget_show_all (exit_menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_shell), about_menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_shell), exit_menu);
gtk_widget_show_all (menu_shell);
indicator = app_indicator_new ("dasom-indicator", "input-keyboard",
APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE);
app_indicator_set_icon_full (indicator, "dasom-indicator", "Dasom");
app_indicator_set_menu (indicator, GTK_MENU (menu_shell));
agent = dasom_agent_new ();
g_signal_connect (agent, "engine-changed",
G_CALLBACK (on_engine_changed), indicator);
g_signal_connect (agent, "disconnected",
G_CALLBACK (on_disconnected), indicator);
g_signal_connect (about_menu, "activate", G_CALLBACK (on_about_menu), indicator);
g_signal_connect (exit_menu, "activate", G_CALLBACK (on_exit_menu), indicator);
gtk_main ();
g_object_unref (agent);
g_object_unref (indicator);
g_object_unref (menu_shell);
if (syslog_initialized)
closelog ();
return EXIT_SUCCESS;
}
void UnityIndicator::init()
{
GtkWidget *menu = gtk_menu_new();
GtkWidget *options = gtk_menu_item_new_with_label(qPrintable(tr("Settings")));
GtkWidget *reload = gtk_menu_item_new_with_label(qPrintable(tr("Refresh database")));
GtkWidget *backup = gtk_menu_item_new_with_label(qPrintable(tr("Backup Manager")));
GtkWidget *separator1 = gtk_separator_menu_item_new();
GtkWidget *about = gtk_menu_item_new_with_label(qPrintable(tr("About QCMA")));
GtkWidget *about_qt = gtk_menu_item_new_with_label(qPrintable(tr("About Qt")));
GtkWidget *separator2 = gtk_separator_menu_item_new();
GtkWidget *quit = gtk_menu_item_new_with_label(qPrintable(tr("Quit")));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), options);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), reload);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), backup);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), separator1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), about);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), about_qt);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), separator2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit);
gulong handle;
handle = g_signal_connect(options, "activate", G_CALLBACK(optionsIndicator), this);
m_handlers.append(QPair<gpointer, gulong>(options, handle));
handle = g_signal_connect(reload, "activate", G_CALLBACK(reloadIndicator), this);
m_handlers.append(QPair<gpointer, gulong>(reload, handle));
handle = g_signal_connect(backup, "activate", G_CALLBACK(backupIndicator), this);
m_handlers.append(QPair<gpointer, gulong>(backup, handle));
handle = g_signal_connect(about, "activate", G_CALLBACK(aboutIndicator), this);
m_handlers.append(QPair<gpointer, gulong>(about, handle));
handle = g_signal_connect(about_qt, "activate", G_CALLBACK(aboutQtIndicator), this);
m_handlers.append(QPair<gpointer, gulong>(about_qt, handle));
handle = g_signal_connect(quit, "activate", G_CALLBACK(quitIndicator), this);
m_handlers.append(QPair<gpointer, gulong>(quit, handle));
gtk_widget_show(options);
gtk_widget_show(reload);
gtk_widget_show(backup);
gtk_widget_show(separator1);
gtk_widget_show(about);
gtk_widget_show(about_qt);
gtk_widget_show(separator2);
gtk_widget_show(quit);
m_indicator = app_indicator_new(
"qcma-appindicator",
"qcma-messages",
APP_INDICATOR_CATEGORY_APPLICATION_STATUS
);
QString icon_path;
QString icon_name = "share/icons/hicolor/64x64/actions/qcma_on.png";
if(QFile("/usr/" + icon_name).exists())
icon_path = QFileInfo("/usr/" + icon_name).absolutePath();
else if(QFile("/usr/local" + icon_name).exists())
icon_path = QFileInfo("/usr/" + icon_name).absolutePath();
if(!icon_path.isEmpty())
{
qDebug() << "Using " << icon_path << " as icon theme path";
app_indicator_set_icon_theme_path(m_indicator, qPrintable(icon_path));
}
else
qDebug() << "Cannot find qcma icons.";
app_indicator_set_status(m_indicator, APP_INDICATOR_STATUS_ACTIVE);
app_indicator_set_menu(m_indicator, GTK_MENU(menu));
}
int
main (int argc, char **argv)
{
GError *error = NULL;
gboolean is_no_daemon = FALSE;
gboolean is_debug = FALSE;
gboolean is_version = FALSE;
GOptionContext *context;
GOptionEntry entries[] = {
{"no-daemon", 0, 0, G_OPTION_ARG_NONE, &is_no_daemon, N_("Do not daemonize"), NULL},
{"debug", 0, 0, G_OPTION_ARG_NONE, &is_debug, N_("Log debugging message"), NULL},
{"version", 0, 0, G_OPTION_ARG_NONE, &is_version, N_("Version"), NULL},
{NULL}
};
context = g_option_context_new ("- indicator for Nimf");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error != NULL)
{
g_warning ("%s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, NIMF_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
if (is_debug)
g_setenv ("G_MESSAGES_DEBUG", "nimf", TRUE);
if (is_version)
{
g_print ("%s %s\n", argv[0], VERSION);
exit (EXIT_SUCCESS);
}
if (is_no_daemon == FALSE)
{
openlog (g_get_prgname (), LOG_PID | LOG_PERROR, LOG_DAEMON);
syslog_initialized = TRUE;
g_log_set_default_handler ((GLogFunc) nimf_log_default_handler, &is_debug);
if (daemon (0, 0) != 0)
{
g_critical ("Couldn't daemonize.");
return EXIT_FAILURE;
}
}
gtk_init (&argc, &argv);
AppIndicator *indicator;
GtkWidget *menu_shell;
GtkWidget *about_menu;
GtkWidget *exit_menu;
menu_shell = gtk_menu_new ();
indicator = app_indicator_new ("nimf-indicator", "input-keyboard",
APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE);
app_indicator_set_icon_full (indicator, "nimf-indicator", "Nimf");
app_indicator_set_menu (indicator, GTK_MENU (menu_shell));
agent = nimf_agent_new ();
g_signal_connect (agent, "engine-changed",
G_CALLBACK (on_engine_changed), indicator);
g_signal_connect (agent, "disconnected",
G_CALLBACK (on_disconnected), indicator);
/* menu */
gchar **engine_ids = nimf_agent_get_loaded_engine_ids (agent);
GtkWidget *engine_menu;
NimfEngineInfo *info;
guint i;
for (i = 0; i < g_strv_length (engine_ids); i++)
{
info = nimf_engine_get_info_by_id (engine_ids[i]);
engine_menu = gtk_menu_item_new_with_label (_(info->engine_name));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_shell), engine_menu);
g_signal_connect (engine_menu, "activate",
G_CALLBACK (on_engine_menu), engine_ids[i]);
g_slice_free (NimfEngineInfo, info);
}
about_menu = gtk_menu_item_new_with_label (_("About"));
exit_menu = gtk_menu_item_new_with_label (_("Exit"));
g_signal_connect (about_menu, "activate",
G_CALLBACK (on_about_menu), NULL);
g_signal_connect (exit_menu, "activate",
G_CALLBACK (on_exit_menu), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_shell), about_menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_shell), exit_menu);
gtk_widget_show_all (menu_shell);
gtk_main ();
g_object_unref (agent);
g_object_unref (indicator);
g_strfreev (engine_ids);
if (syslog_initialized)
closelog ();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
GApplication *app;
#ifdef HAVE_APP_INDICATOR
AppIndicator *indicator;
#else
GtkStatusIcon *statusicon;
#endif /* HAVE_APP_INDICATOR */
GtkWidget *menu;
GOptionContext *context;
GError *error = NULL;
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
g_type_init ();
/* Parse command-line options */
context = g_option_context_new (N_("- Bluetooth applet"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) {
g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"),
error->message, argv[0]);
g_error_free (error);
return 1;
}
if (option_debug == FALSE) {
GError *error = NULL;
app = g_application_new ("org.cinnamon.Bluetooth.applet",
G_APPLICATION_FLAGS_NONE);
if (!g_application_register (app, NULL, &error)) {
g_object_unref (app);
g_warning ("%s", error->message);
g_error_free (error);
return 1;
}
if (g_application_get_is_remote (app)) {
g_object_unref (app);
g_warning ("Applet is already running, exiting");
return 0;
}
} else {
app = NULL;
}
g_set_application_name(_("Bluetooth Applet"));
gtk_window_set_default_icon_name("bluetooth");
applet = g_object_new (BLUETOOTH_TYPE_APPLET, NULL);
g_signal_connect (G_OBJECT (applet), "notify::killswitch-state",
G_CALLBACK (killswitch_state_changed), NULL);
menu = create_popupmenu();
#ifdef HAVE_APP_INDICATOR
indicator = init_notification();
app_indicator_set_menu(indicator, GTK_MENU(menu));
app_indicator_set_title(indicator, _("Bluetooth"));
gsettings = g_settings_new (BLUETOOTH_INDICATOR_GSETTINGS_SCHEMA_ID);
g_signal_connect (gsettings, "changed::" GSETTINGS_VISIBLE_KEY,
G_CALLBACK(update_icon_visibility), NULL);
#else
statusicon = init_notification();
#endif /* HAVE_APP_INDICATOR */
g_signal_connect (G_OBJECT (applet), "devices-changed",
G_CALLBACK (update_device_list), NULL);
g_signal_connect (G_OBJECT (applet), "notify::discoverable",
G_CALLBACK (update_discoverability), NULL);
g_signal_connect (G_OBJECT (applet), "notify::show-full-menu",
G_CALLBACK (update_menu_items), NULL);
killswitch_state_changed ((GObject*) applet, NULL, NULL);
update_menu_items ((GObject*) applet, NULL, NULL);
update_discoverability ((GObject*) applet, NULL, NULL);
update_device_list (applet, NULL);
update_icon_visibility();
#ifndef HAVE_APP_INDICATOR
g_signal_connect(statusicon, "activate",
G_CALLBACK(activate_callback), menu);
g_signal_connect(statusicon, "popup-menu",
G_CALLBACK(popup_callback), menu);
#endif /* HAVE_APP_INDICATOR */
setup_agents(applet);
gtk_main();
gtk_widget_destroy(menu);
cleanup_notification();
g_object_unref(applet);
if (app != NULL)
g_object_unref (app);
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 ("- 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;
}
