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 }