initial

41 files changed, 7189 insertions, 0 deletions

diff --git a/cpufreq/src/Makefile.am b/cpufreq/src/Makefile.am
new file mode 100644
index 00000000..db5679d0
--- /dev/null
+++ b/cpufreq/src/Makefile.am
@@ -0,0 +1,40 @@
+if BUILD_CPUFREQ_SELECTOR
+selector_SUBDIR = cpufreq-selector
+endif
+
+SUBDIRS = $(selector_SUBDIR)
+
+INCLUDES = \
+	-DCPUFREQ_MENU_UI_DIR=\""$(datadir)/mate-2.0/ui"\" 	\
+	$(MATE_APPLETS3_CFLAGS) 				\
+	$(LIBGLADE_CFLAGS)					\
+	$(DBUS_CFLAGS)
+
+libexec_PROGRAMS = cpufreq-applet
+
+if HAVE_LIBCPUFREQ
+cpufreq_files=cpufreq-monitor-libcpufreq.c    cpufreq-monitor-libcpufreq.h
+endif
+
+cpufreq_applet_SOURCES =  \
+	cpufreq-applet.c        	cpufreq-applet.h        	\
+	cpufreq-utils.c			cpufreq-utils.h			\
+	cpufreq-prefs.c         	cpufreq-prefs.h         	\
+	cpufreq-selector.c		cpufreq-selector.h		\
+	cpufreq-popup.c                 cpufreq-popup.h			\
+	cpufreq-monitor.c       	cpufreq-monitor.h	      	\
+	cpufreq-monitor-factory.c	cpufreq-monitor-factory.h	\
+	cpufreq-monitor-procfs.c	cpufreq-monitor-procfs.h	\
+	cpufreq-monitor-sysfs.c	        cpufreq-monitor-sysfs.h	        \
+	$(cpufreq_files)						\
+	cpufreq-monitor-cpuinfo.c       cpufreq-monitor-cpuinfo.h
+
+cpufreq_applet_LDADD =  \
+	$(MATE_APPLETS3_LIBS)   	\
+	$(LIBGLADE_LIBS)		\
+	$(LIBCPUFREQ_LIBS)		\
+	$(DBUS_LIBS)
+
+	
+
+-include $(top_srcdir)/git.mk
diff --git a/cpufreq/src/cpufreq-applet.c b/cpufreq/src/cpufreq-applet.c
new file mode 100644
index 00000000..07a80339
--- /dev/null
+++ b/cpufreq/src/cpufreq-applet.c
@@ -0,0 +1,1032 @@
+/*
+ * MATE CPUFreq Applet 
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <mate-panel-applet.h>
+#include <mate-panel-applet-mateconf.h>
+#include <glib/gi18n.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cpufreq-applet.h"
+#include "cpufreq-prefs.h"
+#include "cpufreq-popup.h"
+#include "cpufreq-monitor.h"
+#include "cpufreq-monitor-factory.h"
+#include "cpufreq-utils.h"
+
+struct _CPUFreqApplet {
+        MatePanelApplet       base;
+
+        /* Visibility */
+	CPUFreqShowMode   show_mode;
+	CPUFreqShowTextMode show_text_mode;
+        gboolean          show_freq;
+        gboolean          show_perc;
+        gboolean          show_unit;
+        gboolean          show_icon;
+
+        CPUFreqMonitor   *monitor;
+
+        MatePanelAppletOrient orient;
+        gint              size;
+
+        GtkWidget        *label;
+        GtkWidget        *unit_label;
+        GtkWidget        *icon;
+        GtkWidget        *box;
+	GtkWidget        *labels_box;
+        GtkWidget        *container;
+        GdkPixbuf        *pixbufs[5];
+
+	gint              max_label_width;
+	gint              max_perc_width;
+	gint              max_unit_width;
+
+	gboolean          need_refresh;
+
+        CPUFreqPrefs     *prefs;
+        CPUFreqPopup     *popup;
+};
+
+struct _CPUFreqAppletClass {
+        MatePanelAppletClass parent_class;
+};
+
+static void     cpufreq_applet_init              (CPUFreqApplet      *applet);
+static void     cpufreq_applet_class_init        (CPUFreqAppletClass *klass);
+
+static void     cpufreq_applet_preferences_cb    (GtkAction          *action,
+                                                  CPUFreqApplet      *applet);
+static void     cpufreq_applet_help_cb           (GtkAction          *action,
+                                                  CPUFreqApplet      *applet);
+static void     cpufreq_applet_about_cb          (GtkAction          *action,
+                                                  CPUFreqApplet      *applet);
+
+static void     cpufreq_applet_pixmap_set_image  (CPUFreqApplet      *applet,
+                                                  gint                perc);
+
+static void     cpufreq_applet_setup             (CPUFreqApplet      *applet);
+static void     cpufreq_applet_update            (CPUFreqApplet      *applet,
+                                                  CPUFreqMonitor     *monitor);
+static void     cpufreq_applet_refresh           (CPUFreqApplet      *applet);
+
+static void     cpufreq_applet_destroy           (GtkObject          *widget);
+static gboolean cpufreq_applet_button_press      (GtkWidget          *widget,
+                                                  GdkEventButton     *event);
+static gboolean cpufreq_applet_key_press         (GtkWidget          *widget,
+                                                  GdkEventKey        *event);
+static void     cpufreq_applet_size_allocate     (GtkWidget          *widget,
+                                                  GtkAllocation      *allocation);
+static void     cpufreq_applet_size_request      (GtkWidget          *widget,
+						  GtkRequisition     *requisition);
+static void     cpufreq_applet_change_orient     (MatePanelApplet        *pa,
+                                                  MatePanelAppletOrient   orient);
+static gboolean cpufreq_applet_factory           (CPUFreqApplet      *applet,
+                                                  const gchar        *iid,
+                                                  gpointer            gdata);
+
+static const gchar *const cpufreq_icons[] = {
+        MATE_PIXMAPSDIR"/cpufreq-applet/cpufreq-25.png",
+        MATE_PIXMAPSDIR"/cpufreq-applet/cpufreq-50.png",
+        MATE_PIXMAPSDIR"/cpufreq-applet/cpufreq-75.png",
+        MATE_PIXMAPSDIR"/cpufreq-applet/cpufreq-100.png",
+        MATE_PIXMAPSDIR"/cpufreq-applet/cpufreq-na.png",
+        NULL
+};
+
+static const GtkActionEntry cpufreq_applet_menu_actions[] = {
+	{ "CPUFreqAppletPreferences", GTK_STOCK_PROPERTIES, N_("_Preferences"),
+	  NULL, NULL,
+	  G_CALLBACK (cpufreq_applet_preferences_cb) },
+	{ "CPUFreqAppletHelp", GTK_STOCK_HELP, N_("_Help"),
+	  NULL, NULL,
+	  G_CALLBACK (cpufreq_applet_help_cb) },
+	{ "CPUFreqAppletAbout", GTK_STOCK_ABOUT, N_("_About"),
+	  NULL, NULL,
+	  G_CALLBACK (cpufreq_applet_about_cb) }
+};
+
+G_DEFINE_TYPE (CPUFreqApplet, cpufreq_applet, PANEL_TYPE_APPLET)
+
+/* Enum Types */
+GType
+cpufreq_applet_show_mode_get_type (void)
+{
+        static GType etype = 0;
+        
+        if (etype == 0) {
+                static const GEnumValue values[] = {
+                        { CPUFREQ_MODE_GRAPHIC, "CPUFREQ_MODE_GRAPHIC", "mode-graphic" },
+                        { CPUFREQ_MODE_TEXT,    "CPUFREQ_MODE_TEXT",    "mode-text" },
+                        { CPUFREQ_MODE_BOTH,    "CPUFREQ_MODE_BOTH",    "mode-both" },
+                        { 0, NULL, NULL }
+                };
+                
+                etype = g_enum_register_static ("CPUFreqShowMode", values);
+        }
+        
+        return etype;
+}
+
+GType
+cpufreq_applet_show_text_mode_get_type (void)
+{
+        static GType etype = 0;
+
+        if (etype == 0) {
+                static const GEnumValue values[] = {
+                        { CPUFREQ_MODE_TEXT_FREQUENCY,      "CPUFREQ_MODE_TEXT_FREQUENCY",      "mode-text-frequency" },
+                        { CPUFREQ_MODE_TEXT_FREQUENCY_UNIT, "CPUFREQ_MODE_TEXT_FREQUENCY_UNIT", "mode-text-frequency-unit" },
+                        { CPUFREQ_MODE_TEXT_PERCENTAGE,     "CPUFREQ_MODE_TEXT_PERCENTAGE",     "mode-text-percentage" },
+                        { 0, NULL, NULL }
+                };
+
+                etype = g_enum_register_static ("CPUFreqShowTextMode", values);
+        }
+
+        return etype;
+}
+
+static void
+cpufreq_applet_init (CPUFreqApplet *applet)
+{
+        applet->prefs = NULL;
+        applet->popup = NULL;
+        applet->monitor = NULL;
+
+        applet->label = gtk_label_new (NULL);
+        applet->unit_label = gtk_label_new (NULL);
+        applet->icon = gtk_image_new ();
+        applet->box = NULL;
+
+	applet->show_mode = CPUFREQ_MODE_BOTH;
+	applet->show_text_mode = CPUFREQ_MODE_TEXT_FREQUENCY_UNIT;
+	
+	applet->need_refresh = TRUE;
+
+        mate_panel_applet_set_flags (MATE_PANEL_APPLET (applet), MATE_PANEL_APPLET_EXPAND_MINOR);
+	mate_panel_applet_set_background_widget (MATE_PANEL_APPLET (applet), GTK_WIDGET (applet));
+
+        applet->size = mate_panel_applet_get_size (MATE_PANEL_APPLET (applet));
+        applet->orient = mate_panel_applet_get_orient (MATE_PANEL_APPLET (applet));
+
+	switch (applet->orient) {
+	case MATE_PANEL_APPLET_ORIENT_LEFT:
+	case MATE_PANEL_APPLET_ORIENT_RIGHT:
+		applet->container = gtk_alignment_new (0.5, 0.5, 0, 0);
+		break;
+	case MATE_PANEL_APPLET_ORIENT_UP:
+	case MATE_PANEL_APPLET_ORIENT_DOWN:
+		applet->container = gtk_alignment_new (0, 0.5, 0, 0);
+		break;
+	}
+
+	gtk_container_add (GTK_CONTAINER (applet), applet->container);
+	gtk_widget_show (applet->container);
+}
+
+static void
+cpufreq_applet_class_init (CPUFreqAppletClass *klass)
+{
+        MatePanelAppletClass *applet_class = MATE_PANEL_APPLET_CLASS (klass);
+        GtkObjectClass   *gtkobject_class = GTK_OBJECT_CLASS (klass);
+        GtkWidgetClass   *widget_class = GTK_WIDGET_CLASS (klass);
+
+        gtkobject_class->destroy = cpufreq_applet_destroy;
+           
+        widget_class->size_allocate = cpufreq_applet_size_allocate;
+	widget_class->size_request = cpufreq_applet_size_request;
+        widget_class->button_press_event = cpufreq_applet_button_press;
+        widget_class->key_press_event = cpufreq_applet_key_press;
+           
+        applet_class->change_orient = cpufreq_applet_change_orient;
+}
+
+static void
+cpufreq_applet_destroy (GtkObject *widget)
+{
+        CPUFreqApplet *applet;
+        gint           i;
+
+        applet = CPUFREQ_APPLET (widget);
+
+        if (applet->monitor) {
+                g_object_unref (G_OBJECT (applet->monitor));
+                applet->monitor = NULL;
+        }
+
+        for (i = 0; i <= 3; i++) {
+                if (applet->pixbufs[i]) {
+                        g_object_unref (G_OBJECT (applet->pixbufs[i]));
+                        applet->pixbufs[i] = NULL;
+                }
+        }
+
+        if (applet->prefs) {
+                g_object_unref (applet->prefs);
+                applet->prefs = NULL;
+        }
+
+        if (applet->popup) {
+                g_object_unref (applet->popup);
+                applet->popup = NULL;
+        }
+
+        GTK_OBJECT_CLASS (cpufreq_applet_parent_class)->destroy (widget);
+}
+
+static void
+cpufreq_applet_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+{
+        CPUFreqApplet *applet;
+        gint           size = 0;
+
+        applet = CPUFREQ_APPLET (widget);
+
+	GTK_WIDGET_CLASS (cpufreq_applet_parent_class)->size_allocate (widget, allocation);
+
+        switch (applet->orient) {
+        case MATE_PANEL_APPLET_ORIENT_LEFT:
+        case MATE_PANEL_APPLET_ORIENT_RIGHT:
+                size = allocation->width;
+                break;
+        case MATE_PANEL_APPLET_ORIENT_UP:
+        case MATE_PANEL_APPLET_ORIENT_DOWN:
+                size = allocation->height;
+                break;
+        }
+
+        if (size != applet->size) {
+                applet->size = size;
+                cpufreq_applet_refresh (applet);
+        }
+}
+
+static gint
+cpufreq_applet_get_max_label_width (CPUFreqApplet *applet)
+{
+	GList *available_freqs;
+	gint   width = 0;
+	
+	if (applet->max_label_width > 0)
+		return applet->max_label_width;
+
+	if (!CPUFREQ_IS_MONITOR (applet->monitor))
+		return 0;
+
+	available_freqs = cpufreq_monitor_get_available_frequencies (applet->monitor);
+	while (available_freqs) {
+		GtkWidget     *label;
+		GtkRequisition req;
+		const gchar   *text;
+		gchar         *freq_text;
+		gint           freq;
+
+		text = (const gchar *) available_freqs->data;
+		freq = atoi (text);
+
+		freq_text = cpufreq_utils_get_frequency_label (freq);
+		label = gtk_label_new (freq_text);
+		gtk_widget_size_request (label, &req);
+
+		width = MAX (width, req.width);
+
+		g_free (freq_text);
+		gtk_widget_destroy (label);
+
+		available_freqs = g_list_next (available_freqs);
+	}
+
+	applet->max_label_width = width;
+
+	return width;
+}
+
+static gint
+cpufreq_applet_get_max_perc_width (CPUFreqApplet *applet)
+{
+	GtkWidget      *label;
+	GtkRequisition req;
+	
+	if (applet->max_perc_width > 0)
+		return applet->max_perc_width;
+
+	label = gtk_label_new ("100%");
+	gtk_widget_size_request (label, &req);
+	applet->max_perc_width = req.width;
+	gtk_widget_destroy (label);
+
+	return applet->max_perc_width;
+}
+
+static gint
+cpufreq_applet_get_max_unit_width (CPUFreqApplet *applet)
+{
+	GtkWidget     *label;
+	GtkRequisition req;
+	gint           w1, w2;
+	
+	if (applet->max_unit_width > 0)
+		return applet->max_unit_width;
+
+	label = gtk_label_new ("GHz");
+	gtk_widget_size_request (label, &req);
+	w1 = req.width;
+
+	gtk_label_set_text (GTK_LABEL (label), "MHz");
+	gtk_widget_size_request (label, &req);
+	w2 = req.width;
+	
+	gtk_widget_destroy (label);
+
+	applet->max_unit_width = MAX (w1, w2);
+
+	return applet->max_unit_width;
+}
+
+static void
+cpufreq_applet_size_request (GtkWidget *widget, GtkRequisition *requisition)
+{
+	CPUFreqApplet *applet;
+	gint           labels_width = 0;
+	gint           width;
+
+	applet = CPUFREQ_APPLET (widget);
+
+	GTK_WIDGET_CLASS (cpufreq_applet_parent_class)->size_request (widget, requisition);
+
+	if (applet->orient == MATE_PANEL_APPLET_ORIENT_LEFT ||
+	    applet->orient == MATE_PANEL_APPLET_ORIENT_RIGHT)
+		return;
+
+	if (applet->show_freq) {
+		labels_width += cpufreq_applet_get_max_label_width (applet) + 2;
+	}
+
+	if (applet->show_perc) {
+		labels_width += cpufreq_applet_get_max_perc_width (applet);
+	}
+
+	if (applet->show_unit) {
+		labels_width += cpufreq_applet_get_max_unit_width (applet);
+	}
+
+	if (applet->show_icon) {
+		GtkRequisition req;
+
+		gtk_widget_size_request (applet->icon, &req);
+		width = GTK_IS_HBOX (applet->box) ?
+			labels_width + req.width + 2 :
+			MAX (labels_width, req.width + 2);
+	} else {
+		width = labels_width;
+	}
+
+	requisition->width = width;
+}
+
+static void
+cpufreq_applet_popup_position_menu (GtkMenu  *menu,
+                                    int      *x,
+                                    int      *y,
+                                    gboolean *push_in,
+                                    gpointer  gdata)
+{
+        GtkWidget      *widget;
+        GtkRequisition  requisition;
+        GtkAllocation   allocation;
+        gint            menu_xpos;
+        gint            menu_ypos;
+
+        widget = GTK_WIDGET (gdata);
+
+        gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
+
+        gdk_window_get_origin (gtk_widget_get_window (widget), &menu_xpos, &menu_ypos);
+
+	gtk_widget_get_allocation (widget, &allocation);
+
+        menu_xpos += allocation.x;
+        menu_ypos += allocation.y;
+
+        switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (widget))) {
+        case MATE_PANEL_APPLET_ORIENT_DOWN:
+        case MATE_PANEL_APPLET_ORIENT_UP:
+                if (menu_ypos > gdk_screen_get_height (gtk_widget_get_screen (widget)) / 2)
+                        menu_ypos -= requisition.height;
+                else
+                        menu_ypos += allocation.height;
+                break;
+        case MATE_PANEL_APPLET_ORIENT_RIGHT:
+        case MATE_PANEL_APPLET_ORIENT_LEFT:
+                if (menu_xpos > gdk_screen_get_width (gtk_widget_get_screen (widget)) / 2)
+                        menu_xpos -= requisition.width;
+                else
+                        menu_xpos += allocation.width;
+                break;
+        default:
+                g_assert_not_reached ();
+        }
+
+        *x = menu_xpos;
+        *y = menu_ypos;
+        *push_in = TRUE;
+}
+
+static void
+cpufreq_applet_menu_popup (CPUFreqApplet *applet,
+                           guint32        time)
+{
+        GtkWidget *menu;
+
+        if (!cpufreq_utils_selector_is_available ())
+                return;
+
+        if (!applet->popup) {
+                applet->popup = cpufreq_popup_new ();
+                cpufreq_popup_set_monitor (applet->popup, applet->monitor);
+		cpufreq_popup_set_parent (applet->popup, GTK_WIDGET (applet));
+        }
+
+        menu = cpufreq_popup_get_menu (applet->popup);
+
+        if (!menu)
+                return;
+
+        gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
+                        cpufreq_applet_popup_position_menu,
+                        (gpointer) applet,
+                        1, time);
+}
+
+static gboolean
+cpufreq_applet_button_press (GtkWidget *widget, GdkEventButton *event)
+{
+        CPUFreqApplet *applet;
+
+        applet = CPUFREQ_APPLET (widget);
+
+        if (event->button == 2)
+                return FALSE;
+
+        if (event->button == 1 &&
+            event->type != GDK_2BUTTON_PRESS &&
+            event->type != GDK_3BUTTON_PRESS) {
+                cpufreq_applet_menu_popup (applet, event->time);
+                
+                return TRUE;
+        }
+        
+        return GTK_WIDGET_CLASS (cpufreq_applet_parent_class)->button_press_event (widget, event);
+}
+
+static gboolean
+cpufreq_applet_key_press (GtkWidget *widget, GdkEventKey *event)
+{
+        CPUFreqApplet *applet;
+
+        applet = CPUFREQ_APPLET (widget);
+
+        switch (event->keyval) {
+        case GDK_KP_Enter:
+        case GDK_ISO_Enter:
+        case GDK_3270_Enter:
+        case GDK_Return:
+        case GDK_space:
+        case GDK_KP_Space:
+                cpufreq_applet_menu_popup (applet, event->time);
+
+                return TRUE;
+        default:
+                break;
+        }
+
+        return FALSE;
+}
+
+static void
+cpufreq_applet_change_orient (MatePanelApplet *pa, MatePanelAppletOrient orient)
+{
+        CPUFreqApplet *applet;
+        GtkAllocation  allocation;
+        gint           size;
+
+        applet = CPUFREQ_APPLET (pa);
+
+        applet->orient = orient;
+
+        gtk_widget_get_allocation (GTK_WIDGET (applet), &allocation);
+
+        if ((orient == MATE_PANEL_APPLET_ORIENT_LEFT) ||
+            (orient == MATE_PANEL_APPLET_ORIENT_RIGHT)) {
+                size = allocation.width;
+		gtk_alignment_set (GTK_ALIGNMENT (applet->container),
+				   0.5, 0.5, 0, 0);
+        } else {
+                size = allocation.height;
+		gtk_alignment_set (GTK_ALIGNMENT (applet->container),
+				   0, 0.5, 0, 0);
+        }
+
+        if (size != applet->size) {
+                applet->size = size;
+                cpufreq_applet_refresh (applet);
+        }
+}
+
+static void
+cpufreq_applet_preferences_cb (GtkAction     *action,
+                               CPUFreqApplet *applet)
+{
+        cpufreq_preferences_dialog_run (applet->prefs,
+                                        gtk_widget_get_screen (GTK_WIDGET (applet)));
+}
+
+static void
+cpufreq_applet_help_cb (GtkAction     *action,
+                        CPUFreqApplet *applet)
+{
+        GError *error = NULL;
+           
+	gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (applet)),
+			"ghelp:cpufreq-applet",
+			gtk_get_current_event_time (),
+			&error);
+
+        if (error) {
+                cpufreq_utils_display_error (_("Could not open help document"),
+                                             error->message);
+                g_error_free (error);
+        }
+}
+
+static void
+cpufreq_applet_about_cb (GtkAction     *action,
+                         CPUFreqApplet *applet)
+{
+        static const gchar *const authors[] = {
+                "Carlos Garcia Campos <[email protected]>",
+                NULL
+        };
+        static const gchar *const documenters[] = {
+                "Carlos Garcia Campos <[email protected]>",
+                "Davyd Madeley <[email protected]>",
+                NULL
+        };
+        static const gchar *const artists[] = {
+                "Pablo Arroyo Loma <[email protected]>",
+                NULL
+        };
+
+        gtk_show_about_dialog (NULL,
+                               "version",       VERSION,
+                               "copyright",     "\xC2\xA9 2004 Carlos Garcia Campos",
+                               "comments",      _("This utility shows the current CPU "
+                                                  "Frequency Scaling."),
+                               "authors",       authors,
+                               "documenters",   documenters,
+                               "artists",       artists, 
+                               "translator-credits",    _("translator-credits"),
+			       "logo-icon-name",        "mate-cpu-frequency-applet",
+                               NULL);
+}
+
+static void
+cpufreq_applet_pixmap_set_image (CPUFreqApplet *applet, gint perc)
+{
+        gint image;
+
+        /* 0-29   -> 25%
+         * 30-69  -> 50%
+         * 70-89  -> 75%
+         * 90-100 -> 100%
+         */
+        if (perc < 30)
+                image = 0;
+        else if ((perc >= 30) && (perc < 70))
+                image = 1;
+        else if ((perc >= 70) && (perc < 90))
+                image = 2;
+        else if ((perc >= 90) && (perc <= 100))
+                image = 3;
+        else
+                image = 4;
+
+        if (applet->pixbufs[image] == NULL) {
+                applet->pixbufs[image] = gdk_pixbuf_new_from_file_at_size (cpufreq_icons[image],
+                                                                           24, 24, NULL);
+        }
+
+        gtk_image_set_from_pixbuf (GTK_IMAGE (applet->icon), applet->pixbufs[image]);
+}
+
+static gboolean
+refresh_cb (CPUFreqApplet *applet)
+{
+	cpufreq_applet_refresh (applet);
+	
+	return FALSE;
+}
+
+static void
+cpufreq_applet_update_visibility (CPUFreqApplet *applet)
+{
+        CPUFreqShowMode     show_mode;
+        CPUFreqShowTextMode show_text_mode;
+        gboolean            show_freq = FALSE;
+        gboolean            show_perc = FALSE;
+        gboolean            show_unit = FALSE;
+        gboolean            show_icon = FALSE;
+        gboolean            changed = FALSE;
+        gboolean            need_update = FALSE;
+
+        show_mode = cpufreq_prefs_get_show_mode (applet->prefs);
+        show_text_mode = cpufreq_prefs_get_show_text_mode (applet->prefs);
+        
+        if (show_mode != CPUFREQ_MODE_GRAPHIC) {
+                show_icon = (show_mode == CPUFREQ_MODE_BOTH);
+
+                switch (show_text_mode) {
+                case CPUFREQ_MODE_TEXT_FREQUENCY:
+                        show_freq = TRUE;
+                        break;
+                case CPUFREQ_MODE_TEXT_PERCENTAGE:
+                        show_perc = TRUE;
+                        break;
+                case CPUFREQ_MODE_TEXT_FREQUENCY_UNIT:
+                        show_freq = TRUE;
+                        show_unit = TRUE;
+                        break;
+                }
+        } else {
+                show_icon = TRUE;
+        }
+
+	if (applet->show_mode != show_mode) {
+		applet->show_mode = show_mode;
+		need_update = TRUE;
+	}
+	
+	if (applet->show_text_mode != show_text_mode) {
+		applet->show_text_mode = show_text_mode;
+		need_update = TRUE;
+	}
+	    
+        if (show_freq != applet->show_freq) {
+                applet->show_freq = show_freq;
+                changed = TRUE;
+        }
+
+        if (show_perc != applet->show_perc) {
+                applet->show_perc = show_perc;
+                changed = TRUE;
+        }
+
+        if (changed) {
+                g_object_set (G_OBJECT (applet->label),
+                              "visible",
+                              applet->show_freq || applet->show_perc,
+                              NULL);
+        }
+
+        if (show_unit != applet->show_unit) {
+                applet->show_unit = show_unit;
+                changed = TRUE;
+
+                g_object_set (G_OBJECT (applet->unit_label),
+                              "visible", applet->show_unit,
+                              NULL);
+        }
+
+        if (show_icon != applet->show_icon) {
+                applet->show_icon = show_icon;
+                changed = TRUE;
+
+                g_object_set (G_OBJECT (applet->icon),
+                              "visible", applet->show_icon,
+                              NULL);
+        }
+
+        if (changed)
+		g_idle_add ((GSourceFunc)refresh_cb, applet);
+
+        if (need_update)
+                cpufreq_applet_update (applet, applet->monitor);
+}
+
+static void
+cpufreq_applet_update (CPUFreqApplet *applet, CPUFreqMonitor *monitor)
+{
+        gchar       *text_mode = NULL;
+        gchar       *freq_label, *unit_label;
+        gint         freq;
+        gint         perc;
+        guint        cpu;
+        const gchar *governor;
+
+        cpu = cpufreq_monitor_get_cpu (monitor);
+        freq = cpufreq_monitor_get_frequency (monitor);
+        perc = cpufreq_monitor_get_percentage (monitor);
+        governor = cpufreq_monitor_get_governor (monitor);
+
+        freq_label = cpufreq_utils_get_frequency_label (freq);
+        unit_label = cpufreq_utils_get_frequency_unit (freq);
+        
+        if (applet->show_freq) {
+                gtk_label_set_text (GTK_LABEL (applet->label), freq_label);
+        }
+
+        if (applet->show_perc) {
+                gchar *text_perc;
+
+                text_perc = g_strdup_printf ("%d%%", perc);
+                gtk_label_set_text (GTK_LABEL (applet->label), text_perc);
+                g_free (text_perc);
+        }
+
+        if (applet->show_unit) {
+                gtk_label_set_text (GTK_LABEL (applet->unit_label), unit_label);
+        }
+
+        if (applet->show_icon) {
+                cpufreq_applet_pixmap_set_image (applet, perc);
+        }
+
+	if (governor) {
+		gchar *gov_text;
+
+		gov_text = g_strdup (governor);
+		gov_text[0] = g_ascii_toupper (gov_text[0]);
+		text_mode = g_strdup_printf ("%s\n%s %s (%d%%)",
+					     gov_text, freq_label,
+					     unit_label, perc);
+		g_free (gov_text);
+	}
+
+        g_free (freq_label);
+        g_free (unit_label);
+
+	if (text_mode) {
+		gchar *text_tip;
+		
+		text_tip = cpufreq_utils_get_n_cpus () == 1 ?
+			g_strdup_printf ("%s", text_mode) :
+			g_strdup_printf ("CPU %u - %s", cpu, text_mode);
+		g_free (text_mode);
+           
+		gtk_widget_set_tooltip_text (GTK_WIDGET (applet), text_tip);
+		g_free (text_tip);
+	}
+
+        /* Call refresh only the first time */
+        if (applet->need_refresh) {
+                cpufreq_applet_refresh (applet);
+		applet->need_refresh = FALSE;
+        }
+}
+
+static gint
+cpufreq_applet_get_widget_size (CPUFreqApplet *applet,
+                                GtkWidget     *widget)
+{
+        GtkRequisition  req;
+        gint            size;
+
+        if (!gtk_widget_get_visible (widget))
+                return 0;
+	
+        gtk_widget_size_request (widget, &req);
+        
+        switch (applet->orient) {
+        case MATE_PANEL_APPLET_ORIENT_LEFT:
+        case MATE_PANEL_APPLET_ORIENT_RIGHT:
+                size = req.width;
+                break;
+        case MATE_PANEL_APPLET_ORIENT_UP:
+        case MATE_PANEL_APPLET_ORIENT_DOWN:
+                size = req.height;
+                break;
+        default:
+                g_assert_not_reached ();
+        }
+
+        return size;
+} 
+
+static void
+cpufreq_applet_refresh (CPUFreqApplet *applet)
+{
+        gint      total_size = 0;
+        gint      panel_size, label_size;
+        gint      unit_label_size, pixmap_size;
+        gint      size_step = 12;
+	gboolean  horizontal;
+        gboolean  do_unref = FALSE;
+
+        panel_size = applet->size - 1; /* 1 pixel margin */
+
+	horizontal = (applet->orient == MATE_PANEL_APPLET_ORIENT_UP ||
+		      applet->orient == MATE_PANEL_APPLET_ORIENT_DOWN);
+	
+        /* We want a fixed label size, the biggest */
+	if (horizontal)
+		label_size = cpufreq_applet_get_widget_size (applet, applet->label);
+	else
+		label_size = cpufreq_applet_get_max_label_width (applet);
+        total_size += label_size;
+
+	if (horizontal)
+		unit_label_size = cpufreq_applet_get_widget_size (applet, applet->unit_label);
+	else
+		unit_label_size = cpufreq_applet_get_max_unit_width (applet);
+        total_size += unit_label_size;
+
+        pixmap_size = cpufreq_applet_get_widget_size (applet, applet->icon);
+        total_size += pixmap_size;
+
+        if (applet->box) {
+                do_unref = TRUE;
+                g_object_ref (applet->icon);
+                gtk_container_remove (GTK_CONTAINER (applet->box), applet->icon);
+		if (applet->labels_box) {
+                        g_object_ref (applet->label);
+                        gtk_container_remove (GTK_CONTAINER (applet->labels_box), applet->label);
+                        g_object_ref (applet->unit_label);
+                        gtk_container_remove (GTK_CONTAINER (applet->labels_box), applet->unit_label);
+                }
+                gtk_widget_destroy (applet->box);
+        }
+
+	if (horizontal) {
+		applet->labels_box = gtk_hbox_new (FALSE, 2);
+		if ((label_size + pixmap_size) <= panel_size)
+			applet->box = gtk_vbox_new (FALSE, 2);
+		else
+			applet->box = gtk_hbox_new (FALSE, 2);
+	} else {
+                if (total_size <= panel_size) {
+                        applet->box = gtk_hbox_new (FALSE, 2);
+                        applet->labels_box  = gtk_hbox_new (FALSE, 2);
+                } else if ((label_size + unit_label_size) <= (panel_size - size_step)) {
+                        applet->box = gtk_vbox_new (FALSE, 2);
+                        applet->labels_box  = gtk_hbox_new (FALSE, 2);
+                } else {
+                        applet->box = gtk_vbox_new (FALSE, 2);
+                        applet->labels_box  = gtk_vbox_new (FALSE, 2);
+                }
+	}
+
+        gtk_box_pack_start (GTK_BOX (applet->labels_box), applet->label, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (applet->labels_box), applet->unit_label, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (applet->box), applet->icon, FALSE, FALSE, 0);
+        
+        gtk_box_pack_start (GTK_BOX (applet->box), applet->labels_box, FALSE, FALSE, 0);
+        gtk_widget_show (applet->labels_box);
+           
+        gtk_container_add (GTK_CONTAINER (applet->container), applet->box);
+        gtk_widget_show (applet->box);
+
+        if (do_unref) {
+                g_object_unref (applet->label);
+                g_object_unref (applet->unit_label);
+                g_object_unref (applet->icon);
+        }
+}
+
+/* Preferences callbacks */
+static void
+cpufreq_applet_prefs_cpu_changed (CPUFreqPrefs  *prefs,
+				  GParamSpec    *arg1,
+				  CPUFreqApplet *applet)
+{
+	cpufreq_monitor_set_cpu (applet->monitor,
+				 cpufreq_prefs_get_cpu (applet->prefs));
+}
+
+static void
+cpufreq_applet_prefs_show_mode_changed (CPUFreqPrefs  *prefs,
+                                        GParamSpec    *arg1,
+                                        CPUFreqApplet *applet)
+{
+        cpufreq_applet_update_visibility (applet);
+}
+
+static void
+cpufreq_applet_setup (CPUFreqApplet *applet)
+{
+	GtkActionGroup *action_group;
+	gchar          *ui_path;
+        AtkObject      *atk_obj;
+        gchar          *prefs_key;
+
+	g_set_application_name  (_("CPU Frequency Scaling Monitor"));
+
+	gtk_window_set_default_icon_name ("mate-cpu-frequency-applet");
+	
+        mate_panel_applet_add_preferences (MATE_PANEL_APPLET (applet),
+                                      "/schemas/apps/cpufreq-applet/prefs", NULL);
+           
+        /* Preferences */
+        if (applet->prefs)
+                g_object_unref (applet->prefs);
+        
+        prefs_key = mate_panel_applet_get_preferences_key (MATE_PANEL_APPLET (applet));
+        applet->prefs = cpufreq_prefs_new (prefs_key);
+        g_free (prefs_key);
+
+	g_signal_connect (G_OBJECT (applet->prefs),
+			  "notify::cpu",
+			  G_CALLBACK (cpufreq_applet_prefs_cpu_changed),
+			  (gpointer) applet);
+        g_signal_connect (G_OBJECT (applet->prefs),
+                          "notify::show-mode",
+                          G_CALLBACK (cpufreq_applet_prefs_show_mode_changed),
+                          (gpointer) applet);
+        g_signal_connect (G_OBJECT (applet->prefs),
+                          "notify::show-text-mode",
+                          G_CALLBACK (cpufreq_applet_prefs_show_mode_changed),
+                          (gpointer) applet);
+
+        /* Monitor */
+        applet->monitor = cpufreq_monitor_factory_create_monitor (
+                cpufreq_prefs_get_cpu (applet->prefs));
+        cpufreq_monitor_run (applet->monitor);
+        g_signal_connect_swapped (G_OBJECT (applet->monitor), "changed",
+                                  G_CALLBACK (cpufreq_applet_update),
+                                  (gpointer) applet);
+           
+        /* Setup the menus */
+	action_group = gtk_action_group_new ("CPUFreq Applet Actions");
+	gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+	gtk_action_group_add_actions (action_group,
+				      cpufreq_applet_menu_actions,
+				      G_N_ELEMENTS (cpufreq_applet_menu_actions),
+				      applet);
+	ui_path = g_build_filename (CPUFREQ_MENU_UI_DIR, "cpufreq-applet-menu.xml", NULL);
+        mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (applet),
+					   ui_path, action_group);
+	g_free (ui_path);
+
+        if (mate_panel_applet_get_locked_down (MATE_PANEL_APPLET (applet))) {
+		GtkAction *action;
+
+		action = gtk_action_group_get_action (action_group, "CPUFreqPreferences");
+		gtk_action_set_visible (action, FALSE);
+        }
+	g_object_unref (action_group);
+
+        atk_obj = gtk_widget_get_accessible (GTK_WIDGET (applet));
+
+        if (GTK_IS_ACCESSIBLE (atk_obj)) {
+                atk_object_set_name (atk_obj, _("CPU Frequency Scaling Monitor"));
+                atk_object_set_description (atk_obj, _("This utility shows the current CPU Frequency"));
+        }
+
+	cpufreq_applet_update_visibility (applet);
+
+	gtk_widget_show (GTK_WIDGET (applet));
+}
+
+static gboolean
+cpufreq_applet_factory (CPUFreqApplet *applet, const gchar *iid, gpointer gdata)
+{
+        gboolean retval = FALSE;
+
+        if (!strcmp (iid, "CPUFreqApplet")) {
+                cpufreq_applet_setup (applet);
+                
+                retval = TRUE;
+        }
+
+        return retval;
+}
+
+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("CPUFreqAppletFactory",
+				  CPUFREQ_TYPE_APPLET,
+				  "cpufreq-applet",
+				  (MatePanelAppletFactoryCallback) cpufreq_applet_factory,
+				  NULL)
diff --git a/cpufreq/src/cpufreq-applet.h b/cpufreq/src/cpufreq-applet.h
new file mode 100644
index 00000000..11d400a1
--- /dev/null
+++ b/cpufreq/src/cpufreq-applet.h
@@ -0,0 +1,61 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef CPUFREQ_APPLET_H
+#define CPUFREQ_APPLET_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_APPLET            (cpufreq_applet_get_type ())
+#define CPUFREQ_APPLET(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_APPLET, CPUFreqApplet))
+#define CPUFREQ_APPLET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_APPLET, CPUFreqAppletClass))
+#define CPUFREQ_IS_APPLET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_APPLET))
+#define CPUFREQ_IS_APPLET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_APPLET))
+#define CPUFREQ_APPLET_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_APPLET, CPUFreqAppletClass))
+
+#define CPUFREQ_TYPE_SHOW_MODE      (cpufreq_applet_show_mode_get_type ())
+#define CPUFREQ_TYPE_SHOW_TEXT_MODE (cpufreq_applet_show_text_mode_get_type ())
+
+typedef struct _CPUFreqApplet      CPUFreqApplet;
+typedef struct _CPUFreqAppletClass CPUFreqAppletClass;
+
+typedef enum {
+        CPUFREQ_MODE_GRAPHIC,
+        CPUFREQ_MODE_TEXT,
+        CPUFREQ_MODE_BOTH
+} CPUFreqShowMode;
+
+typedef enum {
+        CPUFREQ_MODE_TEXT_FREQUENCY,
+        CPUFREQ_MODE_TEXT_FREQUENCY_UNIT,
+        CPUFREQ_MODE_TEXT_PERCENTAGE
+} CPUFreqShowTextMode;
+
+GType    cpufreq_applet_get_type                (void) G_GNUC_CONST;
+
+GType    cpufreq_applet_show_mode_get_type      (void) G_GNUC_CONST;
+GType    cpufreq_applet_show_text_mode_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* CPUFREQ_APPLET_H */
diff --git a/cpufreq/src/cpufreq-monitor-cpuinfo.c b/cpufreq/src/cpufreq-monitor-cpuinfo.c
new file mode 100644
index 00000000..59585d8a
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-cpuinfo.c
@@ -0,0 +1,134 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <string.h>
+#include <stdio.h>
+
+#include "cpufreq-monitor-cpuinfo.h"
+#include "cpufreq-utils.h"
+
+static void     cpufreq_monitor_cpuinfo_class_init (CPUFreqMonitorCPUInfoClass *klass);
+
+static gboolean cpufreq_monitor_cpuinfo_run        (CPUFreqMonitor *monitor);
+
+G_DEFINE_TYPE (CPUFreqMonitorCPUInfo, cpufreq_monitor_cpuinfo, CPUFREQ_TYPE_MONITOR)
+
+static void
+cpufreq_monitor_cpuinfo_init (CPUFreqMonitorCPUInfo *monitor)
+{
+}
+
+static void
+cpufreq_monitor_cpuinfo_class_init (CPUFreqMonitorCPUInfoClass *klass)
+{
+        CPUFreqMonitorClass *monitor_class = CPUFREQ_MONITOR_CLASS (klass);
+
+        monitor_class->run = cpufreq_monitor_cpuinfo_run;
+}
+
+CPUFreqMonitor *
+cpufreq_monitor_cpuinfo_new (guint cpu)
+{
+        CPUFreqMonitorCPUInfo *monitor;
+
+        monitor = g_object_new (CPUFREQ_TYPE_MONITOR_CPUINFO, "cpu", cpu, NULL);
+
+        return CPUFREQ_MONITOR (monitor);
+}
+
+static gboolean
+cpufreq_monitor_cpuinfo_run (CPUFreqMonitor *monitor)
+{
+        gchar *file;
+        gchar                   **lines;
+        gchar *buffer = NULL;
+        gchar                    *p;
+        gint                      cpu, i;
+        gint cur_freq, max_freq;
+        gchar *governor;
+        GError *error = NULL;
+
+        file = g_strdup ("/proc/cpuinfo");
+        if (!cpufreq_file_get_contents (file, &buffer, NULL, &error)) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+
+                g_free (file);
+
+                return FALSE;
+        }
+        g_free (file);
+                
+        /* TODO: SMP support */
+        lines = g_strsplit (buffer, "\n", -1);
+        for (i = 0; lines[i]; i++) {
+                if (g_ascii_strncasecmp ("cpu MHz", lines[i], strlen ("cpu MHz")) == 0) {
+                        p = g_strrstr (lines[i], ":");
+
+                        if (p == NULL) {
+                                g_strfreev (lines);
+                                g_free (buffer);
+                                                  
+                                return FALSE;
+                        }
+
+                        if (strlen (lines[i]) < (size_t)(p - lines[i])) {
+                                g_strfreev (lines);
+                                g_free (buffer);
+                                                  
+                                return FALSE;
+                        }
+
+                        if ((sscanf (p + 1, "%d.", &cpu)) != 1) {
+                                g_strfreev (lines);
+                                g_free (buffer);
+                                                  
+                                return FALSE;
+                        }
+
+                        break;
+                }
+        }
+
+        g_strfreev (lines);
+        g_free (buffer);
+           
+        governor = g_strdup (_("Frequency Scaling Unsupported"));
+        cur_freq = cpu * 1000;
+        max_freq = cur_freq;
+
+        g_object_set (G_OBJECT (monitor),
+                      "governor", governor,
+                      "frequency", cur_freq,
+                      "max-frequency", max_freq,
+                      NULL);
+
+        g_free (governor);
+
+        return TRUE;
+}
+
+
+
+
diff --git a/cpufreq/src/cpufreq-monitor-cpuinfo.h b/cpufreq/src/cpufreq-monitor-cpuinfo.h
new file mode 100644
index 00000000..ec58b405
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-cpuinfo.h
@@ -0,0 +1,50 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_MONITOR_CPUINFO_H__
+#define __CPUFREQ_MONITOR_CPUINFO_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-monitor.h"
+
+#define CPUFREQ_TYPE_MONITOR_CPUINFO            (cpufreq_monitor_cpuinfo_get_type ())
+#define CPUFREQ_MONITOR_CPUINFO(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_MONITOR_CPUINFO, CPUFreqMonitorCPUInfo))
+#define CPUFREQ_MONITOR_CPUINFO_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_MONITOR_CPUINFO, CPUFreqMonitorCPUInfoClass))
+#define CPUFREQ_IS_MONITOR_CPUINFO(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_MONITOR_CPUINFO))
+#define CPUFREQ_IS_MONITOR_CPUINFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_MONITOR_CPUINFO))
+#define CPUFREQ_MONITOR_CPUINFO_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_MONITOR_CPUINFO, CPUFreqMonitorCPUInfoClass))
+
+typedef struct _CPUFreqMonitorCPUInfo      CPUFreqMonitorCPUInfo;
+typedef struct _CPUFreqMonitorCPUInfoClass CPUFreqMonitorCPUInfoClass;
+
+struct _CPUFreqMonitorCPUInfo {
+        CPUFreqMonitor parent;
+};
+
+struct _CPUFreqMonitorCPUInfoClass {
+        CPUFreqMonitorClass parent_class;
+};
+
+GType           cpufreq_monitor_cpuinfo_get_type (void) G_GNUC_CONST;
+CPUFreqMonitor *cpufreq_monitor_cpuinfo_new      (guint cpu);
+
+#endif /* __CPUFREQ_MONITOR_CPUINFO_H__ */
diff --git a/cpufreq/src/cpufreq-monitor-factory.c b/cpufreq/src/cpufreq-monitor-factory.c
new file mode 100644
index 00000000..8b68082c
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-factory.c
@@ -0,0 +1,69 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include "cpufreq-applet.h"
+#include "cpufreq-utils.h"
+#include "cpufreq-monitor-sysfs.h"
+#include "cpufreq-monitor-procfs.h"
+#include "cpufreq-monitor-cpuinfo.h"
+#ifdef HAVE_LIBCPUFREQ
+#include "cpufreq-monitor-libcpufreq.h"
+#endif
+#include "cpufreq-monitor-factory.h"
+
+CPUFreqMonitor *
+cpufreq_monitor_factory_create_monitor (guint cpu)
+{
+	   CPUFreqMonitor *monitor = NULL;
+
+#ifdef HAVE_LIBCPUFREQ
+	   monitor = cpufreq_monitor_libcpufreq_new (cpu);
+	   return monitor;
+#endif	
+	   
+	   if (g_file_test ("/sys/devices/system/cpu/cpu0/cpufreq", G_FILE_TEST_EXISTS)) { /* 2.6 kernel */
+		   monitor = cpufreq_monitor_sysfs_new (cpu);
+	   } else if (g_file_test ("/proc/cpufreq", G_FILE_TEST_EXISTS)) { /* 2.4 kernel (Deprecated)*/
+		   monitor = cpufreq_monitor_procfs_new (cpu);
+	   } else if (g_file_test ("/proc/cpuinfo", G_FILE_TEST_EXISTS)) {
+		   /* If there is no cpufreq support it shows only the cpu frequency,
+		    * I think is better than do nothing. I have to notify it to the user, because
+		    * he could think that cpufreq is supported but it doesn't work succesfully
+		    */
+		   
+		   cpufreq_utils_display_error (_("CPU frequency scaling unsupported"),
+						_("You will not be able to modify the frequency of your machine.  "
+						  "Your machine may be misconfigured or not have hardware support "
+						  "for CPU frequency scaling."));
+		   
+		   monitor = cpufreq_monitor_cpuinfo_new (cpu);
+	   }
+	   
+	   return monitor;
+}
+
diff --git a/cpufreq/src/cpufreq-monitor-factory.h b/cpufreq/src/cpufreq-monitor-factory.h
new file mode 100644
index 00000000..6a14b5f1
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-factory.h
@@ -0,0 +1,33 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef CPUFREQ_MONITOR_FACTORY_H
+#define CPUFREQ_MONITOR_FACTORY_H
+
+#include "cpufreq-monitor.h"
+
+G_BEGIN_DECLS
+
+CPUFreqMonitor *cpufreq_monitor_factory_create_monitor (guint cpu);
+
+G_END_DECLS
+
+#endif /* CPUFREQ_MONITOR_FACTORY_H */
diff --git a/cpufreq/src/cpufreq-monitor-libcpufreq.c b/cpufreq/src/cpufreq-monitor-libcpufreq.c
new file mode 100644
index 00000000..494d9a66
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-libcpufreq.c
@@ -0,0 +1,199 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <stdlib.h>
+#include <cpufreq.h>
+
+#include "cpufreq-monitor-libcpufreq.h"
+#include "cpufreq-utils.h"
+
+static void     cpufreq_monitor_libcpufreq_class_init                (CPUFreqMonitorLibcpufreqClass *klass);
+
+static gboolean cpufreq_monitor_libcpufreq_run                       (CPUFreqMonitor *monitor);
+static GList   *cpufreq_monitor_libcpufreq_get_available_frequencies (CPUFreqMonitor *monitor);
+static GList   *cpufreq_monitor_libcpufreq_get_available_governors   (CPUFreqMonitor *monitor);
+
+G_DEFINE_TYPE (CPUFreqMonitorLibcpufreq, cpufreq_monitor_libcpufreq, CPUFREQ_TYPE_MONITOR)
+
+typedef struct cpufreq_policy                CPUFreqPolicy;
+typedef struct cpufreq_available_frequencies CPUFreqFrequencyList;
+typedef struct cpufreq_available_governors   CPUFreqGovernorList;
+
+static void
+cpufreq_monitor_libcpufreq_init (CPUFreqMonitorLibcpufreq *monitor)
+{
+}
+
+static GObject *
+cpufreq_monitor_libcpufreq_constructor (GType                  type,
+					guint                  n_construct_properties,
+					GObjectConstructParam *construct_params)
+{
+	GObject *object;
+	gulong   max_freq, min_freq;
+	guint    cpu;
+
+	object = G_OBJECT_CLASS (
+		cpufreq_monitor_libcpufreq_parent_class)->constructor (type,
+								       n_construct_properties,
+								       construct_params);
+	g_object_get (G_OBJECT (object),
+		      "cpu", &cpu,
+		      NULL);
+	
+	if (cpufreq_get_hardware_limits (cpu, &min_freq, &max_freq) != 0) {
+		g_warning ("Error getting CPUINFO_MAX\n");
+		max_freq = -1;
+	}
+
+	g_object_set (G_OBJECT (object),
+		      "max-frequency", max_freq,
+		      NULL);
+
+	return object;
+}
+
+static void
+cpufreq_monitor_libcpufreq_class_init (CPUFreqMonitorLibcpufreqClass *klass)
+{
+	GObjectClass        *object_class = G_OBJECT_CLASS (klass);
+        CPUFreqMonitorClass *monitor_class = CPUFREQ_MONITOR_CLASS (klass);
+
+	object_class->constructor = cpufreq_monitor_libcpufreq_constructor;
+	
+        monitor_class->run = cpufreq_monitor_libcpufreq_run;
+        monitor_class->get_available_frequencies = cpufreq_monitor_libcpufreq_get_available_frequencies;
+        monitor_class->get_available_governors = cpufreq_monitor_libcpufreq_get_available_governors;
+}
+
+CPUFreqMonitor *
+cpufreq_monitor_libcpufreq_new (guint cpu)
+{
+        CPUFreqMonitorLibcpufreq *monitor;
+
+        monitor = g_object_new (CPUFREQ_TYPE_MONITOR_LIBCPUFREQ,
+                                "cpu", cpu, NULL);
+
+        return CPUFREQ_MONITOR (monitor);
+}
+
+static gboolean
+cpufreq_monitor_libcpufreq_run (CPUFreqMonitor *monitor)
+{
+        guint          cpu;
+	CPUFreqPolicy *policy;
+
+        g_object_get (G_OBJECT (monitor), "cpu", &cpu, NULL);
+
+	policy = cpufreq_get_policy (cpu);
+	if (!policy) {
+		/* Check whether it failed because
+		 * cpu is not online.
+		 */
+		if (!cpufreq_cpu_exists (cpu)) {
+			g_object_set (G_OBJECT (monitor), "online", FALSE, NULL);
+			return TRUE;
+		}
+		return FALSE;
+	}
+
+        g_object_set (G_OBJECT (monitor),
+		      "online", TRUE,
+                      "governor", policy->governor,
+                      "frequency", cpufreq_get_freq_kernel (cpu),
+                      NULL);
+
+	cpufreq_put_policy (policy);
+        
+        return TRUE;
+}
+
+static gint
+compare (gconstpointer a, gconstpointer b)
+{
+        gint aa, bb;
+
+        aa = atoi ((gchar *) a);
+        bb = atoi ((gchar *) b);
+
+        if (aa == bb)
+                return 0;
+        else if (aa > bb)
+                return -1;
+        else
+                return 1;
+}
+
+static GList *
+cpufreq_monitor_libcpufreq_get_available_frequencies (CPUFreqMonitor *monitor)
+{
+	GList                *list = NULL;
+	guint                 cpu;
+	CPUFreqFrequencyList *freqs, *freq;
+
+        g_object_get (G_OBJECT (monitor),
+                      "cpu", &cpu, NULL);
+
+	freqs = cpufreq_get_available_frequencies (cpu);
+	if (!freqs)
+		return NULL;
+
+	for (freq = freqs; freq; freq = freq->next) {
+		gchar *frequency;
+
+		frequency = g_strdup_printf ("%lu", freq->frequency);
+		
+		if (!g_list_find_custom (list, frequency, compare))
+			list = g_list_prepend (list, frequency);
+		else
+			g_free (frequency);
+	}
+
+	cpufreq_put_available_frequencies (freqs);
+
+        return g_list_sort (list, compare);
+}
+
+static GList *
+cpufreq_monitor_libcpufreq_get_available_governors (CPUFreqMonitor *monitor)
+{
+	guint                cpu;
+        GList               *list = NULL;
+	CPUFreqGovernorList *govs, *gov;
+
+        g_object_get (G_OBJECT (monitor),
+                      "cpu", &cpu, NULL);
+        
+	govs = cpufreq_get_available_governors (cpu);
+	if (!govs)
+		return NULL;
+
+	for (gov = govs; gov; gov = gov->next) {
+		list = g_list_prepend (list, g_strdup (gov->governor));
+	}
+
+	cpufreq_put_available_governors (govs);
+
+        return list;
+}
diff --git a/cpufreq/src/cpufreq-monitor-libcpufreq.h b/cpufreq/src/cpufreq-monitor-libcpufreq.h
new file mode 100644
index 00000000..7b41ea6b
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-libcpufreq.h
@@ -0,0 +1,56 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_MONITOR_LIBCPUFREQ_H__
+#define __CPUFREQ_MONITOR_LIBCPUFREQ_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-monitor.h"
+
+#define CPUFREQ_TYPE_MONITOR_LIBCPUFREQ            \
+	(cpufreq_monitor_libcpufreq_get_type ())
+#define CPUFREQ_MONITOR_LIBCPUFREQ(obj)            \
+	(G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_MONITOR_LIBCPUFREQ, CPUFreqMonitorLibcpufreq))
+#define CPUFREQ_MONITOR_LIBCPUFREQ_CLASS(klass)    \
+	(G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_MONITOR_LIBCPUFREQ, CPUFreqMonitorLibcpufreqClass))
+#define CPUFREQ_IS_MONITOR_LIBCPUFREQ(obj)         \
+	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_MONITOR_LIBCPUFREQ))
+#define CPUFREQ_IS_MONITOR_LIBCPUFREQ_CLASS(klass) \
+	(G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_MONITOR_LIBCPUFREQ))
+#define CPUFREQ_MONITOR_LIBCPUFREQ_GET_CLASS(obj)  \
+	(G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_MONITOR_LIBCPUFREQ, CPUFreqMonitorLibcpufreqClass))
+
+typedef struct _CPUFreqMonitorLibcpufreq      CPUFreqMonitorLibcpufreq;
+typedef struct _CPUFreqMonitorLibcpufreqClass CPUFreqMonitorLibcpufreqClass;
+
+struct _CPUFreqMonitorLibcpufreq {
+        CPUFreqMonitor parent;
+};
+
+struct _CPUFreqMonitorLibcpufreqClass {
+        CPUFreqMonitorClass parent_class;
+};
+
+GType           cpufreq_monitor_libcpufreq_get_type (void) G_GNUC_CONST;
+CPUFreqMonitor *cpufreq_monitor_libcpufreq_new      (guint cpu);
+
+#endif /* __CPUFREQ_MONITOR_LIBCPUFREQ_H__ */
diff --git a/cpufreq/src/cpufreq-monitor-procfs.c b/cpufreq/src/cpufreq-monitor-procfs.c
new file mode 100644
index 00000000..97c635ba
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-procfs.c
@@ -0,0 +1,221 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "cpufreq-monitor-procfs.h"
+#include "cpufreq-utils.h"
+
+static void     cpufreq_monitor_procfs_class_init                (CPUFreqMonitorProcfsClass *klass);
+
+static gboolean cpufreq_monitor_procfs_run                       (CPUFreqMonitor       *monitor);
+static GList   *cpufreq_monitor_procfs_get_available_frequencies (CPUFreqMonitor       *monitor);
+
+G_DEFINE_TYPE (CPUFreqMonitorProcfs, cpufreq_monitor_procfs, CPUFREQ_TYPE_MONITOR)
+
+static void
+cpufreq_monitor_procfs_init (CPUFreqMonitorProcfs *monitor)
+{
+}
+
+static void
+cpufreq_monitor_procfs_class_init (CPUFreqMonitorProcfsClass *klass)
+{
+	CPUFreqMonitorClass *monitor_class = CPUFREQ_MONITOR_CLASS (klass);
+	
+	monitor_class->run = cpufreq_monitor_procfs_run;
+	monitor_class->get_available_frequencies = cpufreq_monitor_procfs_get_available_frequencies;
+}
+
+CPUFreqMonitor *
+cpufreq_monitor_procfs_new (guint cpu)
+{
+	   CPUFreqMonitorProcfs *monitor;
+
+	   monitor = g_object_new (TYPE_CPUFREQ_MONITOR_PROCFS, "cpu", cpu, NULL);
+
+	   return CPUFREQ_MONITOR (monitor);
+}
+
+static gint
+cpufreq_monitor_procfs_get_freq_from_userspace (guint cpu)
+{
+	gchar  *buffer = NULL;
+	gchar  *path;
+	gchar  *p;
+	gchar  *frequency;
+	gint    freq;
+	gint    len;
+	GError *error = NULL;
+	
+	path = g_strdup_printf ("/proc/sys/cpu/%u/speed", cpu);
+
+	if (!cpufreq_file_get_contents (path, &buffer, NULL, &error)) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		g_free (path);
+
+		return -1;
+	}
+
+	g_free (path);
+	
+	/* Try to remove the '\n' */
+	p = g_strrstr (buffer, "\n");
+	len = strlen (buffer);
+	if (p)
+		len -= strlen (p);
+
+	frequency = g_strndup (buffer, len);
+	g_free (buffer);
+	
+	freq = atoi (frequency);
+	g_free (frequency);
+	
+	return freq;
+}
+
+static gboolean
+cpufreq_monitor_procfs_parse (CPUFreqMonitorProcfs *monitor,
+			      gint                 *cpu,
+			      gint                 *fmax,
+			      gint                 *pmin,
+			      gint                 *pmax,
+			      gint                 *fmin,
+			      gchar                *mode)
+{
+	gchar **lines;
+	gchar  *buffer = NULL;
+	gint    i, count;
+	guint   mon_cpu;
+	GError *error = NULL;
+
+	if (!cpufreq_file_get_contents ("/proc/cpufreq", &buffer, NULL, &error)) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		return FALSE;
+	}
+	
+	g_object_get (G_OBJECT (monitor),
+		      "cpu", &mon_cpu, NULL);
+	
+	count = 0;
+	lines = g_strsplit (buffer, "\n", -1);
+	for (i = 0; lines[i]; i++) {
+		if (g_ascii_strncasecmp (lines[i], "CPU", 3) == 0) {
+			/* CPU  0       650000 kHz ( 81 %)  -     800000 kHz (100 %)  -  powersave */
+			count = sscanf (lines[i], "CPU %d %d kHz (%d %%) - %d kHz (%d %%) - %20s",
+					cpu, fmin, pmin, fmax, pmax, mode);
+			
+			if ((guint)(*cpu) == mon_cpu)
+				break;
+		}
+	}
+	
+	g_strfreev (lines);
+	g_free (buffer);
+
+	return (count == 6);
+}	   
+
+static gboolean
+cpufreq_procfs_cpu_is_online (void)
+{
+	return g_file_test ("/proc/cpufreq",
+			    G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR);
+}
+
+static gboolean
+cpufreq_monitor_procfs_run (CPUFreqMonitor *monitor)
+{
+	gint   fmax, fmin, cpu;
+	gint   pmin, pmax;
+	gchar  mode[21];
+	gint   cur_freq, max_freq;
+	gchar *governor;
+
+	if (!cpufreq_monitor_procfs_parse (CPUFREQ_MONITOR_PROCFS (monitor),
+					   &cpu, &fmax, &pmin, &pmax, &fmin, mode)) {
+		/* Check whether it failed because
+		 * cpu is not online.
+		 */
+		if (!cpufreq_procfs_cpu_is_online ()) {
+			g_object_set (G_OBJECT (monitor), "online", FALSE, NULL);
+			return TRUE;
+		}
+		return FALSE;
+	}
+	
+	governor = mode;
+	max_freq = fmax;
+	
+	if (g_ascii_strcasecmp (governor, "powersave") == 0) {
+		cur_freq = fmin;
+	} else if (g_ascii_strcasecmp (governor, "performance") == 0) {
+		cur_freq = fmax;
+	} else if (g_ascii_strcasecmp (governor, "userspace") == 0) {
+		cur_freq = cpufreq_monitor_procfs_get_freq_from_userspace (cpu);
+	} else {
+		cur_freq = fmax;
+	}
+
+	g_object_set (G_OBJECT (monitor),
+		      "online", TRUE,
+		      "governor", governor,
+		      "frequency", cur_freq,
+		      "max-frequency", max_freq,
+		      NULL);
+
+	return TRUE;
+}
+
+static GList *
+cpufreq_monitor_procfs_get_available_frequencies (CPUFreqMonitor *monitor)
+{
+	gint   fmax, fmin, cpu, freq;
+	gint   pmin, pmax;
+	gchar  mode[21];
+	GList *list = NULL;
+	
+	if (!cpufreq_monitor_procfs_parse (CPUFREQ_MONITOR_PROCFS (monitor), &cpu,
+					   &fmax, &pmin, &pmax, &fmin, mode)) {
+		return NULL;
+	}
+	
+	if ((pmax > 0) && (pmax != 100)) {
+		freq = (fmax * 100) / pmax;
+		list = g_list_prepend (list, g_strdup_printf ("%d", freq));
+	}
+	
+	list = g_list_prepend (list, g_strdup_printf ("%d", fmax));
+	if (fmax != fmin)
+		list = g_list_prepend (list, g_strdup_printf ("%d", fmin));
+
+	return g_list_reverse (list);
+}
+
diff --git a/cpufreq/src/cpufreq-monitor-procfs.h b/cpufreq/src/cpufreq-monitor-procfs.h
new file mode 100644
index 00000000..62649152
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-procfs.h
@@ -0,0 +1,54 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_MONITOR_PROCFS_H__
+#define __CPUFREQ_MONITOR_PROCFS_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-monitor.h"
+
+G_BEGIN_DECLS
+
+#define TYPE_CPUFREQ_MONITOR_PROCFS            (cpufreq_monitor_procfs_get_type ())
+#define CPUFREQ_MONITOR_PROCFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CPUFREQ_MONITOR_PROCFS, CPUFreqMonitorProcfs))
+#define CPUFREQ_MONITOR_PROCFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_CPUFREQ_MONITOR_PROCFS, CPUFreqMonitorProcfsClass))
+#define IS_CPUFREQ_MONITOR_PROCFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CPUFREQ_MONITOR_PROCFS))
+#define IS_CPUFREQ_MONITOR_PROCFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CPUFREQ_MONITOR_PROCFS))
+#define CPUFREQ_MONITOR_PROCFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CPUFREQ_MONITOR_PROCFS, CPUFreqMonitorProcfsClass))
+
+typedef struct _CPUFreqMonitorProcfs      CPUFreqMonitorProcfs;
+typedef struct _CPUFreqMonitorProcfsClass CPUFreqMonitorProcfsClass;
+
+struct _CPUFreqMonitorProcfs {
+	   CPUFreqMonitor parent;
+};
+
+struct _CPUFreqMonitorProcfsClass {
+	   CPUFreqMonitorClass parent_class;
+};
+
+GType           cpufreq_monitor_procfs_get_type (void) G_GNUC_CONST;
+CPUFreqMonitor *cpufreq_monitor_procfs_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_MONITOR_PROCFS_H__ */
diff --git a/cpufreq/src/cpufreq-monitor-sysfs.c b/cpufreq/src/cpufreq-monitor-sysfs.c
new file mode 100644
index 00000000..a123a36f
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-sysfs.c
@@ -0,0 +1,345 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "cpufreq-monitor-sysfs.h"
+#include "cpufreq-utils.h"
+
+enum {
+        SCALING_MAX,
+        SCALING_MIN,
+        GOVERNOR,
+        CPUINFO_MAX,
+        SCALING_SETSPEED,
+        SCALING_CUR_FREQ,
+        N_FILES
+};
+
+static void     cpufreq_monitor_sysfs_class_init                (CPUFreqMonitorSysfsClass *klass);
+
+static gboolean cpufreq_monitor_sysfs_run                       (CPUFreqMonitor *monitor);
+static GList   *cpufreq_monitor_sysfs_get_available_frequencies (CPUFreqMonitor *monitor);
+static GList   *cpufreq_monitor_sysfs_get_available_governors   (CPUFreqMonitor *monitor);
+
+static gchar   *cpufreq_sysfs_read                              (const gchar    *path,
+								 GError        **error);
+
+/* /sys/devices/system/cpu/cpu[0]/cpufreq/scaling_max_freq
+ * /sys/devices/system/cpu/cpu[0]/cpufreq/scaling_min_freq
+ * /sys/devices/system/cpu/cpu[0]/cpufreq/scaling_governor
+ * /sys/devices/system/cpu/cpu[0]/cpufreq/cpuinfo_max_freq
+ * /sys/devices/system/cpu/cpu[0]/cpufreq/scaling_setspeed (userspace)
+ * /sys/devices/system/cpu/cpu[0]/cpufreq/scaling_cur_freq (new governors)
+ */
+const gchar *monitor_sysfs_files[] = {
+        "scaling_max_freq",
+        "scaling_min_freq",
+        "scaling_governor",
+        "cpuinfo_max_freq",
+        "scaling_setspeed",
+        "scaling_cur_freq",
+        NULL
+};
+
+#define CPUFREQ_SYSFS_BASE_PATH "/sys/devices/system/cpu/cpu%u/cpufreq/%s"
+
+G_DEFINE_TYPE (CPUFreqMonitorSysfs, cpufreq_monitor_sysfs, CPUFREQ_TYPE_MONITOR)
+
+static void
+cpufreq_monitor_sysfs_init (CPUFreqMonitorSysfs *monitor)
+{
+}
+
+static GObject *
+cpufreq_monitor_sysfs_constructor (GType                  type,
+				   guint                  n_construct_properties,
+				   GObjectConstructParam *construct_params)
+{
+	GObject *object;
+	gchar   *path;
+	gchar   *frequency;
+	gint     max_freq;
+	guint    cpu;
+	GError  *error = NULL;
+
+	object = G_OBJECT_CLASS (
+		cpufreq_monitor_sysfs_parent_class)->constructor (type,
+								  n_construct_properties,
+								  construct_params);
+	g_object_get (G_OBJECT (object),
+		      "cpu", &cpu,
+		      NULL);
+	
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH,
+				cpu, monitor_sysfs_files[CPUINFO_MAX]);
+	
+	frequency = cpufreq_sysfs_read (path, &error);
+	if (!frequency) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+		max_freq = -1;
+	} else {
+		max_freq = atoi (frequency);
+	}
+
+	g_free (path);
+	g_free (frequency);
+
+	g_object_set (G_OBJECT (object),
+		      "max-frequency", max_freq,
+		      NULL);
+
+	return object;
+}
+
+static void
+cpufreq_monitor_sysfs_class_init (CPUFreqMonitorSysfsClass *klass)
+{
+	GObjectClass        *object_class = G_OBJECT_CLASS (klass);
+        CPUFreqMonitorClass *monitor_class = CPUFREQ_MONITOR_CLASS (klass);
+
+	object_class->constructor = cpufreq_monitor_sysfs_constructor;
+	
+        monitor_class->run = cpufreq_monitor_sysfs_run;
+        monitor_class->get_available_frequencies = cpufreq_monitor_sysfs_get_available_frequencies;
+        monitor_class->get_available_governors = cpufreq_monitor_sysfs_get_available_governors;
+}
+
+CPUFreqMonitor *
+cpufreq_monitor_sysfs_new (guint cpu)
+{
+        CPUFreqMonitorSysfs *monitor;
+
+        monitor = g_object_new (CPUFREQ_TYPE_MONITOR_SYSFS,
+                                "cpu", cpu, NULL);
+
+        return CPUFREQ_MONITOR (monitor);
+}
+
+static gchar *
+cpufreq_sysfs_read (const gchar *path,
+		    GError     **error)
+{
+	gchar *buffer = NULL;
+
+	if (!cpufreq_file_get_contents (path, &buffer, NULL, error)) {
+		return NULL;
+	}
+	
+	return g_strchomp (buffer);
+}
+
+static gboolean
+cpufreq_sysfs_cpu_is_online (guint cpu)
+{
+	gchar   *path;
+	gboolean retval;
+	
+	path = g_strdup_printf ("/sys/devices/system/cpu/cpu%u/", cpu);
+	retval = g_file_test (path, G_FILE_TEST_IS_DIR);
+	g_free (path);
+
+	return retval;
+}
+
+static gboolean
+cpufreq_monitor_sysfs_run (CPUFreqMonitor *monitor)
+{
+        guint   cpu;
+	gchar  *frequency;
+        gchar  *governor;
+	gchar  *path;
+	GError *error = NULL;
+
+        g_object_get (G_OBJECT (monitor),
+		      "cpu", &cpu,
+		      NULL);
+
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH,
+				cpu, monitor_sysfs_files[GOVERNOR]);
+	governor = cpufreq_sysfs_read (path, &error);
+	if (!governor) {
+		gboolean retval = FALSE;
+		
+		/* Check whether it failed because
+		 * cpu is not online.
+		 */
+		if (!cpufreq_sysfs_cpu_is_online (cpu)) {
+			g_object_set (G_OBJECT (monitor), "online", FALSE, NULL);
+			retval = TRUE;
+		} else {
+			g_warning ("%s", error->message);
+		}
+		
+		g_error_free (error);
+		g_free (path);
+
+		return retval;
+	}
+	
+	g_free (path);
+
+	if (g_ascii_strcasecmp (governor, "userspace") == 0) {
+		path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH,
+					cpu, monitor_sysfs_files[SCALING_SETSPEED]);
+	} else if (g_ascii_strcasecmp (governor, "powersave") == 0) {
+		path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH,
+					cpu, monitor_sysfs_files[SCALING_MIN]);
+	} else if (g_ascii_strcasecmp (governor, "performance") == 0) {
+		path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH,
+					cpu, monitor_sysfs_files[SCALING_MAX]);
+	} else { /* Ondemand, Conservative, ... */
+		path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH,
+					cpu, monitor_sysfs_files[SCALING_CUR_FREQ]);
+	}
+
+	frequency = cpufreq_sysfs_read (path, &error);
+	if (!frequency) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+		g_free (path);
+		g_free (governor);
+
+		return FALSE;
+	}
+
+	g_free (path);
+
+	g_object_set (G_OBJECT (monitor),
+		      "online", TRUE,
+		      "governor", governor,
+		      "frequency", atoi (frequency),
+		      NULL);
+
+	g_free (governor);
+	g_free (frequency);
+	
+        return TRUE;
+}
+
+static gint
+compare (gconstpointer a, gconstpointer b)
+{
+        gint aa, bb;
+
+        aa = atoi ((gchar *) a);
+        bb = atoi ((gchar *) b);
+
+        if (aa == bb)
+                return 0;
+        else if (aa > bb)
+                return -1;
+        else
+                return 1;
+}
+
+static GList *
+cpufreq_monitor_sysfs_get_available_frequencies (CPUFreqMonitor *monitor)
+{
+        gchar  *path;
+        GList  *list = NULL;
+        gchar **frequencies = NULL;
+        gint    i;
+        guint   cpu;
+        gchar  *buffer = NULL;
+        GError *error = NULL;
+
+        g_object_get (G_OBJECT (monitor),
+                      "cpu", &cpu, NULL);
+
+        path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu, 
+                                "scaling_available_frequencies");
+
+        if (!cpufreq_file_get_contents (path, &buffer, NULL, &error)) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+
+                g_free (path);
+
+                return NULL;
+        }
+
+        g_free (path);
+        
+        buffer = g_strchomp (buffer);
+        frequencies = g_strsplit (buffer, " ", -1);
+
+        i = 0;
+        while (frequencies[i]) {
+                if (!g_list_find_custom (list, frequencies[i], compare))
+                        list = g_list_prepend (list, g_strdup (frequencies[i]));
+                i++;
+        }
+           
+        g_strfreev (frequencies);
+        g_free (buffer);
+
+        return g_list_sort (list, compare);
+}
+
+static GList *
+cpufreq_monitor_sysfs_get_available_governors (CPUFreqMonitor *monitor)
+{
+        gchar   *path;
+        GList   *list = NULL;
+        gchar  **governors = NULL;
+        gint     i;
+        guint    cpu;
+        gchar   *buffer = NULL;
+        GError  *error = NULL;
+
+        g_object_get (G_OBJECT (monitor),
+                      "cpu", &cpu, NULL);
+        
+        path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+                                "scaling_available_governors");
+
+        if (!cpufreq_file_get_contents (path, &buffer, NULL, &error)) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+
+                g_free (path);
+
+                return NULL;
+        }
+
+        g_free (path);
+        
+        buffer = g_strchomp (buffer);
+
+        governors = g_strsplit (buffer, " ", -1);
+
+        i = 0;
+        while (governors[i] != NULL) {
+                list = g_list_prepend (list, g_strdup (governors[i]));
+                i++;
+        }
+           
+        g_strfreev (governors);
+        g_free (buffer);
+
+        return list;
+}
diff --git a/cpufreq/src/cpufreq-monitor-sysfs.h b/cpufreq/src/cpufreq-monitor-sysfs.h
new file mode 100644
index 00000000..ee75dd9b
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor-sysfs.h
@@ -0,0 +1,54 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_MONITOR_SYSFS_H__
+#define __CPUFREQ_MONITOR_SYSFS_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-monitor.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_MONITOR_SYSFS            (cpufreq_monitor_sysfs_get_type ())
+#define CPUFREQ_MONITOR_SYSFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_MONITOR_SYSFS, CPUFreqMonitorSysfs))
+#define CPUFREQ_MONITOR_SYSFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_MONITOR_SYSFS, CPUFreqMonitorSysfsClass))
+#define CPUFREQ_IS_MONITOR_SYSFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_MONITOR_SYSFS))
+#define CPUFREQ_IS_MONITOR_SYSFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_MONITOR_SYSFS))
+#define CPUFREQ_MONITOR_SYSFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_MONITOR_SYSFS, CPUFreqMonitorSysfsClass))
+
+typedef struct _CPUFreqMonitorSysfs      CPUFreqMonitorSysfs;
+typedef struct _CPUFreqMonitorSysfsClass CPUFreqMonitorSysfsClass;
+
+struct _CPUFreqMonitorSysfs {
+        CPUFreqMonitor parent;
+};
+
+struct _CPUFreqMonitorSysfsClass {
+        CPUFreqMonitorClass parent_class;
+};
+
+GType           cpufreq_monitor_sysfs_get_type (void) G_GNUC_CONST;
+CPUFreqMonitor *cpufreq_monitor_sysfs_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_MONITOR_SYSFS_H__ */
diff --git a/cpufreq/src/cpufreq-monitor.c b/cpufreq/src/cpufreq-monitor.c
new file mode 100644
index 00000000..662c94a9
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor.c
@@ -0,0 +1,411 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include "cpufreq-monitor.h"
+
+#define CPUFREQ_MONITOR_GET_PRIVATE(obj) \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj), CPUFREQ_TYPE_MONITOR, CPUFreqMonitorPrivate))
+
+#define CPUFREQ_MONITOR_INTERVAL 1
+
+/* Properties */
+enum {
+        PROP_0,
+        PROP_CPU,
+        PROP_ONLINE,
+        PROP_FREQUENCY,
+        PROP_MAX_FREQUENCY,
+        PROP_GOVERNOR
+};
+
+/* Signals */
+enum {
+        SIGNAL_CHANGED,
+        N_SIGNALS
+};
+
+struct _CPUFreqMonitorPrivate {
+        guint    cpu;
+        gboolean online;
+        gint     cur_freq;
+        gint     max_freq;
+        gchar   *governor;
+        GList   *available_freqs;
+        GList   *available_govs;
+        guint    timeout_handler;
+
+        gboolean changed;
+};
+
+static void   cpufreq_monitor_init         (CPUFreqMonitor      *monitor);
+static void   cpufreq_monitor_class_init   (CPUFreqMonitorClass *klass);
+static void   cpufreq_monitor_finalize     (GObject             *object);
+
+static void   cpufreq_monitor_set_property (GObject             *object,
+                                            guint                prop_id,
+                                            const GValue        *value,
+                                            GParamSpec          *spec);
+static void   cpufreq_monitor_get_property (GObject             *object,
+                                            guint                prop_id,
+                                            GValue              *value,
+                                            GParamSpec          *spec);
+
+static guint signals[N_SIGNALS];
+
+G_DEFINE_ABSTRACT_TYPE (CPUFreqMonitor, cpufreq_monitor, G_TYPE_OBJECT)
+
+static void
+cpufreq_monitor_init (CPUFreqMonitor *monitor)
+{
+        monitor->priv = CPUFREQ_MONITOR_GET_PRIVATE (monitor);
+
+        monitor->priv->governor = NULL;
+        monitor->priv->available_freqs = NULL;
+        monitor->priv->available_govs = NULL;
+        monitor->priv->timeout_handler = 0;
+
+        monitor->priv->changed = FALSE;
+}
+
+static void
+cpufreq_monitor_class_init (CPUFreqMonitorClass *klass)
+{
+        GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+        object_class->set_property = cpufreq_monitor_set_property;
+        object_class->get_property = cpufreq_monitor_get_property;
+
+        /* Public virtual methods */
+        klass->run = NULL;
+        klass->get_available_frequencies = NULL;
+        klass->get_available_governors = NULL;
+
+        g_type_class_add_private (klass, sizeof (CPUFreqMonitorPrivate));
+        
+        /* Porperties */
+        g_object_class_install_property (object_class,
+                                         PROP_CPU,
+                                         g_param_spec_uint ("cpu",
+                                                            "CPU",
+                                                            "The cpu to monitor",
+                                                            0, 
+                                                            G_MAXUINT,
+                                                            0, 
+                                                            G_PARAM_CONSTRUCT |
+                                                            G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_ONLINE,
+                                         g_param_spec_boolean ("online",
+                                                               "Online",
+                                                               "Whether cpu is online",
+                                                               TRUE,
+                                                               G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_FREQUENCY,
+                                         g_param_spec_int ("frequency",
+                                                           "Frequency",
+                                                           "The current cpu frequency",
+                                                           0, 
+                                                           G_MAXINT,
+                                                           0,
+                                                           G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_MAX_FREQUENCY,
+                                         g_param_spec_int ("max-frequency",
+                                                           "MaxFrequency",
+                                                           "The max cpu frequency",
+                                                           0,
+                                                           G_MAXINT,
+                                                           0,
+                                                           G_PARAM_READWRITE));
+        g_object_class_install_property (object_class,
+                                         PROP_GOVERNOR,
+                                         g_param_spec_string ("governor",
+                                                              "Governor",
+                                                              "The current cpufreq governor",
+                                                              NULL,
+                                                              G_PARAM_READWRITE));
+
+        /* Signals */
+        signals[SIGNAL_CHANGED] =
+                g_signal_new ("changed",
+                              G_TYPE_FROM_CLASS (klass),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (CPUFreqMonitorClass, changed),
+                              NULL, NULL,
+                              g_cclosure_marshal_VOID__VOID,
+                              G_TYPE_NONE, 0);
+           
+        object_class->finalize = cpufreq_monitor_finalize;
+}
+
+static void
+cpufreq_monitor_finalize (GObject *object)
+{
+        CPUFreqMonitor *monitor = CPUFREQ_MONITOR (object);
+
+        monitor->priv->online = FALSE;
+        
+        if (monitor->priv->timeout_handler > 0) {
+                g_source_remove (monitor->priv->timeout_handler);
+                monitor->priv->timeout_handler = 0;
+        }
+
+        if (monitor->priv->governor) {
+                g_free (monitor->priv->governor);
+                monitor->priv->governor = NULL;
+        }
+
+        if (monitor->priv->available_freqs) {
+                g_list_foreach (monitor->priv->available_freqs,
+                                (GFunc) g_free,
+                                NULL);
+                g_list_free (monitor->priv->available_freqs);
+                monitor->priv->available_freqs = NULL;
+        }
+
+        if (monitor->priv->available_govs) {
+                g_list_foreach (monitor->priv->available_govs,
+                                (GFunc) g_free,
+                                NULL);
+                g_list_free (monitor->priv->available_govs);
+                monitor->priv->available_govs = NULL;
+        }
+
+        G_OBJECT_CLASS (cpufreq_monitor_parent_class)->finalize (object);
+}
+
+static void
+cpufreq_monitor_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *spec)
+{
+        CPUFreqMonitor *monitor;
+
+        monitor = CPUFREQ_MONITOR (object);
+
+        switch (prop_id) {
+        case PROP_CPU: {
+                guint cpu = g_value_get_uint (value);
+
+                if (cpu != monitor->priv->cpu) {
+                        monitor->priv->cpu = cpu;
+                        monitor->priv->changed = TRUE;
+                }
+        }
+                break;
+        case PROP_ONLINE:
+                monitor->priv->online = g_value_get_boolean (value);
+
+                break;
+        case PROP_FREQUENCY: {
+                gint freq = g_value_get_int (value);
+
+                if (freq != monitor->priv->cur_freq) {
+                        monitor->priv->cur_freq = freq;
+                        monitor->priv->changed = TRUE;
+                }
+        }
+                break;
+        case PROP_MAX_FREQUENCY: {
+                gint freq = g_value_get_int (value);
+
+                if (freq != monitor->priv->max_freq) {
+                        monitor->priv->max_freq = freq;
+                        monitor->priv->changed = TRUE;
+                }
+        }
+                break;
+        case PROP_GOVERNOR: {
+                const gchar *gov = g_value_get_string (value);
+
+                if (monitor->priv->governor) {
+                        if (g_ascii_strcasecmp (gov, monitor->priv->governor) != 0) {
+                                g_free (monitor->priv->governor);
+                                monitor->priv->governor = gov ? g_strdup (gov) : NULL;
+                                monitor->priv->changed = TRUE;
+                        }
+                } else {
+                        monitor->priv->governor = gov ? g_strdup (gov) : NULL;
+                        monitor->priv->changed = TRUE;
+                }
+        }
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
+                break;
+        }
+}
+
+static void
+cpufreq_monitor_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *spec)
+{
+        CPUFreqMonitor *monitor;
+
+        monitor = CPUFREQ_MONITOR (object);
+
+        switch (prop_id) {
+        case PROP_CPU:
+                g_value_set_uint (value, monitor->priv->cpu);
+                break;
+        case PROP_ONLINE:
+                g_value_set_boolean (value, monitor->priv->online);
+                break;
+        case PROP_FREQUENCY:
+                g_value_set_int (value, monitor->priv->cur_freq);
+                break;
+        case PROP_MAX_FREQUENCY:
+                g_value_set_int (value, monitor->priv->max_freq);
+                break;
+        case PROP_GOVERNOR:
+                g_value_set_string (value, monitor->priv->governor);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
+                break;
+        }
+}
+
+static gboolean
+cpufreq_monitor_run_cb (CPUFreqMonitor *monitor)
+{
+        CPUFreqMonitorClass *class;
+        gboolean             retval = FALSE;
+
+        class = CPUFREQ_MONITOR_GET_CLASS (monitor);
+        
+        if (class->run)
+                retval = class->run (monitor);
+
+        if (monitor->priv->changed) {
+                g_signal_emit (monitor, signals[SIGNAL_CHANGED], 0);
+                monitor->priv->changed = FALSE;
+        }
+
+        return retval;
+}
+
+void
+cpufreq_monitor_run (CPUFreqMonitor *monitor)
+{
+        g_return_if_fail (CPUFREQ_IS_MONITOR (monitor));
+
+        if (monitor->priv->timeout_handler > 0)
+                return;
+
+        monitor->priv->timeout_handler =
+                g_timeout_add_seconds (CPUFREQ_MONITOR_INTERVAL,
+                               (GSourceFunc) cpufreq_monitor_run_cb,
+                               (gpointer) monitor);
+}
+
+GList *
+cpufreq_monitor_get_available_frequencies (CPUFreqMonitor *monitor)
+{
+        CPUFreqMonitorClass *class;
+        
+        g_return_val_if_fail (CPUFREQ_IS_MONITOR (monitor), NULL);
+
+        if (!monitor->priv->online)
+                return NULL;
+        
+        if (monitor->priv->available_freqs)
+                return monitor->priv->available_freqs;
+
+        class = CPUFREQ_MONITOR_GET_CLASS (monitor);
+        
+        if (class->get_available_frequencies) {
+                monitor->priv->available_freqs = class->get_available_frequencies (monitor);
+        }
+
+        return monitor->priv->available_freqs;
+}
+
+GList *
+cpufreq_monitor_get_available_governors (CPUFreqMonitor *monitor)
+{
+        CPUFreqMonitorClass *class;
+        
+        g_return_val_if_fail (CPUFREQ_IS_MONITOR (monitor), NULL);
+
+        if (!monitor->priv->online)
+                return NULL;
+        
+        if (monitor->priv->available_govs)
+                return monitor->priv->available_govs;
+
+        class = CPUFREQ_MONITOR_GET_CLASS (monitor);
+        
+        if (class->get_available_governors) {
+                monitor->priv->available_govs = class->get_available_governors (monitor);
+        }
+
+        return monitor->priv->available_govs;
+}
+
+guint
+cpufreq_monitor_get_cpu (CPUFreqMonitor *monitor)
+{
+        g_return_val_if_fail (CPUFREQ_IS_MONITOR (monitor), 0);
+
+        return monitor->priv->cpu;
+}
+
+void
+cpufreq_monitor_set_cpu (CPUFreqMonitor *monitor, guint cpu)
+{
+        g_return_if_fail (CPUFREQ_IS_MONITOR (monitor));
+
+        g_object_set (G_OBJECT (monitor),
+                      "cpu", cpu, NULL);
+}
+
+gint
+cpufreq_monitor_get_frequency (CPUFreqMonitor *monitor)
+{
+        g_return_val_if_fail (CPUFREQ_IS_MONITOR (monitor), -1);
+
+        return monitor->priv->cur_freq;
+}
+
+const gchar *
+cpufreq_monitor_get_governor (CPUFreqMonitor *monitor)
+{
+        g_return_val_if_fail (CPUFREQ_IS_MONITOR (monitor), NULL);
+
+        return monitor->priv->governor;
+}
+
+gint
+cpufreq_monitor_get_percentage (CPUFreqMonitor *monitor)
+{
+        g_return_val_if_fail (CPUFREQ_IS_MONITOR (monitor), -1);
+
+        if (monitor->priv->max_freq > 0) {
+                return ((monitor->priv->cur_freq * 100) / monitor->priv->max_freq);
+        }
+
+        return -1;
+}
diff --git a/cpufreq/src/cpufreq-monitor.h b/cpufreq/src/cpufreq-monitor.h
new file mode 100644
index 00000000..0b9ac508
--- /dev/null
+++ b/cpufreq/src/cpufreq-monitor.h
@@ -0,0 +1,72 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_MONITOR_H__
+#define __CPUFREQ_MONITOR_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_MONITOR            (cpufreq_monitor_get_type ())
+#define CPUFREQ_MONITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_MONITOR, CPUFreqMonitor))
+#define CPUFREQ_MONITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_MONITOR, CPUFreqMonitorClass))
+#define CPUFREQ_IS_MONITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_MONITOR))
+#define CPUFREQ_IS_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_MONITOR))
+#define CPUFREQ_MONITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_MONITOR, CPUFreqMonitorClass))
+
+typedef struct _CPUFreqMonitor        CPUFreqMonitor;
+typedef struct _CPUFreqMonitorClass   CPUFreqMonitorClass;
+typedef struct _CPUFreqMonitorPrivate CPUFreqMonitorPrivate;
+
+struct _CPUFreqMonitor {
+        GObject parent;
+
+        CPUFreqMonitorPrivate *priv;
+};
+
+struct _CPUFreqMonitorClass {
+        GObjectClass parent_class;
+
+        gboolean  (* run)                       (CPUFreqMonitor *monitor);
+        GList    *(* get_available_frequencies) (CPUFreqMonitor *monitor);
+        GList    *(* get_available_governors)   (CPUFreqMonitor *monitor);
+
+        /*< signals >*/
+        void      (* changed)                   (CPUFreqMonitor *monitor);
+};
+
+GType        cpufreq_monitor_get_type                  (void) G_GNUC_CONST;
+
+void         cpufreq_monitor_run                       (CPUFreqMonitor *monitor);
+GList       *cpufreq_monitor_get_available_frequencies (CPUFreqMonitor *monitor);
+GList       *cpufreq_monitor_get_available_governors   (CPUFreqMonitor *monitor);
+
+guint        cpufreq_monitor_get_cpu                   (CPUFreqMonitor *monitor);
+void         cpufreq_monitor_set_cpu                   (CPUFreqMonitor *monitor,
+							guint           cpu);
+const gchar *cpufreq_monitor_get_governor              (CPUFreqMonitor *monitor);
+gint         cpufreq_monitor_get_frequency             (CPUFreqMonitor *monitor);
+gint         cpufreq_monitor_get_percentage            (CPUFreqMonitor *monitor);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_MONITOR_H__ */
diff --git a/cpufreq/src/cpufreq-popup.c b/cpufreq/src/cpufreq-popup.c
new file mode 100644
index 00000000..8486c2b3
--- /dev/null
+++ b/cpufreq/src/cpufreq-popup.c
@@ -0,0 +1,509 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib/gi18n.h>
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cpufreq-popup.h"
+#include "cpufreq-selector.h"
+#include "cpufreq-utils.h"
+
+struct _CPUFreqPopupPrivate {
+	GtkUIManager        *ui_manager;
+	GSList              *radio_group;
+	
+	GtkActionGroup      *freqs_group;
+	GSList              *freqs_actions;
+	
+	GtkActionGroup      *govs_group;
+	GSList              *govs_actions;
+
+	guint                merge_id;
+	gboolean             need_build;
+	gboolean             show_freqs;
+
+	CPUFreqMonitor      *monitor;
+	GtkWidget           *parent;
+};
+
+#define CPUFREQ_POPUP_GET_PRIVATE(object) \
+        (G_TYPE_INSTANCE_GET_PRIVATE ((object), CPUFREQ_TYPE_POPUP, CPUFreqPopupPrivate))
+
+static void cpufreq_popup_init       (CPUFreqPopup      *popup);
+static void cpufreq_popup_class_init (CPUFreqPopupClass *klass);
+static void cpufreq_popup_finalize   (GObject           *object);
+
+G_DEFINE_TYPE (CPUFreqPopup, cpufreq_popup, G_TYPE_OBJECT)
+
+static const gchar *ui_popup =
+"<ui>"
+"    <popup name=\"CPUFreqSelectorPopup\" action=\"PopupAction\">"
+"        <placeholder name=\"FreqsItemsGroup\">"
+"        </placeholder>"
+"        <separator />"
+"        <placeholder name=\"GovsItemsGroup\">"
+"        </placeholder>"
+"    </popup>"
+"</ui>";
+
+#define FREQS_PLACEHOLDER_PATH "/CPUFreqSelectorPopup/FreqsItemsGroup"
+#define GOVS_PLACEHOLDER_PATH "/CPUFreqSelectorPopup/GovsItemsGroup"
+
+static void
+cpufreq_popup_init (CPUFreqPopup *popup)
+{
+	popup->priv = CPUFREQ_POPUP_GET_PRIVATE (popup);
+
+	popup->priv->ui_manager = gtk_ui_manager_new ();
+	popup->priv->radio_group = NULL;
+
+	popup->priv->freqs_group = NULL;
+	popup->priv->freqs_actions = NULL;
+
+	popup->priv->govs_group = NULL;
+	popup->priv->govs_actions = NULL;
+
+	popup->priv->merge_id = 0;
+	popup->priv->need_build = TRUE;
+	popup->priv->show_freqs = FALSE;
+
+	gtk_ui_manager_add_ui_from_string (popup->priv->ui_manager,
+					   ui_popup, -1, NULL);
+	
+	popup->priv->monitor = NULL;
+}
+
+static void
+cpufreq_popup_class_init (CPUFreqPopupClass *klass)
+{
+	GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
+
+	g_type_class_add_private (g_object_class, sizeof (CPUFreqPopupPrivate));
+
+	g_object_class->finalize = cpufreq_popup_finalize;
+}
+
+static void
+cpufreq_popup_finalize (GObject *object)
+{
+	CPUFreqPopup *popup = CPUFREQ_POPUP (object);
+
+	if (popup->priv->ui_manager) {
+		g_object_unref (popup->priv->ui_manager);
+		popup->priv->ui_manager = NULL;
+	}
+
+	if (popup->priv->freqs_group) {
+		g_object_unref (popup->priv->freqs_group);
+		popup->priv->freqs_group = NULL;
+	}
+
+	if (popup->priv->freqs_actions) {
+		g_slist_free (popup->priv->freqs_actions);
+		popup->priv->freqs_actions = NULL;
+	}
+
+	if (popup->priv->govs_group) {
+		g_object_unref (popup->priv->govs_group);
+		popup->priv->govs_group = NULL;
+	}
+
+	if (popup->priv->govs_actions) {
+		g_slist_free (popup->priv->govs_actions);
+		popup->priv->govs_actions = NULL;
+	}
+	
+	if (popup->priv->monitor) {
+		g_object_unref (popup->priv->monitor);
+		popup->priv->monitor = NULL;
+	}
+	
+	G_OBJECT_CLASS (cpufreq_popup_parent_class)->finalize (object);
+}
+
+CPUFreqPopup *
+cpufreq_popup_new (void)
+{
+	CPUFreqPopup *popup;
+
+	popup = CPUFREQ_POPUP (g_object_new (CPUFREQ_TYPE_POPUP,
+					     NULL));
+
+	return popup;
+}
+
+/* Public methods */
+void
+cpufreq_popup_set_monitor (CPUFreqPopup   *popup,
+			   CPUFreqMonitor *monitor)
+{
+	g_return_if_fail (CPUFREQ_IS_POPUP (popup));
+	g_return_if_fail (CPUFREQ_IS_MONITOR (monitor));
+
+	if (popup->priv->monitor == monitor)
+		return;
+	
+	if (popup->priv->monitor)
+		g_object_unref (popup->priv->monitor);
+	popup->priv->monitor = g_object_ref (monitor);
+}
+
+void
+cpufreq_popup_set_parent (CPUFreqPopup *popup,
+			  GtkWidget    *parent)
+{
+	g_return_if_fail (CPUFREQ_IS_POPUP (popup));
+	g_return_if_fail (GTK_IS_WIDGET (parent));
+
+	popup->priv->parent = parent;
+}
+
+static void
+cpufreq_popup_frequencies_menu_activate (GtkAction    *action,
+					 CPUFreqPopup *popup)
+{
+	CPUFreqSelector *selector;
+	const gchar     *name;
+	guint            cpu;
+	guint            freq;
+	guint32          parent;
+
+	if (!gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
+		return;
+
+	selector = cpufreq_selector_get_default ();
+
+	cpu = cpufreq_monitor_get_cpu (popup->priv->monitor);
+	name = gtk_action_get_name (action);
+	freq = (guint) atoi (name + strlen ("Frequency"));
+	parent = GDK_WINDOW_XID (gtk_widget_get_window (popup->priv->parent));
+	
+
+	cpufreq_selector_set_frequency_async (selector, cpu, freq, parent);
+}
+
+static void
+cpufreq_popup_governors_menu_activate (GtkAction    *action,
+				       CPUFreqPopup *popup)
+{
+	CPUFreqSelector *selector;
+	const gchar     *name;
+	guint            cpu;
+	const gchar     *governor;
+	guint32          parent;
+
+	if (!gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
+		return;
+
+	selector = cpufreq_selector_get_default ();
+	
+	cpu = cpufreq_monitor_get_cpu (popup->priv->monitor);
+	name = gtk_action_get_name (action);
+	governor = name + strlen ("Governor");
+	parent = GDK_WINDOW_XID (gtk_widget_get_window (popup->priv->parent));
+
+	cpufreq_selector_set_governor_async (selector, cpu, governor, parent);
+}
+
+static void
+cpufreq_popup_menu_add_action (CPUFreqPopup   *popup,
+			       const gchar    *menu,
+			       GtkActionGroup *action_group,
+			       const gchar    *action_name,
+			       const gchar    *label,
+			       gboolean        sensitive)
+{
+	GtkToggleAction *action;
+	gchar           *name;
+
+	name = g_strdup_printf ("%s%s", menu, action_name);
+	
+	action = g_object_new (GTK_TYPE_RADIO_ACTION,
+			       "name", name,
+			       "label", label,
+			       NULL);
+
+	gtk_action_set_sensitive (GTK_ACTION (action), sensitive);
+	
+	gtk_radio_action_set_group (GTK_RADIO_ACTION (action), popup->priv->radio_group);
+	popup->priv->radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (action));
+	
+	if (g_ascii_strcasecmp (menu, "Frequency") == 0) {
+		popup->priv->freqs_actions = g_slist_prepend (popup->priv->freqs_actions,
+							      (gpointer) action);
+
+		g_signal_connect (action, "activate",
+				  G_CALLBACK (cpufreq_popup_frequencies_menu_activate),
+				  (gpointer) popup);
+	} else if (g_ascii_strcasecmp (menu, "Governor") == 0) {
+		popup->priv->govs_actions = g_slist_prepend (popup->priv->govs_actions,
+							     (gpointer) action);
+
+		g_signal_connect (action, "activate",
+				  G_CALLBACK (cpufreq_popup_governors_menu_activate),
+				  (gpointer) popup);
+	}
+
+	gtk_action_group_add_action (action_group, GTK_ACTION (action));
+	g_object_unref (action);
+	
+	g_free (name);
+}
+
+static void
+frequencies_menu_create_actions (CPUFreqPopup *popup)
+{
+	GList *available_freqs;
+
+	available_freqs = cpufreq_monitor_get_available_frequencies (popup->priv->monitor);
+
+	while (available_freqs) {
+		const gchar *text;
+		gchar       *freq_text;
+		gchar       *label;
+		gchar       *unit;
+		gint         freq;
+		
+		text = (const gchar *) available_freqs->data;
+		freq = atoi (text);
+
+		freq_text = cpufreq_utils_get_frequency_label (freq);
+		unit = cpufreq_utils_get_frequency_unit (freq);
+
+		label = g_strdup_printf ("%s %s", freq_text, unit);
+		g_free (freq_text);
+		g_free (unit);
+
+		cpufreq_popup_menu_add_action (popup,
+					       "Frequency", 
+					       popup->priv->freqs_group,
+					       text, label, TRUE);
+		g_free (label);
+
+		available_freqs = g_list_next (available_freqs);
+	}
+}
+
+static void
+governors_menu_create_actions (CPUFreqPopup *popup)
+{
+	GList *available_govs;
+
+	available_govs = cpufreq_monitor_get_available_governors (popup->priv->monitor);
+	available_govs = g_list_sort (available_govs, (GCompareFunc)g_ascii_strcasecmp);
+
+	while (available_govs) {
+		const gchar *governor;
+		gchar       *label;
+
+		governor = (const gchar *) available_govs->data;
+		if (g_ascii_strcasecmp (governor, "userspace") == 0) {
+			popup->priv->show_freqs = TRUE;
+			available_govs = g_list_next (available_govs);
+			continue;
+		}
+		
+		label = g_strdup (governor);
+		label[0] = g_ascii_toupper (label[0]);
+		
+		cpufreq_popup_menu_add_action (popup,
+					       "Governor",
+					       popup->priv->govs_group,
+					       governor, label, TRUE);
+		g_free (label);
+
+		available_govs = g_list_next (available_govs);
+	}
+}
+
+static void
+cpufreq_popup_build_ui (CPUFreqPopup *popup,
+			GSList       *actions,
+			const gchar  *menu_path)
+{
+	GSList *l = NULL;
+	
+	for (l = actions; l && l->data; l = g_slist_next (l)) { 		
+		GtkAction *action;
+		gchar     *name = NULL;
+		gchar     *label = NULL;
+
+		action = (GtkAction *) l->data;
+
+		g_object_get (G_OBJECT (action),
+			      "name", &name,
+			      "label", &label,
+			      NULL);
+
+		gtk_ui_manager_add_ui (popup->priv->ui_manager,
+				       popup->priv->merge_id,
+				       menu_path,
+				       label, name,
+				       GTK_UI_MANAGER_MENUITEM,
+				       FALSE);
+		
+		g_free (name);
+		g_free (label);
+	}
+}
+
+static void
+cpufreq_popup_build_frequencies_menu (CPUFreqPopup *popup,
+				      const gchar  *path)
+{
+	if (!popup->priv->freqs_group) {
+		GtkActionGroup *action_group;
+
+		action_group = gtk_action_group_new ("FreqsActions");
+		popup->priv->freqs_group = action_group;
+		gtk_action_group_set_translation_domain (action_group, NULL);
+
+		frequencies_menu_create_actions (popup);
+		popup->priv->freqs_actions = g_slist_reverse (popup->priv->freqs_actions);
+		gtk_ui_manager_insert_action_group (popup->priv->ui_manager,
+						    action_group, 0);
+	}
+
+	cpufreq_popup_build_ui (popup,
+				popup->priv->freqs_actions,
+				path);
+}
+
+static void
+cpufreq_popup_build_governors_menu (CPUFreqPopup *popup,
+				    const gchar  *path)
+{
+	if (!popup->priv->govs_group) {
+		GtkActionGroup *action_group;
+
+		action_group = gtk_action_group_new ("GovsActions");
+		popup->priv->govs_group = action_group;
+		gtk_action_group_set_translation_domain (action_group, NULL);
+
+		governors_menu_create_actions (popup);
+		popup->priv->govs_actions = g_slist_reverse (popup->priv->govs_actions);
+		gtk_ui_manager_insert_action_group (popup->priv->ui_manager,
+						    action_group, 1);
+	}
+
+	cpufreq_popup_build_ui (popup,
+				popup->priv->govs_actions,
+				path);
+}
+
+static void
+cpufreq_popup_build_menu (CPUFreqPopup *popup)
+{
+	if (popup->priv->merge_id > 0) {
+		gtk_ui_manager_remove_ui (popup->priv->ui_manager,
+					  popup->priv->merge_id);
+		gtk_ui_manager_ensure_update (popup->priv->ui_manager);
+	}
+	
+	popup->priv->merge_id = gtk_ui_manager_new_merge_id (popup->priv->ui_manager);
+		
+	cpufreq_popup_build_frequencies_menu (popup, FREQS_PLACEHOLDER_PATH);
+	cpufreq_popup_build_governors_menu (popup, GOVS_PLACEHOLDER_PATH);
+
+	gtk_action_group_set_visible (popup->priv->freqs_group,
+				      popup->priv->show_freqs);
+}
+
+static void
+cpufreq_popup_menu_set_active_action (CPUFreqPopup   *popup,
+				      GtkActionGroup *action_group,
+				      const gchar    *prefix,
+				      const gchar    *item)
+{
+	gchar      name[128];
+	GtkAction *action;
+
+	g_snprintf (name, sizeof (name), "%s%s", prefix, item);
+	action = gtk_action_group_get_action (action_group, name);
+	
+	g_signal_handlers_block_by_func (action,
+					 cpufreq_popup_frequencies_menu_activate,
+					 popup);
+	g_signal_handlers_block_by_func (action,
+					 cpufreq_popup_governors_menu_activate,
+					 popup);
+	
+	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
+
+	g_signal_handlers_unblock_by_func (action,
+					   cpufreq_popup_frequencies_menu_activate,
+					   popup);
+	g_signal_handlers_unblock_by_func (action,
+					   cpufreq_popup_governors_menu_activate,
+					   popup);
+}
+
+static void
+cpufreq_popup_menu_set_active (CPUFreqPopup *popup)
+{
+	const gchar *governor;
+
+	governor = cpufreq_monitor_get_governor (popup->priv->monitor);
+	
+	if (g_ascii_strcasecmp (governor, "userspace") == 0) {
+		gchar *active;
+		guint  freq;
+
+		freq = cpufreq_monitor_get_frequency (popup->priv->monitor);
+		active = g_strdup_printf ("%d", freq);
+		cpufreq_popup_menu_set_active_action (popup,
+						      popup->priv->freqs_group,
+						      "Frequency", active);
+		g_free (active);
+	} else {
+		cpufreq_popup_menu_set_active_action (popup,
+						      popup->priv->govs_group,
+						      "Governor", governor);
+	}
+}
+
+GtkWidget *
+cpufreq_popup_get_menu (CPUFreqPopup *popup)
+{
+	GtkWidget *menu;
+	
+	g_return_val_if_fail (CPUFREQ_IS_POPUP (popup), NULL);
+	g_return_val_if_fail (CPUFREQ_IS_MONITOR (popup->priv->monitor), NULL);
+	
+	if (!cpufreq_utils_selector_is_available ())
+		return NULL;
+
+	if (popup->priv->need_build) {
+		cpufreq_popup_build_menu (popup);
+		popup->priv->need_build = FALSE;
+	}
+
+	cpufreq_popup_menu_set_active (popup);
+	
+	menu = gtk_ui_manager_get_widget (popup->priv->ui_manager,
+					  "/CPUFreqSelectorPopup");
+	
+	return menu;
+}
diff --git a/cpufreq/src/cpufreq-popup.h b/cpufreq/src/cpufreq-popup.h
new file mode 100644
index 00000000..3a252d16
--- /dev/null
+++ b/cpufreq/src/cpufreq-popup.h
@@ -0,0 +1,66 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef CPUFREQ_POPUP_H
+#define CPUFREQ_POPUP_H
+
+#include <glib-object.h>
+
+#include "cpufreq-monitor.h"
+#include "cpufreq-prefs.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_POPUP            (cpufreq_popup_get_type ())
+#define CPUFREQ_POPUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_POPUP, CPUFreqPopup))
+#define CPUFREQ_POPUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_POPUP, CPUFreqPopupClass))
+#define CPUFREQ_IS_POPUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_POPUP))
+#define CPUFREQ_IS_POPUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_POPUP))
+#define CPUFREQ_POPUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_POPUP, CPUFreqPopupClass))
+
+typedef struct _CPUFreqPopup        CPUFreqPopup;
+typedef struct _CPUFreqPopupClass   CPUFreqPopupClass;
+typedef struct _CPUFreqPopupPrivate CPUFreqPopupPrivate;
+
+struct _CPUFreqPopup {
+	GObject              base;
+
+	CPUFreqPopupPrivate *priv;
+};
+
+struct _CPUFreqPopupClass {
+	GObjectClass         parent_class;
+};
+
+GType         cpufreq_popup_get_type        (void) G_GNUC_CONST;
+CPUFreqPopup *cpufreq_popup_new             (void);
+
+void          cpufreq_popup_set_preferences (CPUFreqPopup   *popup,
+					     CPUFreqPrefs   *prefs);
+void          cpufreq_popup_set_monitor     (CPUFreqPopup   *popup,
+					     CPUFreqMonitor *monitor);
+void          cpufreq_popup_set_parent      (CPUFreqPopup   *popup,
+					     GtkWidget      *parent);
+GtkWidget    *cpufreq_popup_get_menu        (CPUFreqPopup   *popup);
+
+G_END_DECLS
+
+#endif /* CPUFREQ_POPUP_H */
diff --git a/cpufreq/src/cpufreq-prefs.c b/cpufreq/src/cpufreq-prefs.c
new file mode 100644
index 00000000..a57d02d9
--- /dev/null
+++ b/cpufreq/src/cpufreq-prefs.c
@@ -0,0 +1,705 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <mateconf/mateconf-client.h>
+
+#include "cpufreq-prefs.h"
+#include "cpufreq-utils.h"
+
+enum {
+	PROP_0,
+	PROP_MATECONF_KEY,
+	PROP_CPU,
+	PROP_SHOW_MODE,
+	PROP_SHOW_TEXT_MODE,
+};
+
+struct _CPUFreqPrefsPrivate {
+	MateConfClient        *mateconf_client;
+	gchar              *mateconf_key;
+	
+	guint               cpu;
+	CPUFreqShowMode     show_mode;
+	CPUFreqShowTextMode show_text_mode;
+
+	/* Preferences dialog */
+	GtkWidget *dialog;
+	GtkWidget *show_freq;
+	GtkWidget *show_unit;
+	GtkWidget *show_perc;
+	GtkWidget *cpu_combo;
+	GtkWidget *monitor_settings_box;
+	GtkWidget *show_mode_combo;
+};
+
+#define CPUFREQ_PREFS_GET_PRIVATE(object) \
+        (G_TYPE_INSTANCE_GET_PRIVATE ((object), CPUFREQ_TYPE_PREFS, CPUFreqPrefsPrivate))
+
+static void cpufreq_prefs_init                      (CPUFreqPrefs      *prefs);
+static void cpufreq_prefs_class_init                (CPUFreqPrefsClass *klass);
+static void cpufreq_prefs_finalize                  (GObject           *object);
+
+static void cpufreq_prefs_set_property              (GObject           *object,
+						     guint              prop_id,
+						     const GValue      *value,
+						     GParamSpec        *pspec);
+static void cpufreq_prefs_get_property              (GObject           *object,
+						     guint              prop_id,
+						     GValue            *value,
+						     GParamSpec        *pspec);
+
+static void cpufreq_prefs_dialog_update_sensitivity (CPUFreqPrefs      *prefs);
+
+
+G_DEFINE_TYPE (CPUFreqPrefs, cpufreq_prefs, G_TYPE_OBJECT)
+
+static void
+cpufreq_prefs_init (CPUFreqPrefs *prefs)
+{
+	prefs->priv = CPUFREQ_PREFS_GET_PRIVATE (prefs);
+
+	prefs->priv->mateconf_client = mateconf_client_get_default ();
+	prefs->priv->mateconf_key = NULL;
+
+	prefs->priv->cpu = 0;
+}
+
+static void
+cpufreq_prefs_class_init (CPUFreqPrefsClass *klass)
+{
+	GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
+
+	g_object_class->set_property = cpufreq_prefs_set_property;
+	g_object_class->get_property = cpufreq_prefs_get_property;
+	
+	g_type_class_add_private (g_object_class, sizeof (CPUFreqPrefsPrivate));
+
+	/* Properties */
+	g_object_class_install_property (g_object_class,
+					 PROP_MATECONF_KEY,
+					 g_param_spec_string ("mateconf-key",
+							      "MateConfKey",
+							      "The applet mateconf key",
+							      NULL,
+							      G_PARAM_WRITABLE |
+							      G_PARAM_CONSTRUCT_ONLY));
+	g_object_class_install_property (g_object_class,
+					 PROP_CPU,
+					 g_param_spec_uint ("cpu",
+							    "CPU",
+							    "The monitored cpu",
+							    0,
+							    G_MAXUINT,
+							    0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (g_object_class,
+					 PROP_SHOW_MODE,
+					 g_param_spec_enum ("show-mode",
+							    "ShowMode",
+							    "The applet show mode",
+							    CPUFREQ_TYPE_SHOW_MODE,
+							    CPUFREQ_MODE_BOTH,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (g_object_class,
+					 PROP_SHOW_TEXT_MODE,
+					 g_param_spec_enum ("show-text-mode",
+							    "ShowTextMode",
+							    "The applet show text mode",
+							    CPUFREQ_TYPE_SHOW_TEXT_MODE,
+							    CPUFREQ_MODE_TEXT_FREQUENCY_UNIT,
+							    G_PARAM_READWRITE));
+
+	g_object_class->finalize = cpufreq_prefs_finalize;
+}
+
+static void
+cpufreq_prefs_finalize (GObject *object)
+{
+	CPUFreqPrefs *prefs = CPUFREQ_PREFS (object);
+
+	if (prefs->priv->mateconf_client) {
+		g_object_unref (prefs->priv->mateconf_client);
+		prefs->priv->mateconf_client = NULL;
+	}
+
+	if (prefs->priv->mateconf_key) {
+		g_free (prefs->priv->mateconf_key);
+		prefs->priv->mateconf_key = NULL;
+	}
+
+	if (prefs->priv->dialog) {
+		gtk_widget_destroy (prefs->priv->dialog);
+		prefs->priv->dialog = NULL;
+	}
+
+	G_OBJECT_CLASS (cpufreq_prefs_parent_class)->finalize (object);
+}
+
+static void
+cpufreq_prefs_set_property (GObject      *object,
+			    guint         prop_id,
+			    const GValue *value,
+			    GParamSpec   *pspec)
+{
+	CPUFreqPrefs *prefs = CPUFREQ_PREFS (object);
+	gboolean      update_sensitivity = FALSE;
+
+	switch (prop_id) {
+	case PROP_MATECONF_KEY:
+		prefs->priv->mateconf_key = g_value_dup_string (value);
+		break;
+	case PROP_CPU: {
+		guint cpu;
+
+		cpu = g_value_get_uint (value);
+		if (prefs->priv->cpu != cpu) {
+			gchar *key;
+			
+			prefs->priv->cpu = cpu;
+			key = g_strjoin ("/",
+					 prefs->priv->mateconf_key,
+					 "cpu",
+					 NULL);
+			mateconf_client_set_int (prefs->priv->mateconf_client,
+					      key, prefs->priv->cpu,
+					      NULL);
+			g_free (key);
+		}
+	}
+		break;
+	case PROP_SHOW_MODE: {
+		CPUFreqShowMode mode;
+
+		mode = g_value_get_enum (value);
+		if (prefs->priv->show_mode != mode) {
+			gchar *key;
+
+			update_sensitivity = TRUE;
+			prefs->priv->show_mode = mode;
+			key = g_strjoin ("/",
+					 prefs->priv->mateconf_key,
+					 "show_mode",
+					 NULL);
+			mateconf_client_set_int (prefs->priv->mateconf_client,
+					      key, prefs->priv->show_mode,
+					      NULL);
+			g_free (key);
+		}
+	}
+		break;
+	case PROP_SHOW_TEXT_MODE: {
+		CPUFreqShowTextMode mode;
+
+		mode = g_value_get_enum (value);
+		if (prefs->priv->show_text_mode != mode) {
+			gchar *key;
+
+			update_sensitivity = TRUE;
+			prefs->priv->show_text_mode = mode;
+			key = g_strjoin ("/",
+					 prefs->priv->mateconf_key,
+					 "show_text_mode",
+					 NULL);
+			mateconf_client_set_int (prefs->priv->mateconf_client,
+					      key, prefs->priv->show_text_mode,
+					      NULL);
+			g_free (key);
+		}
+	}
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+	}
+
+	if (prefs->priv->dialog && update_sensitivity)
+		cpufreq_prefs_dialog_update_sensitivity (prefs);
+}
+
+static void
+cpufreq_prefs_get_property (GObject    *object,
+			    guint       prop_id,
+			    GValue     *value,
+			    GParamSpec *pspec)
+{
+	CPUFreqPrefs *prefs = CPUFREQ_PREFS (object);
+
+	switch (prop_id) {
+	case PROP_MATECONF_KEY:
+		/* Is not readable */
+		break;
+	case PROP_CPU:
+		g_value_set_uint (value, prefs->priv->cpu);
+		break;
+	case PROP_SHOW_MODE:
+		g_value_set_enum (value, prefs->priv->show_mode);
+		break;
+	case PROP_SHOW_TEXT_MODE:
+		g_value_set_enum (value, prefs->priv->show_text_mode);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+	}
+}
+
+static void
+cpufreq_prefs_setup (CPUFreqPrefs *prefs)
+{
+	guint                cpu;
+	CPUFreqShowMode      show_mode;
+	CPUFreqShowTextMode  show_text_mode;
+	gchar               *key;
+	GError              *error = NULL;
+
+	g_assert (MATECONF_IS_CLIENT (prefs->priv->mateconf_client));
+	g_assert (prefs->priv->mateconf_key != NULL);
+
+	key = g_strjoin ("/", prefs->priv->mateconf_key, "cpu", NULL);
+	cpu = mateconf_client_get_int (prefs->priv->mateconf_client,
+				    key, &error);
+	g_free (key);
+	/* In case anything went wrong with mateconf, get back to the default */
+	if (error) {
+		g_warning ("%s", error->message);
+		cpu = 0;
+		g_error_free (error);
+		error = NULL;
+	}
+	prefs->priv->cpu = cpu;
+
+	key = g_strjoin ("/", prefs->priv->mateconf_key, "show_mode", NULL);
+	show_mode = mateconf_client_get_int (prefs->priv->mateconf_client,
+					  key, &error);
+	g_free (key);
+	/* In case anything went wrong with mateconf, get back to the default */
+	if (error ||
+	    show_mode < CPUFREQ_MODE_GRAPHIC ||
+	    show_mode > CPUFREQ_MODE_BOTH) {
+		show_mode = CPUFREQ_MODE_BOTH;
+		if (error) {
+			g_warning ("%s", error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+	prefs->priv->show_mode = show_mode;
+
+	key = g_strjoin ("/", prefs->priv->mateconf_key, "show_text_mode", NULL);
+	show_text_mode = mateconf_client_get_int (prefs->priv->mateconf_client,
+					       key, &error);
+	g_free (key);
+	/* In case anything went wrong with mateconf, get back to the default */
+	if (error ||
+	    show_text_mode < CPUFREQ_MODE_TEXT_FREQUENCY ||
+	    show_text_mode > CPUFREQ_MODE_TEXT_PERCENTAGE) {
+		show_text_mode = CPUFREQ_MODE_TEXT_FREQUENCY_UNIT;
+		if (error) {
+			g_warning ("%s", error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+	prefs->priv->show_text_mode = show_text_mode;
+}
+
+CPUFreqPrefs *
+cpufreq_prefs_new (const gchar *mateconf_key)
+{
+	CPUFreqPrefs *prefs;
+
+	g_return_val_if_fail (mateconf_key != NULL, NULL);
+
+	prefs = CPUFREQ_PREFS (g_object_new (CPUFREQ_TYPE_PREFS,
+					     "mateconf-key", mateconf_key,
+					     NULL));
+	
+	cpufreq_prefs_setup (prefs);
+
+	return prefs;
+}
+
+/* Public Methods */
+guint
+cpufreq_prefs_get_cpu (CPUFreqPrefs *prefs)
+{
+	g_return_val_if_fail (CPUFREQ_IS_PREFS (prefs), 0);
+	
+	return MIN (prefs->priv->cpu, cpufreq_utils_get_n_cpus () - 1);
+}
+
+CPUFreqShowMode
+cpufreq_prefs_get_show_mode (CPUFreqPrefs *prefs)
+{
+	g_return_val_if_fail (CPUFREQ_IS_PREFS (prefs),
+			      CPUFREQ_MODE_BOTH);
+
+	return prefs->priv->show_mode;
+}
+
+CPUFreqShowTextMode
+cpufreq_prefs_get_show_text_mode (CPUFreqPrefs *prefs)
+{
+	g_return_val_if_fail (CPUFREQ_IS_PREFS (prefs),
+			      CPUFREQ_MODE_TEXT_FREQUENCY_UNIT);
+
+	return prefs->priv->show_text_mode;
+}
+
+/* Preferences Dialog */
+static gboolean
+cpufreq_prefs_key_is_writable (CPUFreqPrefs *prefs, const gchar *key)
+{
+        gboolean  writable;
+        gchar    *fullkey;
+
+	g_assert (prefs->priv->mateconf_client != NULL);
+
+	fullkey = g_strjoin ("/", prefs->priv->mateconf_key, key, NULL);
+        writable = mateconf_client_key_is_writable (prefs->priv->mateconf_client,
+						 fullkey, NULL);
+        g_free (fullkey);
+
+        return writable;
+}
+
+static void
+cpufreq_prefs_dialog_show_freq_toggled (GtkWidget *show_freq, CPUFreqPrefs *prefs)
+{
+	CPUFreqShowTextMode show_text_mode;
+           
+        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_freq))) {
+		GtkWidget *show_unit = prefs->priv->show_unit;
+
+                if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_unit)))
+                        show_text_mode = CPUFREQ_MODE_TEXT_FREQUENCY_UNIT;
+                else
+                        show_text_mode = CPUFREQ_MODE_TEXT_FREQUENCY;
+
+		g_object_set (G_OBJECT (prefs),
+			      "show-text-mode", show_text_mode,
+			      NULL);
+	}
+}	
+
+static void
+cpufreq_prefs_dialog_show_unit_toggled (GtkWidget *show_unit, CPUFreqPrefs *prefs)
+{
+	CPUFreqShowTextMode show_text_mode;
+           
+        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_unit))) {
+                show_text_mode = CPUFREQ_MODE_TEXT_FREQUENCY_UNIT;
+        } else {
+                show_text_mode = CPUFREQ_MODE_TEXT_FREQUENCY;
+        }
+
+	g_object_set (G_OBJECT (prefs),
+		      "show-text-mode", show_text_mode,
+		      NULL);
+}
+
+static void
+cpufreq_prefs_dialog_show_perc_toggled (GtkWidget *show_perc, CPUFreqPrefs *prefs)
+{
+
+	CPUFreqShowTextMode show_text_mode;
+	
+        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_perc))) {
+                /* Show cpu usage in percentage */
+                show_text_mode = CPUFREQ_MODE_TEXT_PERCENTAGE;
+
+		g_object_set (G_OBJECT (prefs),
+			      "show-text-mode", show_text_mode,
+			      NULL);
+        }
+}
+
+static void
+cpufreq_prefs_dialog_cpu_number_changed (GtkWidget *cpu_combo, CPUFreqPrefs *prefs)
+{
+        gint cpu;
+	
+        cpu = gtk_combo_box_get_active (GTK_COMBO_BOX (prefs->priv->cpu_combo));
+
+        if (cpu >= 0) {
+		g_object_set (G_OBJECT (prefs),
+			      "cpu", cpu,
+			      NULL);
+        }
+}
+
+static void
+cpufreq_prefs_dialog_show_mode_changed (GtkWidget *show_mode_combo, CPUFreqPrefs *prefs)
+{
+	CPUFreqShowMode show_mode;
+           
+        show_mode = gtk_combo_box_get_active (GTK_COMBO_BOX (show_mode_combo));
+	g_object_set (G_OBJECT (prefs),
+		      "show-mode", show_mode,
+		      NULL);
+}
+
+static void
+cpufreq_prefs_dialog_response_cb (CPUFreqPrefs *prefs,
+				  gint          response,
+				  GtkDialog    *dialog)
+{
+        GError *error = NULL;
+
+        if (response == GTK_RESPONSE_HELP) {
+		gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (prefs->priv->dialog)),
+			"ghelp:cpufreq-applet?cpufreq-applet-prefs",
+			gtk_get_current_event_time (),
+			&error);
+
+                if (error) {
+                        cpufreq_utils_display_error (_("Could not open help document"),
+						     error->message);
+                        g_error_free (error);
+		}
+        } else {
+                gtk_widget_destroy (prefs->priv->dialog);
+                prefs->priv->dialog = NULL;
+        }
+}
+
+static void
+cpufreq_prefs_dialog_update_visibility (CPUFreqPrefs *prefs)
+{
+	if (cpufreq_utils_get_n_cpus () > 1)
+		gtk_widget_show (prefs->priv->monitor_settings_box);
+	else
+		gtk_widget_hide (prefs->priv->monitor_settings_box);
+}
+
+static void
+cpufreq_prefs_dialog_update_sensitivity (CPUFreqPrefs *prefs)
+{
+	gtk_widget_set_sensitive (prefs->priv->show_mode_combo,
+				  cpufreq_prefs_key_is_writable (prefs, "show_mode"));
+	
+	if (prefs->priv->show_mode != CPUFREQ_MODE_GRAPHIC) {
+		gboolean key_writable;
+		
+		key_writable = cpufreq_prefs_key_is_writable (prefs, "show_text_mode");
+		
+		gtk_widget_set_sensitive (prefs->priv->show_freq,
+					  (TRUE && key_writable));
+		gtk_widget_set_sensitive (prefs->priv->show_perc,
+					  (TRUE && key_writable));
+		
+		if (prefs->priv->show_text_mode == CPUFREQ_MODE_TEXT_PERCENTAGE)
+			gtk_widget_set_sensitive (prefs->priv->show_unit,
+						  FALSE);
+		else
+			gtk_widget_set_sensitive (prefs->priv->show_unit,
+						  (TRUE && key_writable));
+	} else {
+		gtk_widget_set_sensitive (prefs->priv->show_freq, FALSE);
+		gtk_widget_set_sensitive (prefs->priv->show_unit, FALSE);
+		gtk_widget_set_sensitive (prefs->priv->show_perc, FALSE);
+	}
+}
+
+static void
+cpufreq_prefs_dialog_update (CPUFreqPrefs *prefs)
+{
+	if (cpufreq_utils_get_n_cpus () > 1) {
+		gtk_combo_box_set_active (GTK_COMBO_BOX (prefs->priv->cpu_combo),
+					  MIN (prefs->priv->cpu, cpufreq_utils_get_n_cpus () - 1));
+	}
+
+	gtk_combo_box_set_active (GTK_COMBO_BOX (prefs->priv->show_mode_combo),
+				  prefs->priv->show_mode);
+	
+	switch (prefs->priv->show_text_mode) {
+	case CPUFREQ_MODE_TEXT_FREQUENCY:
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prefs->priv->show_freq),
+					      TRUE);
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prefs->priv->show_unit),
+					      FALSE);
+
+		break;
+	case CPUFREQ_MODE_TEXT_FREQUENCY_UNIT:
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prefs->priv->show_freq),
+					      TRUE);
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prefs->priv->show_unit),
+					      TRUE);
+
+		break;
+	case CPUFREQ_MODE_TEXT_PERCENTAGE:
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prefs->priv->show_perc),
+					      TRUE);
+
+		break;
+	}
+}
+
+static void
+cpufreq_prefs_dialog_cpu_combo_setup (CPUFreqPrefs *prefs)
+{
+	GtkListStore    *model;
+	GtkTreeIter      iter;
+	GtkCellRenderer *renderer;
+	guint            i;
+	guint            n_cpus;
+
+	model = gtk_list_store_new (1, G_TYPE_STRING);
+	gtk_combo_box_set_model (GTK_COMBO_BOX (prefs->priv->cpu_combo),
+				 GTK_TREE_MODEL (model));
+
+	n_cpus = cpufreq_utils_get_n_cpus ();
+	
+	for (i = 0; i < n_cpus; i++) {
+		gchar *text_label;
+		
+		text_label = g_strdup_printf ("CPU %u", i);
+
+		gtk_list_store_append (model, &iter);
+		gtk_list_store_set (model, &iter,
+				    0, text_label,
+				    -1);
+
+		g_free (text_label);
+	}
+
+	g_object_unref (model);
+
+	renderer = gtk_cell_renderer_text_new ();
+	gtk_cell_layout_clear (GTK_CELL_LAYOUT (prefs->priv->cpu_combo));
+	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (prefs->priv->cpu_combo),
+				    renderer, TRUE);
+	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (prefs->priv->cpu_combo),
+					renderer,
+					"text", 0,
+					NULL);
+}
+
+static void
+cpufreq_prefs_dialog_show_mode_combo_setup (CPUFreqPrefs *prefs)
+{
+	GtkListStore    *model;
+	GtkTreeIter      iter;
+	GtkCellRenderer *renderer;
+
+	model = gtk_list_store_new (1, G_TYPE_STRING);
+	gtk_combo_box_set_model (GTK_COMBO_BOX (prefs->priv->show_mode_combo),
+				 GTK_TREE_MODEL (model));
+
+	gtk_list_store_append (model, &iter);
+	gtk_list_store_set (model, &iter,
+			    0, _("Graphic"),
+			    -1);
+
+	gtk_list_store_append (model, &iter);
+	gtk_list_store_set (model, &iter,
+			    0, _("Text"),
+			    -1);
+
+	gtk_list_store_append (model, &iter);
+	gtk_list_store_set (model, &iter,
+			    0, _("Graphic and Text"),
+			    -1);
+
+	g_object_unref (model);
+
+	renderer = gtk_cell_renderer_text_new ();
+	gtk_cell_layout_clear (GTK_CELL_LAYOUT (prefs->priv->show_mode_combo));
+	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (prefs->priv->show_mode_combo),
+				    renderer, TRUE);
+	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (prefs->priv->show_mode_combo),
+					renderer,
+					"text", 0,
+					NULL);
+}
+
+static void
+cpufreq_prefs_dialog_create (CPUFreqPrefs *prefs)
+{
+	GtkBuilder *builder;
+
+	builder = gtk_builder_new ();
+	gtk_builder_add_from_file (builder, GTK_BUILDERDIR "/cpufreq-preferences.ui", NULL);
+
+	prefs->priv->dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog"));
+
+	prefs->priv->cpu_combo = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_cpu_number"));
+	
+	prefs->priv->show_mode_combo = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_show_mode"));
+	
+	prefs->priv->show_freq = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_show_freq"));
+	prefs->priv->show_unit = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_show_unit"));
+	prefs->priv->show_perc = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_show_perc"));
+
+	prefs->priv->monitor_settings_box = GTK_WIDGET (gtk_builder_get_object (builder, "monitor_settings_box"));
+
+	g_object_unref (builder);
+
+	cpufreq_prefs_dialog_show_mode_combo_setup (prefs);
+	
+	if (cpufreq_utils_get_n_cpus () > 1)
+		cpufreq_prefs_dialog_cpu_combo_setup (prefs);
+		
+	g_signal_connect_swapped (G_OBJECT (prefs->priv->dialog), "response",
+				  G_CALLBACK (cpufreq_prefs_dialog_response_cb),
+				  (gpointer) prefs);
+	
+	g_signal_connect (G_OBJECT (prefs->priv->show_freq), "toggled",
+			  G_CALLBACK (cpufreq_prefs_dialog_show_freq_toggled),
+			  (gpointer) prefs);
+	g_signal_connect (G_OBJECT (prefs->priv->show_unit), "toggled",
+			  G_CALLBACK (cpufreq_prefs_dialog_show_unit_toggled),
+			  (gpointer) prefs);
+	g_signal_connect (G_OBJECT (prefs->priv->show_perc), "toggled",
+			  G_CALLBACK (cpufreq_prefs_dialog_show_perc_toggled),
+			  (gpointer) prefs);
+	g_signal_connect (G_OBJECT (prefs->priv->cpu_combo), "changed",
+			  G_CALLBACK (cpufreq_prefs_dialog_cpu_number_changed),
+			  (gpointer) prefs);
+	g_signal_connect (G_OBJECT (prefs->priv->show_mode_combo), "changed",
+			  G_CALLBACK (cpufreq_prefs_dialog_show_mode_changed),
+			  (gpointer) prefs);
+}
+
+void 
+cpufreq_preferences_dialog_run (CPUFreqPrefs *prefs, GdkScreen *screen)
+{
+        g_return_if_fail (CPUFREQ_IS_PREFS (prefs));
+
+        if (prefs->priv->dialog) {
+                /* Dialog already exist, only show it */
+                gtk_window_present (GTK_WINDOW (prefs->priv->dialog));
+                return;
+        }
+
+	cpufreq_prefs_dialog_create (prefs);
+        gtk_window_set_screen (GTK_WINDOW (prefs->priv->dialog), screen);
+
+	cpufreq_prefs_dialog_update_sensitivity (prefs);
+	cpufreq_prefs_dialog_update_visibility (prefs);
+	cpufreq_prefs_dialog_update (prefs);
+
+	gtk_widget_show (prefs->priv->dialog);
+}
diff --git a/cpufreq/src/cpufreq-prefs.h b/cpufreq/src/cpufreq-prefs.h
new file mode 100644
index 00000000..8be9abe8
--- /dev/null
+++ b/cpufreq/src/cpufreq-prefs.h
@@ -0,0 +1,66 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef CPUFREQ_PREFS_H
+#define CPUFREQ_PREFS_H
+
+#include <gdk/gdk.h>
+#include <glib-object.h>
+#include "cpufreq-applet.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_PREFS            (cpufreq_prefs_get_type ())
+#define CPUFREQ_PREFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_PREFS, CPUFreqPrefs))
+#define CPUFREQ_PREFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_PREFS, CPUFreqPrefsClass))
+#define CPUFREQ_IS_PREFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_PREFS))
+#define CPUFREQ_IS_PREFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_PREFS))
+#define CPUFREQ_PREFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_PREFS, CPUFreqPrefsClass))
+
+typedef struct _CPUFreqPrefs        CPUFreqPrefs;
+typedef struct _CPUFreqPrefsClass   CPUFreqPrefsClass;
+typedef struct _CPUFreqPrefsPrivate CPUFreqPrefsPrivate;
+
+struct _CPUFreqPrefs {
+	GObject              base;
+
+	CPUFreqPrefsPrivate *priv;
+};
+
+struct _CPUFreqPrefsClass {
+	GObjectClass         parent_class;
+};
+
+GType               cpufreq_prefs_get_type           (void) G_GNUC_CONST;
+
+CPUFreqPrefs       *cpufreq_prefs_new                (const gchar  *mateconf_key);
+
+guint               cpufreq_prefs_get_cpu            (CPUFreqPrefs *prefs);
+CPUFreqShowMode     cpufreq_prefs_get_show_mode      (CPUFreqPrefs *prefs);
+CPUFreqShowTextMode cpufreq_prefs_get_show_text_mode (CPUFreqPrefs *prefs);
+
+/* Properties dialog */
+void                cpufreq_preferences_dialog_run   (CPUFreqPrefs *prefs,
+						      GdkScreen    *screen);
+
+G_END_DECLS
+
+#endif /* CPUFREQ_PREFS_H */
diff --git a/cpufreq/src/cpufreq-selector.c b/cpufreq/src/cpufreq-selector.c
new file mode 100644
index 00000000..d5a37e15
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector.c
@@ -0,0 +1,289 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <config.h>
+
+#ifdef HAVE_POLKIT
+#include <dbus/dbus-glib.h>
+#endif /* HAVE_POLKIT */
+
+#include "cpufreq-selector.h"
+
+struct _CPUFreqSelector {
+	GObject parent;
+
+#ifdef HAVE_POLKIT
+	DBusGConnection *system_bus;
+#endif /* HAVE_POLKIT */
+};
+
+struct _CPUFreqSelectorClass {
+	GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (CPUFreqSelector, cpufreq_selector, G_TYPE_OBJECT)
+
+static void
+cpufreq_selector_finalize (GObject *object)
+{
+	CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
+
+#ifdef HAVE_POLKIT
+	selector->system_bus = NULL;
+#endif /* HAVE_POLKIT */
+
+	G_OBJECT_CLASS (cpufreq_selector_parent_class)->finalize (object);
+}
+
+static void
+cpufreq_selector_class_init (CPUFreqSelectorClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize = cpufreq_selector_finalize;
+}
+
+static void
+cpufreq_selector_init (CPUFreqSelector *selector)
+{
+}
+
+CPUFreqSelector *
+cpufreq_selector_get_default (void)
+{
+	static CPUFreqSelector *selector = NULL;
+
+	if (!selector)
+		selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR, NULL));
+
+	return selector;
+}
+
+#ifdef HAVE_POLKIT
+typedef enum {
+	FREQUENCY,
+	GOVERNOR
+} CPUFreqSelectorCall;
+
+typedef struct {
+	CPUFreqSelector *selector;
+	
+	CPUFreqSelectorCall call;
+
+	guint  cpu;
+	guint  frequency;
+	gchar *governor;
+
+	guint32 parent_xid;
+} SelectorAsyncData;
+
+static void selector_set_frequency_async (SelectorAsyncData *data);
+static void selector_set_governor_async  (SelectorAsyncData *data);
+
+static void
+selector_async_data_free (SelectorAsyncData *data)
+{
+	if (!data)
+		return;
+
+	g_free (data->governor);
+	g_free (data);
+}
+
+static gboolean
+cpufreq_selector_connect_to_system_bus (CPUFreqSelector *selector,
+					GError         **error)
+{
+	if (selector->system_bus)
+		return TRUE;
+
+	selector->system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, error);
+
+	return (selector->system_bus != NULL);
+}
+
+static void
+dbus_set_call_notify_cb (DBusGProxy     *proxy,
+			 DBusGProxyCall *call,
+			 gpointer        user_data)
+{
+	SelectorAsyncData *data;
+	GError            *error = NULL;
+
+	data = (SelectorAsyncData *)user_data;
+	
+	if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID)) {
+		selector_async_data_free (data);
+		return;
+	}
+
+	selector_async_data_free (data);
+	g_warning ("%s", error->message);
+	g_error_free (error);
+}
+
+static void
+selector_set_frequency_async (SelectorAsyncData *data)
+{
+	DBusGProxy *proxy;
+	GError     *error = NULL;
+
+	if (!cpufreq_selector_connect_to_system_bus (data->selector, &error)) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		selector_async_data_free (data);
+
+		return;
+	}
+
+	proxy = dbus_g_proxy_new_for_name (data->selector->system_bus,
+					   "org.mate.CPUFreqSelector",
+					   "/org/mate/cpufreq_selector/selector",
+					   "org.mate.CPUFreqSelector");
+
+	dbus_g_proxy_begin_call_with_timeout (proxy, "SetFrequency",
+					      dbus_set_call_notify_cb,
+					      data, NULL,
+					      INT_MAX,
+					      G_TYPE_UINT, data->cpu,
+					      G_TYPE_UINT, data->frequency,
+					      G_TYPE_INVALID,
+					      G_TYPE_INVALID);
+}
+
+void
+cpufreq_selector_set_frequency_async (CPUFreqSelector *selector,
+				      guint            cpu,
+				      guint            frequency,
+				      guint32          parent)
+{
+	SelectorAsyncData *data;
+
+	data = g_new0 (SelectorAsyncData, 1);
+
+	data->selector = selector;
+	data->call = FREQUENCY;
+	data->cpu = cpu;
+	data->frequency = frequency;
+	data->parent_xid = parent;
+
+	selector_set_frequency_async (data);
+}
+
+static void
+selector_set_governor_async (SelectorAsyncData *data)
+{
+	DBusGProxy *proxy;
+	GError     *error = NULL;
+
+	if (!cpufreq_selector_connect_to_system_bus (data->selector, &error)) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		selector_async_data_free (data);
+
+		return;
+	}
+
+	proxy = dbus_g_proxy_new_for_name (data->selector->system_bus,
+					   "org.mate.CPUFreqSelector",
+					   "/org/mate/cpufreq_selector/selector",
+					   "org.mate.CPUFreqSelector");
+
+	dbus_g_proxy_begin_call_with_timeout (proxy, "SetGovernor",
+					      dbus_set_call_notify_cb,
+					      data, NULL,
+					      INT_MAX,
+					      G_TYPE_UINT, data->cpu,
+					      G_TYPE_STRING, data->governor,
+					      G_TYPE_INVALID,
+					      G_TYPE_INVALID);
+}
+
+void
+cpufreq_selector_set_governor_async (CPUFreqSelector *selector,
+				     guint            cpu,
+				     const gchar     *governor,
+				     guint32          parent)
+{
+	SelectorAsyncData *data;
+
+	data = g_new0 (SelectorAsyncData, 1);
+
+	data->selector = selector;
+	data->call = GOVERNOR;
+	data->cpu = cpu;
+	data->governor = g_strdup (governor);
+	data->parent_xid = parent;
+
+	selector_set_governor_async (data);
+}
+#else /* !HAVE_POLKIT */
+static void
+cpufreq_selector_run_command (CPUFreqSelector *selector,
+			      const gchar     *args)
+{
+	gchar  *command;
+	gchar  *path;
+	GError *error = NULL;
+
+	path = g_find_program_in_path ("cpufreq-selector");
+
+	if (!path)
+		return;
+
+	command = g_strdup_printf ("%s %s", path, args);
+	g_free (path);
+
+	g_spawn_command_line_async (command, &error);
+	g_free (command);
+
+	if (error) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+	}
+}
+
+void
+cpufreq_selector_set_frequency_async (CPUFreqSelector *selector,
+				      guint            cpu,
+				      guint            frequency,
+				      guint32          parent)
+{
+	gchar *args;
+
+	args = g_strdup_printf ("-c %u -f %u", cpu, frequency);
+	cpufreq_selector_run_command (selector, args);
+	g_free (args);
+}
+
+void
+cpufreq_selector_set_governor_async (CPUFreqSelector *selector,
+				     guint            cpu,
+				     const gchar     *governor,
+				     guint32          parent)
+{
+	gchar *args;
+
+	args = g_strdup_printf ("-c %u -g %s", cpu, governor);
+	cpufreq_selector_run_command (selector, args);
+	g_free (args);
+}
+#endif /* HAVE_POLKIT */
diff --git a/cpufreq/src/cpufreq-selector.h b/cpufreq/src/cpufreq-selector.h
new file mode 100644
index 00000000..5941d416
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector.h
@@ -0,0 +1,51 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __CPUFREQ_SELECTOR_H__
+#define __CPUFREQ_SELECTOR_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR            (cpufreq_selector_get_type ())
+#define CPUFREQ_SELECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelector))
+#define CPUFREQ_SELECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorClass))
+#define CPUFREQ_IS_SELECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR))
+#define CPUFREQ_IS_SELECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR))
+#define CPUFREQ_SELECTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorClass))
+
+typedef struct _CPUFreqSelector        CPUFreqSelector;
+typedef struct _CPUFreqSelectorClass   CPUFreqSelectorClass;
+
+GType            cpufreq_selector_get_type            (void) G_GNUC_CONST;
+
+CPUFreqSelector *cpufreq_selector_get_default         (void);
+void             cpufreq_selector_set_frequency_async (CPUFreqSelector *selector,
+						       guint            cpu,
+						       guint            frequency,
+						       guint32          parent);
+void             cpufreq_selector_set_governor_async  (CPUFreqSelector *selector,
+						       guint            cpu,
+						       const gchar     *governor,
+						       guint32          parent);
+	
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_H__ */
diff --git a/cpufreq/src/cpufreq-selector/Makefile.am b/cpufreq/src/cpufreq-selector/Makefile.am
new file mode 100644
index 00000000..b2db7a97
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/Makefile.am
@@ -0,0 +1,89 @@
+cpufreqselectordir = $(bindir)
+
+INCLUDES = $(CPUFREQ_SELECTOR_CFLAGS)
+
+if HAVE_POLKIT
+INCLUDES += \
+	$(DBUS_CFLAGS)		\
+	$(POLKIT_CFLAGS)
+endif
+
+bin_PROGRAMS = cpufreq-selector
+
+install-exec-hook:
+if CPUFREQ_SELECTOR_SUID
+	chmod 4755 $(DESTDIR)$(bindir)/cpufreq-selector
+endif
+
+
+if HAVE_LIBCPUFREQ
+cpufreq_files=cpufreq-selector-libcpufreq.c        cpufreq-selector-libcpufreq.h
+endif
+
+if HAVE_POLKIT
+service_files=cpufreq-selector-service.c       cpufreq-selector-service.h
+endif
+
+cpufreq_selector_SOURCES = \
+	cpufreq-selector.c               cpufreq-selector.h        	\
+	cpufreq-selector-sysfs.c         cpufreq-selector-sysfs.h  	\
+	cpufreq-selector-procfs.c        cpufreq-selector-procfs.h 	\
+	$(cpufreq_files)					   	\
+	$(service_files)						\
+	cpufreq-selector-factory.c	 cpufreq-selector-factory.h	\
+	$(BUILT_SOURCES)						\
+	main.c
+
+cpufreq_selector_LDADD = \
+	$(CPUFREQ_SELECTOR_LIBS) 	\
+	$(LIBCPUFREQ_LIBS)
+
+if HAVE_POLKIT
+cpufreq_selector_LDADD += \
+	$(DBUS_LIBS)		\
+	$(POLKIT_LIBS)
+endif
+
+cpufreq_selector_LDFLAGS = $(LDFLAGS) -Wl,-z,now
+
+dbus_services_in_files = org.mate.CPUFreqSelector.service.in
+polkit_in_files = org.mate.cpufreqselector.policy.in
+
+dbus_servicesdir = $(datadir)/dbus-1/system-services
+dbus_confdir = $(sysconfdir)/dbus-1/system.d
+polkitdir = $(datadir)/polkit-1/actions
+
+if HAVE_POLKIT
+BUILT_SOURCES = cpufreq-selector-service-glue.h
+
+cpufreq-selector-service-glue.h: $(srcdir)/cpufreq-selector-service.xml
+	dbus-binding-tool --prefix=cpufreq_selector_service --mode=glib-server	\
+	                  --output=cpufreq-selector-service-glue.h		\
+	                  $(srcdir)/cpufreq-selector-service.xml
+
+dbus_services_DATA = $(dbus_services_in_files:.service.in=.service)
+$(dbus_services_DATA): $(dbus_services_in_files)
+	sed -e "s|\@BINDIR\@|$(DESTDIR)$(bindir)|" $< > $@
+dbus_conf_DATA = org.mate.CPUFreqSelector.conf
+
+@INTLTOOL_POLICY_RULE@
+polkit_DATA = $(polkit_in_files:.policy.in=.policy)
+
+else
+dbus_services_DATA=
+dbus_conf_DATA=
+polkit_DATA=
+endif
+
+EXTRA_DIST = \
+	cpufreq-selector-service.xml	\
+	$(dbus_services_in_files)	\
+	org.mate.CPUFreqSelector.conf	\
+	$(polkit_in_files)
+
+CLEANFILES = \
+	$(BUILT_SOURCES)	\
+	$(dbus_services_DATA)	\
+	$(polkit_DATA)
+
+-include $(top_srcdir)/git.mk
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.c
new file mode 100644
index 00000000..024b5cb7
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.c
@@ -0,0 +1,47 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "cpufreq-selector-factory.h"
+#include "cpufreq-selector-sysfs.h"
+#include "cpufreq-selector-procfs.h"
+#ifdef HAVE_LIBCPUFREQ
+#include "cpufreq-selector-libcpufreq.h"
+#endif
+
+CPUFreqSelector *
+cpufreq_selector_factory_create_selector (guint cpu)
+{
+	CPUFreqSelector *selector = NULL;
+	
+#ifdef HAVE_LIBCPUFREQ
+	selector = cpufreq_selector_libcpufreq_new (cpu);
+#else
+	if (g_file_test ("/sys/devices/system/cpu/cpu0/cpufreq", G_FILE_TEST_EXISTS)) { /* 2.6 kernel */
+		selector = cpufreq_selector_sysfs_new (cpu);
+	} else if (g_file_test ("/proc/cpufreq", G_FILE_TEST_EXISTS)) { /* 2.4 kernel */
+		selector = cpufreq_selector_procfs_new (cpu);
+	}
+#endif /* HAVE_LIBCPUFREQ */
+
+	return selector;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.h
new file mode 100644
index 00000000..fba0a8dc
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.h
@@ -0,0 +1,31 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef CPUFREQ_SELECTOR_FACTORY
+#define CPUFREQ_SELECTOR_FACTORY
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+CPUFreqSelector *cpufreq_selector_factory_create_selector (guint cpu);
+
+G_END_DECLS
+
+#endif /* CPUFREQ_SELECTOR_FACTORY */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.c
new file mode 100644
index 00000000..4b9573b3
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.c
@@ -0,0 +1,197 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <cpufreq.h>
+#include <stdlib.h>
+
+#include "cpufreq-selector-libcpufreq.h"
+
+static void     cpufreq_selector_libcpufreq_init          (CPUFreqSelectorLibcpufreq      *selector);
+static void     cpufreq_selector_libcpufreq_class_init    (CPUFreqSelectorLibcpufreqClass *klass);
+
+static gboolean cpufreq_selector_libcpufreq_set_frequency (CPUFreqSelector           *selector,
+							   guint                      frequency,
+							   GError                   **error);
+static gboolean cpufreq_selector_libcpufreq_set_governor  (CPUFreqSelector           *selector,
+							   const gchar               *governor,
+							   GError                   **error);
+
+G_DEFINE_TYPE (CPUFreqSelectorLibcpufreq, cpufreq_selector_libcpufreq, CPUFREQ_TYPE_SELECTOR)
+
+typedef struct cpufreq_policy                CPUFreqPolicy;
+typedef struct cpufreq_available_frequencies CPUFreqFrequencyList;
+typedef struct cpufreq_available_governors   CPUFreqGovernorList;
+
+static void
+cpufreq_selector_libcpufreq_init (CPUFreqSelectorLibcpufreq *selector)
+{
+}
+
+static void
+cpufreq_selector_libcpufreq_class_init (CPUFreqSelectorLibcpufreqClass *klass)
+{
+        CPUFreqSelectorClass *selector_class = CPUFREQ_SELECTOR_CLASS (klass);
+
+	selector_class->set_frequency = cpufreq_selector_libcpufreq_set_frequency;
+        selector_class->set_governor = cpufreq_selector_libcpufreq_set_governor;
+}
+
+CPUFreqSelector *
+cpufreq_selector_libcpufreq_new (guint cpu)
+{
+        CPUFreqSelector *selector;
+
+        selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ,
+						   "cpu", cpu, 
+						   NULL));
+
+        return selector;
+}
+
+static guint 
+cpufreq_selector_libcpufreq_get_valid_frequency (CPUFreqSelectorLibcpufreq *selector,
+						 guint                      frequency)
+{
+	guint                 cpu;
+	gint                  dist = G_MAXINT;
+	guint                 retval = 0;
+	CPUFreqFrequencyList *freqs, *freq;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	freqs = cpufreq_get_available_frequencies (cpu);
+	if (!freqs)
+		return 0;
+
+	for (freq = freqs; freq; freq = freq->next) {
+		guint current_dist;
+		
+		if (freq->frequency == frequency) {
+			cpufreq_put_available_frequencies (freqs);
+
+			return frequency;
+		}
+
+		current_dist = abs (freq->frequency - frequency);
+		if (current_dist < dist) {
+			dist = current_dist;
+			retval = freq->frequency;
+		}
+	}
+
+	return retval;
+}
+
+static gboolean
+cpufreq_selector_libcpufreq_set_frequency (CPUFreqSelector *selector,
+					   guint            frequency,
+					   GError         **error)
+{
+	guint freq;
+	guint cpu;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	freq = cpufreq_selector_libcpufreq_get_valid_frequency (CPUFREQ_SELECTOR_LIBCPUFREQ (selector),
+								frequency);
+	if (cpufreq_set_frequency (cpu, freq) != 0) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_SET_FREQUENCY,
+			     "Cannot set frequency '%d'",
+			     frequency);
+		
+		return FALSE;
+	}
+	
+	return TRUE;
+}
+
+static gboolean
+cpufreq_selector_libcpufreq_validate_governor (CPUFreqSelectorLibcpufreq *selector,
+					       const gchar               *governor)
+{
+	guint                cpu;
+	CPUFreqGovernorList *govs, *gov;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	govs = cpufreq_get_available_governors (cpu);
+	if (!govs)
+		return FALSE;
+
+	for (gov = govs; gov; gov = gov->next) {
+		if (g_ascii_strcasecmp (gov->governor, governor) == 0) {
+			cpufreq_put_available_governors (govs);
+
+			return TRUE;
+		}
+	}
+
+	cpufreq_put_available_governors (govs);
+
+	return FALSE;
+}
+
+static gboolean
+cpufreq_selector_libcpufreq_set_governor (CPUFreqSelector *selector,
+					  const gchar     *governor,
+					  GError         **error)
+{
+	CPUFreqSelectorLibcpufreq *selector_libcpufreq;
+	guint                      cpu;
+
+	selector_libcpufreq = CPUFREQ_SELECTOR_LIBCPUFREQ (selector);
+
+	if (!cpufreq_selector_libcpufreq_validate_governor (selector_libcpufreq, governor)) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_GOVERNOR,
+			     "Invalid governor '%s'",
+			     governor);
+		
+		return FALSE;
+	}
+	
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	if (cpufreq_modify_policy_governor (cpu, (gchar *)governor) != 0) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_GOVERNOR,
+			     "Invalid governor '%s'",
+			     governor);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.h
new file mode 100644
index 00000000..37dcda63
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.h
@@ -0,0 +1,61 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_LIBCPUFREQ_H__
+#define __CPUFREQ_SELECTOR_LIBCPUFREQ_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ            \
+	(cpufreq_selector_libcpufreq_get_type ())
+#define CPUFREQ_SELECTOR_LIBCPUFREQ(obj)            \
+	(G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ, CPUFreqSelectorLibcpufreq))
+#define CPUFREQ_SELECTOR_LIBCPUFREQ_CLASS(klass)    \
+	(G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ, CPUFreqSelectorLibcpufreqClass))
+#define CPUFREQ_IS_SELECTOR_LIBCPUFREQ(obj)         \
+	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ))
+#define CPUFREQ_IS_SELECTOR_LIBCPUFREQ_CLASS(klass) \
+	(G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ))
+#define CPUFREQ_SELECTOR_LIBCPUFREQ_GET_CLASS(obj)  \
+	(G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ, CPUFreqSelectorLibcpufreqClass))
+
+typedef struct _CPUFreqSelectorLibcpufreq      CPUFreqSelectorLibcpufreq;
+typedef struct _CPUFreqSelectorLibcpufreqClass CPUFreqSelectorLibcpufreqClass;
+
+struct _CPUFreqSelectorLibcpufreq {
+        CPUFreqSelector parent;
+};
+
+struct _CPUFreqSelectorLibcpufreqClass {
+        CPUFreqSelectorClass parent_class;
+};
+
+
+GType            cpufreq_selector_libcpufreq_get_type (void) G_GNUC_CONST;
+CPUFreqSelector *cpufreq_selector_libcpufreq_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_SYSFS_H__ */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.c
new file mode 100644
index 00000000..f08d681d
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.c
@@ -0,0 +1,243 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "cpufreq-selector-procfs.h"
+
+static void     cpufreq_selector_procfs_init          (CPUFreqSelectorProcfs      *selector);
+static void     cpufreq_selector_procfs_class_init    (CPUFreqSelectorProcfsClass *klass);
+
+static gboolean cpufreq_selector_procfs_set_frequency (CPUFreqSelector            *selector,
+						       guint                       frequency,
+						       GError                    **error);
+static gboolean cpufreq_selector_procfs_set_governor  (CPUFreqSelector            *selector,
+						       const gchar                *governor,
+						       GError                    **error);
+
+G_DEFINE_TYPE (CPUFreqSelectorProcfs, cpufreq_selector_procfs, CPUFREQ_TYPE_SELECTOR)
+
+static void
+cpufreq_selector_procfs_init (CPUFreqSelectorProcfs *selector)
+{
+}
+
+static void
+cpufreq_selector_procfs_class_init (CPUFreqSelectorProcfsClass *klass)
+{
+        CPUFreqSelectorClass *selector_class = CPUFREQ_SELECTOR_CLASS (klass);
+
+	selector_class->set_frequency = cpufreq_selector_procfs_set_frequency;
+        selector_class->set_governor = cpufreq_selector_procfs_set_governor;
+}
+
+CPUFreqSelector *
+cpufreq_selector_procfs_new (guint cpu)
+{
+        CPUFreqSelector *selector;
+
+        selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR_PROCFS,
+						   "cpu", cpu,
+						   NULL));
+
+        return selector;
+}
+
+static gboolean
+cpufreq_procfs_read (guint    selector_cpu,
+		     guint   *fmax,
+		     guint   *pmin,
+		     guint   *pmax,
+		     guint   *fmin,
+		     gchar   *mode,
+		     GError **error)
+{
+	gchar  **lines;
+	gchar   *buffer = NULL;
+	gint     i;
+	guint    cpu;
+	gboolean found = FALSE;
+	
+	if (!g_file_get_contents ("/proc/cpufreq", &buffer, NULL, error)) {
+		return FALSE;
+	}
+
+	lines = g_strsplit (buffer, "\n", -1);
+	for (i = 0; lines[i]; i++) {
+		if (g_ascii_strncasecmp (lines[i], "CPU", 3) == 0) {
+			/* CPU  0       650000 kHz ( 81 %)  -     800000 kHz (100 %)  -  powersave */
+			sscanf (lines[i], "CPU %u %u kHz (%u %%) - %u kHz (%u %%) - %20s",
+				&cpu, fmin, pmin, fmax, pmax, mode);
+
+			if (cpu == selector_cpu) {
+				found = TRUE;
+				break;
+			}
+		}
+	}
+
+	g_strfreev (lines);
+	g_free (buffer);
+
+	if (!found) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_CPU,
+			     "Invalid CPU number '%d'",
+			     selector_cpu);
+		
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static gboolean
+cpufreq_procfs_write (const gchar *path,
+		      const gchar *setting,
+		      GError     **error)
+{
+	FILE *fd;
+
+	fd = g_fopen (path, "w");
+
+	if (!fd) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to open '%s' for writing: "
+			     "g_fopen() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		return FALSE;
+	}
+
+	if (g_fprintf (fd, "%s", setting) < 0) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to write '%s': "
+			     "g_fprintf() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		fclose (fd);
+
+		return FALSE;
+	}
+
+	fclose (fd);
+
+	return TRUE;
+}
+
+static gboolean 
+cpufreq_selector_procfs_set_frequency (CPUFreqSelector *selector,
+				       guint            frequency,
+				       GError         **error)
+{
+        gchar *str;
+	gchar *path;
+	guint  freq;
+	guint  cpu;
+	guint  pmin, pmax;
+	guint  sc_max, sc_min;
+	gchar  mode[21];
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	if (!cpufreq_procfs_read (cpu, &sc_max, &pmin, &pmax, &sc_min, mode, error)) {
+		return FALSE;
+	}
+
+	if (g_ascii_strcasecmp (mode, "userspace") != 0) {
+		if (!cpufreq_selector_procfs_set_governor (selector,
+							   "userspace",
+							   error)) {
+			return FALSE;
+		}
+	}
+
+	if (frequency != sc_max && frequency != sc_min) {
+		if (abs (sc_max - frequency) < abs (frequency - sc_min))
+			freq = sc_max;
+		else
+			freq = sc_min;
+	} else {
+		freq = frequency;
+	}
+	
+	path = g_strdup_printf ("/proc/sys/cpu/%u/speed", cpu);
+	str = g_strdup_printf ("%u", freq);
+	if (!cpufreq_procfs_write (path, str, error)) {
+		g_free (path);
+		g_free (str);
+
+		return FALSE;
+	}
+
+	g_free (path);
+	g_free (str);
+	
+	return TRUE;
+}
+        
+static gboolean
+cpufreq_selector_procfs_set_governor (CPUFreqSelector *selector,
+				      const gchar     *governor,
+				      GError         **error)
+{
+	gchar *str;
+	guint  cpu;
+	guint  pmin, pmax;
+	guint  sc_max, sc_min;
+	gchar  mode[21];
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	if (!cpufreq_procfs_read (cpu, &sc_max, &pmin, &pmax, &sc_min, mode, error)) {
+		return FALSE;
+	}
+
+	if (g_ascii_strcasecmp (governor, mode) == 0)
+		return TRUE;
+
+	str = g_strdup_printf ("%u:%u:%u:%s", cpu, sc_min, sc_max, governor);
+
+	if (!cpufreq_procfs_write ("/proc/cpufreq", str, error)) {
+		g_free (str);
+
+		return FALSE;
+	}
+
+	g_free (str);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.h
new file mode 100644
index 00000000..55193731
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.h
@@ -0,0 +1,54 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_PROCFS_H__
+#define __CPUFREQ_SELECTOR_PROCFS_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_PROCFS            (cpufreq_selector_procfs_get_type ())
+#define CPUFREQ_SELECTOR_PROCFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_PROCFS, CPUFreqSelectorProcfs))
+#define CPUFREQ_SELECTOR_PROCFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_PROCFS, CPUFreqSelectorProcfsClass))
+#define CPUFREQ_IS_SELECTOR_PROCFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_PROCFS))
+#define CPUFREQ_IS_SELECTOR_PROCFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_PROCFS))
+#define CPUFREQ_SELECTOR_PROCFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_PROCFS, CPUFreqSelectorProcfsClass))
+
+typedef struct _CPUFreqSelectorProcfs         CPUFreqSelectorProcfs;
+typedef struct _CPUFreqSelectorProcfsClass    CPUFreqSelectorProcfsClass;
+
+struct _CPUFreqSelectorProcfs {
+        CPUFreqSelector parent;
+};
+
+struct _CPUFreqSelectorProcfsClass {
+        CPUFreqSelectorClass parent_class;
+};
+
+GType            cpufreq_selector_procfs_get_type (void) G_GNUC_CONST;
+CPUFreqSelector *cpufreq_selector_procfs_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_PROCFS_H__ */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
new file mode 100644
index 00000000..696ff220
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
@@ -0,0 +1,487 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <polkit/polkit.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "cpufreq-selector.h"
+#include "cpufreq-selector-factory.h"
+#include "cpufreq-selector-service.h"
+
+#include "cpufreq-selector-service-glue.h"
+
+#define MAX_CPUS 255
+
+struct _CPUFreqSelectorService {
+        GObject parent;
+
+	CPUFreqSelector *selectors[MAX_CPUS];
+	gint             selectors_max;
+
+	DBusGConnection *system_bus;
+	
+	/* PolicyKit */
+	PolkitAuthority   *authority;
+};
+
+struct _CPUFreqSelectorServiceClass {
+        GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (CPUFreqSelectorService, cpufreq_selector_service, G_TYPE_OBJECT)
+
+#define BUS_NAME "org.mate.CPUFreqSelector"
+
+GType
+cpufreq_selector_service_error_get_type (void)
+{
+	static GType etype = 0;
+
+	if (G_UNLIKELY (etype == 0)) {
+		static const GEnumValue values[] = {
+			{ SERVICE_ERROR_GENERAL,            "SERVICE_ERROR_GENERAL",            "GeneralError" },
+			{ SERVICE_ERROR_DBUS,               "SERVICE_ERROR_DBUS",               "DBUSError" },
+			{ SERVICE_ERROR_ALREADY_REGISTERED, "SERVICE_ERROR_ALREADY_REGISTERED", "AlreadyRegistered" },
+			{ SERVICE_ERROR_NOT_AUTHORIZED,     "SERVICE_ERROR_NOT_AUTHORIZED",     "NotAuthorized"},
+			{ 0, NULL, NULL}
+		};
+		
+		etype = g_enum_register_static ("CPUFreqSelectorServiceError", values);
+	}
+
+	return etype;
+}
+
+GQuark
+cpufreq_selector_service_error_quark (void)
+{
+	static GQuark error_quark = 0;
+
+	if (G_UNLIKELY (error_quark == 0))
+		error_quark =
+			g_quark_from_static_string ("cpufreq-selector-service-error-quark");
+	
+	return error_quark;
+}
+
+static void
+cpufreq_selector_service_finalize (GObject *object)
+{
+	CPUFreqSelectorService *service = CPUFREQ_SELECTOR_SERVICE (object);
+	gint i;
+
+	service->system_bus = NULL;
+	
+	if (service->selectors_max >= 0) {
+		for (i = 0; i < service->selectors_max; i++) {
+			if (service->selectors[i]) {
+				g_object_unref (service->selectors[i]);
+				service->selectors[i] = NULL;
+			}
+		}
+
+		service->selectors_max = -1;
+	}
+
+	if (service->authority) {
+		g_object_unref (service->authority);
+		service->authority = NULL;
+	}
+
+	G_OBJECT_CLASS (cpufreq_selector_service_parent_class)->finalize (object);
+}
+
+static void
+cpufreq_selector_service_class_init (CPUFreqSelectorServiceClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize = cpufreq_selector_service_finalize;
+}
+
+static void
+cpufreq_selector_service_init (CPUFreqSelectorService *service)
+{
+	service->selectors_max = -1;
+}
+
+CPUFreqSelectorService *
+cpufreq_selector_service_get_instance (void)
+{
+	static CPUFreqSelectorService *service = NULL;
+
+	if (!service)
+		service = CPUFREQ_SELECTOR_SERVICE (g_object_new (CPUFREQ_TYPE_SELECTOR_SERVICE, NULL));
+
+	return service;
+}
+
+static gboolean
+service_shutdown (gpointer user_data)
+{
+	g_object_unref (SELECTOR_SERVICE);
+
+	return FALSE;
+}
+
+static void
+reset_killtimer (void)
+{
+	static guint timer_id = 0;
+
+	if (timer_id > 0)
+		g_source_remove (timer_id);
+
+	timer_id = g_timeout_add_seconds (30,
+					  (GSourceFunc) service_shutdown,
+					  NULL);
+}
+
+gboolean
+cpufreq_selector_service_register (CPUFreqSelectorService *service,
+				   GError                **error)
+{
+	DBusGConnection *connection;
+	DBusGProxy      *bus_proxy;
+	gboolean         res;
+	guint            result;
+	GError          *err = NULL;
+
+	if (service->system_bus) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_ALREADY_REGISTERED,
+			     "Service %s already registered", BUS_NAME);
+		return FALSE;
+	}
+
+	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
+	if (!connection) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_DBUS,
+			     "Couldn't connect to system bus: %s",
+			     err->message);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	bus_proxy = dbus_g_proxy_new_for_name (connection,
+					       DBUS_SERVICE_DBUS,
+					       DBUS_PATH_DBUS,
+					       DBUS_INTERFACE_DBUS);
+	if (!bus_proxy) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_DBUS,
+			     "Could not construct bus_proxy object");
+		return FALSE;
+	}
+
+	res = dbus_g_proxy_call (bus_proxy,
+				 "RequestName",
+				 &err,
+				 G_TYPE_STRING, BUS_NAME,
+				 G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
+				 G_TYPE_INVALID,
+				 G_TYPE_UINT, &result,
+				 G_TYPE_INVALID);
+	g_object_unref (bus_proxy);
+	
+	if (!res) {
+		if (err) {
+			g_set_error (error,
+				     CPUFREQ_SELECTOR_SERVICE_ERROR,
+				     SERVICE_ERROR_DBUS,
+				     "Failed to acquire %s: %s",
+				     BUS_NAME, err->message);
+			g_error_free (err);
+		} else {
+			g_set_error (error,
+				     CPUFREQ_SELECTOR_SERVICE_ERROR,
+				     SERVICE_ERROR_DBUS,
+				     "Failed to acquire %s", BUS_NAME);
+		}
+
+		return FALSE;
+	}
+
+	if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_ALREADY_REGISTERED,
+			     "Service %s already registered", BUS_NAME);
+		return FALSE;
+	}
+
+	service->authority = polkit_authority_get ();
+
+	service->system_bus = connection;
+
+	dbus_g_object_type_install_info (CPUFREQ_TYPE_SELECTOR_SERVICE,
+					 &dbus_glib_cpufreq_selector_service_object_info);
+	dbus_g_connection_register_g_object (connection,
+					     "/org/mate/cpufreq_selector/selector",
+					     G_OBJECT (service));
+	dbus_g_error_domain_register (CPUFREQ_SELECTOR_SERVICE_ERROR, NULL,
+				      CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR);
+
+	reset_killtimer ();
+
+	return TRUE;
+}
+
+static CPUFreqSelector *
+get_selector_for_cpu (CPUFreqSelectorService *service,
+		      guint                   cpu)
+{
+	if (!service->selectors[cpu]) {
+		service->selectors[cpu] = cpufreq_selector_factory_create_selector (cpu);
+		if (!service->selectors[cpu])
+			return NULL;
+		
+		if (service->selectors_max < cpu)
+			service->selectors_max = cpu;
+	}
+	
+	return service->selectors[cpu];
+}
+
+/* PolicyKit */
+static gboolean
+cpufreq_selector_service_check_policy (CPUFreqSelectorService *service,
+				       DBusGMethodInvocation  *context,
+				       GError                **error)
+{
+	PolkitSubject             *subject;
+	PolkitAuthorizationResult *result;
+	gchar                     *sender;
+	gboolean                   ret;
+
+	sender = dbus_g_method_get_sender (context);
+	subject = polkit_system_bus_name_new (sender);
+	g_free (sender);
+
+	result = polkit_authority_check_authorization_sync (service->authority,
+                                                            subject,
+                                                            "org.mate.cpufreqselector",
+                                                            NULL,
+                                                            POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
+                                                            NULL, error);
+        g_object_unref (subject);
+
+        if (*error) {
+		g_warning ("Check policy: %s", (*error)->message);
+		g_object_unref (result);
+
+		return FALSE;
+	}
+
+	ret = polkit_authorization_result_get_is_authorized (result);
+	if (!ret) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_NOT_AUTHORIZED,
+			     "Caller is not authorized");
+	}
+
+	g_object_unref (result);
+
+	return ret;
+}
+
+/* D-BUS interface */
+gboolean
+cpufreq_selector_service_set_frequency (CPUFreqSelectorService *service,
+					guint                   cpu,
+					guint                   frequency,
+					DBusGMethodInvocation  *context)
+{
+	CPUFreqSelector *selector;
+	GError          *error = NULL;
+
+	reset_killtimer ();
+
+	if (!cpufreq_selector_service_check_policy (service, context, &error)) {
+		dbus_g_method_return_error (context, error);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+	if (cpu > MAX_CPUS) {
+		GError *err;
+		
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting frequency on cpu %d: Invalid cpu",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	selector = get_selector_for_cpu (service, cpu);
+	if (!selector) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting frequency on cpu %d: No cpufreq support",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	cpufreq_selector_set_frequency (selector, frequency, &error);
+	if (error) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting frequency %d on cpu %d: %s",
+				   frequency, cpu, error->message);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+		g_error_free (error);
+
+		return FALSE;
+	}
+	
+	dbus_g_method_return (context);
+	
+	return TRUE;
+}
+
+gboolean
+cpufreq_selector_service_set_governor (CPUFreqSelectorService *service,
+				       guint                   cpu,
+				       const gchar            *governor,
+				       DBusGMethodInvocation  *context)
+{
+	CPUFreqSelector *selector;
+	GError          *error = NULL;
+
+	reset_killtimer ();
+
+	if (!cpufreq_selector_service_check_policy (service, context, &error)) {
+		dbus_g_method_return_error (context, error);
+		g_error_free (error);
+
+		return FALSE;
+	}
+	
+	if (cpu > MAX_CPUS) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting governor on cpu %d: Invalid cpu",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	selector = get_selector_for_cpu (service, cpu);
+	if (!selector) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting governor on cpu %d: No cpufreq support",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	cpufreq_selector_set_governor (selector, governor, &error);
+	if (error) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting governor %s on cpu %d: %s",
+				   governor, cpu, error->message);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+	dbus_g_method_return (context);
+	
+	return TRUE;
+}
+
+
+gboolean
+cpufreq_selector_service_can_set (CPUFreqSelectorService *service,
+				  DBusGMethodInvocation  *context)
+{
+	PolkitSubject             *subject;
+	PolkitAuthorizationResult *result;
+	gchar                     *sender;
+	gboolean                   ret;
+        GError                    *error = NULL;
+
+	reset_killtimer ();
+
+	sender = dbus_g_method_get_sender (context);
+	subject = polkit_system_bus_name_new (sender);
+	g_free (sender);
+
+	result = polkit_authority_check_authorization_sync (service->authority,
+                                                            subject,
+                                                            "org.mate.cpufreqselector",
+                                                            NULL,
+                                                            0,
+                                                            NULL,
+							    &error);
+        g_object_unref (subject);
+
+	if (error) {
+		dbus_g_method_return_error (context, error);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+        if (polkit_authorization_result_get_is_authorized (result)) {
+		ret = TRUE;
+	} else if (polkit_authorization_result_get_is_challenge (result)) {
+		ret = TRUE;
+	} else {
+		ret = FALSE;
+	}
+
+	g_object_unref (result);
+
+        dbus_g_method_return (context, ret);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.h
new file mode 100644
index 00000000..a6bcc77b
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.h
@@ -0,0 +1,71 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __CPUFREQ_SELECTOR_SERVICE_H__
+#define __CPUFREQ_SELECTOR_SERVICE_H__
+
+#include <glib-object.h>
+#include <dbus/dbus-glib.h>
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_SERVICE            (cpufreq_selector_service_get_type ())
+#define CPUFREQ_SELECTOR_SERVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_SERVICE, CPUFreqSelectorService))
+#define CPUFREQ_SELECTOR_SERVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_SERVICE, CPUFreqSelectorServiceClass))
+#define CPUFREQ_IS_SELECTOR_SERVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_SERVICE))
+#define CPUFREQ_IS_SELECTOR_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_SERVICE))
+#define CPUFREQ_SELECTOR_SERVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_SERVICE, CPUFreqSelectorServiceClass))
+
+#define SELECTOR_SERVICE                         (cpufreq_selector_service_get_instance ())
+
+#define CPUFREQ_SELECTOR_SERVICE_ERROR           (cpufreq_selector_service_error_quark ())
+#define CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR      (cpufreq_selector_service_error_get_type ())
+
+enum {
+	SERVICE_ERROR_GENERAL,
+	SERVICE_ERROR_DBUS,
+	SERVICE_ERROR_ALREADY_REGISTERED,
+	SERVICE_ERROR_NOT_AUTHORIZED
+};
+
+typedef struct _CPUFreqSelectorService        CPUFreqSelectorService;
+typedef struct _CPUFreqSelectorServiceClass   CPUFreqSelectorServiceClass;
+
+GType                   cpufreq_selector_service_get_type       (void) G_GNUC_CONST;
+GType                   cpufreq_selector_service_error_get_type (void) G_GNUC_CONST;
+GQuark                  cpufreq_selector_service_error_quark    (void) G_GNUC_CONST;
+CPUFreqSelectorService *cpufreq_selector_service_get_instance   (void);
+gboolean                cpufreq_selector_service_register       (CPUFreqSelectorService *service,
+								 GError                **error);
+
+gboolean                cpufreq_selector_service_set_frequency  (CPUFreqSelectorService *service,
+								 guint                   cpu,
+								 guint                   frequency,
+								 DBusGMethodInvocation  *context);
+gboolean                cpufreq_selector_service_set_governor   (CPUFreqSelectorService *service,
+								 guint                   cpu,
+								 const gchar            *governor,
+								 DBusGMethodInvocation  *context);
+gboolean               cpufreq_selector_service_can_set         (CPUFreqSelectorService *service,
+								 DBusGMethodInvocation  *context);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_SERVICE_H__ */
+
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.xml b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.xml
new file mode 100644
index 00000000..798dd5b2
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.xml
@@ -0,0 +1,23 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+
+<node name="/org/mate/CPUFreqSelector">
+  <interface name="org.mate.CPUFreqSelector">
+    <method name="SetFrequency">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="cpu" direction="in" type="u"/>
+      <arg name="frequency" direction="in" type="u"/>
+    </method>
+
+    <method name="SetGovernor">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="cpu" direction="in" type="u"/>
+      <arg name="governor" direction="in" type="s"/>
+    </method>
+
+    <method name="CanSet">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="result" direction="out" type="b"/>
+    </method>
+
+  </interface>
+</node>
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.c
new file mode 100644
index 00000000..ae790caf
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.c
@@ -0,0 +1,430 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "cpufreq-selector-sysfs.h"
+
+#define CPUFREQ_SELECTOR_SYSFS_GET_PRIVATE(obj) \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfsPrivate))
+
+struct _CPUFreqSelectorSysfsPrivate {
+	GList *available_freqs;
+	GList *available_govs;
+};
+
+static void     cpufreq_selector_sysfs_init          (CPUFreqSelectorSysfs      *selector);
+static void     cpufreq_selector_sysfs_class_init    (CPUFreqSelectorSysfsClass *klass);
+static void     cpufreq_selector_sysfs_finalize      (GObject                   *object);
+
+static gboolean cpufreq_selector_sysfs_set_frequency (CPUFreqSelector           *selector,
+						      guint                      frequency,
+						      GError                   **error);
+static gboolean cpufreq_selector_sysfs_set_governor  (CPUFreqSelector           *selector,
+						      const gchar               *governor,
+						      GError                   **error);
+
+#define CPUFREQ_SYSFS_BASE_PATH "/sys/devices/system/cpu/cpu%u/cpufreq/%s"
+
+G_DEFINE_TYPE (CPUFreqSelectorSysfs, cpufreq_selector_sysfs, CPUFREQ_TYPE_SELECTOR)
+
+static void
+cpufreq_selector_sysfs_init (CPUFreqSelectorSysfs *selector)
+{
+	selector->priv = CPUFREQ_SELECTOR_SYSFS_GET_PRIVATE (selector);
+
+	selector->priv->available_freqs = NULL;
+	selector->priv->available_govs = NULL;
+}
+
+static void
+cpufreq_selector_sysfs_class_init (CPUFreqSelectorSysfsClass *klass)
+{
+        GObjectClass         *object_class = G_OBJECT_CLASS (klass);
+        CPUFreqSelectorClass *selector_class = CPUFREQ_SELECTOR_CLASS (klass);
+
+        g_type_class_add_private (klass, sizeof (CPUFreqSelectorSysfsPrivate));
+
+	selector_class->set_frequency = cpufreq_selector_sysfs_set_frequency;
+        selector_class->set_governor = cpufreq_selector_sysfs_set_governor;
+
+        object_class->finalize = cpufreq_selector_sysfs_finalize;
+}
+
+static void
+cpufreq_selector_sysfs_finalize (GObject *object)
+{
+        CPUFreqSelectorSysfs *selector = CPUFREQ_SELECTOR_SYSFS (object);
+
+        if (selector->priv->available_freqs) {
+                g_list_foreach (selector->priv->available_freqs,
+                                (GFunc) g_free,
+				NULL);
+                g_list_free (selector->priv->available_freqs);
+                selector->priv->available_freqs = NULL;
+	}
+           
+        if (selector->priv->available_govs) {
+                g_list_foreach (selector->priv->available_govs,
+                                (GFunc) g_free,
+				NULL);
+                g_list_free (selector->priv->available_govs);
+                selector->priv->available_govs = NULL;
+	}
+
+	G_OBJECT_CLASS (cpufreq_selector_sysfs_parent_class)->finalize (object);
+}
+
+CPUFreqSelector *
+cpufreq_selector_sysfs_new (guint cpu)
+{
+        CPUFreqSelector *selector;
+
+        selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR_SYSFS,
+						   "cpu", cpu, 
+						   NULL));
+
+        return selector;
+}
+
+static gchar *
+cpufreq_sysfs_read (const gchar *path,
+		    GError     **error)
+{
+	gchar  *buffer = NULL;
+
+	if (!g_file_get_contents (path, &buffer, NULL, error)) {
+		return NULL;
+	}
+
+	return g_strchomp (buffer);
+}
+
+static gboolean
+cpufreq_sysfs_write (const gchar *path,
+		     const gchar *setting,
+		     GError     **error)
+{
+	FILE *fd;
+
+	fd = g_fopen (path, "w");
+
+	if (!fd) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to open '%s' for writing: "
+			     "g_fopen() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		return FALSE;
+	}
+
+	if (g_fprintf (fd, "%s", setting) < 0) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to write '%s': "
+			     "g_fprintf() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		fclose (fd);
+
+		return FALSE;
+	}
+
+	fclose (fd);
+
+	return TRUE;
+}
+
+static gint
+compare (gconstpointer a, gconstpointer b)
+{
+        gint aa, bb;
+	
+        aa = atoi ((gchar *) a);
+        bb = atoi ((gchar *) b);
+	
+        if (aa == bb)
+                return 0;
+        else if (aa > bb)
+                return -1;
+        else
+                return 1;
+}
+
+static GList *
+cpufreq_selector_sysfs_get_freqs (CPUFreqSelectorSysfs *selector)
+{
+        gchar  *buffer;
+        GList  *list = NULL;
+        gchar **frequencies = NULL;
+        gint    i;
+        gchar  *path;
+	guint   cpu;
+	GError *error = NULL;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+	
+        path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu, 
+				"scaling_available_frequencies");
+
+	buffer = cpufreq_sysfs_read (path, &error);
+	if (!buffer) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		g_free (path);
+
+		return NULL;
+	}
+
+	g_free (path);
+
+	frequencies = g_strsplit (buffer, " ", -1);
+
+	i = 0;
+	while (frequencies[i]) {
+		if (!g_list_find_custom (list, frequencies[i], compare))
+			list = g_list_prepend (list, g_strdup (frequencies[i]));
+		i++;
+	}
+
+	g_strfreev (frequencies);
+	g_free (buffer);
+
+	return g_list_sort (list, compare);
+}
+
+static const gchar *
+cpufreq_selector_sysfs_get_valid_frequency (CPUFreqSelectorSysfs *selector,
+					    guint                 frequency)
+{
+	GList       *list = NULL;
+	GList       *l;
+	gint         dist = G_MAXINT;
+	const gchar *retval = NULL;
+	
+	if (!selector->priv->available_freqs) {
+		list = cpufreq_selector_sysfs_get_freqs (selector);
+		selector->priv->available_freqs = list;
+	} else {
+		list = selector->priv->available_freqs;
+	}
+
+	if (!list)
+		return NULL;
+
+	for (l = list; l && l->data; l = g_list_next (l)) {
+		const gchar *freq;
+		guint        f;
+		guint        current_dist;
+
+		freq = (const gchar *) l->data;
+		f = atoi (freq);
+
+		if (f == frequency)
+			return freq;
+
+		current_dist = abs (frequency - f);
+		if (current_dist < dist) {
+			dist = current_dist;
+			retval = freq;
+		}
+	}
+
+	return retval;
+}
+
+static gboolean
+cpufreq_selector_sysfs_set_frequency (CPUFreqSelector *selector,
+				      guint            frequency,
+				      GError         **error)
+{
+	gchar       *governor;
+	gchar       *path;
+	const gchar *frequency_text;
+	guint        cpu;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+	
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+				"scaling_governor");
+	
+	governor = cpufreq_sysfs_read (path, error);
+	g_free (path);
+	
+	if (!governor)
+		return FALSE;
+
+	if (g_ascii_strcasecmp (governor, "userspace") != 0) {
+		if (!cpufreq_selector_sysfs_set_governor (selector,
+							  "userspace",
+							  error)) {
+			g_free (governor);
+
+			return FALSE;
+		}
+	}
+
+	g_free (governor);
+
+	frequency_text =
+		cpufreq_selector_sysfs_get_valid_frequency (CPUFREQ_SELECTOR_SYSFS (selector),
+							    frequency);
+	if (!frequency_text) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_SET_FREQUENCY,
+			     "Cannot set frequency '%d'",
+			     frequency);
+
+		return FALSE;
+	}
+
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+				"scaling_setspeed");
+	if (!cpufreq_sysfs_write (path, frequency_text, error)) {
+		g_free (path);
+		
+		return FALSE;
+	}
+	
+	g_free (path);
+	
+	return TRUE;
+}
+
+static GList *
+cpufreq_selector_sysfs_get_govs (CPUFreqSelectorSysfs *selector)
+{
+	gchar  *buffer;
+	GList  *list = NULL;
+	gchar **governors = NULL;
+	gint    i;
+	gchar  *path;
+	guint   cpu;
+	GError *error = NULL;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu, 
+				"scaling_available_governors");
+
+	buffer = cpufreq_sysfs_read (path, &error);
+	if (!buffer) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		g_free (path);
+
+		return NULL;
+	}
+
+	g_free (path);
+
+	governors = g_strsplit (buffer, " ", -1);
+
+	i = 0;
+	while (governors[i]) {
+		list = g_list_prepend (list, g_strdup (governors[i]));
+		i++;
+	}
+
+	g_strfreev (governors);
+	g_free (buffer);
+	
+	return list;
+}
+
+static gboolean
+cpufreq_selector_sysfs_validate_governor (CPUFreqSelectorSysfs *selector,
+					  const gchar          *governor)
+{
+	GList *list = NULL;
+	
+	if (!selector->priv->available_govs) {
+		list = cpufreq_selector_sysfs_get_govs (selector);
+		selector->priv->available_govs = list;
+	} else {
+		list = selector->priv->available_govs;
+	}
+
+	if (!list)
+		return FALSE;
+	
+	list = g_list_find_custom (selector->priv->available_govs,
+				   governor,
+				   (GCompareFunc) g_ascii_strcasecmp);
+	
+	return (list != NULL);
+}
+
+static gboolean
+cpufreq_selector_sysfs_set_governor (CPUFreqSelector *selector,
+				     const gchar     *governor,
+				     GError         **error)
+{
+	CPUFreqSelectorSysfs *selector_sysfs;
+        gchar                *path;
+	guint                 cpu;
+
+	selector_sysfs = CPUFREQ_SELECTOR_SYSFS (selector);
+
+	if (!cpufreq_selector_sysfs_validate_governor (selector_sysfs, governor)) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_GOVERNOR,
+			     "Invalid governor '%s'",
+			     governor);
+		
+		return FALSE;
+	}
+	
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+        path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+				"scaling_governor");
+
+	if (!cpufreq_sysfs_write (path, governor, error)) {
+		g_free (path);
+		
+		return FALSE;
+	}
+
+        g_free (path);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.h
new file mode 100644
index 00000000..a2608bbc
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.h
@@ -0,0 +1,58 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_SYSFS_H__
+#define __CPUFREQ_SELECTOR_SYSFS_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_SYSFS            (cpufreq_selector_sysfs_get_type ())
+#define CPUFREQ_SELECTOR_SYSFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfs))
+#define CPUFREQ_SELECTOR_SYSFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfsClass))
+#define CPUFREQ_IS_SELECTOR_SYSFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_SYSFS))
+#define CPUFREQ_IS_SELECTOR_SYSFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_SYSFS))
+#define CPUFREQ_SELECTOR_SYSFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfsClass))
+
+typedef struct _CPUFreqSelectorSysfs        CPUFreqSelectorSysfs;
+typedef struct _CPUFreqSelectorSysfsClass   CPUFreqSelectorSysfsClass;
+typedef struct _CPUFreqSelectorSysfsPrivate CPUFreqSelectorSysfsPrivate;
+
+struct _CPUFreqSelectorSysfs {
+        CPUFreqSelector parent;
+
+	CPUFreqSelectorSysfsPrivate *priv;
+};
+
+struct _CPUFreqSelectorSysfsClass {
+        CPUFreqSelectorClass parent_class;
+};
+
+
+GType            cpufreq_selector_sysfs_get_type (void) G_GNUC_CONST;
+CPUFreqSelector *cpufreq_selector_sysfs_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_SYSFS_H__ */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector.c b/cpufreq/src/cpufreq-selector/cpufreq-selector.c
new file mode 100644
index 00000000..f019fec3
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector.c
@@ -0,0 +1,173 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include "cpufreq-selector.h"
+
+#define CPUFREQ_SELECTOR_GET_PRIVATE(obj) \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorPrivate))
+
+enum {
+	PROP_0,
+	PROP_CPU
+};
+
+struct _CPUFreqSelectorPrivate {
+	guint  cpu;
+};
+
+static void cpufreq_selector_init         (CPUFreqSelector      *selector);
+static void cpufreq_selector_class_init   (CPUFreqSelectorClass *klass);
+
+static void cpufreq_selector_set_property (GObject              *object,
+					   guint                 prop_id,
+					   const GValue         *value,
+					   GParamSpec           *spec);
+static void cpufreq_selector_get_property (GObject              *object,
+					   guint                 prop_id,
+					   GValue               *value,
+					   GParamSpec           *spec);
+
+G_DEFINE_ABSTRACT_TYPE (CPUFreqSelector, cpufreq_selector, G_TYPE_OBJECT)
+
+GQuark
+cpufreq_selector_error_quark (void)
+{
+	static GQuark error_quark = 0;
+
+	if (error_quark == 0)
+		error_quark =
+			g_quark_from_static_string ("cpufreq-selector-error-quark");
+
+	return error_quark;
+}
+
+static void
+cpufreq_selector_init (CPUFreqSelector *selector)
+{
+
+	selector->priv = CPUFREQ_SELECTOR_GET_PRIVATE (selector);
+
+        selector->priv->cpu = 0;
+}
+
+static void
+cpufreq_selector_class_init (CPUFreqSelectorClass *klass)
+{
+        GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+        g_type_class_add_private (klass, sizeof (CPUFreqSelectorPrivate));
+
+        object_class->set_property = cpufreq_selector_set_property;
+        object_class->get_property = cpufreq_selector_get_property;
+
+	/* Public virtual methods */
+	klass->set_frequency = NULL;
+	klass->set_governor = NULL;
+
+	/* Porperties */
+        g_object_class_install_property (object_class,
+					 PROP_CPU,
+                                         g_param_spec_uint ("cpu",
+							    NULL,
+							    NULL,
+                                                            0,
+							    G_MAXUINT,
+							    0,
+							    G_PARAM_CONSTRUCT_ONLY |
+                                                            G_PARAM_READWRITE));
+}
+
+static void
+cpufreq_selector_set_property (GObject      *object,
+			       guint         prop_id,
+			       const GValue *value,
+			       GParamSpec   *spec)
+{
+	CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
+
+        switch (prop_id) {
+        case PROP_CPU:
+                selector->priv->cpu = g_value_get_uint (value);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
+		break;
+        }
+}
+
+static void
+cpufreq_selector_get_property (GObject    *object,
+			       guint       prop_id,
+			       GValue     *value,
+			       GParamSpec *spec)
+{
+	CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
+
+        switch (prop_id) {
+        case PROP_CPU:
+                g_value_set_uint (value, selector->priv->cpu);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
+		break;
+        }
+}
+
+gboolean
+cpufreq_selector_set_frequency (CPUFreqSelector *selector,
+				guint            frequency,
+				GError         **error)
+{
+	CPUFreqSelectorClass *class;
+	
+	g_return_val_if_fail (CPUFREQ_IS_SELECTOR (selector), FALSE);
+	g_return_val_if_fail (frequency > 0, FALSE);
+
+	class = CPUFREQ_SELECTOR_GET_CLASS (selector);
+	
+	if (class->set_frequency) {
+		return class->set_frequency (selector, frequency, error);
+	}
+
+	return FALSE;
+}
+
+gboolean
+cpufreq_selector_set_governor (CPUFreqSelector *selector,
+			       const gchar     *governor,
+			       GError         **error)
+{
+	CPUFreqSelectorClass *class;
+	
+        g_return_val_if_fail (CPUFREQ_IS_SELECTOR (selector), FALSE);
+	g_return_val_if_fail (governor != NULL, FALSE);
+
+	class = CPUFREQ_SELECTOR_GET_CLASS (selector);
+	
+        if (class->set_governor) {
+                return class->set_governor (selector, governor, error);
+        }
+
+	return FALSE;
+}
+
+
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector.h b/cpufreq/src/cpufreq-selector/cpufreq-selector.h
new file mode 100644
index 00000000..73e41054
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector.h
@@ -0,0 +1,74 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_H__
+#define __CPUFREQ_SELECTOR_H__
+
+#include <glib-object.h>
+
+#define CPUFREQ_TYPE_SELECTOR            (cpufreq_selector_get_type ())
+#define CPUFREQ_SELECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelector))
+#define CPUFREQ_SELECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorClass))
+#define CPUFREQ_IS_SELECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR))
+#define CPUFREQ_IS_SELECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR))
+#define CPUFREQ_SELECTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorClass))
+
+#define CPUFREQ_SELECTOR_ERROR (cpufreq_selector_error_quark ())
+
+enum {
+	SELECTOR_ERROR_INVALID_CPU,
+	SELECTOR_ERROR_INVALID_GOVERNOR,
+	SELECTOR_ERROR_SET_FREQUENCY
+};
+
+typedef struct _CPUFreqSelector        CPUFreqSelector;
+typedef struct _CPUFreqSelectorClass   CPUFreqSelectorClass;
+typedef struct _CPUFreqSelectorPrivate CPUFreqSelectorPrivate;
+
+struct _CPUFreqSelector {
+        GObject parent;
+
+	CPUFreqSelectorPrivate *priv;
+};
+
+struct _CPUFreqSelectorClass {
+        GObjectClass parent_class;
+
+	gboolean  (* set_frequency) (CPUFreqSelector *selector,
+				     guint            frequency,
+				     GError         **error);
+        gboolean  (* set_governor)  (CPUFreqSelector *selector,
+				     const gchar     *governor,
+				     GError         **error);
+};
+
+
+GType    cpufreq_selector_get_type      (void) G_GNUC_CONST;
+GQuark   cpufreq_selector_error_quark   (void) G_GNUC_CONST;
+
+gboolean cpufreq_selector_set_frequency (CPUFreqSelector *selector,
+					 guint            frequency,
+					 GError         **error);
+gboolean cpufreq_selector_set_governor  (CPUFreqSelector *selector,
+					 const gchar     *governor,
+					 GError         **error);
+
+#endif /* __CPUFREQ_SELECTOR_H__ */
diff --git a/cpufreq/src/cpufreq-selector/main.c b/cpufreq/src/cpufreq-selector/main.c
new file mode 100644
index 00000000..f0fbb7b1
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/main.c
@@ -0,0 +1,233 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib.h>
+#include <glib-object.h>
+
+#ifdef HAVE_POLKIT
+#include "cpufreq-selector-service.h"
+#endif
+#include "cpufreq-selector-factory.h"
+
+
+static gint    cpu = 0;
+static gchar  *governor = NULL;
+static gulong  frequency = 0;
+
+static const GOptionEntry options[] = {
+	{ "cpu",       'c', 0, G_OPTION_ARG_INT,    &cpu,       "CPU Number",       NULL },
+	{ "governor",  'g', 0, G_OPTION_ARG_STRING, &governor,  "Governor",         NULL },
+	{ "frequency", 'f', 0, G_OPTION_ARG_INT,    &frequency, "Frequency in KHz", NULL },
+	{ NULL }
+};
+
+#ifdef HAVE_POLKIT
+static void
+do_exit (GMainLoop *loop,
+	 GObject   *object)
+{
+	if (g_main_loop_is_running (loop))
+		g_main_loop_quit (loop);
+}
+
+static void
+cpufreq_selector_set_values_dbus (void)
+{
+	DBusGConnection *connection;
+	DBusGProxy      *proxy;
+	gboolean         res;
+	GError          *error = NULL;
+
+	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
+	if (!connection) {
+		g_printerr ("Couldn't connect to system bus: %s\n",
+			    error->message);
+		g_error_free (error);
+
+		return;
+	}
+
+	proxy = dbus_g_proxy_new_for_name (connection,
+					   "org.mate.CPUFreqSelector",
+					   "/org/mate/cpufreq_selector/selector",
+					   "org.mate.CPUFreqSelector");
+	if (!proxy) {
+		g_printerr ("Could not construct proxy object\n");
+
+		return;
+	}
+
+	if (governor) {
+		res = dbus_g_proxy_call (proxy, "SetGovernor", &error,
+					 G_TYPE_UINT, cpu,
+					 G_TYPE_STRING, governor,
+					 G_TYPE_INVALID,
+					 G_TYPE_INVALID);
+		if (!res) {
+			if (error) {
+				g_printerr ("Error calling SetGovernor: %s\n", error->message);
+				g_error_free (error);
+			} else {
+				g_printerr ("Error calling SetGovernor\n");
+			}
+			
+			g_object_unref (proxy);
+			
+			return;
+		}
+	}
+
+	if (frequency != 0) {
+		res = dbus_g_proxy_call (proxy, "SetFrequency", &error,
+					 G_TYPE_UINT, cpu,
+					 G_TYPE_UINT, frequency,
+					 G_TYPE_INVALID,
+					 G_TYPE_INVALID);
+		if (!res) {
+			if (error) {
+				g_printerr ("Error calling SetFrequency: %s\n", error->message);
+				g_error_free (error);
+			} else {
+				g_printerr ("Error calling SetFrequency\n");
+			}
+			
+			g_object_unref (proxy);
+			
+			return;
+		}
+	}
+
+	g_object_unref (proxy);
+}
+#endif /* HAVE_POLKIT */
+
+static void
+cpufreq_selector_set_values (void)
+{
+	CPUFreqSelector *selector;
+	GError          *error = NULL;
+
+	selector = cpufreq_selector_factory_create_selector (cpu);
+	if (!selector) {
+		g_printerr ("No cpufreq support\n");
+
+		return;
+	}
+
+	if (governor) {
+		cpufreq_selector_set_governor (selector, governor, &error);
+
+		if (error) {
+			g_printerr ("%s\n", error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+
+	if (frequency != 0) {
+		cpufreq_selector_set_frequency (selector, frequency, &error);
+
+		if (error) {
+			g_printerr ("%s\n", error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+
+	g_object_unref (selector);
+}
+
+gint
+main (gint argc, gchar **argv)
+{
+#ifdef HAVE_POLKIT
+	GMainLoop      *loop;
+#endif
+        GOptionContext *context;
+	GError         *error = NULL;
+
+#ifndef HAVE_POLKIT
+	if (geteuid () != 0) {
+		g_printerr ("You must be root\n");
+
+		return 1;
+	}
+	
+	if (argc < 2) {
+		g_printerr ("Missing operand after `cpufreq-selector'\n");
+		g_printerr ("Try `cpufreq-selector --help' for more information.\n");
+
+		return 1;
+	}
+#endif
+	
+	g_type_init ();
+
+	context = g_option_context_new ("- CPUFreq Selector");
+	g_option_context_add_main_entries (context, options, NULL);
+	
+	if (!g_option_context_parse (context, &argc, &argv, &error)) {
+		if (error) {
+			g_printerr ("%s\n", error->message);
+			g_error_free (error);
+		} 
+
+		g_option_context_free (context);
+		
+		return 1;
+	}
+	
+	g_option_context_free (context);
+	
+#ifdef HAVE_POLKIT
+	if (!cpufreq_selector_service_register (SELECTOR_SERVICE, &error)) {
+		if (governor || frequency != 0) {
+			cpufreq_selector_set_values_dbus ();
+
+			return 0;
+		}
+
+		g_printerr ("%s\n", error->message);
+		g_error_free (error);
+
+		return 1;
+	}
+
+	cpufreq_selector_set_values ();
+
+	loop = g_main_loop_new (NULL, FALSE);
+	g_object_weak_ref (G_OBJECT (SELECTOR_SERVICE),
+			   (GWeakNotify) do_exit,
+			   loop);
+		
+	g_main_loop_run (loop);
+
+	g_main_loop_unref (loop);
+#else /* !HAVE_POLKIT */
+	cpufreq_selector_set_values ();
+#endif /* HAVE_POLKIT */
+
+        return 0;
+}
diff --git a/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.conf b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.conf
new file mode 100644
index 00000000..c4b27a23
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.conf
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE busconfig PUBLIC
+	  "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+	  "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+
+<busconfig>
+
+  <!-- Only root can own the service -->
+  <policy user="root">
+    <allow own="org.mate.CPUFreqSelector"/>
+    <allow send_interface="org.mate.CPUFreqSelector"/>
+  </policy>
+
+  <policy context="default">
+    <allow send_interface="org.mate.CPUFreqSelector"/>
+  </policy>
+
+</busconfig>
+	  
diff --git a/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.service.in b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.service.in
new file mode 100644
index 00000000..e402df2e
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.service.in
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=org.mate.CPUFreqSelector
+Exec=@BINDIR@/cpufreq-selector
+User=root
diff --git a/cpufreq/src/cpufreq-selector/org.mate.cpufreqselector.policy.in b/cpufreq/src/cpufreq-selector/org.mate.cpufreqselector.policy.in
new file mode 100644
index 00000000..f1249cd2
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/org.mate.cpufreqselector.policy.in
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE policyconfig PUBLIC
+	  "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+	  "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
+
+<policyconfig>
+
+  <vendor>The MATE Project</vendor>
+  <vendor_url>http://www.mate.org/</vendor_url>
+  <icon_name>mate-cpu-frequency-applet</icon_name>
+
+  <action id="org.mate.cpufreqselector">
+    <_description>Change CPU Frequency scaling</_description>
+    <_message>Privileges are required to change the CPU Frequency scaling.</_message>
+    <defaults>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>auth_admin_keep</allow_active>
+    </defaults>
+  </action>
+
+</policyconfig>
diff --git a/cpufreq/src/cpufreq-utils.c b/cpufreq/src/cpufreq-utils.c
new file mode 100644
index 00000000..47b80c1f
--- /dev/null
+++ b/cpufreq/src/cpufreq-utils.c
@@ -0,0 +1,311 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2006 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <config.h>
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include "cpufreq-utils.h"
+
+#ifdef HAVE_POLKIT
+#include <dbus/dbus-glib.h>
+#endif /* HAVE_POLKIT */
+
+guint
+cpufreq_utils_get_n_cpus (void)
+{
+	gint   mcpu = -1;
+	gchar *file = NULL;
+	static guint n_cpus = 0;
+
+	if (n_cpus > 0)
+		return n_cpus;
+	
+	do {
+		if (file)
+			g_free (file);
+		mcpu ++;
+		file = g_strdup_printf ("/sys/devices/system/cpu/cpu%d", mcpu);
+	} while (g_file_test (file, G_FILE_TEST_EXISTS));
+	g_free (file);
+
+	if (mcpu >= 0) {
+		n_cpus = (guint)mcpu;
+		return mcpu;
+	}
+
+	mcpu = -1;
+	file = NULL;
+	do {
+		if (file)
+			g_free (file);
+		mcpu ++;
+		file = g_strdup_printf ("/proc/sys/cpu/%d", mcpu);
+	} while (g_file_test (file, G_FILE_TEST_EXISTS));
+	g_free (file);
+
+	if (mcpu >= 0) {
+		n_cpus = (guint)mcpu;
+		return mcpu;
+	}
+
+	n_cpus = 1;
+	
+	return 1;
+}
+
+void
+cpufreq_utils_display_error (const gchar *message,
+			     const gchar *secondary)
+{
+	GtkWidget *dialog;
+
+	g_return_if_fail (message != NULL);
+
+	dialog = gtk_message_dialog_new (NULL,
+					 GTK_DIALOG_DESTROY_WITH_PARENT,
+					 GTK_MESSAGE_ERROR,
+					 GTK_BUTTONS_OK,
+					 "%s", message);
+	if (secondary) {
+		gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+							  "%s", secondary);
+	}
+	
+	gtk_window_set_title (GTK_WINDOW (dialog), ""); /* as per HIG */
+	gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), TRUE);
+	g_signal_connect (G_OBJECT (dialog),
+			  "response",
+			  G_CALLBACK (gtk_widget_destroy), NULL);
+	gtk_widget_show (dialog);
+}
+
+#ifdef HAVE_POLKIT
+#define CACHE_VALIDITY_SEC 2
+
+static gboolean
+selector_is_available (void)
+{
+        DBusGProxy             *proxy;
+	static DBusGConnection *system_bus = NULL;
+	GError                 *error = NULL;
+	gboolean                result;
+
+	if (!system_bus) {
+		system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
+		if (!system_bus) {
+			g_warning ("%s", error->message);
+			g_error_free (error);
+
+			return FALSE;
+		}
+	}
+
+        proxy = dbus_g_proxy_new_for_name (system_bus,
+                                           "org.mate.CPUFreqSelector",
+                                           "/org/mate/cpufreq_selector/selector",
+                                           "org.mate.CPUFreqSelector");
+
+        if (!dbus_g_proxy_call (proxy, "CanSet", &error,
+                           	G_TYPE_INVALID,
+                           	G_TYPE_BOOLEAN, &result,
+                           	G_TYPE_INVALID)) {
+		g_warning ("Error calling org.mate.CPUFreqSelector.CanSet: %s", error->message);
+		g_error_free (error);
+		result = FALSE;
+	}
+
+	g_object_unref (proxy);
+
+	return result;
+}
+
+gboolean
+cpufreq_utils_selector_is_available (void)
+{
+	static gboolean cache = FALSE;
+	static time_t   last_refreshed = 0;
+	time_t          now;
+
+	time (&now);
+	if (ABS (now - last_refreshed) > CACHE_VALIDITY_SEC) {
+		cache = selector_is_available ();
+		last_refreshed = now;
+	}
+
+	return cache;
+}
+#else /* !HAVE_POLKIT */
+gboolean
+cpufreq_utils_selector_is_available (void)
+{
+	struct stat *info;
+	gchar       *path = NULL;
+
+	path = g_find_program_in_path ("cpufreq-selector");
+	if (!path)
+		return FALSE;
+
+	if (geteuid () == 0) {
+		g_free (path);
+		return TRUE;
+	}
+
+	info = (struct stat *) g_malloc (sizeof (struct stat));
+
+	if ((lstat (path, info)) != -1) {
+		if ((info->st_mode & S_ISUID) && (info->st_uid == 0)) {
+			g_free (info);
+			g_free (path);
+
+			return TRUE;
+		}
+	}
+
+	g_free (info);
+	g_free (path);
+
+	return FALSE;
+}
+#endif /* HAVE_POLKIT_MATE */
+
+gchar *
+cpufreq_utils_get_frequency_label (guint freq)
+{
+	gint divisor;
+	
+	if (freq > 999999) /* freq (kHz) */
+		divisor = (1000 * 1000);
+	else
+		divisor = 1000;
+
+	if (((freq % divisor) == 0) || divisor == 1000) /* integer */
+		return g_strdup_printf ("%d", freq / divisor);
+	else /* float */
+		return g_strdup_printf ("%3.2f", ((gfloat)freq / divisor));
+}
+
+gchar *
+cpufreq_utils_get_frequency_unit (guint freq)
+{
+	if (freq > 999999) /* freq (kHz) */
+		return g_strdup ("GHz");
+	else
+		return g_strdup ("MHz");
+}
+
+gboolean
+cpufreq_utils_governor_is_automatic (const gchar *governor)
+{
+	g_return_val_if_fail (governor != NULL, FALSE);
+	
+	if (g_ascii_strcasecmp (governor, "userspace") == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+gboolean
+cpufreq_file_get_contents (const gchar *filename,
+			   gchar      **contents,
+			   gsize       *length,
+			   GError     **error)
+{
+	gint     fd;
+	GString *buffer = NULL;
+	gchar   *display_filename;
+	
+	g_return_val_if_fail (filename != NULL, FALSE);
+	g_return_val_if_fail (contents != NULL, FALSE);
+
+	display_filename = g_filename_display_name (filename);
+
+	*contents = NULL;
+	if (length)
+		*length = 0;
+
+	fd = open (filename, O_RDONLY);
+	if (fd < 0) {
+		gint save_errno = errno;
+
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (save_errno),
+			     "Failed to open file '%s': %s",
+			     display_filename,
+			     g_strerror (save_errno));
+		g_free (display_filename);
+
+		return FALSE;
+	}
+
+	while (TRUE) {
+		ssize_t bytes_read;
+		gchar  buf[1024];
+		
+		bytes_read = read (fd, buf, sizeof (buf));
+		if (bytes_read < 0) { /* Error */
+			if (errno != EINTR) {
+				gint save_errno = errno;
+				
+				g_set_error (error,
+					     G_FILE_ERROR,
+					     g_file_error_from_errno (save_errno),
+					     "Failed to read from file '%s': %s",
+					     display_filename,
+					     g_strerror (save_errno));
+
+				if (buffer)
+					g_string_free (buffer, TRUE);
+				
+				g_free (display_filename);
+				close (fd);
+				
+				return FALSE;
+			}
+		} else if (bytes_read == 0) { /* EOF */
+			break;
+		} else {
+			if (!buffer)
+				buffer = g_string_sized_new (bytes_read);
+			buffer = g_string_append_len (buffer, buf, bytes_read);
+		}
+	}
+
+	g_free (display_filename);
+
+	if (buffer)
+		*contents = g_string_free (buffer, FALSE);
+	
+	if (length)
+		*length = strlen (*contents);
+
+	close (fd);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-utils.h b/cpufreq/src/cpufreq-utils.h
new file mode 100644
index 00000000..9420c651
--- /dev/null
+++ b/cpufreq/src/cpufreq-utils.h
@@ -0,0 +1,44 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2006 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef CPUFREQ_UTILS_H
+#define CPUFREQ_UTILS_H
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/* Useful global methods */
+guint    cpufreq_utils_get_n_cpus            (void);
+void     cpufreq_utils_display_error         (const gchar *message,
+					      const gchar *secondary);
+gboolean cpufreq_utils_selector_is_available (void);
+gchar   *cpufreq_utils_get_frequency_label   (guint        freq);
+gchar   *cpufreq_utils_get_frequency_unit    (guint        freq);
+gboolean cpufreq_utils_governor_is_automatic (const gchar *governor);
+gboolean cpufreq_file_get_contents           (const gchar *filename,
+					      gchar      **contents,
+					      gsize       *length,
+					      GError     **error);
+
+G_END_DECLS
+
+#endif /* CPUFREQ_UTILS_H */