fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-02-03 23:00:28 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

2005-02-21 Dan Williams <dcbw@redhat.com>

Browse source 
* panel-applet/NMWirelessApplet.[ch]
	  panel-applet/menu-info.[ch]
		- Give the panel applet some major love: menu items are no longer
			subclasses of GtkCheckMenuItem, they are actual GtkCheckMenuItems.
			This allows the applet to actually reflect theme changes correctly,
			since themeing of subclassed items in GTK _sucks_.


git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@465 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Dan Williams 2005-02-22 00:29:15 +00:00
parent 0e81733c1d
commit 8eed3ac89b
5 changed files with 407 additions and 416 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
ChangeLog
View file

@ -1,3 +1,12 @@
2005-02-21 Dan Williams <dcbw@redhat.com>
* panel-applet/NMWirelessApplet.[ch]
panel-applet/menu-info.[ch]
- Give the panel applet some major love: menu items are no longer
subclasses of GtkCheckMenuItem, they are actual GtkCheckMenuItems.
This allows the applet to actually reflect theme changes correctly,
since themeing of subclassed items in GTK _sucks_.
2005-02-18 Dan Williams <dcbw@redhat.com>
* libnm_glib/libnm_glib.[ch]

330
panel-applet/NMWirelessApplet.c
View file

