static void
egg_status_icon_init (EggStatusIcon *status_icon)
{
status_icon->priv = g_new0 (EggStatusIconPrivate, 1);
status_icon->priv->image_type = GTK_IMAGE_EMPTY;
status_icon->priv->size = G_MAXINT;
status_icon->priv->tray_icon = GTK_WIDGET (egg_tray_icon_new (NULL));
gtk_widget_add_events (GTK_WIDGET (status_icon->priv->tray_icon),
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_signal_connect_swapped (status_icon->priv->tray_icon, "button-release-event",
G_CALLBACK (egg_status_icon_button_release), status_icon);
status_icon->priv->image = gtk_image_new ();
/* Center the icon */
gtk_misc_set_alignment (GTK_MISC (status_icon->priv->image), 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (status_icon->priv->tray_icon),
status_icon->priv->image);
g_signal_connect_swapped (status_icon->priv->image, "size-allocate",
G_CALLBACK (egg_status_icon_size_allocate), status_icon);
gtk_widget_show (status_icon->priv->image);
gtk_widget_show (status_icon->priv->tray_icon);
status_icon->priv->tooltips = gtk_tooltips_new ();
g_object_ref (status_icon->priv->tooltips);
gtk_object_sink (GTK_OBJECT (status_icon->priv->tooltips));
}
int
main(int argc, char *argv[])
{
GtkWidget *icon;
EggTrayIcon *tray;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
bind_textdomain_codeset(PACKAGE, "UTF-8");
uim_init();
gtk_init(&argc, &argv);
tray = egg_tray_icon_new("uim");
gtk_window_set_wmclass(GTK_WINDOW(tray), "ibus-ui-gtk", "ibus-ui-gtk");
icon = uim_toolbar_trayicon_new();
g_signal_connect(G_OBJECT(tray), "embedded", G_CALLBACK(embedded_cb), icon);
gtk_container_add(GTK_CONTAINER(tray), icon);
gtk_widget_show(GTK_WIDGET(tray));
gtk_main();
uim_quit();
return 0;
}
void *adm_new_systray(GdkPixbuf *pixbufA[],int nb , char *name)
{
flipflop=0;
systray_icon = GTK_WIDGET (egg_tray_icon_new ("Avidemux"));
nbListOfIcons=nb;
if(listOfIcons) ADM_dealloc(listOfIcons);
listOfIcons=NULL;
listOfIcons=ADM_alloc(sizeof( GdkPixbuf *)*nb);
memcpy(listOfIcons,pixbufA,sizeof(GdkPixbuf *)*nb);
img = gtk_image_new_from_pixbuf (listOfIcons[0]);
evbox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (systray_icon), evbox);
gtk_container_add (GTK_CONTAINER (evbox), img);
gtk_widget_show_all (systray_icon);
gtk_widget_realize (systray_icon);
gtk_widget_show (systray_icon);
systray_icon_tooltips = gtk_tooltips_new ();
gtk_tooltips_enable (systray_icon_tooltips);
gtk_tooltips_set_tip (systray_icon_tooltips, systray_icon, "avidemux", "");
return (void *)systray_icon;
}
void tray_init(GtkWidget * main_window) {
gdk_pixbuf_xlib_init (GDK_DISPLAY(), DefaultScreen (GDK_DISPLAY()));
/* local copy */
window = main_window;
gtk_window_get_position(GTK_WINDOW(window), &x_pos, &y_pos);
tray_create_menu();
busy_ani = tray_icon_load_animation ("busy.ani", TRUE);
ready_ani = tray_icon_load_animation("ready.ani", FALSE);
frame_basic = load_pixmap_as_pixbuf("trayicon/frame_basic.png");
if (frame_basic)
tray_icon = egg_tray_icon_new ("xqf", frame_basic);
if (tray_icon && tray_icon->ready) {
g_signal_connect(tray_icon, "button_press_event", G_CALLBACK(tray_icon_pressed),tray_icon);
gtk_widget_hide(window);
}
else
gtk_widget_show(window);
}
void DockLet::Create(DockLetIconType iconType)
{
docklet = egg_tray_icon_new("StarDict");
box = gtk_event_box_new();
if (iconType == DOCKLET_NORMAL_ICON) {
gtk_tooltips_set_tip(gpAppFrame->tooltips, box,_("StarDict"),NULL);
image = gtk_image_new_from_pixbuf(gpAppFrame->oAppSkin.docklet_normal_icon.get());
} else if (iconType == DOCKLET_SCAN_ICON) {
gtk_tooltips_set_tip(gpAppFrame->tooltips, box,_("StarDict - Scanning"),NULL);
image = gtk_image_new_from_pixbuf(gpAppFrame->oAppSkin.docklet_scan_icon.get());
} else {
gtk_tooltips_set_tip(gpAppFrame->tooltips, box,_("StarDict - Stopped"),NULL);
image = gtk_image_new_from_pixbuf(gpAppFrame->oAppSkin.docklet_stop_icon.get());
}
current_icon = iconType;
g_signal_connect(G_OBJECT(docklet), "embedded", G_CALLBACK(EmbeddedCallback), NULL);
g_signal_connect(G_OBJECT(docklet), "destroy", G_CALLBACK(DestroyedCallback), this);
g_signal_connect(G_OBJECT(box), "button-press-event", G_CALLBACK(ButtonPressCallback), this);
gtk_container_add(GTK_CONTAINER(box), image);
gtk_container_add(GTK_CONTAINER(docklet), box);
gtk_widget_show_all(GTK_WIDGET(docklet));
/* ref the docklet before we bandy it about the place */
g_object_ref(G_OBJECT(docklet));
}
void create_tray_icon(struct _tray_icon *tray, gboolean runned)
{
gchar *hint;
char *image_file;
if (runned == TRUE)
{
hint = _("X Neural Switcher RUNNED");
image_file = "gxneur-run.png";
}
else
{
hint = _("X Neural Switcher STOPPED");
image_file = "gxneur-stop.png";
}
if (tray != NULL)
{
gtk_object_destroy (GTK_OBJECT (tray->tooltip));
tray->tooltip = NULL;
gtk_widget_destroy (GTK_WIDGET (tray->popup_menu));
tray->popup_menu = NULL;
gtk_widget_destroy (GTK_WIDGET (tray->image));
tray->image = NULL;
gtk_widget_destroy (GTK_WIDGET (tray->evbox));
tray->evbox = NULL;
}
else
{
tray = g_new0(struct _tray_icon, 1);
tray->clock = egg_clock_new();
g_signal_connect (G_OBJECT(tray->clock), "time-changed", G_CALLBACK (clock_check_xneur), tray);
tray->eggtray = egg_tray_icon_new(_("X Neural Switcher"));
g_signal_connect(G_OBJECT(tray->eggtray), "button_press_event", G_CALLBACK(tray_icon_press), tray);
g_signal_connect(G_OBJECT(tray->eggtray), "button_release_event", G_CALLBACK(tray_icon_release), tray);
}
tray->tooltip = gtk_tooltips_new();
tray->popup_menu = create_menu_icon(tray);
tray->evbox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(tray->evbox), 0);
gtk_widget_set_size_request(tray->evbox, 25, 20);
gtk_tooltips_set_tip(tray->tooltip, GTK_WIDGET(tray->eggtray), hint, NULL);
tray->image = create_pixmap(tray->evbox, image_file);
gtk_container_add(GTK_CONTAINER(tray->evbox), tray->image);
gtk_container_add(GTK_CONTAINER(tray->eggtray), tray->evbox);
gtk_widget_show_all (GTK_WIDGET (tray->eggtray));
return;
}
void *
tray_icon_new_from_data (const char *name, const char *data, unsigned long size)
{
TrayIcon *ticon;
GdkPixbufLoader *loader;
GdkPixbufAnimation *animation;
gboolean rc;
ticon = malloc (sizeof (TrayIcon));
if (__running)
gtk_main_quit();
pthread_mutex_lock(&mutex);
ticon->icon = egg_tray_icon_new ((const gchar *) name);
ticon->eventbox = gtk_event_box_new ();
g_signal_connect (ticon->eventbox, "button_press_event",
G_CALLBACK (tray_icon_pressed), ticon);
gtk_container_add (GTK_CONTAINER (ticon->icon), ticon->eventbox);
// tray icon image
loader=gdk_pixbuf_loader_new();
rc = gdk_pixbuf_loader_write (loader, (const guchar *)data, (gsize) size,NULL);
gdk_pixbuf_loader_close (loader,NULL);
if(rc)
{
// get animation
animation=gdk_pixbuf_loader_get_animation(loader);
ticon->image = gtk_image_new_from_animation (animation);
}
gtk_container_add (GTK_CONTAINER (ticon->eventbox), ticon->image);
gtk_widget_show_all (GTK_WIDGET (ticon->icon));
pthread_mutex_unlock(&mutex);
if (__running)
pthread_cond_signal(&cond);
return (void *) ticon;
}
static void
dock_build ()
{
GtkWidget *image;
GtkWidget *eventbox;
dock = egg_tray_icon_new ("Pornview");
eventbox = gtk_event_box_new ();
image = pixbuf_create_pixmap_from_xpm_data (dock_xpm);
GTK_WIDGET_SET_FLAGS (image, GTK_NO_WINDOW);
image->requisition.width = 22;
image->requisition.height = 22;
gtk_widget_set_events (GTK_WIDGET (eventbox),
gtk_widget_get_events (eventbox) |
GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);
gtk_signal_connect (GTK_OBJECT (eventbox), "button_press_event",
GTK_SIGNAL_FUNC (cb_dock_clicked), NULL);
gtk_widget_show (eventbox);
/*
* add the status to the plug
*/
gtk_object_set_data (GTK_OBJECT (dock), "pixmapg", image);
gtk_container_add (GTK_CONTAINER (eventbox), image);
gtk_container_add (GTK_CONTAINER (dock), eventbox);
gtk_widget_show_all (GTK_WIDGET (dock));
/*
* add the popup menu
*/
popup_item_factory =
gtk_item_factory_new (GTK_TYPE_MENU, "<popup>", NULL);
#ifdef ENABLE_NLS
gtk_item_factory_set_translate_func (popup_item_factory,
(GtkTranslateFunc) gettext, NULL,
NULL);
#endif
gtk_item_factory_create_items (popup_item_factory,
dock_popupmenu_factory_count,
dock_popupmenu_factory, NULL);
popup_menu = gtk_item_factory_get_widget (popup_item_factory, "<popup>");
}
int main(int argc,char **argv)
{
Vnkb *vnkb;
VnkbDocklet *docklet = g_new0(VnkbDocklet,1);
vnkb = g_new0(Vnkb,1);
vnkb->panel = docklet;
gtk_init(&argc,&argv);
vnkb->update_charset = vnkb_docklet_update_charset;
vnkb->update_method = vnkb_docklet_update_method;
vnkb->update_enabled = vnkb_docklet_update_enabled;
vnkb->update_spelling = vnkb_docklet_update_spelling;
vnkb->driver_changed = vnkb_docklet_driver_changed;
docklet->docklet = egg_tray_icon_new("Gaim");
docklet->actions = gtk_action_group_new("MenuActions");
gtk_action_group_set_translation_domain(docklet->actions,GETTEXT_PACKAGE);
gtk_action_group_add_actions(docklet->actions,entries,G_N_ELEMENTS(entries),vnkb);
gtk_action_group_add_radio_actions(docklet->actions,im_entries,G_N_ELEMENTS(im_entries),0,G_CALLBACK(im_change_cb),vnkb);
gtk_action_group_add_radio_actions(docklet->actions,cs_entries,G_N_ELEMENTS(cs_entries),0,G_CALLBACK(cs_change_cb),vnkb);
gtk_action_group_add_toggle_actions(docklet->actions,toggle_entries,G_N_ELEMENTS(toggle_entries),vnkb);
docklet->uim = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(docklet->uim,docklet->actions,0);
gtk_ui_manager_add_ui_from_string(docklet->uim,xml,-1,NULL);
docklet->menu = gtk_ui_manager_get_widget(docklet->uim,"/MainMenu");
vnkb_init(vnkb,GTK_WIDGET(docklet->docklet));
g_signal_connect(G_OBJECT(vnkb->button),
"button-press-event",
G_CALLBACK(button_press_hack),
vnkb);
//signal_connect(G_OBJECT(vnkb->button),"popup-menu",G_CALLBACK(button_popup_cb),NULL);
//g_signal_connect(G_OBJECT(docklet), "embedded", G_CALLBACK(docklet_x11_embedded_cb), NULL);
//g_signal_connect(G_OBJECT(docklet), "destroy", G_CALLBACK(docklet_x11_destroyed_cb), NULL);
//g_signal_connect(G_OBJECT(box), "button-press-event", G_CALLBACK(docklet_x11_clicked_cb), NULL);
/* ref the docklet before we bandy it about the place */
g_object_ref(G_OBJECT(docklet->docklet));
gtk_main();
return 0;
}
void
mn_notify_init(void)
{
GtkWidget *eventbox;
GtkWidget *tray_icon_image;
GtkWidget *tray_icon;
GtkTooltips *tray_icon_tooltip;
gchar *tmp;
tray_icon = GTK_WIDGET(egg_tray_icon_new("Test"));
gtk_widget_set_usize(tray_icon, 22, 22);
gtk_widget_realize(tray_icon);
tmp = g_strdup_printf("%s/mononoke.jpg", mn.env.icons_dir);
tray_icon_image =
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file_at_size
(tmp, 20, 20, NULL));
g_free(tmp);
eventbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eventbox), tray_icon_image);
gtk_container_add(GTK_CONTAINER(tray_icon), eventbox);
g_signal_connect(G_OBJECT(eventbox), "button_press_event",
G_CALLBACK(mn_tray_clicked), NULL);
g_signal_connect(GTK_OBJECT(tray_icon), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed), &tray_icon);
g_signal_connect(G_OBJECT(tray_icon), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed), NULL);
//finalize
gtk_widget_show(GTK_WIDGET(tray_icon));
gtk_widget_show(eventbox);
gtk_widget_show(GTK_WIDGET(tray_icon_image));
//tooltip
tray_icon_tooltip = gtk_tooltips_new();
gtk_tooltips_set_tip(tray_icon_tooltip, GTK_WIDGET(tray_icon),
"Mononoke Notify", NULL);
gtk_tooltips_set_delay(tray_icon_tooltip, 1000);
}
wxTaskBarIconAreaBase::wxTaskBarIconAreaBase()
{
if (IsProtocolSupported())
{
m_widget = GTK_WIDGET(egg_tray_icon_new("systray icon"));
gtk_window_set_resizable(GTK_WINDOW(m_widget), false);
wxLogTrace(_T("systray"), _T("using freedesktop.org systray spec"));
}
wxTopLevelWindow::Create(
NULL, wxID_ANY, _T("systray icon"),
wxDefaultPosition, wxDefaultSize,
wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR | wxSIMPLE_BORDER |
wxFRAME_SHAPED,
wxEmptyString /*eggtray doesn't like setting wmclass*/);
m_invokingWindow = NULL;
}
void dock_create()
{
GtkWidget *eb; /* wrzucamy tu pixmape, zeby reagowala na
eventy takie jake klikniecie */
dock_widget = GTK_WIDGET(egg_tray_icon_new("glen"));
create_menu();
eb = gtk_event_box_new();
image = gtk_image_new();
gtk_container_add(GTK_CONTAINER(eb), image);
gtk_container_add(GTK_CONTAINER(dock_widget), eb);
gtk_widget_show_all(dock_widget);
g_signal_connect(G_OBJECT(dock_widget), "button_press_event",
G_CALLBACK(clicked_cb), NULL);
tips = gtk_tooltips_new();
dock_set_status(TLEN_PRESENCE_UNAVAILABLE, NULL);
}
void PortableTrayIcon::Show()
{
#ifdef _WIN32
m_tray.SetIcon(LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(APP_ICON_ID)));
m_tray.Show();
#else
m_tray_icon = egg_tray_icon_new ("NoteCase");
m_tips = gtk_tooltips_new ();
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)¬ecase_xpm);
GdkPixbuf *destpix = gdk_pixbuf_scale_simple(pixbuf, 16, 16, GDK_INTERP_BILINEAR);
GtkWidget *icon = gtk_image_new_from_pixbuf(destpix);
GtkWidget *box = gtk_event_box_new ();
g_object_unref (G_OBJECT (pixbuf)); //TOFIX???
g_object_unref (G_OBJECT (destpix));
gtk_container_add (GTK_CONTAINER (box), icon);
gtk_container_add (GTK_CONTAINER (m_tray_icon), box);
gtk_widget_show_all (GTK_WIDGET (m_tray_icon));
g_signal_connect (G_OBJECT (box), "button-press-event", G_CALLBACK (clicked), NULL);
#endif
}
int main(int argc, char** argv){
GdkPixbuf* pixbuf;
GtkWidget* box, *image;
EggTrayIcon* tray_icon;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
gtk_set_locale();
gtk_init(&argc, &argv);
add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
mainWindow = create_mainWindow();
initTimes();
tray_icon = egg_tray_icon_new("prayertimes");
box = gtk_event_box_new();
image = gtk_image_new();
g_signal_connect(box, "button-press-event",
G_CALLBACK(icon_clicked_cb), NULL);
gtk_container_add(GTK_CONTAINER(box), image);
gtk_container_add(GTK_CONTAINER(tray_icon), box);
gtk_widget_show_all(GTK_WIDGET(tray_icon));
g_object_ref(tray_icon);
pixbuf = create_pixbuf(TRAYICON_IMAGE);
gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
g_object_unref(pixbuf);
gtk_widget_show(mainWindow);
gtk_main();
return 0;
}
void *
tray_icon_new (const char *name, const char *image)
{
TrayIcon *ticon;
ticon = malloc (sizeof (TrayIcon));
if (__running)
gtk_main_quit();
pthread_mutex_lock(&mutex);
ticon->icon = egg_tray_icon_new ((const gchar *) name);
ticon->eventbox = gtk_event_box_new ();
g_signal_connect (ticon->eventbox, "button_press_event",
G_CALLBACK (tray_icon_pressed), ticon);
gtk_container_add (GTK_CONTAINER (ticon->icon), ticon->eventbox);
// tray icon image
ticon->image = gtk_image_new_from_file ((const gchar *) image);
gtk_container_add (GTK_CONTAINER (ticon->eventbox), ticon->image);
gtk_widget_show_all (GTK_WIDGET (ticon->icon));
pthread_mutex_unlock(&mutex);
if (__running)
pthread_cond_signal(&cond);
return (void *) ticon;
}
gboolean create_tray(gpointer data)
{
if (da)
return FALSE;
destroy_other_tray();
egg_tray_icon = egg_tray_icon_new ("hime");
if (!egg_tray_icon)
return FALSE;
GtkWidget *event_box = gtk_event_box_new ();
// Do not use this, otherwise tray menu fails
// gtk_event_box_set_visible_window (event_box, FALSE);
gtk_container_add (GTK_CONTAINER (egg_tray_icon), event_box);
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text (event_box, _("左:中英切換 中:小鍵盤 右:選項"));
#else
GtkTooltips *tips = gtk_tooltips_new ();
gtk_tooltips_set_tip (GTK_TOOLTIPS (tips), event_box, _("左:中英切換 中:小鍵盤 右:選項"), NULL);
#endif
g_signal_connect (G_OBJECT (event_box), "button-press-event",
G_CALLBACK (tray_button_press_event_cb), NULL);
GError *err = NULL;
if (pixbuf)
g_object_unref(pixbuf);
char icon_fname[128];
get_icon_path(HIME_TRAY_PNG, icon_fname);
pixbuf = gdk_pixbuf_new_from_file(icon_fname, &err);
int pwidth = gdk_pixbuf_get_width (pixbuf);
int pheight = gdk_pixbuf_get_height (pixbuf);
da = gtk_drawing_area_new();
g_signal_connect (G_OBJECT (event_box), "destroy",
G_CALLBACK (gtk_widget_destroyed), &da);
#if !GTK_CHECK_VERSION(2,91,0)
g_signal_connect(G_OBJECT(da), "expose-event", G_CALLBACK(cb_expose), NULL);
#else
g_signal_connect(G_OBJECT(da), "draw", G_CALLBACK(cb_expose), NULL);
#endif
gtk_container_add (GTK_CONTAINER (event_box), da);
gtk_widget_set_size_request(GTK_WIDGET(egg_tray_icon), pwidth, pheight);
gtk_widget_show_all (GTK_WIDGET (egg_tray_icon));
tray_da_win = gtk_widget_get_window(da);
// tray window is not ready ??
if (!tray_da_win || !GTK_WIDGET_DRAWABLE(da)) {
gtk_widget_destroy(GTK_WIDGET(egg_tray_icon));
da = NULL;
return FALSE;
}
PangoContext *context=gtk_widget_get_pango_context(da);
PangoFontDescription* desc=pango_context_get_font_description(context);
// dbg("zz %s %d\n", pango_font_description_to_string(desc), PANGO_SCALE);
pango = gtk_widget_create_pango_layout(da, NULL);
pango_layout_set_font_description(pango, desc);
#if 1
// strange bug, why do we need this ?
desc = (PangoFontDescription *)pango_layout_get_font_description(pango);
#endif
pango_font_description_set_size(desc, 9 * PANGO_SCALE);
#if 0
dbg("aa %s\n", pango_font_description_to_string(desc));
dbg("context %x %x\n", pango_layout_get_context(pango), context);
dbg("font %x %x\n",pango_layout_get_font_description(pango), desc);
#endif
#if !GTK_CHECK_VERSION(2,90,6)
gc = gdk_gc_new (tray_da_win);
#endif
return FALSE;
}
bool loop(int argc, char** argv) {
char home[256]; //NEED TO MAKE THIS DYNAMIC
strcpy(home, getenv("HOME"));
//parse the config file
settings.parse_config(strcat(home, config_file));
//load the controls into list
ElementList list(settings.card);
list_ptr = &list;
//reorder the controls to the order specified in the config file
settings.reorder_list(&list);
//set the scale
list.set_scale((Element::scale_t)settings.scaling);
//set the auto_mute
list.set_auto_mute(settings.auto_mute);
//initialize gtk
gtk_init(&argc, &argv);
//set up the tray_slider that goes in the tray
if (settings.enable_tray_icon){
GtkWidget *tray_frame;
tray_frame = gtk_alignment_new(0.5,0.0,0,0);
settings.tray_slider = new retro_slider;
settings.set_tray_slider(&list);
settings.apply_to_tray_slider(settings.tray_slider);
if (list.num_elems > 0){
settings.tray_slider->init(tray_frame, (void*)settings.tray_control, &Element::get_callback, &Element::set_callback, (settings.tray_control->values > 1));
} else {
settings.tray_control = NULL;
}
//set up the small window that holds the tray_slider
settings.slider_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_resizable(GTK_WINDOW(settings.slider_window), false);
gtk_window_set_decorated(GTK_WINDOW(settings.slider_window), false);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(settings.slider_window), true);
gtk_window_set_skip_pager_hint(GTK_WINDOW(settings.slider_window), true);
gtk_widget_set_usize(settings.slider_window, settings.tray_slider->width, settings.tray_slider->height);
//don't want accidental closure of the slider window to destroy the window
g_signal_connect(settings.slider_window, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
//want the widow to go away when it loses focus
g_signal_connect(settings.slider_window, "focus-out-event", G_CALLBACK (gtk_widget_hide), NULL);
gtk_container_add( GTK_CONTAINER(settings.slider_window), tray_frame );
//we want it hidden by default, but it must be shown at least once or else scrolling over the icon will cause a hang
gtk_widget_show_all(settings.slider_window);
gtk_widget_hide_all(settings.slider_window);
//set up tray icon
#if GTK_CHECK_VERSION(2,16,0)
settings.tray_icon = gtk_status_icon_new();
gtk_status_icon_set_from_file(settings.tray_icon, VOL_MUTED_IMAGE);
#else
settings.tray_icon = GTK_WIDGET(egg_tray_icon_new("Retrovol Tray Icon"));
//set the background color
bool enable_tray_icon_background_color = settings.enable_tray_icon_background_color;
GdkColor bg_color;
char bg_color_str[8];
if (cmdline_enable_bg_color){
enable_tray_icon_background_color = true;
strcpy(bg_color_str, cmdline_bg_color);
} else if (settings.enable_tray_icon_background_color){
settings.nftoh(settings.tray_icon_background_color, bg_color_str);
}
if (enable_tray_icon_background_color){
if (gdk_color_parse(bg_color_str, &bg_color)){
GtkStyle *style = gtk_style_copy(gtk_widget_get_style(settings.tray_icon));
style->bg[GTK_STATE_NORMAL] = bg_color;
gtk_widget_set_style(settings.tray_icon, style);
} else {
fprintf(stderr, _("Error: Failed to set background color to %s\n"), bg_color_str);
}
}
//set up the images
settings.tray_icon_image = gtk_image_new();
gtk_container_add( GTK_CONTAINER(settings.tray_icon), settings.tray_icon_image );
gtk_image_set_from_file(GTK_IMAGE(settings.tray_icon_image), VOL_MEDIUM_IMAGE);
//set the event mask
gtk_widget_set_events (settings.tray_icon, GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK);
#endif
//signals
g_signal_connect(G_OBJECT(settings.tray_icon), "button_press_event", G_CALLBACK (&tray_button_press_event_callback), settings.slider_window);
if (settings.tray_control){
g_signal_connect(G_OBJECT(settings.tray_icon), "scroll_event", G_CALLBACK (&retro_slider::scroll_event_callback), settings.tray_slider);
}
#if GTK_CHECK_VERSION(2,16,0)
//make icon visible
gtk_status_icon_set_visible(settings.tray_icon, true);
#else
//handle situations where the icon's window dies, such as due to the tray itself exiting
g_signal_connect(G_OBJECT(settings.tray_icon), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
//make icon visible
gtk_widget_show_all(settings.tray_icon);
#endif
//set up the popup menu (the function checks if it should actually do anything)
set_menu();
}
//set up the window
settings.main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//gtk_window_set_position(GTK_WINDOW(settings.main_window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(settings.main_window), settings.window_width, settings.window_height);
gtk_window_set_title(GTK_WINDOW(settings.main_window), "Retrovol");
restore_posdim();
g_signal_connect(settings.main_window, "configure-event", G_CALLBACK (save_posdim), NULL);
//if the tray icon is enabled, we want the window to hide rather than closing
if (settings.enable_tray_icon){
g_signal_connect(settings.main_window, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
}
//make the over_box, which will hold stuff like the menu, status bar, and the actual content in the middle
GtkWidget *over_box;
over_box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(settings.main_window), over_box);
//define the menu
GtkItemFactoryEntry menu_items_1[] = {
{ (gchar*)_("/_File"), NULL, NULL, 0, (gchar*)"<Branch>" },
{ (gchar*)_("/File/_Configure"), (gchar*)"<CTRL>C", G_CALLBACK(configure), 0, (gchar*)"<StockItem>", GTK_STOCK_EXECUTE },
{ (gchar*)_("/File/_Quit"), (gchar*)"<CTRL>Q", G_CALLBACK(close_window), 0, (gchar*)"<StockItem>", GTK_STOCK_QUIT },
};
gint nmenu_items_1 = sizeof (menu_items_1) / sizeof (menu_items_1[0]);
GtkItemFactoryEntry menu_items_2[] = {
{ (gchar*)_("/_File"), NULL, NULL, 0, (gchar*)"<Branch>" },
{ (gchar*)_("/File/_Configure"), (gchar*)"<CTRL>C", G_CALLBACK(configure), 0, (gchar*)"<StockItem>", GTK_STOCK_EXECUTE },
{ (gchar*)_("/File/_Exit completely"), (gchar*)"<CTRL>E", G_CALLBACK(gtk_main_quit), 0, (gchar*)"<StockItem>", GTK_STOCK_QUIT },
{ (gchar*)_("/File/_Quit"), (gchar*)"<CTRL>Q", G_CALLBACK(close_window), 0, (gchar*)"<StockItem>", GTK_STOCK_QUIT },
};
gint nmenu_items_2 = sizeof (menu_items_2) / sizeof (menu_items_2[0]);
GtkItemFactoryEntry *menu_items;
gint nmenu_items;
//if the tray menu is enabled, don't have the "Exit" entry in the main menu
if (settings.enable_tray_menu){
menu_items = menu_items_1;
nmenu_items = nmenu_items_1;
} else {
menu_items = menu_items_2;
nmenu_items = nmenu_items_2;
}
//build the menu
GtkWidget *menubar;
menubar = get_menubar_menu(settings.main_window, menu_items, nmenu_items, "<RetrovolMain>");
gtk_box_pack_start(GTK_BOX(over_box), menubar, FALSE, TRUE, 0);
//use a scrolled window
GtkWidget *scrolled_window;
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(over_box), scrolled_window);
//put the stuff into a viewport manually, so we can specify that it should have no shadow
GtkWidget *viewport;
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scrolled_window), viewport);
//and create an Hbox to hold all the stuff
GtkWidget *hbox;
if (settings.vertical){
hbox = gtk_hbox_new(TRUE, 2);
gtk_container_add(GTK_CONTAINER(viewport), hbox);
} else {
hbox = gtk_vbox_new(TRUE, 2);
gtk_container_add(GTK_CONTAINER(viewport), hbox);
}
//add the sliders
retro_slider *sliders = new retro_slider[list.num_items];
for(int i=0; i<list.num_items; i++){
//use a vbox w/ slider on top and label on bottom
GtkWidget *vbox;
if (settings.vertical){
vbox = gtk_vbox_new(FALSE, 2);
} else {
vbox = gtk_hbox_new(FALSE, 2);
}
gtk_box_pack_start(GTK_BOX(hbox), vbox, false, false, 0);
if (strcmp(list.items[i]->type, "INTEGER") == 0){
//integers need sliders
//the rslider pseudo-widget likes to be inside a container, lets use a GtkAlignment
GtkWidget *frame;
if (settings.vertical){
frame = gtk_alignment_new(0.5,0.0,0,0);
gtk_box_pack_start(GTK_BOX(vbox), frame, false, false, 0);
} else {
frame = gtk_alignment_new(0.0,0.5,0,0);
gtk_box_pack_end(GTK_BOX(vbox), frame, false, false, 0);
}
//make the slider and associate with a control
settings.apply_to_slider(&sliders[i]);
sliders[i].init(frame, (void*)list.items[i], &Element::get_callback, &Element::set_callback, (list.items[i]->values > 1));
} else if (strcmp(list.items[i]->type, "BOOLEAN") == 0){
//booleans need checkboxes
GtkWidget *alignment;
if (settings.vertical){
alignment = gtk_alignment_new(0.5,1.0,0,0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0);
} else {
alignment = gtk_alignment_new(1.0,0.5,0,0);
gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0);
}
GtkWidget *chkbx;
chkbx = gtk_check_button_new();
//set it to the current state
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chkbx), (bool)list.items[i]->get());
//bind to the toggle_checkbox function
Element* ptr = list.items[i];
g_signal_connect(GTK_TOGGLE_BUTTON(chkbx), "toggled", G_CALLBACK (toggle_checkbox), ptr);
g_signal_connect_after(GTK_TOGGLE_BUTTON(chkbx), "expose-event", G_CALLBACK (refresh_checkbox), ptr);
gtk_container_add(GTK_CONTAINER(alignment), chkbx);
} else if (strcmp(list.items[i]->type, "ENUMERATED") == 0){
GtkWidget *alignment;
if (settings.vertical){
alignment = gtk_alignment_new(0.5,0.5,0,0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0);
} else {
alignment = gtk_alignment_new(1.0,0.5,0,0);
gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0);
}
//insert a combobox with the different options
GtkWidget *combo_box;
combo_box=gtk_combo_box_new_text();
for(unsigned int n=0; n<list.items[i]->number_of_enums; n++){
gtk_combo_box_append_text(GTK_COMBO_BOX(combo_box), list.items[i]->enums[n]);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), list.items[i]->get());
//bind to the change_combo_box function
g_signal_connect(GTK_COMBO_BOX(combo_box), "changed", G_CALLBACK (change_combo_box), list.items[i]);
gtk_container_add(GTK_CONTAINER(alignment), combo_box);
}
//add a checkbox for sliders that are muteable
if (list.items[i]->switch_id >= 0){
GtkWidget *alignment;
if (settings.vertical){
alignment = gtk_alignment_new(0.5,1.0,0,0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, true, true, 0);
} else {
alignment = gtk_alignment_new(1.0,0.5,0,0);
gtk_box_pack_end(GTK_BOX(vbox), alignment, true, true, 0);
}
GtkWidget *chkbx;
chkbx = gtk_check_button_new();
//set it to the current state
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chkbx), (bool)list.elems[list.items[i]->switch_id].get());
//bind to the toggle_checkbox function
g_signal_connect(GTK_TOGGLE_BUTTON(chkbx), "toggled", G_CALLBACK (toggle_checkbox), &(list.elems[list.items[i]->switch_id]));
g_signal_connect_after(GTK_TOGGLE_BUTTON(chkbx), "expose-event", G_CALLBACK (refresh_checkbox), &(list.elems[list.items[i]->switch_id]));
gtk_container_add(GTK_CONTAINER(alignment), chkbx);
}
//display the name of the control
GtkWidget *alignment;
char wrapped[256];
if (settings.vertical){
alignment = gtk_alignment_new(0.5,1.0,0,0);
gtk_box_pack_end(GTK_BOX(vbox), alignment, false, false, 0);
word_wrap(wrapped, list.items[i]->short_name);
} else {
alignment = gtk_alignment_new(1.0,0.5,0,0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, false, false, 0);
strcpy(wrapped, list.items[i]->short_name);
}
GtkWidget *label;
label = gtk_label_new(wrapped);
gtk_container_add(GTK_CONTAINER(alignment), label);
}
//finish the window stuff
if (!start_hidden){ gtk_widget_show_all(settings.main_window); }
g_signal_connect(settings.main_window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
//add some periodic refreshment to keep the icon and window up-to-date
#if GTK_CHECK_VERSION(2,14,0)
int timeout = g_timeout_add_seconds(1, update, NULL);
#else
//this is less efficient than g_timeout_add_seconds()
int timeout = g_timeout_add(1000, update, NULL);
#endif
//finished with gtk setup
gtk_main();
//stop the timeout
g_source_remove(timeout);
//have the window shown again if it was open before we restarted
if (settings.resume_main){
settings.resume_main = false;
start_hidden = false;
} else {
start_hidden = true;
}
return(settings.restart);
}
void wxTaskBarIcon::Private::SetIcon()
{
#if GTK_CHECK_VERSION(2,10,0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,10,0) == NULL)
{
if (m_statusIcon)
gtk_status_icon_set_from_pixbuf(m_statusIcon, m_bitmap.GetPixbuf());
else
{
m_statusIcon = gtk_status_icon_new_from_pixbuf(m_bitmap.GetPixbuf());
g_signal_connect(m_statusIcon, "activate",
G_CALLBACK(icon_activate), m_taskBarIcon);
g_signal_connect(m_statusIcon, "popup_menu",
G_CALLBACK(status_icon_popup_menu), m_taskBarIcon);
}
}
else
#endif
{
#ifndef __WXGTK3__
m_size = 0;
if (m_eggTrayIcon)
{
GtkWidget* image = gtk_bin_get_child(GTK_BIN(m_eggTrayIcon));
gtk_image_set_from_pixbuf(GTK_IMAGE(image), m_bitmap.GetPixbuf());
}
else
{
m_eggTrayIcon = GTK_WIDGET(egg_tray_icon_new("wxTaskBarIcon"));
gtk_widget_add_events(m_eggTrayIcon, GDK_BUTTON_PRESS_MASK);
g_signal_connect(m_eggTrayIcon, "size_allocate",
G_CALLBACK(icon_size_allocate), this);
g_signal_connect(m_eggTrayIcon, "destroy",
G_CALLBACK(icon_destroy), this);
g_signal_connect(m_eggTrayIcon, "button_press_event",
G_CALLBACK(icon_button_press_event), m_taskBarIcon);
g_signal_connect(m_eggTrayIcon, "popup_menu",
G_CALLBACK(icon_popup_menu), m_taskBarIcon);
GtkWidget* image = gtk_image_new_from_pixbuf(m_bitmap.GetPixbuf());
gtk_container_add(GTK_CONTAINER(m_eggTrayIcon), image);
gtk_widget_show_all(m_eggTrayIcon);
}
#endif
}
#if wxUSE_TOOLTIPS
const char *tip_text = NULL;
if (!m_tipText.empty())
tip_text = m_tipText.utf8_str();
#if GTK_CHECK_VERSION(2,10,0)
if (m_statusIcon)
{
#if GTK_CHECK_VERSION(2,16,0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,16,0) == NULL)
gtk_status_icon_set_tooltip_text(m_statusIcon, tip_text);
else
#endif
{
#ifndef __WXGTK3__
gtk_status_icon_set_tooltip(m_statusIcon, tip_text);
#endif
}
}
else
#endif // GTK_CHECK_VERSION(2,10,0)
{
#ifndef __WXGTK3__
if (tip_text && m_tooltips == NULL)
{
m_tooltips = gtk_tooltips_new();
g_object_ref(m_tooltips);
gtk_object_sink(GTK_OBJECT(m_tooltips));
}
if (m_tooltips)
gtk_tooltips_set_tip(m_tooltips, m_eggTrayIcon, tip_text, "");
#endif
}
#endif // wxUSE_TOOLTIPS
}