@ -66,10 +66,6 @@
#define GTK_STOCK_ABOUT GTK_STOCK_DIALOG_INFO
#endif
static GtkWidget * nmwa_populate_menu (NMWirelessApplet *applet);
static void nmwa_dispose_menu_items (NMWirelessApplet *applet);
static gboolean nmwa_toplevel_menu_button_press (GtkWidget *widget, GdkEventButton *event, gpointer user_data);
static GObject * nmwa_constructor (GType type, guint n_props, GObjectConstructParam *construct_props);
static void setup_stock (void);
static void nmwa_icons_init (NMWirelessApplet *applet);
@ -504,28 +500,6 @@ void show_warning_dialog (gboolean error, gchar *mesg, ...)
}
/*
* nmwa_destroy
*
* Destroy the applet and clean up its data
*
*/
static void nmwa_destroy (NMWirelessApplet *applet, gpointer user_data)
{
if (applet->menu)
nmwa_dispose_menu_items (applet);
if (applet->redraw_timeout_id > 0)
{
gtk_timeout_remove (applet->redraw_timeout_id);
applet->redraw_timeout_id = 0;
}
if (applet->gconf_client)
g_object_unref (G_OBJECT (applet->gconf_client));
}
/*
* nmwa_update_network_timestamp
*
@ -659,24 +633,6 @@ static void nmwa_menu_item_activate (GtkMenuItem *item, gpointer user_data)
}
/*
* nmwa_menu_show_cb
*
* Pop up the wireless networks menu in response to a click on the applet
*
*/
static void nmwa_menu_show_cb (GtkWidget *menu, NMWirelessApplet *applet)
{
if (!applet->tooltips)
applet->tooltips = gtk_tooltips_new ();
gtk_tooltips_set_tip (applet->tooltips, applet->event_box, NULL, NULL);
nmwa_dispose_menu_items (applet);
nmwa_populate_menu (applet);
gtk_widget_show (applet->menu);
}
/*
* nmwa_menu_add_separator_item
*
@ -725,22 +681,36 @@ static void nmwa_menu_add_device_item (GtkWidget *menu, NetworkDevice *device, g
if (device->type == DEVICE_TYPE_WIRED_ETHERNET)
{
menu_item = nm_menu_wired_new ();
nm_menu_wired_update (NM_MENU_WIRED (menu_item), device, n_devices);
NMWiredMenuItem *item = wired_menu_item_new ();
GtkCheckMenuItem *gtk_item;
gtk_item = wired_menu_item_get_check_item (item);
wired_menu_item_update (item, device, n_devices);
if (applet->active_device == device)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
gtk_check_menu_item_set_active (gtk_item, TRUE);
g_object_set_data (G_OBJECT (gtk_item), "device", g_strdup (device->nm_device));
g_object_set_data (G_OBJECT (gtk_item), "nm-item-data", item);
g_signal_connect(G_OBJECT (gtk_item), "activate", G_CALLBACK (nmwa_menu_item_activate), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), GTK_WIDGET (gtk_item));
gtk_widget_show (GTK_WIDGET (gtk_item));
}
else
{
menu_item = nm_menu_network_new ();
nm_menu_network_update (NM_MENU_NETWORK (menu_item), device, n_devices);
NMWirelessMenuItem *item = wireless_menu_item_new ();
GtkMenuItem *gtk_item;
gtk_item = wireless_menu_item_get_item (item);
wireless_menu_item_update (item, device, n_devices);
g_object_set_data (G_OBJECT (gtk_item), "device", g_strdup (device->nm_device));
g_object_set_data (G_OBJECT (gtk_item), "nm-item-data", item);
g_signal_connect(G_OBJECT (gtk_item), "activate", G_CALLBACK (nmwa_menu_item_activate), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), GTK_WIDGET (gtk_item));
gtk_widget_show (GTK_WIDGET (gtk_item));
}
g_object_set_data (G_OBJECT (menu_item), "device", g_strdup (device->nm_device));
g_signal_connect(G_OBJECT (menu_item), "activate", G_CALLBACK(nmwa_menu_item_activate), applet);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
}
@ -813,22 +783,26 @@ static void nmwa_menu_device_add_networks (GtkWidget *menu, NetworkDevice *dev,
/* Add all networks in our network list to the menu */
for (list = dev->networks; list; list = list->next)
{
GtkWidget *menu_item;
WirelessNetwork *net;
NMNetworkMenuItem *item;
GtkCheckMenuItem *gtk_item;
WirelessNetwork *net;
net = (WirelessNetwork *) list->data;
menu_item = nm_menu_wireless_new (applet->encryption_size_group);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
item = network_menu_item_new (applet->encryption_size_group);
gtk_item = network_menu_item_get_check_item (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), GTK_WIDGET (gtk_item));
if (applet->active_device == dev && net->active)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
nm_menu_wireless_update (NM_MENU_WIRELESS (menu_item), net, has_encrypted);
gtk_check_menu_item_set_active (gtk_item, TRUE);
network_menu_item_update (item, net, has_encrypted);
g_object_set_data (G_OBJECT (menu_item), "network", g_strdup (net->essid));
g_object_set_data (G_OBJECT (menu_item), "nm_device", g_strdup (dev->nm_device));
g_signal_connect(G_OBJECT (menu_item), "activate", G_CALLBACK (nmwa_menu_item_activate), applet);
g_object_set_data (G_OBJECT (gtk_item), "network", g_strdup (net->essid));
g_object_set_data (G_OBJECT (gtk_item), "nm_device", g_strdup (dev->nm_device));
g_object_set_data (G_OBJECT (gtk_item), "nm-item-data", item);
g_signal_connect(G_OBJECT (gtk_item), "activate", G_CALLBACK (nmwa_menu_item_activate), applet);
gtk_widget_show (menu_item);
gtk_widget_show (GTK_WIDGET (gtk_item));
}
}
@ -945,6 +919,21 @@ static void nmwa_menu_add_devices (GtkWidget *menu, NMWirelessApplet *applet)
}
static void nmwa_set_scanning_enabled_cb (GtkWidget *widget, NMWirelessApplet *applet)
{
g_return_if_fail (applet != NULL);
nmwa_dbus_enable_scanning (applet, !applet->scanning_enabled);
}
static void nmwa_set_wireless_enabled_cb (GtkWidget *widget, NMWirelessApplet *applet)
{
g_return_if_fail (applet != NULL);
nmwa_dbus_enable_scanning (applet, !applet->wireless_enabled);
}
/*
* nmwa_menu_item_data_free
*
@ -957,6 +946,7 @@ static void nmwa_menu_item_data_free (GtkWidget *menu_item, gpointer data)
GtkWidget *menu;
g_return_if_fail (menu_item != NULL);
g_return_if_fail (data != NULL);
menu = GTK_WIDGET(data);
@ -972,7 +962,13 @@ static void nmwa_menu_item_data_free (GtkWidget *menu_item, gpointer data)
g_free (tag);
}
gtk_container_remove(GTK_CONTAINER(menu), menu_item);
if ((tag = g_object_get_data (G_OBJECT (menu_item), "nm-item-data")))
{
g_object_set_data (G_OBJECT (menu_item), "nm-item-data", NULL);
g_free (tag);
}
gtk_widget_destroy (menu_item);
}
@ -982,51 +978,75 @@ static void nmwa_menu_item_data_free (GtkWidget *menu_item, gpointer data)
* Destroy the menu and each of its items data tags
*
*/
static void nmwa_dispose_menu_items (NMWirelessApplet *applet)
static void nmwa_dropdown_menu_clear (GtkWidget *menu)
{
g_return_if_fail (applet != NULL);
g_return_if_fail (menu != NULL);
/* Free the "network" data on each menu item */
gtk_container_foreach (GTK_CONTAINER (applet->menu), nmwa_menu_item_data_free, applet->menu);
/* Free the "network" data on each menu item, and destroy the item */
gtk_container_foreach (GTK_CONTAINER (menu), nmwa_menu_item_data_free, menu);
}
/*
* nmwa_populate_menu
* nmwa_dropdown_menu_populate
*
* Set up our networks menu from scratch
*
*/
static GtkWidget * nmwa_populate_menu (NMWirelessApplet *applet)
static void nmwa_dropdown_menu_populate (GtkWidget *menu, NMWirelessApplet *applet)
{
GtkWidget *menu = applet->menu;
g_return_val_if_fail (applet != NULL, NULL);
g_return_if_fail (menu != NULL);
g_return_if_fail (applet != NULL);
if (applet->applet_state == APPLET_STATE_NO_NM)
{
nmwa_menu_add_text_item (menu, _("NetworkManager is not running..."));
return NULL;
else
nmwa_menu_add_devices (menu, applet);
}
/*
* nmwa_dropdown_menu_show_cb
*
* Pop up the wireless networks menu
*
*/
static void nmwa_dropdown_menu_show_cb (GtkWidget *menu, NMWirelessApplet *applet)
{
g_return_if_fail (menu != NULL);
g_return_if_fail (applet != NULL);
if (!applet->tooltips)
applet->tooltips = gtk_tooltips_new ();
gtk_tooltips_set_tip (applet->tooltips, applet->event_box, NULL, NULL);
if (applet->dropdown_menu && (menu == applet->dropdown_menu))
{
nmwa_dropdown_menu_clear (applet->dropdown_menu);
nmwa_dropdown_menu_populate (applet->dropdown_menu, applet);
gtk_widget_show_all (applet->dropdown_menu);
}
nmwa_menu_add_devices (menu, applet);
return (menu);
}
static void nmwa_set_scanning_enabled_cb (GtkWidget *widget, NMWirelessApplet *applet)
/*
* nmwa_dropdown_menu_create
*
* Create the applet's dropdown menu
*
*/
static GtkWidget *nmwa_dropdown_menu_create (GtkMenuItem *parent, NMWirelessApplet *applet)
{
g_return_if_fail (applet != NULL);
GtkWidget *menu;
nmwa_dbus_enable_scanning (applet, !applet->scanning_enabled);
}
g_return_val_if_fail (parent != NULL, NULL);
g_return_val_if_fail (applet != NULL, NULL);
static void nmwa_set_wireless_enabled_cb (GtkWidget *widget, NMWirelessApplet *applet)
{
g_return_if_fail (applet != NULL);
menu = gtk_menu_new ();
gtk_container_set_border_width (GTK_CONTAINER (menu), 0);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (parent), menu);
g_signal_connect (menu, "show", G_CALLBACK (nmwa_dropdown_menu_show_cb), applet);
nmwa_dbus_enable_scanning (applet, !applet->wireless_enabled);
return menu;
}
@ -1134,53 +1154,32 @@ static GtkWidget *nmwa_context_menu_create (NMWirelessApplet *applet)
/*
* nmwa_setup_widgets
* nmwa_theme_change_cb
*
* Intialize the applet's widgets and packing, create the initial
* menu of networks.
* Destroy the popdown menu when the theme changes
*
*/
static void nmwa_setup_widgets (NMWirelessApplet *applet)
static void nmwa_theme_change_cb (NMWirelessApplet *applet)
{
GtkWidget *menu_bar;
GtkWidget *event_box;
g_return_if_fail (applet != NULL);
/* construct pixmap widget */
applet->pixmap = gtk_image_new ();
applet->event_box = gtk_event_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (applet->event_box), 0);
if (applet->dropdown_menu)
nmwa_dropdown_menu_clear (applet->dropdown_menu);
menu_bar = gtk_menu_bar_new ();
gtk_container_add (GTK_CONTAINER(applet->event_box), menu_bar);
applet->toplevel_menu = gtk_menu_item_new();
gtk_widget_set_name (applet->toplevel_menu, "ToplevelMenu");
gtk_container_set_border_width (GTK_CONTAINER (applet->toplevel_menu), 0);
gtk_container_add (GTK_CONTAINER(applet->toplevel_menu), applet->pixmap);
gtk_menu_shell_append (GTK_MENU_SHELL(menu_bar), applet->toplevel_menu);
applet->context_menu = nmwa_context_menu_create (applet);
g_signal_connect (applet->toplevel_menu, "button_press_event", G_CALLBACK (nmwa_toplevel_menu_button_press), applet);
applet->menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (applet->toplevel_menu), applet->menu);
g_signal_connect (applet->menu, "show", G_CALLBACK (nmwa_menu_show_cb), applet);
applet->encryption_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (applet), applet->event_box);
gtk_widget_show_all (GTK_WIDGET (applet));
if (applet->top_menu_item)
{
gtk_menu_item_remove_submenu (GTK_MENU_ITEM (applet->top_menu_item));
applet->dropdown_menu = nmwa_dropdown_menu_create (GTK_MENU_ITEM (applet->top_menu_item), applet);
}
}
/*
* nmwa_toplevel_menu_button_press
* nmwa_toplevel_menu_button_press_cb
*
* Handle right-clicks for the context popup menu
*
*/
static gboolean nmwa_toplevel_menu_button_press (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
static gboolean nmwa_toplevel_menu_button_press_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
NMWirelessApplet *applet = (NMWirelessApplet *)user_data;
@ -1199,6 +1198,70 @@ static gboolean nmwa_toplevel_menu_button_press (GtkWidget *widget, GdkEventButt
return (FALSE);
}
/*
* nmwa_setup_widgets
*
* Intialize the applet's widgets and packing, create the initial
* menu of networks.
*
*/
static void nmwa_setup_widgets (NMWirelessApplet *applet)
{
GtkWidget *menu_bar;
GtkWidget *event_box;
/* Event box for tooltips */
applet->event_box = gtk_event_box_new ();
gtk_container_set_border_width (GTK_CONTAINER (applet->event_box), 0);
menu_bar = gtk_menu_bar_new ();
applet->top_menu_item = gtk_menu_item_new();
gtk_widget_set_name (applet->top_menu_item, "ToplevelMenu");
gtk_container_set_border_width (GTK_CONTAINER (applet->top_menu_item), 0);
g_signal_connect (applet->top_menu_item, "button_press_event", G_CALLBACK (nmwa_toplevel_menu_button_press_cb), applet);
applet->dropdown_menu = nmwa_dropdown_menu_create (GTK_MENU_ITEM (applet->top_menu_item), applet);
applet->pixmap = gtk_image_new ();
/* Set up the widget structure and show the applet */
gtk_container_add (GTK_CONTAINER(applet->top_menu_item), applet->pixmap);
gtk_menu_shell_append (GTK_MENU_SHELL(menu_bar), applet->top_menu_item);
gtk_container_add (GTK_CONTAINER(applet->event_box), menu_bar);
gtk_container_add (GTK_CONTAINER (applet), applet->event_box);
gtk_widget_show_all (GTK_WIDGET (applet));
applet->context_menu = nmwa_context_menu_create (applet);
applet->encryption_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
}
/*
* nmwa_destroy
*
* Destroy the applet and clean up its data
*
*/
static void nmwa_destroy (NMWirelessApplet *applet, gpointer user_data)
{
if (applet->dropdown_menu)
nmwa_dropdown_menu_clear (applet->dropdown_menu);
if (applet->top_menu_item)
gtk_menu_item_remove_submenu (GTK_MENU_ITEM (applet->top_menu_item));
if (applet->redraw_timeout_id > 0)
{
gtk_timeout_remove (applet->redraw_timeout_id);
applet->redraw_timeout_id = 0;
}
if (applet->gconf_client)
g_object_unref (G_OBJECT (applet->gconf_client));
}
/*
* nmwa_get_instance
*
@ -1237,7 +1300,8 @@ static GtkWidget * nmwa_get_instance (NMWirelessApplet *applet)
/* Load pixmaps and create applet widgets */
nmwa_setup_widgets (applet);
g_signal_connect (applet,"destroy", G_CALLBACK (nmwa_destroy), NULL);
g_signal_connect (applet, "destroy", G_CALLBACK (nmwa_destroy), NULL);
g_signal_connect (applet, "style-set", G_CALLBACK (nmwa_theme_change_cb), NULL);
/* Start redraw timeout */
nmwa_start_redraw_timeout (applet);
@ -1283,16 +1347,16 @@ nmwa_icons_free (NMWirelessApplet *applet)
{
gint i;
g_object_unref (applet->no_nm_icon);
g_object_unref (applet->wired_icon);
g_object_unref (applet->adhoc_icon);
g_object_unref (applet->no_nm_icon);
g_object_unref (applet->wired_icon);
g_object_unref (applet->adhoc_icon);
for (i = 0; i < NUM_WIRED_CONNECTING_FRAMES; i++)
g_object_unref (applet->wired_connecting_icons[i]);
g_object_unref (applet->wireless_00_icon);
g_object_unref (applet->wireless_25_icon);
g_object_unref (applet->wireless_50_icon);
g_object_unref (applet->wireless_75_icon);
g_object_unref (applet->wireless_100_icon);
g_object_unref (applet->wireless_00_icon);
g_object_unref (applet->wireless_25_icon);
g_object_unref (applet->wireless_50_icon);
g_object_unref (applet->wireless_75_icon);
g_object_unref (applet->wireless_100_icon);
for (i = 0; i < NUM_WIRELESS_CONNECTING_FRAMES; i++)
g_object_unref (applet->wireless_connecting_icons[i]);
for (i = 0; i < NUM_WIRELESS_SCANNING_FRAMES; i++)

4
panel-applet/NMWirelessApplet.h
View file

@ -144,8 +144,8 @@ typedef struct
/* Direct UI elements */
GtkWidget *pixmap;
GtkWidget *menu;
GtkWidget *toplevel_menu;
GtkWidget *top_menu_item;
GtkWidget *dropdown_menu;
GtkWidget *event_box;
GtkSizeGroup *encryption_size_group;
GtkTooltips *tooltips;

400
panel-applet/menu-info.c
View file

@ -30,6 +30,7 @@
#include <config.h>
#endif
#include <stdio.h>
#include <glib/gi18n.h>
#include <string.h>
#include "menu-info.h"
@ -41,253 +42,225 @@
#include "NMWirelessAppletDbus.h"
static gboolean nm_menu_wired_expose_event (GtkWidget *widget, GdkEventExpose *event);
static gboolean nm_menu_wireless_expose_event (GtkWidget *widget, GdkEventExpose *event);
/****************************************************************
* Wired menu item
****************************************************************/
G_DEFINE_TYPE (NMMenuWired, nm_menu_wired, GTK_TYPE_CHECK_MENU_ITEM);
static void
nm_menu_wired_init (NMMenuWired *menu_wired)
struct NMWiredMenuItem
{
menu_wired->label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (menu_wired->label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (menu_wired), menu_wired->label);
gtk_widget_show (menu_wired->label);
GtkCheckMenuItem *check_item;
GtkLabel *label;
};
NMWiredMenuItem *wired_menu_item_new (void)
{
NMWiredMenuItem *item = g_malloc0 (sizeof (NMWiredMenuItem));
g_return_val_if_fail (item != NULL, NULL);
item->check_item = GTK_CHECK_MENU_ITEM (gtk_check_menu_item_new ());
item->label = GTK_LABEL (gtk_label_new (NULL));
gtk_misc_set_alignment (GTK_MISC (item->label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (item->check_item), GTK_WIDGET (item->label));
gtk_widget_show (GTK_WIDGET (item->label));
return item;
}
GtkCheckMenuItem *wired_menu_item_get_check_item (NMWiredMenuItem *item)
{
g_return_val_if_fail (item != NULL, NULL);
return item->check_item;
}
void wired_menu_item_update (NMWiredMenuItem *item, NetworkDevice *dev, const gint n_devices)
{
gchar *text;
gchar *dev_name;
g_return_if_fail (dev != NULL);
g_return_if_fail (item != NULL);
g_assert (dev->type == DEVICE_TYPE_WIRED_ETHERNET);
dev_name = dev->hal_name ? dev->hal_name : dev->nm_name;
if (n_devices > 1)
text = g_strdup_printf (_("Wired Network (%s)"), dev_name);
else
text = g_strdup (_("Wired Network"));
gtk_label_set_text (GTK_LABEL (item->label), text);
/* Only dim the item if the device supports carrier detection AND
* we know it doesn't have a link.
*/
if (dev->supports_carrier_detect == TRUE)
gtk_widget_set_sensitive (GTK_WIDGET (item->check_item), dev->link);
}
static void
nm_menu_wired_class_init (NMMenuWiredClass *klass)
/****************************************************************
* Wireless menu item
****************************************************************/
struct NMWirelessMenuItem
{
GTK_WIDGET_CLASS (klass)->expose_event = nm_menu_wired_expose_event;
}
GtkMenuItem *menu_item;
GtkLabel *label;
};
/* Bad hack */
static gboolean
nm_menu_wired_expose_event (GtkWidget *widget, GdkEventExpose *event)
static gboolean label_expose (GtkWidget *widget)
{
gboolean retval;
GtkStyle *old_style;
old_style = NM_MENU_WIRED (widget)->label->style;
NM_MENU_WIRED (widget)->label->style =
gtk_rc_get_style_by_paths (gtk_settings_get_default (),
"GtkWindow.GtkMenu.GtkMenuItem.GtkLabel",
"GtkWindow.GtkMenu.GtkMenuItem.GtkLabel",
GTK_TYPE_LABEL);
retval = GTK_WIDGET_CLASS (nm_menu_wired_parent_class)->expose_event (widget, event);
NM_MENU_WIRED (widget)->label->style = old_style;
return retval;
}
GtkWidget *
nm_menu_wired_new (void)
{
GtkWidget *retval = g_object_new (nm_menu_wired_get_type (), NULL);
return retval;
}
void
nm_menu_wired_update (NMMenuWired *menu_wired,
NetworkDevice *dev,
gint n_devices)
{
gchar *text;
gchar *dev_name;
g_assert (dev->type == DEVICE_TYPE_WIRED_ETHERNET);
dev_name = dev->hal_name ? dev->hal_name : dev->nm_name;
if (n_devices > 1)
text = g_strdup_printf (_("Wired Network (%s)"), dev_name);
else
text = g_strdup (_("Wired Network"));
gtk_label_set_text (GTK_LABEL (menu_wired->label), text);
/* Only dim the item if the device supports carrier detection AND
* we know it doesn't have a link.
*/
if (dev->supports_carrier_detect == TRUE)
gtk_widget_set_sensitive (GTK_WIDGET (menu_wired), dev->link);
}
/* NMMenuNetwork */
G_DEFINE_TYPE (NMMenuNetwork, nm_menu_network, GTK_TYPE_MENU_ITEM);
static gboolean
label_expose (GtkWidget *widget)
{
/* Bad hack to make the label draw normally, instead of insensitive. */
widget->state = GTK_STATE_NORMAL;
/* Bad hack to make the label draw normally, instead of insensitive. */
widget->state = GTK_STATE_NORMAL;
return FALSE;
return FALSE;
}
static void
nm_menu_network_init (NMMenuNetwork *menu_network)
NMWirelessMenuItem *wireless_menu_item_new (void)
{
menu_network->label = gtk_label_new (NULL);
NMWirelessMenuItem *item = g_malloc0 (sizeof (NMWirelessMenuItem));
/* Make sure it looks slightly different if the label determines the width of the widget */
gtk_misc_set_padding (GTK_MISC (menu_network->label), 6, 0);
g_signal_connect (menu_network->label, "expose-event", G_CALLBACK (label_expose), NULL);
g_return_val_if_fail (item != NULL, NULL);
gtk_container_add (GTK_CONTAINER (menu_network), menu_network->label);
gtk_widget_show (menu_network->label);
item->menu_item = GTK_MENU_ITEM (gtk_menu_item_new ());
gtk_widget_set_sensitive (GTK_WIDGET (menu_network), FALSE);
/* Make sure it looks slightly different if the label determines the width of the widget */
item->label = GTK_LABEL (gtk_label_new (NULL));
gtk_misc_set_padding (GTK_MISC (item->label), 6, 0);
g_signal_connect (G_OBJECT (item->label), "expose-event", G_CALLBACK (label_expose), NULL);
gtk_container_add (GTK_CONTAINER (item->menu_item), GTK_WIDGET (item->label));
gtk_widget_show (GTK_WIDGET (item->label));
gtk_widget_set_sensitive (GTK_WIDGET (item->menu_item), FALSE);
return item;
}
GtkMenuItem *wireless_menu_item_get_item (NMWirelessMenuItem *item)
{
g_return_val_if_fail (item != NULL, NULL);
return item->menu_item;
}
void wireless_menu_item_update (NMWirelessMenuItem *item, NetworkDevice *dev, const gint n_devices)
{
char *text;
const char *dev_name;
gint n_essids;
n_essids = g_slist_length (dev->networks);
dev_name = dev->hal_name ? dev->hal_name : dev->nm_name;
g_return_if_fail (dev != NULL);
g_return_if_fail (item != NULL);
g_assert (dev->type == DEVICE_TYPE_WIRELESS_ETHERNET);
if (n_devices > 1)
text = g_strdup_printf (ngettext ("Wireless Network (%s)", "Wireless Networks (%s)", n_essids), dev_name);
else
text = g_strdup (ngettext ("Wireless Network", "Wireless Networks", n_essids));
gtk_label_set_markup (GTK_LABEL (item->label), text);
g_free (text);
}
static void
nm_menu_network_class_init (NMMenuNetworkClass *menu_network)
/****************************************************************
* Wireless Network menu item
****************************************************************/
struct NMNetworkMenuItem
{
GtkCheckMenuItem *check_item;
GtkLabel *label;
GtkWidget *cell_view;
GtkWidget *security_image;
GObject *progress_bar;
};
NMNetworkMenuItem *network_menu_item_new (GtkSizeGroup *encryption_size_group)
{
GtkWidget *hbox;
NMNetworkMenuItem *item = g_malloc0 (sizeof (NMNetworkMenuItem));
g_return_val_if_fail (item != NULL, NULL);
item->check_item = GTK_CHECK_MENU_ITEM (gtk_check_menu_item_new ());
gtk_check_menu_item_set_draw_as_radio (item->check_item, TRUE);
hbox = gtk_hbox_new (FALSE, 6);
item->label = GTK_LABEL (gtk_label_new (NULL));
gtk_misc_set_alignment (GTK_MISC (item->label), 0.0, 0.5);
item->security_image = gtk_image_new ();
gtk_size_group_add_widget (encryption_size_group, item->security_image);
gtk_container_add (GTK_CONTAINER (item->check_item), hbox);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (item->label), TRUE, TRUE, 0);
item->cell_view = gtk_cell_view_new ();
item->progress_bar = g_object_new (GTK_TYPE_CELL_RENDERER_PROGRESS, "text", "", NULL);
gtk_cell_renderer_set_fixed_size (GTK_CELL_RENDERER (item->progress_bar), 150, -1);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (item->cell_view), GTK_CELL_RENDERER (item->progress_bar), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), item->cell_view, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), item->security_image, FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (item->label));
gtk_widget_show (item->cell_view);
gtk_widget_show (hbox);
return item;
}
GtkWidget *
nm_menu_network_new (void)
GtkCheckMenuItem *network_menu_item_get_check_item (NMNetworkMenuItem *item)
{
GtkWidget *retval = g_object_new (nm_menu_network_get_type (), NULL);
g_return_val_if_fail (item != NULL, NULL);
return retval;
}
void
nm_menu_network_update (NMMenuNetwork *menu_network,
NetworkDevice *network,
gint n_devices)
{
char *text, *markup;
const char *network_name;
gint n_essids;
n_essids = g_slist_length (network->networks);
network_name = network->hal_name ? network->hal_name : network->nm_name;
g_assert (network->type == DEVICE_TYPE_WIRELESS_ETHERNET);
if (n_devices > 1)
text = g_strdup_printf (ngettext ("Wireless Network (%s)", "Wireless Networks (%s)", n_essids), network_name);
else
text = g_strdup (ngettext ("Wireless Network", "Wireless Networks", n_essids));
markup = g_markup_printf_escaped ("<span foreground=\"#aaaaaa\">%s</span>", text);
gtk_label_set_markup (GTK_LABEL (menu_network->label), markup);
g_free (markup);
g_free (text);
}
/* NMMenuWireless items*/
G_DEFINE_TYPE (NMMenuWireless, nm_menu_wireless, GTK_TYPE_CHECK_MENU_ITEM);
static void
nm_menu_wireless_init (NMMenuWireless *menu_info)
{
GtkWidget *hbox;
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (menu_info), TRUE);
hbox = gtk_hbox_new (FALSE, 6);
menu_info->label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (menu_info->label), 0.0, 0.5);
menu_info->security_image = gtk_image_new ();
gtk_container_add (GTK_CONTAINER (menu_info), hbox);
gtk_box_pack_start (GTK_BOX (hbox), menu_info->label, TRUE, TRUE, 0);
menu_info->cell_view = gtk_cell_view_new ();
menu_info->progress_bar = g_object_new (GTK_TYPE_CELL_RENDERER_PROGRESS,
"text", "",
NULL);
gtk_cell_renderer_set_fixed_size (GTK_CELL_RENDERER (menu_info->progress_bar), 150, -1);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (menu_info->cell_view),
GTK_CELL_RENDERER (menu_info->progress_bar),
TRUE);
gtk_box_pack_start (GTK_BOX (hbox), menu_info->cell_view, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), menu_info->security_image, FALSE, FALSE, 0);
gtk_widget_show (menu_info->label);
gtk_widget_show (menu_info->cell_view);
gtk_widget_show (hbox);
}
static void
nm_menu_wireless_class_init (NMMenuWirelessClass *menu_info_class)
{
GTK_WIDGET_CLASS (menu_info_class)->expose_event = nm_menu_wireless_expose_event;
}
GtkWidget *
nm_menu_wireless_new (GtkSizeGroup *encryption_size_group)
{
GtkWidget *retval = g_object_new (nm_menu_wireless_get_type (), NULL);
gtk_size_group_add_widget (encryption_size_group,
NM_MENU_WIRELESS (retval)->security_image);
return retval;
}
/* Bad hack */
static gboolean
nm_menu_wireless_expose_event (GtkWidget *widget, GdkEventExpose *event)
{
gboolean retval;
GtkStyle *old_style;
old_style = NM_MENU_WIRELESS (widget)->label->style;
NM_MENU_WIRELESS (widget)->label->style =
gtk_rc_get_style_by_paths (gtk_settings_get_default (),
"GtkWindow.GtkMenu.GtkMenuItem.GtkLabel",
"GtkWindow.GtkMenu.GtkMenuItem.GtkLabel",
GTK_TYPE_LABEL);
retval = GTK_WIDGET_CLASS (nm_menu_wireless_parent_class)->expose_event (widget, event);
NM_MENU_WIRELESS (widget)->label->style = old_style;
return retval;
return item->check_item;
}
/* has_encrypted means that the wireless network has an encrypted
* area, and thus we need to allow for spacing.
*/
void
nm_menu_wireless_update (NMMenuWireless *menu_info,
WirelessNetwork *network,
gboolean has_encrypted)
void network_menu_item_update (NMNetworkMenuItem *item, WirelessNetwork *network, const gboolean is_encrypted)
{
char *display_essid;
char *display_essid;
display_essid = nm_menu_wireless_escape_essid_for_display (network->essid);
gtk_label_set_text (GTK_LABEL (menu_info->label), display_essid);
g_free (display_essid);
g_return_if_fail (item != NULL);
g_return_if_fail (network != NULL);
g_object_set (G_OBJECT (menu_info->progress_bar),
"value", CLAMP ((int) network->strength, 0, 100),
NULL);
display_essid = nm_menu_network_escape_essid_for_display (network->essid);
gtk_label_set_text (GTK_LABEL (item->label), display_essid);
g_free (display_essid);
/* Deal with the encrypted icon */
g_object_set (menu_info->security_image, "visible", has_encrypted, NULL);
g_object_set (G_OBJECT (item->progress_bar), "value", CLAMP ((int) network->strength, 0, 100), NULL);
if (network->encrypted)
gtk_image_set_from_stock (GTK_IMAGE (menu_info->security_image), "gnome-lockscreen", GTK_ICON_SIZE_MENU);
else
gtk_image_set_from_stock (GTK_IMAGE (menu_info->security_image), NULL, GTK_ICON_SIZE_MENU);
/* Deal with the encrypted icon */
g_object_set (item->security_image, "visible", is_encrypted, NULL);
if (network->encrypted)
gtk_image_set_from_stock (GTK_IMAGE (item->security_image), "gnome-lockscreen", GTK_ICON_SIZE_MENU);
else
gtk_image_set_from_stock (GTK_IMAGE (item->security_image), NULL, GTK_ICON_SIZE_MENU);
}
/****************************************************************
* Utility stuff
****************************************************************/
/* This is copied from eel.
*/
static char *
eel_make_valid_utf8 (const char *name)
static char *eel_make_valid_utf8 (const char *name)
{
GString *string;
const char *remainder, *invalid;
@ -324,11 +297,10 @@ eel_make_valid_utf8 (const char *name)
return g_string_free (string, FALSE);
}
char *
nm_menu_wireless_escape_essid_for_display (const char *essid)
char *nm_menu_network_escape_essid_for_display (const char *essid)
{
if (g_utf8_validate (essid, -1, NULL))
return g_strdup (essid);
else
return eel_make_valid_utf8 (essid);
if (g_utf8_validate (essid, -1, NULL))
return g_strdup (essid);
else
return eel_make_valid_utf8 (essid);
}

80
panel-applet/menu-info.h
View file

@ -22,83 +22,29 @@
#ifndef MENU_INFO_H
#define MENU_INFO_H
/* We have two widgets that we use here.
*/
#include <gtk/gtk.h>
#include "NMWirelessApplet.h"
#define NM_TYPE_MENU_WIRED (nm_menu_wired_get_type ())
#define NM_MENU_WIRED(widget) (G_TYPE_CHECK_INSTANCE_CAST ((widget), NM_TYPE_MENU_WIRED, NMMenuWired))
#define NM_TYPE_MENU_NETWORK (nm_menu_network_get_type ())
#define NM_MENU_NETWORK(widget) (G_TYPE_CHECK_INSTANCE_CAST ((widget), NM_TYPE_MENU_NETWORK, NMMenuNetwork))
#define NM_TYPE_MENU_WIRELESS (nm_menu_wireless_get_type ())
#define NM_MENU_WIRELESS(widget) (G_TYPE_CHECK_INSTANCE_CAST ((widget), NM_TYPE_MENU_WIRELESS, NMMenuWireless))
typedef struct NMWiredMenuItem NMWiredMenuItem;
typedef struct NMWirelessMenuItem NMWirelessMenuItem;
typedef struct NMNetworkMenuItem NMNetworkMenuItem;
typedef struct
{
GtkCheckMenuItemClass parent_class;
} NMMenuWiredClass;
NMWiredMenuItem *wired_menu_item_new (void);
GtkCheckMenuItem *wired_menu_item_get_check_item (NMWiredMenuItem *item);
void wired_menu_item_update (NMWiredMenuItem *item, NetworkDevice *dev, const gint n_devices);
typedef struct
{
GtkCheckMenuItem parent;
GtkWidget *label;
} NMMenuWired;
NMWirelessMenuItem *wireless_menu_item_new (void);
GtkMenuItem *wireless_menu_item_get_item (NMWirelessMenuItem *item);
void wireless_menu_item_update (NMWirelessMenuItem *item, NetworkDevice *dev, const gint n_devices);
typedef struct
{
GtkMenuItemClass parent_class;
} NMMenuNetworkClass;
typedef struct
{
GtkMenuItem parent;
GtkWidget *event_box;
GtkWidget *label;
} NMMenuNetwork;
typedef struct
{
GtkCheckMenuItemClass parent_class;
} NMMenuWirelessClass;
typedef struct
{
GtkCheckMenuItem parent;
GtkWidget *label;
GtkWidget *cell_view;
GtkWidget *security_image;
GObject *progress_bar;
} NMMenuWireless;
GType nm_menu_wired_get_type (void);
GtkWidget *nm_menu_wired_new (void);
void nm_menu_wired_update (NMMenuWired *menu_wired,
NetworkDevice *network,
gint n_devices);
GType nm_menu_network_get_type (void);
GtkWidget *nm_menu_network_new (void);
void nm_menu_network_update (NMMenuNetwork *menu_network,
NetworkDevice *network,
gint n_devices);
GType nm_menu_wireless_get_type (void);
GtkWidget *nm_menu_wireless_new (GtkSizeGroup *encryption_size_group);
void nm_menu_wireless_update (NMMenuWireless *menu_info,
WirelessNetwork *network,
gboolean has_encrypted);
NMNetworkMenuItem *network_menu_item_new (GtkSizeGroup *encryption_size_group);
GtkCheckMenuItem *network_menu_item_get_check_item (NMNetworkMenuItem *item);
void network_menu_item_update (NMNetworkMenuItem *item, WirelessNetwork *network, const gboolean is_encrypted);
/* Helper function; escapes an essid for human readable display. */
char *nm_menu_wireless_escape_essid_for_display (const char *essid);
char *nm_menu_network_escape_essid_for_display (const char *essid);
#endif /* MENU_INFO_H */