+## Process this file with automake to produce Makefile.in

+INCLUDES = -DGNOMELOCALEDIR=\""$(datadir)/locale/"\" \

+ -DG_LOG_DOMAIN=\""Sensors Applet"\" \

+ -DPIXMAPS_DIR=\""$(datadir)/pixmaps/$(PACKAGE)/"\" \

+ -DDATADIR=\""$(datadir)"\" \

+ -DLIBDIR=\""$(libdir)"\" \

+ -DSENSORS_APPLET_PLUGIN_DIR=\""$(libdir)/$(PACKAGE)/plugins/"\" \

+ -DSYSCONFDIR=\""$(sysconfdir)"\" \

+ -DPREFIX=\""$(prefix)"\" \

+ -I$(top_srcdir) \

+ $(GLIB_CFLAGS) $(GTK_CFLAGS) $(GNOME_CFLAGS) $(CAIRO_CFLAGS) $(LIBNOTIFY_CFLAGS)

+

+

+LIBS = $(GLIB_LIBS) $(GTK_LIBS) $(GNOME_LIBS) $(CAIRO_LIBS) $(LIBNOTIFY_LIBS)

+

+if LIBNOTIFY

+libnotify_SRC = active-sensor-libnotify.c \

+ active-sensor-libnotify.h

+else

+libnotify_SRC =

+endif

+

+libexec_PROGRAMS = sensors-applet

+sensors_applet_SOURCES = main.c \

+ about-dialog.c \

+ about-dialog.h \

+ active-sensor.c \

+ active-sensor.h \

+ prefs-dialog.c \

+ prefs-dialog.h \

+ sensor-config-dialog.c \

+ sensor-config-dialog.h \

+ sensors-applet.c \

+ sensors-applet.h \

+ sensors-applet-sensor.h \

+ sensors-applet-plugins.c \

+ sensors-applet-plugins.h \

+ sensors-applet-gconf.c \

+ sensors-applet-gconf.h \

+ $(libnotify_SRC)

+

+# install headers for plugins to use

+INST_H_FILES = sensors-applet-plugin.h sensors-applet-sensor.h

+

+headerdir = $(prefix)/include/sensors-applet

+

+header_DATA = $(INST_H_FILES)

+

+# since it is separate

+EXTRA_DIST = sensors-applet-plugin.h \ No newline at end of file

+# Makefile.in generated by automake 1.11.1 from Makefile.am.

+# @configure_input@

+

+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,

+# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,

+# Inc.

+# This Makefile.in is free software; the Free Software Foundation

+# gives unlimited permission to copy and/or distribute it,

+# with or without modifications, as long as this notice is preserved.

+

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without

+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

+# PARTICULAR PURPOSE.

+

+@SET_MAKE@

+

+

+VPATH = @srcdir@

+pkgdatadir = $(datadir)/@PACKAGE@

+pkgincludedir = $(includedir)/@PACKAGE@

+pkglibdir = $(libdir)/@PACKAGE@

+pkglibexecdir = $(libexecdir)/@PACKAGE@

+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd

+install_sh_DATA = $(install_sh) -c -m 644

+install_sh_PROGRAM = $(install_sh) -c

+install_sh_SCRIPT = $(install_sh) -c

+INSTALL_HEADER = $(INSTALL_DATA)

+transform = $(program_transform_name)

+NORMAL_INSTALL = :

+PRE_INSTALL = :

+POST_INSTALL = :

+NORMAL_UNINSTALL = :

+PRE_UNINSTALL = :

+POST_UNINSTALL = :

+build_triplet = @build@

+host_triplet = @host@

+libexec_PROGRAMS = sensors-applet$(EXEEXT)

+subdir = sensors-applet

+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \

+ $(srcdir)/config.h.in

+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4

+am__aclocal_m4_deps = $(top_srcdir)/configure.ac

+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

+ $(ACLOCAL_M4)

+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs

+CONFIG_HEADER = config.h

+CONFIG_CLEAN_FILES =

+CONFIG_CLEAN_VPATH_FILES =

+am__installdirs = "$(DESTDIR)$(libexecdir)" "$(DESTDIR)$(headerdir)"

+PROGRAMS = $(libexec_PROGRAMS)

+am__sensors_applet_SOURCES_DIST = main.c about-dialog.c about-dialog.h \

+ active-sensor.c active-sensor.h prefs-dialog.c prefs-dialog.h \

+ sensor-config-dialog.c sensor-config-dialog.h sensors-applet.c \

+ sensors-applet.h sensors-applet-sensor.h \

+ sensors-applet-plugins.c sensors-applet-plugins.h \

+ sensors-applet-gconf.c sensors-applet-gconf.h \

+ active-sensor-libnotify.c active-sensor-libnotify.h

+@LIBNOTIFY_TRUE@am__objects_1 = active-sensor-libnotify.$(OBJEXT)

+am_sensors_applet_OBJECTS = main.$(OBJEXT) about-dialog.$(OBJEXT) \

+ active-sensor.$(OBJEXT) prefs-dialog.$(OBJEXT) \

+ sensor-config-dialog.$(OBJEXT) sensors-applet.$(OBJEXT) \

+ sensors-applet-plugins.$(OBJEXT) \

+ sensors-applet-gconf.$(OBJEXT) $(am__objects_1)

+sensors_applet_OBJECTS = $(am_sensors_applet_OBJECTS)

+sensors_applet_LDADD = $(LDADD)

+DEFAULT_INCLUDES = -I.@am__isrc@

+depcomp = $(SHELL) $(top_srcdir)/depcomp

+am__depfiles_maybe = depfiles

+am__mv = mv -f

+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \

+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)

+LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \

+ --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \

+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)

+CCLD = $(CC)

+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \

+ --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \

+ $(LDFLAGS) -o $@

+SOURCES = $(sensors_applet_SOURCES)

+DIST_SOURCES = $(am__sensors_applet_SOURCES_DIST)

+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;

+am__vpath_adj = case $$p in \

+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \

+ *) f=$$p;; \

+ esac;

+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;

+am__install_max = 40

+am__nobase_strip_setup = \

+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`

+am__nobase_strip = \

+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"

+am__nobase_list = $(am__nobase_strip_setup); \

+ for p in $$list; do echo "$$p $$p"; done | \

+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \

+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \

+ if (++n[$$2] == $(am__install_max)) \

+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \

+ END { for (dir in files) print dir, files[dir] }'

+am__base_list = \

+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \

+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'

+DATA = $(header_DATA)

+ETAGS = etags

+CTAGS = ctags

+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

+ACLOCAL = @ACLOCAL@

+ALL_LINGUAS = @ALL_LINGUAS@

+AMTAR = @AMTAR@

+AR = @AR@

+ATICONFIG_EXE = @ATICONFIG_EXE@

+AUTOCONF = @AUTOCONF@

+AUTOHEADER = @AUTOHEADER@

+AUTOMAKE = @AUTOMAKE@

+AWK = @AWK@

+CAIRO_CFLAGS = @CAIRO_CFLAGS@

+CAIRO_LIBS = @CAIRO_LIBS@

+CATALOGS = @CATALOGS@

+CATOBJEXT = @CATOBJEXT@

+CC = @CC@

+CCDEPMODE = @CCDEPMODE@

+CFLAGS = @CFLAGS@

+CPP = @CPP@

+CPPFLAGS = @CPPFLAGS@

+CYGPATH_W = @CYGPATH_W@

+DATADIRNAME = @DATADIRNAME@

+DBUSGLIB_CFLAGS = @DBUSGLIB_CFLAGS@

+DBUSGLIB_LIBS = @DBUSGLIB_LIBS@

+DEFS = @DEFS@

+DEPDIR = @DEPDIR@

+DISTCHECK_CONFIGURE_FLAGS = @DISTCHECK_CONFIGURE_FLAGS@

+DOC_USER_FORMATS = @DOC_USER_FORMATS@

+DSYMUTIL = @DSYMUTIL@

+DUMPBIN = @DUMPBIN@

+ECHO_C = @ECHO_C@

+ECHO_N = @ECHO_N@

+ECHO_T = @ECHO_T@

+EGREP = @EGREP@

+EXEEXT = @EXEEXT@

+FGREP = @FGREP@

+GETTEXT_PACKAGE = @GETTEXT_PACKAGE@

+GLIB_CFLAGS = @GLIB_CFLAGS@

+GLIB_LIBS = @GLIB_LIBS@

+GMOFILES = @GMOFILES@

+GMSGFMT = @GMSGFMT@

+GNOME_CFLAGS = @GNOME_CFLAGS@

+GNOME_LIBS = @GNOME_LIBS@

+GREP = @GREP@

+GTK_CFLAGS = @GTK_CFLAGS@

+GTK_LIBS = @GTK_LIBS@

+HELP_DIR = @HELP_DIR@

+INSTALL = @INSTALL@

+INSTALL_DATA = @INSTALL_DATA@

+INSTALL_PROGRAM = @INSTALL_PROGRAM@

+INSTALL_SCRIPT = @INSTALL_SCRIPT@

+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@

+INSTOBJEXT = @INSTOBJEXT@

+INTLLIBS = @INTLLIBS@

+INTLTOOL_EXTRACT = @INTLTOOL_EXTRACT@

+INTLTOOL_MERGE = @INTLTOOL_MERGE@

+INTLTOOL_PERL = @INTLTOOL_PERL@

+INTLTOOL_UPDATE = @INTLTOOL_UPDATE@

+LD = @LD@

+LDFLAGS = @LDFLAGS@

+LIBATASMART_CFLAGS = @LIBATASMART_CFLAGS@

+LIBATASMART_LIBS = @LIBATASMART_LIBS@

+LIBNOTIFY_CFLAGS = @LIBNOTIFY_CFLAGS@

+LIBNOTIFY_LIBS = @LIBNOTIFY_LIBS@

+LIBOBJS = @LIBOBJS@

+LIBS = $(GLIB_LIBS) $(GTK_LIBS) $(GNOME_LIBS) $(CAIRO_LIBS) $(LIBNOTIFY_LIBS)

+LIBSENSORS_CFLAGS = @LIBSENSORS_CFLAGS@

+LIBSENSORS_LIBS = @LIBSENSORS_LIBS@

+LIBTOOL = @LIBTOOL@

+LIPO = @LIPO@

+LN_S = @LN_S@

+LTLIBOBJS = @LTLIBOBJS@

+MAINT = @MAINT@

+MAKEINFO = @MAKEINFO@

+MKDIR_P = @MKDIR_P@

+MKINSTALLDIRS = @MKINSTALLDIRS@

+MSGFMT = @MSGFMT@

+MSGFMT_OPTS = @MSGFMT_OPTS@

+MSGMERGE = @MSGMERGE@

+NM = @NM@

+NMEDIT = @NMEDIT@

+NVIDIA_CFLAGS = @NVIDIA_CFLAGS@

+NVIDIA_LIBS = @NVIDIA_LIBS@

+OBJDUMP = @OBJDUMP@

+OBJEXT = @OBJEXT@

+OMF_DIR = @OMF_DIR@

+OTOOL = @OTOOL@

+OTOOL64 = @OTOOL64@

+PACKAGE = @PACKAGE@

+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@

+PACKAGE_NAME = @PACKAGE_NAME@

+PACKAGE_STRING = @PACKAGE_STRING@

+PACKAGE_TARNAME = @PACKAGE_TARNAME@

+PACKAGE_URL = @PACKAGE_URL@

+PACKAGE_VERSION = @PACKAGE_VERSION@

+PATH_SEPARATOR = @PATH_SEPARATOR@

+PKG_CONFIG = @PKG_CONFIG@

+PLUGIN_LIBTOOL_FLAGS = @PLUGIN_LIBTOOL_FLAGS@

+POFILES = @POFILES@

+POSUB = @POSUB@

+PO_IN_DATADIR_FALSE = @PO_IN_DATADIR_FALSE@

+PO_IN_DATADIR_TRUE = @PO_IN_DATADIR_TRUE@

+RANLIB = @RANLIB@

+SED = @SED@

+SET_MAKE = @SET_MAKE@

+SHELL = @SHELL@

+STRIP = @STRIP@

+USE_NLS = @USE_NLS@

+VERSION = @VERSION@

+WARN_CFLAGS = @WARN_CFLAGS@

+XGETTEXT = @XGETTEXT@

+XSLTPROC = @XSLTPROC@

+abs_builddir = @abs_builddir@

+abs_srcdir = @abs_srcdir@

+abs_top_builddir = @abs_top_builddir@

+abs_top_srcdir = @abs_top_srcdir@

+ac_ct_CC = @ac_ct_CC@

+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@

+am__include = @am__include@

+am__leading_dot = @am__leading_dot@

+am__quote = @am__quote@

+am__tar = @am__tar@

+am__untar = @am__untar@

+bindir = @bindir@

+build = @build@

+build_alias = @build_alias@

+build_cpu = @build_cpu@

+build_os = @build_os@

+build_vendor = @build_vendor@

+builddir = @builddir@

+datadir = @datadir@

+datarootdir = @datarootdir@

+docdir = @docdir@

+dvidir = @dvidir@

+exec_prefix = @exec_prefix@

+host = @host@

+host_alias = @host_alias@

+host_cpu = @host_cpu@

+host_os = @host_os@

+host_vendor = @host_vendor@

+htmldir = @htmldir@

+includedir = @includedir@

+infodir = @infodir@

+install_sh = @install_sh@

+libdir = @libdir@

+libexecdir = @libexecdir@

+localedir = @localedir@

+localstatedir = @localstatedir@

+lt_ECHO = @lt_ECHO@

+mandir = @mandir@

+mkdir_p = @mkdir_p@

+oldincludedir = @oldincludedir@

+pdfdir = @pdfdir@

+prefix = @prefix@

+program_transform_name = @program_transform_name@

+psdir = @psdir@

+sbindir = @sbindir@

+sharedstatedir = @sharedstatedir@

+srcdir = @srcdir@

+sysconfdir = @sysconfdir@

+target_alias = @target_alias@

+top_build_prefix = @top_build_prefix@

+top_builddir = @top_builddir@

+top_srcdir = @top_srcdir@

+INCLUDES = -DGNOMELOCALEDIR=\""$(datadir)/locale/"\" \

+ -DG_LOG_DOMAIN=\""Sensors Applet"\" \

+ -DPIXMAPS_DIR=\""$(datadir)/pixmaps/$(PACKAGE)/"\" \

+ -DDATADIR=\""$(datadir)"\" \

+ -DLIBDIR=\""$(libdir)"\" \

+ -DSENSORS_APPLET_PLUGIN_DIR=\""$(libdir)/$(PACKAGE)/plugins/"\" \

+ -DSYSCONFDIR=\""$(sysconfdir)"\" \

+ -DPREFIX=\""$(prefix)"\" \

+ -I$(top_srcdir) \

+ $(GLIB_CFLAGS) $(GTK_CFLAGS) $(GNOME_CFLAGS) $(CAIRO_CFLAGS) $(LIBNOTIFY_CFLAGS)

+

+@LIBNOTIFY_FALSE@libnotify_SRC =

+@LIBNOTIFY_TRUE@libnotify_SRC = active-sensor-libnotify.c \

+@LIBNOTIFY_TRUE@ active-sensor-libnotify.h

+

+sensors_applet_SOURCES = main.c \

+ about-dialog.c \

+ about-dialog.h \

+ active-sensor.c \

+ active-sensor.h \

+ prefs-dialog.c \

+ prefs-dialog.h \

+ sensor-config-dialog.c \

+ sensor-config-dialog.h \

+ sensors-applet.c \

+ sensors-applet.h \

+ sensors-applet-sensor.h \

+ sensors-applet-plugins.c \

+ sensors-applet-plugins.h \

+ sensors-applet-gconf.c \

+ sensors-applet-gconf.h \

+ $(libnotify_SRC)

+

+

+# install headers for plugins to use

+INST_H_FILES = sensors-applet-plugin.h sensors-applet-sensor.h

+headerdir = $(prefix)/include/sensors-applet

+header_DATA = $(INST_H_FILES)

+

+# since it is separate

+EXTRA_DIST = sensors-applet-plugin.h

+all: config.h

+ $(MAKE) $(AM_MAKEFLAGS) all-am

+

+.SUFFIXES:

+.SUFFIXES: .c .lo .o .obj

+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)

+ @for dep in $?; do \

+ case '$(am__configure_deps)' in \

+ *$$dep*) \

+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \

+ && { if test -f $@; then exit 0; else break; fi; }; \

+ exit 1;; \

+ esac; \

+ done; \

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu sensors-applet/Makefile'; \

+ $(am__cd) $(top_srcdir) && \

+ $(AUTOMAKE) --gnu sensors-applet/Makefile

+.PRECIOUS: Makefile

+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

+ @case '$?' in \

+ *config.status*) \

+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \

+ *) \

+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \

+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \

+ esac;

+

+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)

+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

+

+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)

+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)

+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

+$(am__aclocal_m4_deps):

+

+config.h: stamp-h1

+ @if test ! -f $@; then \

+ rm -f stamp-h1; \

+ $(MAKE) $(AM_MAKEFLAGS) stamp-h1; \

+ else :; fi

+

+stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status

+ @rm -f stamp-h1

+ cd $(top_builddir) && $(SHELL) ./config.status sensors-applet/config.h

+$(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)

+ ($(am__cd) $(top_srcdir) && $(AUTOHEADER))

+ rm -f stamp-h1

+ touch $@

+

+distclean-hdr:

+ -rm -f config.h stamp-h1

+install-libexecPROGRAMS: $(libexec_PROGRAMS)

+ @$(NORMAL_INSTALL)

+ test -z "$(libexecdir)" || $(MKDIR_P) "$(DESTDIR)$(libexecdir)"

+ @list='$(libexec_PROGRAMS)'; test -n "$(libexecdir)" || list=; \

+ for p in $$list; do echo "$$p $$p"; done | \

+ sed 's/$(EXEEXT)$$//' | \

+ while read p p1; do if test -f $$p || test -f $$p1; \

+ then echo "$$p"; echo "$$p"; else :; fi; \

+ done | \

+ sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \

+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \

+ sed 'N;N;N;s,\n, ,g' | \

+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \

+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \

+ if ($$2 == $$4) files[d] = files[d] " " $$1; \

+ else { print "f", $$3 "/" $$4, $$1; } } \

+ END { for (d in files) print "f", d, files[d] }' | \

+ while read type dir files; do \

+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \

+ test -z "$$files" || { \

+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(libexecdir)$$dir'"; \

+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(libexecdir)$$dir" || exit $$?; \

+ } \

+ ; done

+

+uninstall-libexecPROGRAMS:

+ @$(NORMAL_UNINSTALL)

+ @list='$(libexec_PROGRAMS)'; test -n "$(libexecdir)" || list=; \

+ files=`for p in $$list; do echo "$$p"; done | \

+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \

+ -e 's/$$/$(EXEEXT)/' `; \

+ test -n "$$list" || exit 0; \

+ echo " ( cd '$(DESTDIR)$(libexecdir)' && rm -f" $$files ")"; \

+ cd "$(DESTDIR)$(libexecdir)" && rm -f $$files

+

+clean-libexecPROGRAMS:

+ @list='$(libexec_PROGRAMS)'; test -n "$$list" || exit 0; \

+ echo " rm -f" $$list; \

+ rm -f $$list || exit $$?; \

+ test -n "$(EXEEXT)" || exit 0; \

+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \

+ echo " rm -f" $$list; \

+ rm -f $$list

+sensors-applet$(EXEEXT): $(sensors_applet_OBJECTS) $(sensors_applet_DEPENDENCIES)

+ @rm -f sensors-applet$(EXEEXT)

+ $(LINK) $(sensors_applet_OBJECTS) $(sensors_applet_LDADD) $(LIBS)

+

+mostlyclean-compile:

+ -rm -f *.$(OBJEXT)

+

+distclean-compile:

+ -rm -f *.tab.c

+

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/about-dialog.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/active-sensor-libnotify.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/active-sensor.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prefs-dialog.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sensor-config-dialog.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sensors-applet-gconf.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sensors-applet-plugins.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sensors-applet.Po@am__quote@

+

+.c.o:

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<

+@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po

+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@

+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

+@am__fastdepCC_FALSE@ $(COMPILE) -c $<

+

+.c.obj:

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`

+@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po

+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@

+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

+@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`

+

+.c.lo:

+@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<

+@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo

+@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@

+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

+@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<

+

+mostlyclean-libtool:

+ -rm -f *.lo

+

+clean-libtool:

+ -rm -rf .libs _libs

+install-headerDATA: $(header_DATA)

+ @$(NORMAL_INSTALL)

+ test -z "$(headerdir)" || $(MKDIR_P) "$(DESTDIR)$(headerdir)"

+ @list='$(header_DATA)'; test -n "$(headerdir)" || list=; \

+ for p in $$list; do \

+ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \

+ echo "$$d$$p"; \

+ done | $(am__base_list) | \

+ while read files; do \

+ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(headerdir)'"; \

+ $(INSTALL_DATA) $$files "$(DESTDIR)$(headerdir)" || exit $$?; \

+ done

+

+uninstall-headerDATA:

+ @$(NORMAL_UNINSTALL)

+ @list='$(header_DATA)'; test -n "$(headerdir)" || list=; \

+ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \

+ test -n "$$files" || exit 0; \

+ echo " ( cd '$(DESTDIR)$(headerdir)' && rm -f" $$files ")"; \

+ cd "$(DESTDIR)$(headerdir)" && rm -f $$files

+

+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)

+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \

+ unique=`for i in $$list; do \

+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \

+ done | \

+ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \

+ END { if (nonempty) { for (i in files) print i; }; }'`; \

+ mkid -fID $$unique

+tags: TAGS

+

+TAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \

+ $(TAGS_FILES) $(LISP)

+ set x; \

+ here=`pwd`; \

+ list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \

+ unique=`for i in $$list; do \

+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \

+ done | \

+ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \

+ END { if (nonempty) { for (i in files) print i; }; }'`; \

+ shift; \

+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \

+ test -n "$$unique" || unique=$$empty_fix; \

+ if test $$# -gt 0; then \

+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \

+ "$$@" $$unique; \

+ else \

+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \

+ $$unique; \

+ fi; \

+ fi

+ctags: CTAGS

+CTAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \

+ $(TAGS_FILES) $(LISP)

+ list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \

+ unique=`for i in $$list; do \

+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \

+ done | \

+ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \

+ END { if (nonempty) { for (i in files) print i; }; }'`; \

+ test -z "$(CTAGS_ARGS)$$unique" \

+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \

+ $$unique

+

+GTAGS:

+ here=`$(am__cd) $(top_builddir) && pwd` \

+ && $(am__cd) $(top_srcdir) \

+ && gtags -i $(GTAGS_ARGS) "$$here"

+

+distclean-tags:

+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

+

+distdir: $(DISTFILES)

+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \

+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \

+ list='$(DISTFILES)'; \

+ dist_files=`for file in $$list; do echo $$file; done | \

+ sed -e "s|^$$srcdirstrip/||;t" \

+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \

+ case $$dist_files in \

+ */*) $(MKDIR_P) `echo "$$dist_files" | \

+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \

+ sort -u` ;; \

+ esac; \

+ for file in $$dist_files; do \

+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \

+ if test -d $$d/$$file; then \

+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \

+ if test -d "$(distdir)/$$file"; then \

+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \

+ fi; \

+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \

+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \

+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \

+ fi; \

+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \

+ else \

+ test -f "$(distdir)/$$file" \

+ || cp -p $$d/$$file "$(distdir)/$$file" \

+ || exit 1; \

+ fi; \

+ done

+check-am: all-am

+check: check-am

+all-am: Makefile $(PROGRAMS) $(DATA) config.h

+installdirs:

+ for dir in "$(DESTDIR)$(libexecdir)" "$(DESTDIR)$(headerdir)"; do \

+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \

+ done

+install: install-am

+install-exec: install-exec-am

+install-data: install-data-am

+uninstall: uninstall-am

+

+install-am: all-am

+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am

+

+installcheck: installcheck-am

+install-strip:

+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \

+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \

+ `test -z '$(STRIP)' || \

+ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install

+mostlyclean-generic:

+

+clean-generic:

+

+distclean-generic:

+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)

+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)

+

+maintainer-clean-generic:

+ @echo "This command is intended for maintainers to use"

+ @echo "it deletes files that may require special tools to rebuild."

+clean: clean-am

+

+clean-am: clean-generic clean-libexecPROGRAMS clean-libtool \

+ mostlyclean-am

+

+distclean: distclean-am

+ -rm -rf ./$(DEPDIR)

+ -rm -f Makefile

+distclean-am: clean-am distclean-compile distclean-generic \

+ distclean-hdr distclean-tags

+

+dvi: dvi-am

+

+dvi-am:

+

+html: html-am

+

+html-am:

+

+info: info-am

+

+info-am:

+

+install-data-am: install-headerDATA

+

+install-dvi: install-dvi-am

+

+install-dvi-am:

+

+install-exec-am: install-libexecPROGRAMS

+

+install-html: install-html-am

+

+install-html-am:

+

+install-info: install-info-am

+

+install-info-am:

+

+install-man:

+

+install-pdf: install-pdf-am

+

+install-pdf-am:

+

+install-ps: install-ps-am

+

+install-ps-am:

+

+installcheck-am:

+

+maintainer-clean: maintainer-clean-am

+ -rm -rf ./$(DEPDIR)

+ -rm -f Makefile

+maintainer-clean-am: distclean-am maintainer-clean-generic

+

+mostlyclean: mostlyclean-am

+

+mostlyclean-am: mostlyclean-compile mostlyclean-generic \

+ mostlyclean-libtool

+

+pdf: pdf-am

+

+pdf-am:

+

+ps: ps-am

+

+ps-am:

+

+uninstall-am: uninstall-headerDATA uninstall-libexecPROGRAMS

+

+.MAKE: all install-am install-strip

+

+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \

+ clean-libexecPROGRAMS clean-libtool ctags distclean \

+ distclean-compile distclean-generic distclean-hdr \

+ distclean-libtool distclean-tags distdir dvi dvi-am html \

+ html-am info info-am install install-am install-data \

+ install-data-am install-dvi install-dvi-am install-exec \

+ install-exec-am install-headerDATA install-html \

+ install-html-am install-info install-info-am \

+ install-libexecPROGRAMS install-man install-pdf install-pdf-am \

+ install-ps install-ps-am install-strip installcheck \

+ installcheck-am installdirs maintainer-clean \

+ maintainer-clean-generic mostlyclean mostlyclean-compile \

+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \

+ tags uninstall uninstall-am uninstall-headerDATA \

+ uninstall-libexecPROGRAMS

+

+

+# Tell versions [3.59,3.63) of GNU make to not export all variables.

+# Otherwise a system limit (for SysV at least) may be exceeded.

+.NOEXPORT:

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#include <gnome.h>

+#include "about-dialog.h"

+

+void about_dialog_open(SensorsApplet *sensors_applet) {

+ gchar *translator;

+ const gchar *authors[] = {

+ "Alex Murray <[email protected]>",

+ NULL

+ };

+

+ if (_("Translator") == "Translator") {

+ translator = NULL;

+ } else {

+ translator = g_strdup(_("To translator: Put your name here to show up in the About dialog as the translator"));

+ }

+

+ /* Construct the about dialog */

+ gtk_show_about_dialog(NULL,

+ "program-name", PACKAGE_NAME,

+ "version", PACKAGE_VERSION,

+ "copyright", "(C) 2005-2009, Alex Murray <[email protected]>",

+ "authors", authors,

+ "documenters", authors,

+ "translator-credits", translator,

+ "logo-icon-name", SENSORS_APPLET_ICON,

+ "website", "http://sensors-applet.sourceforge.net/",

+ NULL);

+

+

+ if (translator != NULL) {

+ g_free(translator);

+ }

+

+}

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef ABOUT_DIALOG_H

+#define ABOUT_DIALOG_H

+

+#include "sensors-applet.h"

+

+/* function prototypes */

+void about_dialog_open(SensorsApplet *sensors_applet);

+

+#endif /* ABOUT_DIALOG_H */

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#ifdef HAVE_LIBNOTIFY

+#include <libnotify/notify.h>

+#endif

+

+#include "active-sensor-libnotify.h"

+

+static void notif_closed_cb(NotifyNotification *notification,

+ ActiveSensor *active_sensor)

+{

+ g_assert(notification != NULL && active_sensor != NULL);

+

+ int i;

+

+ g_debug("Notification was closed.. setting reference to NULL so we can show again if needed.");

+

+ // set notif reference to NULL

+ for (i = 0; i < NUM_NOTIFS; i++) {

+ if (active_sensor->notification[i] == notification) {

+ active_sensor->notification[i] = NULL;

+ break;

+ }

+ }

+}

+

+

+void active_sensor_libnotify_notify_end(ActiveSensor *active_sensor,

+ NotifType notif_type) {

+ GError *error = NULL;

+ if (active_sensor->notification[notif_type]) {

+ g_debug("Closing notification");

+ if(!notify_notification_close(active_sensor->notification[notif_type],

+ &error)) {

+ g_warning("Error closing notification: %s", error->message);

+ g_error_free(error);

+ }

+ g_object_unref(active_sensor->notification[notif_type]);

+ active_sensor->notification[notif_type] = NULL;

+ }

+}

+

+void active_sensor_libnotify_notify(ActiveSensor *active_sensor,

+ NotifType notif_type,

+ const gchar *summary,

+ const gchar *message,

+ const gchar *icon_filename,

+ gint timeout_msecs,

+ GtkWidget *attach) {

+ GError *error = NULL;

+

+ if (!notify_is_initted()) {

+ if (!notify_init(PACKAGE)) {

+ return;

+ }

+ }

+ g_debug("Doing notification %s: %s: %s", (notif_type == SENSOR_INTERFACE_ERROR ? "interface-error" : "other") ,summary, message);

+

+ /* leave any existing notification since most likely hasn't changed */

+ if (active_sensor->notification[notif_type] != NULL) {

+ return;

+/* active_sensor_libnotify_notify_end(active_sensor, notif_type); */

+ }

+

+ /* now create a new one */

+ g_debug("Creating new notification");

+ active_sensor->notification[notif_type] = notify_notification_new(summary,

+ message,

+ icon_filename,

+ attach);

+ g_signal_connect(active_sensor->notification[notif_type], "closed",

+ G_CALLBACK(notif_closed_cb),

+ active_sensor);

+

+ notify_notification_set_urgency(active_sensor->notification[notif_type],

+ NOTIFY_URGENCY_CRITICAL);

+

+

+ /* timeout may have changed so update it */

+ notify_notification_set_timeout(active_sensor->notification[notif_type],

+ timeout_msecs);

+

+

+ g_debug("showing notification");

+ if (!notify_notification_show(active_sensor->notification[notif_type], &error)) {

+ g_debug("Error showing notification: %s", error->message);

+ g_error_free(error);

+ }

+

+

+

+}

+

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef ACTIVE_SESNOR_LIBNOTIFY_H

+#define ACTIVE_SENSOR_LIBNOTIFY_H

+

+#include "sensors-applet.h"

+#include "active-sensor.h"

+

+void active_sensor_libnotify_notify(ActiveSensor *active_sensor,

+ NotifType notif_type,

+ const gchar *summary,

+ const gchar *message,

+ const gchar *icon_filename,

+ gint timeout_msecs,

+ GtkWidget *attach);

+void active_sensor_libnotify_notify_end(ActiveSensor *active_sensor,

+ NotifType notif_type);

+

+#endif /* SENSORS_APPLET_LIBNOTIFY_H */

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#ifdef HAVE_STRING_H

+#include <string.h>

+#endif /* HAVE_STRING_H */

+

+#include <gconf/gconf-client.h>

+#include <gnome.h>

+

+#include "active-sensor.h"

+#include "sensors-applet-plugins.h"

+#include "sensors-applet-gconf.h"

+

+typedef enum {

+ VERY_LOW_SENSOR_VALUE = 0,

+ LOW_SENSOR_VALUE,

+ NORMAL_SENSOR_VALUE,

+ HIGH_SENSOR_VALUE,

+ VERY_HIGH_SENSOR_VALUE

+} SensorValueRange;

+

+/* Cast a given value to a valid SensorValueRange */

+#define SENSOR_VALUE_RANGE(x) ((SensorValueRange)(CLAMP(x, VERY_LOW_SENSOR_VALUE, VERY_HIGH_SENSOR_VALUE)))

+

+#define CAIRO_GRAPH_COLOR_GRADIENT 0.4

+

+static const gchar * const temp_overlay_icons[] = {

+ PIXMAPS_DIR "very-low-temp-icon.png",

+ PIXMAPS_DIR "low-temp-icon.png",

+ PIXMAPS_DIR "normal-temp-icon.png",

+ PIXMAPS_DIR "high-temp-icon.png",

+ PIXMAPS_DIR "very-high-temp-icon.png"

+};

+

+static gdouble sensor_value_range_normalised(gdouble value,

+ gdouble low_value,

+ gdouble high_value) {

+ return ((value - low_value)/(high_value - low_value));

+}

+

+static SensorValueRange sensor_value_range(gdouble sensor_value,

+ gdouble low_value,

+ gdouble high_value) {

+ gdouble range;

+ range = sensor_value_range_normalised(sensor_value, low_value, high_value)*(gdouble)(VERY_HIGH_SENSOR_VALUE);

+

+ /* check if need to round up, otherwise let int conversion

+ * round down for us and make sure it is a valid range

+ * value */

+ return SENSOR_VALUE_RANGE(((gint)range + ((range - ((gint)range)) >= 0.5)));

+}

+

+

+static gboolean active_sensor_execute_alarm(ActiveSensor *active_sensor,

+ NotifType notif_type) {

+ int pid;

+

+ sensors_applet_notify_active_sensor(active_sensor, notif_type);

+ g_debug("EXECUTING %s ALARM: %s",

+ (notif_type == LOW_ALARM ?

+ "LOW" : "HIGH"),

+ active_sensor->alarm_command[notif_type]);

+ pid = gnome_execute_shell(NULL,

+ active_sensor->alarm_command[notif_type]);

+ g_debug("Command executed in shell with pid %d", pid);

+

+ return (pid != -1);

+}

+

+static gboolean active_sensor_execute_low_alarm(ActiveSensor *active_sensor) {

+ return active_sensor_execute_alarm(active_sensor, LOW_ALARM);

+}

+

+static gboolean active_sensor_execute_high_alarm(ActiveSensor *active_sensor) {

+ return active_sensor_execute_alarm(active_sensor, HIGH_ALARM);

+}

+

+/* needs to be able to be called by the config dialog when the alarm

+ * command changes */

+void active_sensor_alarm_off(ActiveSensor *active_sensor,

+ NotifType notif_type) {

+ g_assert(active_sensor);

+

+ if (active_sensor->alarm_timeout_id[notif_type] != -1) {

+ g_debug("Disabling %s alarm.",

+ (notif_type == LOW_ALARM ? "LOW" : "HIGH"));

+ if (!g_source_remove(active_sensor->alarm_timeout_id[notif_type])) {

+ g_debug("Error removing alarm source");

+ }

+ g_free(active_sensor->alarm_command[notif_type]);

+ active_sensor->alarm_timeout_id[notif_type] = -1;

+

+ }

+ sensors_applet_notify_end(active_sensor, notif_type);

+}

+

+static void active_sensor_all_alarms_off(ActiveSensor *active_sensor) {

+ /* turn off any alarms */

+ int i;

+ for (i = 0; i < NUM_ALARMS; i++) {

+ if (active_sensor->alarm_timeout_id[i] >= 0) {

+ g_debug("-- turning off notif with type %d ---", i);

+ active_sensor_alarm_off(active_sensor, i);

+ }

+ }

+}

+

+static void active_sensor_alarm_on(ActiveSensor *active_sensor,

+ NotifType notif_type) {

+ GtkTreeModel *model;

+ GtkTreePath *tree_path;

+ GtkTreeIter iter;

+

+ g_assert(active_sensor);

+

+ model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);

+ tree_path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);

+

+ if (gtk_tree_model_get_iter(model, &iter, tree_path)) {

+

+ if (active_sensor->alarm_timeout_id[notif_type] == -1) {

+ /* alarm is not currently on */

+ gtk_tree_model_get(model,

+ &iter,

+ (notif_type == LOW_ALARM ?

+ LOW_ALARM_COMMAND_COLUMN :

+ HIGH_ALARM_COMMAND_COLUMN),

+ &(active_sensor->alarm_command[notif_type]),

+ ALARM_TIMEOUT_COLUMN, &(active_sensor->alarm_timeout),

+ -1);

+ g_debug("Activating alarm to repeat every %d seconds", active_sensor->alarm_timeout);

+

+ /* execute alarm once, then add to time to

+ keep repeating it */

+ active_sensor_execute_alarm(active_sensor, notif_type);

+ int timeout = (active_sensor->alarm_timeout <= 0 ?

+ G_MAXINT :

+ active_sensor->alarm_timeout);

+ switch (notif_type) {

+ case LOW_ALARM:

+ active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,

+ (GSourceFunc)active_sensor_execute_low_alarm,

+ active_sensor);

+ break;

+ case HIGH_ALARM:

+ active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,

+ (GSourceFunc)active_sensor_execute_high_alarm,

+ active_sensor);

+ break;

+ default:

+ g_debug("Unkown notif type: %d", notif_type);

+ }

+

+

+ }

+ }

+ gtk_tree_path_free(tree_path);

+

+}

+

+/**

+ * Compares two ActiveSensors and returns -1 if a comes before b in the tree,

+ * 0 if refer to same row, 1 if b comes before a

+ */

+gint active_sensor_compare(ActiveSensor *a, ActiveSensor *b) {

+ GtkTreePath *a_tree_path, *b_tree_path;

+ gint ret_val;

+

+ g_assert(a);

+ g_assert(b);

+

+ a_tree_path = gtk_tree_row_reference_get_path(a->sensor_row);

+ b_tree_path = gtk_tree_row_reference_get_path(b->sensor_row);

+

+ ret_val = gtk_tree_path_compare(a_tree_path, b_tree_path);

+

+ gtk_tree_path_free(a_tree_path);

+ gtk_tree_path_free(b_tree_path);

+

+ return ret_val;

+}

+

+static void active_sensor_update_icon(ActiveSensor *active_sensor,

+ GdkPixbuf *base_icon,

+ SensorType sensor_type) {

+

+ GdkPixbuf *overlay_icon, *new_icon;

+ const gchar *overlay_icon_filename = NULL;

+ SensorValueRange value_range;

+

+ g_assert(active_sensor);

+

+ /* select overlay icon

+ * depending on sensor

+ * value */

+ value_range = sensor_value_range(active_sensor->sensor_values[0],

+ active_sensor->sensor_low_value,

+ active_sensor->sensor_high_value);

+

+ if (sensor_type == TEMP_SENSOR) {

+ overlay_icon_filename = temp_overlay_icons[value_range];

+ }

+

+ /* load base icon */

+ new_icon = gdk_pixbuf_copy(base_icon);

+

+ /* only load overlay if required */

+ if (overlay_icon_filename) {

+ overlay_icon = gdk_pixbuf_new_from_file_at_size(overlay_icon_filename,

+ DEFAULT_ICON_SIZE,

+ DEFAULT_ICON_SIZE,

+ NULL);

+ if (overlay_icon) {

+ gdk_pixbuf_composite(overlay_icon, new_icon,

+ 0, 0,

+ DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE,

+ 0, 0,

+ 1.0, 1.0,

+ GDK_INTERP_BILINEAR,

+ 255);

+

+ g_object_unref(overlay_icon);

+ }

+ }

+ gtk_image_set_from_pixbuf(GTK_IMAGE(active_sensor->icon),

+ new_icon);

+ g_object_unref(new_icon);

+

+}

+

+static void active_sensor_update_graph(ActiveSensor *as) {

+ gdouble line_height;

+ gdouble width, height;

+ gdouble x, y;

+ cairo_t *cr;

+ cairo_pattern_t *pattern;

+ gint i;

+ GdkPixmap *pixmap;

+

+ width = as->graph->allocation.width;

+ height = as->graph->allocation.height;

+

+ /* only do if drawable - will not be drawable if not currently

+ * displayed on screen */

+ if (GDK_IS_DRAWABLE(as->graph->window)) {

+ /* use pixmap, draw to it, then use gdk to draw the

+ * pixmap onto the drawable surface of the graph to

+ * stop flickering */

+ pixmap = gdk_pixmap_new(as->graph->window,

+ width, height, -1);

+

+ cr = gdk_cairo_create(pixmap);

+

+ /* so we can set a clipping area, as well as fill the

+ * back of the graph black */

+ cairo_rectangle(cr,

+ 0, 0,

+ width,

+ height);

+ /* clip to rectangle and keep it as a path so can be

+ * filled below */

+ cairo_clip_preserve(cr);

+

+ /* use black for bg color of graphs */

+ cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);

+ cairo_fill(cr);

+

+

+ /* determine height to scale line at for each value -

+ * only do as many as will fit or the number of

+ * samples that we have */

+ for (i = 0; i < MIN(as->num_samples, width); i++) {

+ /* need to remove one more to make it line up

+ * properly when drawing */

+ x = width - i - 1;

+ y = height;

+

+ line_height = sensor_value_range_normalised(as->sensor_values[i],

+ as->sensor_low_value,

+ as->sensor_high_value) * height;

+

+

+

+ if (line_height > 0) {

+ cairo_move_to(cr,

+ x,

+ y);

+ cairo_line_to(cr, x,

+ y - line_height);

+ }

+

+ }

+ /* make lines a gradient from slightly darker than

+ * chosen color at bottom of graph, to slightly

+ * lighter than chosen color at top of graph */

+ pattern = cairo_pattern_create_linear(x, y,

+ x, 0);

+ cairo_pattern_add_color_stop_rgb(pattern,

+ 0,

+ as->graph_color.red / 65535.0 - CAIRO_GRAPH_COLOR_GRADIENT,

+ as->graph_color.green / 65535.0 - CAIRO_GRAPH_COLOR_GRADIENT,

+ as->graph_color.blue / 65535.0 - CAIRO_GRAPH_COLOR_GRADIENT);

+

+ cairo_pattern_add_color_stop_rgb(pattern,

+ height,

+ as->graph_color.red / 65535.0 + CAIRO_GRAPH_COLOR_GRADIENT,

+ as->graph_color.green / 65535.0 + CAIRO_GRAPH_COLOR_GRADIENT,

+ as->graph_color.blue / 65535.0 + CAIRO_GRAPH_COLOR_GRADIENT);

+

+ cairo_set_source(cr, pattern);

+ cairo_stroke(cr);

+ cairo_pattern_destroy(pattern);

+ cairo_destroy(cr);

+

+ /* now draw pixmap onto drawable surface */

+ gdk_draw_drawable(as->graph->window,

+ as->graph->style->fg_gc[GTK_WIDGET_STATE(as->graph)],

+ pixmap,

+ 0, 0,

+ 0, 0,

+ -1, -1);

+ /* don't need pixmap anymore */

+ g_object_unref(pixmap);

+ }

+}

+

+void active_sensor_destroy(ActiveSensor *active_sensor) {

+ g_debug("-- destroying active sensor label...");

+ gtk_object_destroy(GTK_OBJECT(active_sensor->label));

+

+ g_debug("-- destroying active sensor icon..");

+ gtk_object_destroy(GTK_OBJECT(active_sensor->icon));

+

+ g_debug("-- destroying active sensor value...");

+ gtk_object_destroy(GTK_OBJECT(active_sensor->value));

+

+ g_debug("-- destroying active sensor graph and frame...");

+ gtk_object_destroy(GTK_OBJECT(active_sensor->graph));

+ gtk_object_destroy(GTK_OBJECT(active_sensor->graph_frame));

+

+ g_debug("-- destroying active sensor values...");

+ g_free(active_sensor->sensor_values);

+

+ active_sensor_all_alarms_off(active_sensor);

+

+ g_free(active_sensor);

+}

+

+

+gboolean graph_expose_event_cb(GtkWidget *graph,

+ GdkEventExpose *event,

+ gpointer data) {

+ ActiveSensor *as;

+

+ as = (ActiveSensor *)data;

+

+ active_sensor_update_graph(as);

+ /* propagate event onwards */

+ return FALSE;

+}

+

+static void active_sensor_set_graph_dimensions(ActiveSensor *as,

+ gint width,

+ gint height) {

+ gdouble *old_values;

+ gint num_samples, old_num_samples;

+ gint graph_width, graph_height;

+

+ /* dimensions are really for graph frame, so need to remove

+ * extra width added by graph frame - make sure not less than

+ * 1 - always need atleast 1 sample */

+ graph_width = CLAMP(width - GRAPH_FRAME_EXTRA_WIDTH, 1, width - GRAPH_FRAME_EXTRA_WIDTH);

+ graph_height = CLAMP(height - GRAPH_FRAME_EXTRA_WIDTH, 1 , height - GRAPH_FRAME_EXTRA_WIDTH);

+

+ g_debug("setting graph dimensions to %d x %d", graph_width, graph_height);

+ num_samples = graph_width;

+

+ if (as->sensor_values) {

+ old_values = as->sensor_values;

+ old_num_samples = as->num_samples;

+

+ as->num_samples = num_samples;

+ as->sensor_values = g_malloc0(sizeof(gdouble)*as->num_samples);

+ memcpy(as->sensor_values,

+ old_values,

+ MIN(old_num_samples, as->num_samples)*sizeof(gdouble));

+

+ g_free(old_values);

+ } else {

+ as->sensor_values = g_malloc0(sizeof(gdouble)*num_samples);

+ as->num_samples = num_samples;

+ }

+

+ /* update graph frame size request */

+ gtk_widget_set_size_request(as->graph,

+ graph_width,

+ graph_height);

+}

+

+void active_sensor_update_graph_dimensions(ActiveSensor *as,

+ gint sizes[2]) {

+ active_sensor_set_graph_dimensions(as, sizes[0], sizes[1]);

+ active_sensor_update_graph(as);

+}

+

+ActiveSensor *active_sensor_new(SensorsApplet *sensors_applet,

+ GtkTreeRowReference *sensor_row) {

+ ActiveSensor *active_sensor;

+ PanelAppletOrient orient;

+ gint graph_size;

+ gboolean horizontal;

+

+ g_assert(sensors_applet);

+ g_assert(sensor_row);

+

+ g_debug("creating new active sensor");

+

+ active_sensor = g_new0(ActiveSensor, 1);

+ active_sensor->sensors_applet = sensors_applet;

+

+ active_sensor->sensor_row = sensor_row;

+

+ int i;

+ for (i = 0; i < NUM_NOTIFS; i++) {

+ active_sensor->alarm_timeout_id[i] = -1;

+ }

+

+ active_sensor->label = gtk_label_new("");

+ active_sensor->value = gtk_label_new("");

+ active_sensor->icon = gtk_image_new();

+

+ active_sensor->graph = gtk_drawing_area_new();

+ active_sensor->graph_frame = gtk_frame_new(NULL);

+ gtk_frame_set_shadow_type(GTK_FRAME(active_sensor->graph_frame),

+ GTK_SHADOW_IN);

+ gtk_container_add(GTK_CONTAINER(active_sensor->graph_frame),

+ active_sensor->graph);

+ gtk_widget_add_events(active_sensor->graph_frame,

+ GDK_ALL_EVENTS_MASK);

+

+ /* need to set size according to orientation */

+ orient = panel_applet_get_orient(active_sensor->sensors_applet->applet);

+ graph_size = panel_applet_gconf_get_int(active_sensor->sensors_applet->applet,

+ GRAPH_SIZE, NULL);

+

+ horizontal = ((orient == PANEL_APPLET_ORIENT_UP) ||

+ (orient == PANEL_APPLET_ORIENT_DOWN));

+

+ active_sensor_set_graph_dimensions(active_sensor,

+ (horizontal ? graph_size : sensors_applet->size),

+ (horizontal ? sensors_applet->size : graph_size));

+

+ g_signal_connect(G_OBJECT(active_sensor->graph),

+ "expose_event",

+ G_CALLBACK(graph_expose_event_cb),

+ active_sensor);

+

+ active_sensor->updated = FALSE;

+ return active_sensor;

+}

+

+static void active_sensor_update_sensor_value(ActiveSensor *as,

+ gdouble sensor_value) {

+

+ /* only if have more than 1 sample stored */

+ if (as->num_samples > 1) {

+ memmove(&(as->sensor_values[1]),

+ as->sensor_values,

+ (as->num_samples - 1)*sizeof(gdouble));

+ }

+

+ as->sensor_values[0] = sensor_value;

+}

+

+void active_sensor_update(ActiveSensor *active_sensor,

+ SensorsApplet *sensors_applet) {

+

+ GtkTreeModel *model;

+ GtkTreeIter iter;

+ GtkTreePath *path;

+

+ /* instance data from the tree for this sensor */

+ gchar *sensor_path = NULL;

+ gchar *sensor_id = NULL;

+ gchar *sensor_label = NULL;

+ SensorType sensor_type;

+ gchar *sensor_interface;

+ gboolean sensor_enabled;

+ gdouble sensor_low_value;

+ gdouble sensor_high_value;

+ gboolean sensor_alarm_enabled;

+ gdouble sensor_multiplier;

+ gdouble sensor_offset;

+ gdouble sensor_value;

+ GdkPixbuf *icon_pixbuf;

+ gchar *graph_color;

+

+ /* to build the list of labels as we go */

+ gchar *value_text = NULL;

+ gchar *old_value_text;

+

+ TemperatureScale scale;

+ DisplayMode display_mode;

+

+ GError *error = NULL;

+

+ gchar *tooltip = NULL;

+ gchar *value_tooltip = NULL;

+

+ /* hidden gconf options */

+ GConfClient *client;

+ gint font_size = 0;

+ gboolean hide_units = FALSE;

+

+ g_assert(active_sensor);

+ g_assert(active_sensor->sensor_row);

+ g_assert(sensors_applet);

+

+ model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);

+ path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);

+

+ /* if can successfully get iter can proceed */

+ if (gtk_tree_model_get_iter(model, &iter, path)) {

+ gtk_tree_path_free(path);

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &iter,

+ PATH_COLUMN, &sensor_path,

+ ID_COLUMN, &sensor_id,

+ LABEL_COLUMN, &sensor_label,

+ INTERFACE_COLUMN, &sensor_interface,

+ SENSOR_TYPE_COLUMN, &sensor_type,

+ ENABLE_COLUMN, &sensor_enabled,

+ LOW_VALUE_COLUMN, &sensor_low_value,

+ HIGH_VALUE_COLUMN, &sensor_high_value,

+ ALARM_ENABLE_COLUMN, &sensor_alarm_enabled,

+ MULTIPLIER_COLUMN, &sensor_multiplier,

+ OFFSET_COLUMN, &sensor_offset,

+ ICON_PIXBUF_COLUMN, &icon_pixbuf,

+ GRAPH_COLOR_COLUMN, &graph_color,

+ -1);

+

+

+ SensorsAppletPluginGetSensorValue get_sensor_value;

+ /* only call function if is in hash table for plugin */

+ if ((get_sensor_value = sensors_applet_plugins_get_sensor_value_func(sensors_applet, sensor_interface)) != NULL) {

+ sensor_value = get_sensor_value(sensor_path,

+ sensor_id,

+ sensor_type,

+ &error);

+

+

+ if (error) {

+ g_debug("Error updating active sensor: %s", error->message);

+ sensors_applet_notify_active_sensor(active_sensor,

+ SENSOR_INTERFACE_ERROR);

+

+ /* hard code text as ERROR */

+ value_text = g_strdup(_("ERROR"));

+ value_tooltip = g_strdup_printf("- %s", error->message);

+ g_error_free(error);

+ error = NULL;

+

+ /* set sensor value to an error code -

+ * note this is not unique */

+ sensor_value = -1;

+ } else {

+ /* use hidden gconf key for hide_units */

+

+ if ((client = gconf_client_get_default()) != NULL) {

+ hide_units = gconf_client_get_bool(client,

+ "/apps/sensors-applet/" HIDE_UNITS,

+ &error);

+ if (error) {

+ g_debug("Could not get hide units from GConf - assuming false");

+ hide_units = FALSE;

+ g_error_free(error);

+ error = NULL;

+ }

+

+ g_object_unref(client);

+ }

+

+

+ /* scale value and set text using this

+ * value */

+ switch (sensor_type) {

+ case TEMP_SENSOR:

+

+ scale = (TemperatureScale)panel_applet_gconf_get_int(sensors_applet->applet, TEMPERATURE_SCALE, NULL);

+ /* scale value */

+ sensor_value = sensors_applet_convert_temperature(sensor_value,

+ CELSIUS,

+ scale);

+

+ sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;

+ switch (scale) {

+ case FAHRENHEIT:

+ value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_FAHRENHEIT));

+ /* tooltip should

+ * always display

+ * units */

+ value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_FAHRENHEIT);

+

+ break;

+ case CELSIUS:

+ value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_CELSIUS));

+ value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_CELSIUS);

+ break;

+ case KELVIN:

+ value_text = g_strdup_printf("%2.0f", sensor_value);

+ value_tooltip = g_strdup(value_text);

+ break;

+ }

+ break;

+

+ case FAN_SENSOR:

+ sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;

+ value_text = g_strdup_printf("%4.0f %s", sensor_value, (hide_units ? "" : UNITS_RPM));

+ value_tooltip = g_strdup_printf("%4.0f %s", sensor_value, UNITS_RPM);

+

+ break;

+

+ case VOLTAGE_SENSOR:

+ sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;

+ value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_VOLTAGE));

+ value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_VOLTAGE);

+

+ break;

+

+ case CURRENT_SENSOR:

+ sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;

+ value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_CURRENT));

+ value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_CURRENT);

+ break;

+

+ } /* end switch(sensor_type) */

+ } /* end else on error */

+

+ /* setup for tooltips */

+ tooltip = g_strdup_printf("%s %s", sensor_label, value_tooltip);

+ g_free(value_tooltip);

+

+ /* only do icons and labels / graphs if needed */

+ display_mode = panel_applet_gconf_get_int(sensors_applet->applet,

+ DISPLAY_MODE,

+ NULL);

+

+ /* most users wont have a font size set */

+ if ((client = gconf_client_get_default()) != NULL) {

+ font_size = gconf_client_get_int(client,

+ "/apps/sensors-applet/" FONT_SIZE,

+ &error);

+ if (error) {

+ g_debug("Could not get font size from GConf - assuming default size");

+ font_size = 0;

+ g_error_free(error);

+ error = NULL;

+ }

+

+ g_object_unref(client);

+ }

+

+

+ /* do icon if needed */

+ if (display_mode == DISPLAY_ICON ||

+ display_mode == DISPLAY_ICON_WITH_VALUE) {

+ /* update icon if icon range has changed if no

+ * update has been done before */

+ if ((sensor_value_range(sensor_value, sensor_low_value, sensor_high_value) != sensor_value_range(active_sensor->sensor_values[0], active_sensor->sensor_low_value, active_sensor->sensor_high_value)) || !(active_sensor->updated)) {

+ active_sensor_update_sensor_value(active_sensor,

+ sensor_value);

+ active_sensor->sensor_low_value = sensor_low_value;

+ active_sensor->sensor_high_value = sensor_high_value;

+ active_sensor_update_icon(active_sensor, icon_pixbuf, sensor_type);

+ }

+ /* always update tooltip */

+ gtk_widget_set_tooltip_text(active_sensor->icon,

+ tooltip);

+ }

+ active_sensor_update_sensor_value(active_sensor,

+ sensor_value);

+ active_sensor->sensor_low_value = sensor_low_value;

+ active_sensor->sensor_high_value = sensor_high_value;

+

+ /* do graph if needed */

+ if (display_mode == DISPLAY_GRAPH) {

+ /* update graph color in case has changed */

+ gdk_color_parse(graph_color,

+ &(active_sensor->graph_color));

+

+ active_sensor_update_graph(active_sensor);

+ gtk_widget_set_tooltip_text(active_sensor->graph,

+ tooltip);

+

+ }

+

+ old_value_text = value_text;

+

+ if (sensor_alarm_enabled) {

+ if (sensor_value >= sensor_high_value ||

+ sensor_value <= sensor_low_value) {

+ /* make value text red and

+ * activate alarm */

+ if (display_mode == DISPLAY_LABEL_WITH_VALUE ||

+ display_mode == DISPLAY_ICON_WITH_VALUE ||

+ display_mode == DISPLAY_VALUE) {

+ value_text = g_markup_printf_escaped("<span foreground=\"#FF0000\">%s</span>", old_value_text);

+

+ g_free(old_value_text);

+ }

+ /* could have both coditions at once */

+ if (sensor_value >= sensor_high_value) {

+ active_sensor_alarm_on(active_sensor, HIGH_ALARM);

+ }

+

+ if (sensor_value <= sensor_low_value) {

+ active_sensor_alarm_on(active_sensor, LOW_ALARM);

+ }

+

+ } else {

+ /* make sure alarms are off */

+ active_sensor_all_alarms_off(active_sensor);

+ }

+ } else { /* else for if alarm enabled */

+ /* make sure all alarms are off */

+ active_sensor_all_alarms_off(active_sensor);

+ }

+

+ /* do value label */

+ if (display_mode == DISPLAY_LABEL_WITH_VALUE ||

+ display_mode == DISPLAY_ICON_WITH_VALUE ||

+ display_mode == DISPLAY_VALUE) {

+ if (font_size) {

+ old_value_text = value_text;

+

+ value_text = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);

+ g_free(old_value_text);

+ }

+ gtk_label_set_markup(GTK_LABEL(active_sensor->value),

+ value_text);

+

+

+ gtk_widget_set_tooltip_text(active_sensor->value,

+ tooltip);

+ }

+ /* finished with value text */

+ g_free(value_text);

+

+ /* do label label */

+ if (display_mode == DISPLAY_LABEL_WITH_VALUE) {

+ if (font_size) {

+ old_value_text = sensor_label;

+ sensor_label = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);

+ g_free(old_value_text);

+ }

+ gtk_label_set_markup(GTK_LABEL(active_sensor->label),

+ sensor_label);

+ gtk_widget_set_tooltip_text(active_sensor->label,

+ tooltip);

+

+ }

+

+ g_free(tooltip);

+ } else {

+ g_debug("no get_sensor_value function yet installed for interface %s.", sensor_interface);

+ }

+ g_free(sensor_path);

+ g_free(sensor_id);

+ g_free(sensor_label);

+ g_free(sensor_interface);

+ g_free(graph_color);

+ g_object_unref(icon_pixbuf);

+

+ } else {

+ g_debug("Error getting iter when updating sensor...");

+

+ }

+ active_sensor->updated = TRUE;

+

+}

+

+/* to be called when the icon within the GtkRowReference that this

+ * sensor references is changed - updates icon based upon value in the

+ * ActiveSensor */

+void active_sensor_icon_changed(ActiveSensor *active_sensor,

+ SensorsApplet *sensors_applet) {

+

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+

+ SensorType sensor_type;

+ GdkPixbuf *icon_pixbuf;

+

+ g_assert(active_sensor);

+ g_assert(sensors_applet);

+

+ model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);

+ path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);

+

+ /* if can successfully get iter can proceed */

+ if (gtk_tree_model_get_iter(model, &iter, path)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &iter,

+ SENSOR_TYPE_COLUMN, &sensor_type,

+ ICON_PIXBUF_COLUMN, &icon_pixbuf,

+ -1);

+

+ active_sensor_update_icon(active_sensor,

+ icon_pixbuf,

+ sensor_type);

+ g_object_unref(icon_pixbuf);

+ }

+ gtk_tree_path_free(path);

+}

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef ACTIVE_SENSOR_H

+#define ACTIVE_SENSOR_H

+

+#ifdef HAVE_LIBNOTIFY

+#include <libnotify/notify.h>

+#include "active-sensor-libnotify.h"

+#endif

+

+#include "sensors-applet.h"

+

+struct _ActiveSensor {

+ SensorsApplet *sensors_applet;

+

+ /* widgets to render to display the sensor */

+ GtkWidget *label;

+ GtkWidget *icon;

+ GtkWidget *value;

+ GtkWidget *graph;

+ GtkWidget *graph_frame;

+

+ GdkColor graph_color;

+

+ GtkTreeRowReference *sensor_row;

+

+#ifdef HAVE_LIBNOTIFY

+ NotifyNotification *notification[NUM_NOTIFS];

+#endif

+

+ gboolean updated;

+

+ /* alarm related stuff */

+ gint alarm_timeout_id[NUM_ALARMS];

+ gchar *alarm_command[NUM_ALARMS];

+ gint alarm_timeout;

+

+ /* buffer of sensor values */

+ gdouble *sensor_values;

+

+ /* length of sensor_values buffer */

+ gint num_samples;

+

+ gdouble sensor_low_value;

+ gdouble sensor_high_value;

+};

+

+ActiveSensor *active_sensor_new(SensorsApplet *sensors_applet,

+ GtkTreeRowReference *sensor_row);

+void active_sensor_destroy(ActiveSensor *active_sensor);

+gint active_sensor_compare(ActiveSensor *a, ActiveSensor *b);

+void active_sensor_update(ActiveSensor *sensor, SensorsApplet *sensors_applet);

+void active_sensor_icon_changed(ActiveSensor *sensor, SensorsApplet *sensors_applet);

+void active_sensor_update_graph_dimensions(ActiveSensor *as,

+ gint dimensions[2]);

+void active_sensor_alarm_off(ActiveSensor *active_sensor, NotifType notif_type);

+#endif /* ACTIVE_SENSOR_H */

+/* sensors-applet/config.h.in. Generated from configure.ac by autoheader. */

+

+/* aticonfig executable */

+#undef ATICONFIG_EXE

+

+/* always defined to indicate that i18n is enabled */

+#undef ENABLE_NLS

+

+/* Package name for gettext */

+#undef GETTEXT_PACKAGE

+

+/* Define to 1 if you have the <arpa/inet.h> header file. */

+#undef HAVE_ARPA_INET_H

+

+/* using aticonfig */

+#undef HAVE_ATICONFIG

+

+/* Define to 1 if you have the `bind_textdomain_codeset' function. */

+#undef HAVE_BIND_TEXTDOMAIN_CODESET

+

+/* Define to 1 if you have the `dcgettext' function. */

+#undef HAVE_DCGETTEXT

+

+/* Define to 1 if you have the <dlfcn.h> header file. */

+#undef HAVE_DLFCN_H

+

+/* Define to 1 if you have the <fcntl.h> header file. */

+#undef HAVE_FCNTL_H

+

+/* Define if the GNU gettext() function is already present or preinstalled. */

+#undef HAVE_GETTEXT

+

+/* Define to 1 if you have the <inttypes.h> header file. */

+#undef HAVE_INTTYPES_H

+

+/* Define if your <locale.h> file defines LC_MESSAGES. */

+#undef HAVE_LC_MESSAGES

+

+/* libnotify available */

+#undef HAVE_LIBNOTIFY

+

+/* libsensors is available */

+#undef HAVE_LIBSENSORS

+

+/* Define to 1 if you have the <locale.h> header file. */

+#undef HAVE_LOCALE_H

+

+/* Define to 1 if you have the <memory.h> header file. */

+#undef HAVE_MEMORY_H

+

+/* Define to 1 if you have the <netinet/in.h> header file. */

+#undef HAVE_NETINET_IN_H

+

+/* Define to 1 if you have the <NVCtrl/NVCtrlLib.h> header file. */

+#undef HAVE_NVCTRL_NVCTRLLIB_H

+

+/* Define to 1 if you have the <NVCtrl/NVCtrl.h> header file. */

+#undef HAVE_NVCTRL_NVCTRL_H

+

+/* nvidia sensors available */

+#undef HAVE_NVIDIA

+

+/* Define to 1 if you have the <regex.h> header file. */

+#undef HAVE_REGEX_H

+

+/* Define to 1 if you have the <sensors/sensors.h> header file. */

+#undef HAVE_SENSORS_SENSORS_H

+

+/* Define to 1 if you have the <stdint.h> header file. */

+#undef HAVE_STDINT_H

+

+/* Define to 1 if you have the <stdio.h> header file. */

+#undef HAVE_STDIO_H

+

+/* Define to 1 if you have the <stdlib.h> header file. */

+#undef HAVE_STDLIB_H

+

+/* Define to 1 if you have the <strings.h> header file. */

+#undef HAVE_STRINGS_H

+

+/* Define to 1 if you have the <string.h> header file. */

+#undef HAVE_STRING_H

+

+/* Define to 1 if you have the <sys/ioctl.h> header file. */

+#undef HAVE_SYS_IOCTL_H

+

+/* Define to 1 if you have the <sys/socket.h> header file. */

+#undef HAVE_SYS_SOCKET_H

+

+/* Define to 1 if you have the <sys/stat.h> header file. */

+#undef HAVE_SYS_STAT_H

+

+/* Define to 1 if you have the <sys/types.h> header file. */

+#undef HAVE_SYS_TYPES_H

+

+/* Define to 1 if you have the <unistd.h> header file. */

+#undef HAVE_UNISTD_H

+

+/* Define to 1 if you have the <X11/Xlib.h> header file. */

+#undef HAVE_X11_XLIB_H

+

+/* Define to 1 if you have the <\> header file. */

+#undef HAVE__

+

+/* Define to the sub-directory in which libtool stores uninstalled libraries.

+ */

+#undef LT_OBJDIR

+

+/* Name of package */

+#undef PACKAGE

+

+/* Define to the address where bug reports for this package should be sent. */

+#undef PACKAGE_BUGREPORT

+

+/* Define to the full name of this package. */

+#undef PACKAGE_NAME

+

+/* Define to the full name and version of this package. */

+#undef PACKAGE_STRING

+

+/* Define to the one symbol short name of this package. */

+#undef PACKAGE_TARNAME

+

+/* Define to the home page for this package. */

+#undef PACKAGE_URL

+

+/* Define to the version of this package. */

+#undef PACKAGE_VERSION

+

+/* Define to 1 if you have the ANSI C header files. */

+#undef STDC_HEADERS

+

+/* Version number of package */

+#undef VERSION

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#include <panel-applet.h>

+#include <string.h>

+#include "sensors-applet.h"

+

+static gboolean sensors_applet_fill(PanelApplet *applet,

+ const gchar *iid,

+ gpointer data) {

+ SensorsApplet *sensors_applet;

+ gboolean retval = FALSE;

+ if (strcmp(iid, "OAFIID:SensorsApplet") == 0) {

+ sensors_applet = g_new0(SensorsApplet, 1);

+ sensors_applet->applet = applet;

+ sensors_applet_init(sensors_applet);

+ retval = TRUE;

+ }

+ return retval;

+}

+

+PANEL_APPLET_BONOBO_FACTORY ("OAFIID:SensorsApplet_Factory",

+ PANEL_TYPE_APPLET,

+ PACKAGE,

+ PACKAGE_VERSION,

+ sensors_applet_fill,

+ NULL);

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#include <libgnome/libgnome.h>

+#include "sensors-applet-gconf.h"

+#include "prefs-dialog.h"

+#include "sensor-config-dialog.h"

+

+#define OLD_TEMP_SCALE 0

+#define NEW_TEMP_SCALE 1

+

+/* when a user closes the prefs-dialog we assume that applet is now

+ setup, so store all values in gconf */

+void prefs_dialog_close(SensorsApplet *sensors_applet) {

+

+ if (sensors_applet->sensors != NULL) {

+ if (sensors_applet_gconf_save_sensors(sensors_applet))

+ panel_applet_gconf_set_bool(sensors_applet->applet,

+ IS_SETUP, TRUE, NULL);

+ }

+ if (sensors_applet->prefs_dialog) {

+ gtk_widget_destroy(GTK_WIDGET(sensors_applet->prefs_dialog->dialog));

+ g_free(sensors_applet->prefs_dialog);

+ sensors_applet->prefs_dialog = NULL;

+

+ }

+ if (sensors_applet->timeout_id == 0) {

+ sensors_applet->timeout_id = g_timeout_add_seconds(panel_applet_gconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000, (GSourceFunc)sensors_applet_update_active_sensors, sensors_applet);

+ }

+

+

+}

+

+void prefs_dialog_response(GtkDialog *prefs_dialog,

+ gint response,

+ gpointer data) {

+

+ SensorsApplet *sensors_applet;

+ GError *error = NULL;

+ gint current_page;

+ gchar *uri;

+

+ sensors_applet = (SensorsApplet *)data;

+

+ switch (response) {

+ case GTK_RESPONSE_HELP:

+ g_debug("loading help in prefs");

+ current_page = gtk_notebook_get_current_page(sensors_applet->prefs_dialog->notebook);

+ uri = g_strdup_printf("ghelp:sensors-applet?%s",

+ ((current_page == 0) ?

+ "sensors-applet-general-options" :

+ ((current_page == 1) ?

+ "sensors-applet-sensors" :

+ NULL)));

+ gtk_show_uri(NULL, uri, gtk_get_current_event_time(), &error);

+ g_free(uri);

+

+ if (error) {

+ g_debug("Could not open help document: %s ",error->message);

+ g_error_free (error);

+ }

+ break;

+ default:

+ g_debug("closing prefs dialog");

+ prefs_dialog_close(sensors_applet);

+ }

+}

+

+

+static gboolean prefs_dialog_convert_low_and_high_values(GtkTreeModel *model,

+ GtkTreePath *path,

+ GtkTreeIter *iter,

+ TemperatureScale scales[2]) {

+ SensorType sensor_type;

+ gdouble low_value, high_value;

+

+ gtk_tree_model_get(model,

+ iter,

+ SENSOR_TYPE_COLUMN, &sensor_type,

+ LOW_VALUE_COLUMN, &low_value,

+ HIGH_VALUE_COLUMN, &high_value,

+ -1);

+

+ if (sensor_type == TEMP_SENSOR)

+ {

+ low_value = sensors_applet_convert_temperature(low_value,

+ scales[OLD_TEMP_SCALE],

+ scales[NEW_TEMP_SCALE]);

+

+ high_value = sensors_applet_convert_temperature(high_value,

+ scales[OLD_TEMP_SCALE],

+ scales[NEW_TEMP_SCALE]);

+

+

+ gtk_tree_store_set(GTK_TREE_STORE(model),

+ iter,

+ LOW_VALUE_COLUMN, low_value,

+ HIGH_VALUE_COLUMN, high_value,

+ -1);

+ }

+ return FALSE;

+}

+

+

+static void prefs_dialog_timeout_changed(GtkSpinButton *button,

+ PrefsDialog *prefs_dialog) {

+ gint value;

+ value = (gint)(gtk_spin_button_get_value(button) * 1000);

+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet, TIMEOUT, value, NULL);

+}

+

+static void prefs_dialog_display_mode_changed(GtkComboBox *display_mode_combo_box,

+ PrefsDialog *prefs_dialog) {

+

+ int display_mode;

+

+ display_mode = gtk_combo_box_get_active(display_mode_combo_box);

+

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),

+ (display_mode != DISPLAY_ICON) &&

+ (display_mode != DISPLAY_VALUE) &&

+ (display_mode != DISPLAY_GRAPH));

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),

+ (display_mode != DISPLAY_ICON) &&

+ (display_mode != DISPLAY_VALUE) &&

+ (display_mode != DISPLAY_GRAPH));

+

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),

+ (display_mode == DISPLAY_GRAPH));

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),

+ (display_mode == DISPLAY_GRAPH));

+

+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet,

+ DISPLAY_MODE,

+ gtk_combo_box_get_active(display_mode_combo_box),

+ NULL);

+

+ sensors_applet_display_layout_changed(prefs_dialog->sensors_applet);

+}

+

+static void prefs_dialog_layout_mode_changed(GtkComboBox *layout_mode_combo_box,

+ PrefsDialog *prefs_dialog) {

+

+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet,

+ LAYOUT_MODE,

+ gtk_combo_box_get_active(layout_mode_combo_box),

+ NULL);

+

+ sensors_applet_display_layout_changed(prefs_dialog->sensors_applet);

+}

+

+

+static void prefs_dialog_temperature_scale_changed(GtkComboBox *temperature_scale_combo_box,

+ PrefsDialog *prefs_dialog) {

+ /* get old temp scale value */

+ TemperatureScale scales[2];

+ GtkTreeModel *model;

+

+ scales[OLD_TEMP_SCALE] = (TemperatureScale)panel_applet_gconf_get_int(prefs_dialog->sensors_applet->applet,

+ TEMPERATURE_SCALE,

+ NULL);

+

+ scales[NEW_TEMP_SCALE] = (TemperatureScale)gtk_combo_box_get_active(temperature_scale_combo_box);

+

+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet,

+ TEMPERATURE_SCALE,

+ scales[NEW_TEMP_SCALE],

+ NULL);

+

+ /* now go thru and convert all low and high sensor values in

+ * the tree to either celcius or Fahrenheit */

+ model = gtk_tree_view_get_model(prefs_dialog->view);

+ gtk_tree_model_foreach(model,

+ (GtkTreeModelForeachFunc)prefs_dialog_convert_low_and_high_values,

+ scales);

+

+ /* finally update display of active sensors */

+ sensors_applet_update_active_sensors(prefs_dialog->sensors_applet);

+}

+

+

+#ifdef HAVE_LIBNOTIFY

+static void prefs_dialog_display_notifications_toggled(GtkCheckButton *display_notifications,

+ PrefsDialog *prefs_dialog) {

+

+ gboolean notify;

+

+ notify = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(display_notifications));

+ panel_applet_gconf_set_bool(prefs_dialog->sensors_applet->applet,

+ DISPLAY_NOTIFICATIONS,

+ notify,

+ NULL);

+

+ if (notify) {

+ sensors_applet_update_active_sensors(prefs_dialog->sensors_applet);

+ } else {

+ sensors_applet_notify_end_all(prefs_dialog->sensors_applet);

+ }

+}

+#endif

+

+static void prefs_dialog_graph_size_changed(GtkSpinButton *button,

+ PrefsDialog *prefs_dialog) {

+ gint value;

+ value = (gint)(gtk_spin_button_get_value(button));

+ panel_applet_gconf_set_int(prefs_dialog->sensors_applet->applet, GRAPH_SIZE, value, NULL);

+

+ /* notify change of number of samples */

+ sensors_applet_graph_size_changed(prefs_dialog->sensors_applet);

+

+}

+

+/* callbacks for the tree of sensors */

+static void prefs_dialog_sensor_toggled(GtkCellRenderer *renderer, gchar *path_str, PrefsDialog *prefs_dialog) {

+ GtkTreeIter iter;

+ GtkTreePath *path;

+

+ gboolean old_value;

+

+ path = gtk_tree_path_new_from_string(path_str);

+

+ gtk_tree_model_get_iter(GTK_TREE_MODEL(prefs_dialog->sensors_applet->sensors), &iter, path);

+ gtk_tree_model_get(GTK_TREE_MODEL(prefs_dialog->sensors_applet->sensors),

+ &iter,

+ ENABLE_COLUMN, &old_value,

+ -1);

+

+ if (old_value) {

+ sensors_applet_sensor_disabled(prefs_dialog->sensors_applet,

+ path);

+ } else {

+ sensors_applet_sensor_enabled(prefs_dialog->sensors_applet,

+ path);

+ }

+

+ gtk_tree_store_set(prefs_dialog->sensors_applet->sensors, &iter,

+ ENABLE_COLUMN, !old_value,

+ -1);

+

+ gtk_tree_path_free(path);

+}

+

+static void prefs_dialog_sensor_name_changed(GtkCellRenderer *renderer, gchar *path_str, gchar *new_text, PrefsDialog *prefs_dialog) {

+ GtkTreeIter iter;

+ GtkTreePath *path = gtk_tree_path_new_from_string(path_str);

+

+ gtk_tree_model_get_iter(GTK_TREE_MODEL(prefs_dialog->sensors_applet->sensors), &iter, path);

+

+ gtk_tree_store_set(prefs_dialog->sensors_applet->sensors, &iter, LABEL_COLUMN, new_text, -1);

+

+ sensors_applet_update_sensor(prefs_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void prefs_dialog_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, PrefsDialog *prefs_dialog) {

+ /* only bring up dialog this if is a sensor - ie has no

+ * children */

+ GtkTreeIter iter;

+ GtkTreeModel *model;

+

+ model = gtk_tree_view_get_model(view);

+ /* make sure can set iter first */

+ if (gtk_tree_model_get_iter(model, &iter, path) && !gtk_tree_model_iter_has_child(model, &iter)) {

+ sensor_config_dialog_create(prefs_dialog->sensors_applet);

+ }

+}

+

+

+static void prefs_dialog_sensor_up_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {

+ GtkTreeModel *model;

+ GtkTreeIter iter;

+ GtkTreePath *path;

+

+ if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {

+ /* if has no prev node set up button insentive */

+ path = gtk_tree_model_get_path(model, &iter);

+ if (gtk_tree_path_prev(path)) {

+ GtkTreeIter prev_iter;

+ /* check is a valid node in out model */

+ if (gtk_tree_model_get_iter(model, &prev_iter, path)) {

+ gtk_tree_store_move_before(GTK_TREE_STORE(model),

+ &iter,

+ &prev_iter);

+ g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,

+ "changed");

+

+ sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);

+

+

+ }

+ }

+

+ gtk_tree_path_free(path);

+

+ }

+}

+

+static void prefs_dialog_sensor_down_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {

+ GtkTreeModel *model;

+ GtkTreeIter iter;

+ GtkTreeIter iter_next;

+

+ if (gtk_tree_selection_get_selected(prefs_dialog->sensors_applet->selection, &model, &iter)) {

+ iter_next = iter;

+ /* if has no next node set down button insentive */

+ if (gtk_tree_model_iter_next(model, &iter_next)) {

+ gtk_tree_store_move_after(GTK_TREE_STORE(model),

+ &iter,

+ &iter_next);

+ g_signal_emit_by_name(prefs_dialog->sensors_applet->selection,

+ "changed");

+ sensors_applet_reorder_sensors(prefs_dialog->sensors_applet);

+

+ }

+ }

+}

+

+

+

+static void prefs_dialog_sensor_config_button_clicked(GtkButton *button, PrefsDialog *prefs_dialog) {

+ sensor_config_dialog_create(prefs_dialog->sensors_applet);

+}

+

+

+/* if a sensor is selected, make config sure button is able to be

+ * clicked and also set the sensitivities properly for the up and down

+ * buttons */

+static void prefs_dialog_selection_changed(GtkTreeSelection *selection,

+ PrefsDialog *prefs_dialog) {

+ GtkTreeIter iter;

+ GtkTreePath *path;

+ GtkTreeModel *model;

+ /* if there is a selection with no children make config button

+ * sensitive */

+ if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

+ if (!gtk_tree_model_iter_has_child(model, &iter)) {

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_config_button), TRUE);

+ } else {

+ /* otherwise make insensitive */

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_config_button), FALSE);

+ }

+

+ /* if has no prev node set up button insentive */

+ path = gtk_tree_model_get_path(model, &iter);

+ if (gtk_tree_path_prev(path)) {

+ GtkTreeIter prev_iter;

+ /* check is a valid node in out model */

+ if (gtk_tree_model_get_iter(model, &prev_iter, path)) {

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), TRUE);

+ } else {

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);

+ }

+ } else {

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);

+ }

+

+ gtk_tree_path_free(path);

+

+ /* if has no next node set down button insentive */

+ if (gtk_tree_model_iter_next(model, &iter)) {

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), TRUE);

+ } else {

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);

+ }

+

+ } else {

+ /* otherwise make all insensitive */

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_config_button), FALSE);

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);

+

+ }

+}

+

+void prefs_dialog_open(SensorsApplet *sensors_applet) {

+ gchar *header_text;

+ PrefsDialog *prefs_dialog;

+ DisplayMode display_mode;

+

+ g_assert(sensors_applet->prefs_dialog == NULL);

+

+ /* while prefs dialog is open, stop the updating of sensors so

+ * we don't get any race conditions due to concurrent updates

+ * of the labels, values and icons linked lists etc. */

+ if (sensors_applet->timeout_id != 0) {

+ if (g_source_remove(sensors_applet->timeout_id)) {

+ sensors_applet->timeout_id = 0;

+ }

+ }

+

+ sensors_applet->prefs_dialog = g_new0(PrefsDialog, 1);

+ prefs_dialog = sensors_applet->prefs_dialog;

+

+ prefs_dialog->sensors_applet = sensors_applet;

+

+ prefs_dialog->dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Sensors Applet Preferences"),

+ NULL,

+ GTK_DIALOG_NO_SEPARATOR,

+ GTK_STOCK_HELP,

+ GTK_RESPONSE_HELP,

+ GTK_STOCK_CLOSE,

+ GTK_RESPONSE_CLOSE,

+ NULL));

+ g_object_set(prefs_dialog->dialog,

+ "border-width", 12,

+ "default-width", 480,

+ "default-height", 350,

+ NULL);

+

+ gtk_box_set_homogeneous(GTK_BOX(prefs_dialog->dialog->vbox), FALSE);

+

+ gtk_box_set_spacing(GTK_BOX(prefs_dialog->dialog->vbox), 5);

+

+

+ g_signal_connect(prefs_dialog->dialog,

+ "response", G_CALLBACK(prefs_dialog_response),

+ sensors_applet);

+

+ g_signal_connect_swapped(prefs_dialog->dialog,

+ "delete-event", G_CALLBACK(prefs_dialog_close),

+ sensors_applet);

+

+ g_signal_connect_swapped(prefs_dialog->dialog,

+ "destroy", G_CALLBACK(prefs_dialog_close),

+ sensors_applet);

+

+ /* if no SensorsList's have been created, this is because

+ we haven't been able to access any sensors */

+ if (sensors_applet->sensors == NULL) {

+ GtkWidget *label;

+ label = gtk_label_new(_("No sensors found!"));

+ gtk_box_pack_start_defaults(GTK_BOX(prefs_dialog->dialog->vbox), label);

+ return;

+ }

+

+

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Display"));

+ prefs_dialog->display_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+ prefs_dialog->display_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());

+

+

+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("label with value"));

+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("icon with value"));

+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("value only"));

+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("icon only"));

+ gtk_combo_box_append_text(prefs_dialog->display_mode_combo_box, _("graph only"));

+

+

+ display_mode = panel_applet_gconf_get_int(sensors_applet->applet, DISPLAY_MODE, NULL);

+ gtk_combo_box_set_active(prefs_dialog->display_mode_combo_box, display_mode);

+

+ g_signal_connect(prefs_dialog->display_mode_combo_box,

+ "changed",

+ G_CALLBACK(prefs_dialog_display_mode_changed),

+ prefs_dialog);

+

+

+

+ /* use spaces in label to indent */

+ prefs_dialog->display_mode_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("_Display sensors in panel as"),

+ "mnemonic-widget", prefs_dialog->display_mode_combo_box,

+ "xalign", 0.0,

+ NULL);

+

+

+

+

+ prefs_dialog->layout_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());

+

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),

+ (display_mode != DISPLAY_ICON) &&

+ (display_mode != DISPLAY_VALUE) &&

+ (display_mode != DISPLAY_GRAPH));

+

+ gtk_combo_box_append_text(prefs_dialog->layout_mode_combo_box, _("beside labels / icons"));

+ gtk_combo_box_append_text(prefs_dialog->layout_mode_combo_box, _("below labels / icons"));

+

+ gtk_combo_box_set_active(prefs_dialog->layout_mode_combo_box, panel_applet_gconf_get_int(sensors_applet->applet, LAYOUT_MODE, NULL));

+

+ g_signal_connect(prefs_dialog->layout_mode_combo_box,

+ "changed",

+ G_CALLBACK(prefs_dialog_layout_mode_changed),

+ prefs_dialog);

+

+ prefs_dialog->layout_mode_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("Preferred _position of sensor values"),

+ "mnemonic-widget", prefs_dialog->layout_mode_combo_box,

+ "xalign", 0.0,

+ NULL);

+

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),

+ (display_mode != DISPLAY_ICON) &&

+ (display_mode != DISPLAY_VALUE) &&

+ (display_mode != DISPLAY_GRAPH));

+

+ prefs_dialog->temperature_scale_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());

+

+ gtk_combo_box_append_text(prefs_dialog->temperature_scale_combo_box, _("Kelvin"));

+ gtk_combo_box_append_text(prefs_dialog->temperature_scale_combo_box, _("Celsius"));

+ gtk_combo_box_append_text(prefs_dialog->temperature_scale_combo_box, _("Fahrenheit"));

+

+ gtk_combo_box_set_active(prefs_dialog->temperature_scale_combo_box, panel_applet_gconf_get_int(sensors_applet->applet, TEMPERATURE_SCALE, NULL));

+

+ g_signal_connect(prefs_dialog->temperature_scale_combo_box,

+ "changed",

+ G_CALLBACK(prefs_dialog_temperature_scale_changed),

+ prefs_dialog);

+

+ prefs_dialog->temperature_scale_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("_Temperature scale"),

+ "mnemonic-widget", prefs_dialog->temperature_scale_combo_box,

+ "xalign", 0.0,

+ NULL);

+

+ prefs_dialog->graph_size_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", (gdouble)panel_applet_gconf_get_int(sensors_applet->applet,

+ GRAPH_SIZE,

+ NULL),

+ "lower", 1.0,

+ "upper", 100.0,

+ "step-increment", 1.0,

+ "page-increment", 10.0,

+ "page-size", 0.0,

+ NULL);

+

+ prefs_dialog->graph_size_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", prefs_dialog->graph_size_adjust,

+ "climb-rate", 1.0,

+ "digits", 0,

+ "value", (gdouble)panel_applet_gconf_get_int(sensors_applet->applet,

+ GRAPH_SIZE,

+ NULL),

+ "width-chars", 4,

+ NULL);

+

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),

+ (display_mode == DISPLAY_GRAPH));

+

+ prefs_dialog->graph_size_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("Graph _size (pixels)"),

+ "mnemonic-widget", prefs_dialog->graph_size_spinbutton,

+ "xalign", 0.0,

+ NULL);

+

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),

+ (display_mode == DISPLAY_GRAPH));

+

+ g_signal_connect(prefs_dialog->graph_size_spinbutton, "value-changed",

+ G_CALLBACK(prefs_dialog_graph_size_changed),

+ prefs_dialog);

+

+

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Update"));

+ prefs_dialog->update_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+

+ prefs_dialog->timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", 2.0,

+ "lower", 1.5,

+ "upper", 10.0,

+ "step-increment", 0.5,

+ "page-increment", 1.0,

+ "page-size", 0.0,

+ NULL);

+

+ prefs_dialog->timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", prefs_dialog->timeout_adjust,

+ "climb-rate", 0.5,

+ "digits", 1,

+ "value", (gdouble) panel_applet_gconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000.0,

+ "width-chars", 4,

+ NULL);

+

+

+ prefs_dialog->timeout_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("Update _interval (secs)"),

+ "mnemonic-widget", prefs_dialog->timeout_spinbutton,

+ "xalign", 0.0,

+ NULL);

+

+ g_signal_connect(prefs_dialog->timeout_spinbutton, "value-changed",

+ G_CALLBACK(prefs_dialog_timeout_changed),

+ prefs_dialog);

+

+#ifdef HAVE_LIBNOTIFY

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Notifications"));

+ prefs_dialog->notifications_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+ prefs_dialog->display_notifications = g_object_new(GTK_TYPE_CHECK_BUTTON,

+ "use-underline", TRUE,

+ "label", _("Display _notifications"),

+ NULL);

+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(prefs_dialog->display_notifications),

+ panel_applet_gconf_get_bool(sensors_applet->applet,

+ DISPLAY_NOTIFICATIONS,

+ NULL));

+ g_signal_connect(prefs_dialog->display_notifications,

+ "toggled",

+ G_CALLBACK(prefs_dialog_display_notifications_toggled),

+ prefs_dialog);

+#endif

+

+ /* SIZE AND LAYOUT */

+ /* keep all widgets same size */

+ prefs_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

+

+ gtk_size_group_add_widget(prefs_dialog->size_group,

+ GTK_WIDGET(prefs_dialog->display_mode_combo_box));

+

+ gtk_size_group_add_widget(prefs_dialog->size_group,

+ GTK_WIDGET(prefs_dialog->layout_mode_combo_box));

+

+ gtk_size_group_add_widget(prefs_dialog->size_group,

+ GTK_WIDGET(prefs_dialog->temperature_scale_combo_box));

+

+ gtk_size_group_add_widget(prefs_dialog->size_group,

+ GTK_WIDGET(prefs_dialog->timeout_spinbutton));

+

+ g_object_unref(prefs_dialog->size_group);

+

+ prefs_dialog->globals_table = g_object_new(GTK_TYPE_TABLE,

+ "homogeneous", FALSE,

+ "n-columns", 3,

+#ifdef HAVE_LIBNOTIFY

+ "n-rows", 9,

+#else

+ "n-rows", 7,

+#endif

+ "row-spacing", 6,

+ "column-spacing", 12,

+ NULL);

+

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->display_header),

+ 0, 2,

+ 0, 1,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->display_mode_label),

+ 1, 2,

+ 1, 2,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->display_mode_combo_box),

+ 2, 3,

+ 1, 2,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->layout_mode_label),

+ 1, 2,

+ 2, 3,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->layout_mode_combo_box),

+ 2, 3,

+ 2, 3,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->graph_size_label),

+ 1, 2,

+ 3, 4,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->graph_size_spinbutton),

+ 2, 3,

+ 3, 4,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->temperature_scale_label),

+ 1, 2,

+ 4, 5,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->temperature_scale_combo_box),

+ 2, 3,

+ 4, 5,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->update_header),

+ 0, 2,

+ 5, 6,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->timeout_label),

+ 1, 2,

+ 6, 7,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->timeout_spinbutton),

+ 2, 3,

+ 6, 7,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+

+#ifdef HAVE_LIBNOTIFY

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->notifications_header),

+ 0, 2,

+ 7, 8,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+

+ gtk_table_attach(prefs_dialog->globals_table,

+ GTK_WIDGET(prefs_dialog->display_notifications),

+ 1, 2,

+ 8, 9,

+ GTK_FILL,

+ GTK_FILL,

+ 0,

+ 0);

+#endif

+

+

+ prefs_dialog->view = g_object_new(GTK_TYPE_TREE_VIEW,

+ "model", GTK_TREE_MODEL(sensors_applet->sensors),

+ "rules-hint", TRUE,

+ "reorderable", FALSE,

+ "enable-search", TRUE,

+ "search-column", LABEL_COLUMN,

+ NULL);

+

+ /* get double clicks on rows - do same as configure sensor

+ * button clicks */

+ g_signal_connect(prefs_dialog->view, "row-activated",

+ G_CALLBACK(prefs_dialog_row_activated),

+ prefs_dialog);

+

+ prefs_dialog->id_renderer = gtk_cell_renderer_text_new();

+ prefs_dialog->label_renderer = gtk_cell_renderer_text_new();

+ g_object_set(prefs_dialog->label_renderer,

+ "editable", TRUE,

+ NULL);

+

+ g_signal_connect(prefs_dialog->label_renderer, "edited",

+ G_CALLBACK(prefs_dialog_sensor_name_changed),

+ prefs_dialog);

+

+ prefs_dialog->enable_renderer = gtk_cell_renderer_toggle_new();

+ g_signal_connect(prefs_dialog->enable_renderer, "toggled",

+ G_CALLBACK(prefs_dialog_sensor_toggled),

+ prefs_dialog);

+ prefs_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();

+

+ prefs_dialog->id_column = gtk_tree_view_column_new_with_attributes(_("Sensor"),

+ prefs_dialog->id_renderer,

+ "text", ID_COLUMN,

+ NULL);

+

+ gtk_tree_view_column_set_min_width(prefs_dialog->id_column, 90);

+

+ prefs_dialog->label_column = gtk_tree_view_column_new_with_attributes(_("Label"),

+ prefs_dialog->label_renderer,

+ "text", LABEL_COLUMN,

+ "visible", VISIBLE_COLUMN,

+ NULL);

+

+ gtk_tree_view_column_set_min_width(prefs_dialog->label_column, 100);

+

+ /* create the tooltip */

+ gtk_widget_set_tooltip_text(GTK_WIDGET(prefs_dialog->view),

+ _("Labels can be edited directly by clicking on them."));

+ prefs_dialog->enable_column = gtk_tree_view_column_new_with_attributes(_("Enabled"),

+ prefs_dialog->enable_renderer,

+ "active", ENABLE_COLUMN,

+ "visible", VISIBLE_COLUMN,

+ NULL);

+

+ prefs_dialog->icon_column = gtk_tree_view_column_new_with_attributes(_("Icon"),

+ prefs_dialog->icon_renderer,

+ "pixbuf", ICON_PIXBUF_COLUMN,

+ "visible", VISIBLE_COLUMN,

+ NULL);

+ gtk_tree_view_append_column(prefs_dialog->view,

+ prefs_dialog->id_column);

+ gtk_tree_view_append_column(prefs_dialog->view,

+ prefs_dialog->icon_column);

+ gtk_tree_view_append_column(prefs_dialog->view,

+ prefs_dialog->label_column);

+ gtk_tree_view_append_column(prefs_dialog->view,

+ prefs_dialog->enable_column);

+

+ gtk_tree_view_columns_autosize(prefs_dialog->view);

+

+ prefs_dialog->scrolled_window = g_object_new(GTK_TYPE_SCROLLED_WINDOW,

+ "hadjustment", NULL,

+ "height-request", 200,

+ "hscrollbar-policy", GTK_POLICY_AUTOMATIC,

+ "vadjustment",NULL,

+ "vscrollbar-policy", GTK_POLICY_AUTOMATIC,

+ NULL);

+

+ gtk_container_add(GTK_CONTAINER(prefs_dialog->scrolled_window), GTK_WIDGET(prefs_dialog->view));

+

+ /* GtkTree Selection */

+ sensors_applet->selection = gtk_tree_view_get_selection(prefs_dialog->view);

+ /* allow user to only select one row at a time at most */

+ gtk_tree_selection_set_mode(sensors_applet->selection, GTK_SELECTION_SINGLE);

+ /* when selection is changed, make sure sensor_config button is

+ activated */

+

+ /* Create buttons for user to interact with sensors tree */

+ prefs_dialog->sensor_up_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_UP));

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);

+

+ g_signal_connect(prefs_dialog->sensor_up_button, "clicked",

+ G_CALLBACK(prefs_dialog_sensor_up_button_clicked),

+ prefs_dialog);

+

+ prefs_dialog->sensor_down_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_DOWN));

+ gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);

+

+ g_signal_connect(prefs_dialog->sensor_down_button, "clicked",

+ G_CALLBACK(prefs_dialog_sensor_down_button_clicked),

+ prefs_dialog);

+

+

+ prefs_dialog->buttons_box = GTK_VBUTTON_BOX(gtk_vbutton_box_new());

+

+ gtk_button_box_set_layout(GTK_BUTTON_BOX(prefs_dialog->buttons_box),

+ GTK_BUTTONBOX_SPREAD);

+

+ gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE, FALSE, 0);

+

+ gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE, FALSE, 0);

+

+ prefs_dialog->sensors_hbox = g_object_new(GTK_TYPE_HBOX,

+ "border-width", 5,

+ "homogeneous", FALSE,

+ "spacing", 5,

+ NULL);

+

+ gtk_box_pack_start(prefs_dialog->sensors_hbox,

+ GTK_WIDGET(prefs_dialog->scrolled_window),

+ TRUE, TRUE, 0); /* make sure window takes

+ * up most of room */

+

+ gtk_box_pack_start(prefs_dialog->sensors_hbox,

+ GTK_WIDGET(prefs_dialog->buttons_box),

+ FALSE, FALSE, 0);

+

+

+ /* Sensor Config button */

+ /* initially make button insensitive until user selects a row

+ from the sensors tree */

+ prefs_dialog->sensor_config_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_PROPERTIES));

+ g_object_set(prefs_dialog->sensor_config_button,

+ "sensitive", FALSE,

+ NULL);

+

+

+ g_signal_connect(sensors_applet->selection,

+ "changed",

+ G_CALLBACK(prefs_dialog_selection_changed),

+ prefs_dialog);

+

+ /* pass selection to signal handler so we can give user a

+ sensors_applet->prefs_dialog with the selected rows alarm

+ value and enable */

+ g_signal_connect(prefs_dialog->sensor_config_button, "clicked",

+ G_CALLBACK(prefs_dialog_sensor_config_button_clicked),

+ prefs_dialog);

+

+ prefs_dialog->sensor_config_hbox = g_object_new(GTK_TYPE_HBOX,

+ "border-width", 5,

+ "homogeneous", FALSE,

+ "spacing", 0,

+ NULL);

+ gtk_box_pack_end(prefs_dialog->sensor_config_hbox,

+ GTK_WIDGET(prefs_dialog->sensor_config_button),

+ FALSE, FALSE, 0);

+

+ /* pack sensors_vbox */

+ prefs_dialog->sensors_vbox = g_object_new(GTK_TYPE_VBOX,

+ "border-width", 5,

+ "homogeneous", FALSE,

+ "spacing", 0,

+ NULL);

+

+ gtk_box_pack_start(prefs_dialog->sensors_vbox,

+ GTK_WIDGET(prefs_dialog->sensors_hbox),

+ TRUE, TRUE, 0);

+ gtk_box_pack_start(prefs_dialog->sensors_vbox,

+ GTK_WIDGET(prefs_dialog->sensor_config_hbox),

+ FALSE, FALSE, 0);

+

+ prefs_dialog->globals_alignment = g_object_new(GTK_TYPE_ALIGNMENT,

+ "xalign", 0.5,

+ "yalign", 0.0,

+ "top-padding", 12,

+ "left-padding", 12,

+ "bottom-padding", 12,

+ "right-padding", 12,

+ NULL);

+ gtk_container_add(GTK_CONTAINER(prefs_dialog->globals_alignment),

+ GTK_WIDGET(prefs_dialog->globals_table));

+

+ prefs_dialog->notebook = g_object_new(GTK_TYPE_NOTEBOOK,

+ NULL);

+

+ gtk_notebook_append_page(prefs_dialog->notebook,

+ GTK_WIDGET(prefs_dialog->globals_alignment),

+ gtk_label_new(_("General Options")));

+

+ gtk_notebook_append_page(prefs_dialog->notebook,

+ GTK_WIDGET(prefs_dialog->sensors_vbox),

+ gtk_label_new(_("Sensors")));

+

+ /* pack notebook into prefs_dialog */

+ gtk_box_pack_start_defaults(GTK_BOX(prefs_dialog->dialog->vbox),

+ GTK_WIDGET(prefs_dialog->notebook));

+

+

+ gtk_widget_show_all(GTK_WIDGET(prefs_dialog->dialog));

+}

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef PREFS_DIALOG_H

+#define PREFS_DIALOG_H

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include "sensors-applet.h"

+

+typedef struct {

+ SensorsApplet *sensors_applet;

+ GtkDialog *dialog;

+ GtkNotebook *notebook;

+

+ /* widgets for global prefs */

+ GtkSpinButton *timeout_spinbutton, *graph_size_spinbutton;

+ GtkTable *globals_table;

+ GtkHSeparator *globals_separator;

+ GtkComboBox *display_mode_combo_box, *layout_mode_combo_box, *temperature_scale_combo_box;

+ GtkLabel *timeout_label, *display_mode_label, *layout_mode_label, *temperature_scale_label, *graph_size_label, *update_header, *display_header;

+ GtkAdjustment *timeout_adjust, *graph_size_adjust;

+

+#ifdef HAVE_LIBNOTIFY

+ GtkCheckButton *display_notifications;

+ GtkLabel *notifications_header;

+#endif

+

+ /* widgets for sensors tree */

+ GtkTreeView *view;

+ GtkTreeViewColumn *id_column, *label_column, *enable_column, *icon_column;

+ GtkCellRenderer *id_renderer, *label_renderer, *enable_renderer, *icon_renderer;

+ GtkScrolledWindow *scrolled_window;

+

+ GtkVButtonBox *buttons_box; /* holds sensor reorder buttons */

+ GtkBox *sensors_hbox; /* holds scrolled window and

+ * buttons_vbox */

+ GtkAlignment *globals_alignment;

+ GtkBox *sensors_vbox; /* holds sensors_hbox and sensor_config_hbox */

+ GtkBox *sensor_config_hbox; /* holds config button */

+ GtkSizeGroup *size_group; /* so comboboxes all

+ * request the same size */

+

+ GtkButton *sensor_up_button;

+ GtkButton *sensor_down_button;

+ GtkButton *sensor_config_button;

+} PrefsDialog;

+

+/* function prototypes */

+void prefs_dialog_open(SensorsApplet *sensors_applet);

+void prefs_dialog_close(SensorsApplet *sensors_applet);

+

+#endif /* PREFS_DIALOG_H */

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#include <gnome.h>

+#include "sensor-config-dialog.h"

+#include "sensors-applet.h"

+

+#define SPINBUTTON_WIDTH_CHARS 8

+#define VALUE_DECIMAL_PLACES 3

+

+typedef struct {

+ SensorsApplet *sensors_applet;

+

+ GtkWidget *dialog;

+ /* icon widgets */

+ GtkLabel *icon_header, *icon_type_label;

+ GtkComboBox *icon_type_combo_box;

+ GtkAlignment *icon_type_combo_box_aligner;

+ GtkCellRenderer *icon_renderer;

+

+ /* Graph Color chooser */

+ GtkColorButton *graph_color_button;

+ GtkAlignment *graph_color_button_aligner;

+ GtkLabel *graph_color_label, *graph_header;

+

+ /* multiplier and offset widgets */

+ GtkLabel *scale_header, *multiplier_label, *offset_label;

+ GtkAlignment *multiplier_spinbutton_aligner, *offset_spinbutton_aligner;

+ GtkAdjustment *multiplier_adjust, *offset_adjust;

+ GtkSpinButton *multiplier_spinbutton, *offset_spinbutton;

+

+ GtkLabel *limits_header;

+ GtkLabel *low_value_label, *high_value_label;

+ GtkAlignment *low_value_spinbutton_aligner, *high_value_spinbutton_aligner;

+ GtkAdjustment *low_value_adjust, *high_value_adjust;

+ GtkSpinButton *low_value_spinbutton, *high_value_spinbutton;

+

+ /* alarm widgets */

+ GtkLabel *alarm_header;

+ GtkLabel *low_alarm_command_label, *high_alarm_command_label, *alarm_timeout_label;

+ GtkAlignment *alarm_timeout_spinbutton_aligner;

+ GtkAdjustment *alarm_timeout_adjust;

+ GtkSpinButton *alarm_timeout_spinbutton;

+ GtkTable *table;

+ GtkAlignment *alarm_enable_aligner;

+ GtkCheckButton *alarm_enable_checkbutton;

+ GtkEntry *low_alarm_command_entry, *high_alarm_command_entry;

+

+ GtkSizeGroup *size_group;

+} SensorConfigDialog;

+

+static void sensor_config_dialog_response(GtkDialog *dialog,

+ gint response,

+ gpointer data) {

+ SensorConfigDialog *config_dialog;

+ GError *error = NULL;

+

+ config_dialog = (SensorConfigDialog *)data;

+

+ switch (response) {

+ case GTK_RESPONSE_HELP:

+ g_debug("loading help in config dialog");

+ gtk_show_uri(NULL,

+ "ghelp:sensors-applet?sensors-applet-sensors",

+ gtk_get_current_event_time(),

+ &error);

+

+ if (error) {

+ g_debug("Could not open help document: %s ",error->message);

+ g_error_free (error);

+ }

+ break;

+ default:

+ g_debug("destroying config dialog");

+ gtk_widget_destroy(GTK_WIDGET(dialog));

+ }

+}

+

+static void sensor_config_dialog_multiplier_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+ gdouble value;

+

+ value = gtk_spin_button_get_value(spinbutton);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ MULTIPLIER_COLUMN, value,

+ -1);

+

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_offset_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+ gdouble value;

+

+ value = gtk_spin_button_get_value(spinbutton);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ OFFSET_COLUMN, value,

+ -1);

+

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_low_value_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+ gdouble value;

+

+ value = gtk_spin_button_get_value(spinbutton);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ LOW_VALUE_COLUMN, value,

+ -1);

+

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_high_value_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+ gdouble value;

+

+ value = gtk_spin_button_get_value(spinbutton);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ HIGH_VALUE_COLUMN, value,

+ -1);

+

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_alarm_toggled(GtkToggleButton *button, SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+

+ gboolean value;

+ value = gtk_toggle_button_get_active(button);

+

+ /* update state of alarm widgets */

+ gtk_widget_set_sensitive(GTK_WIDGET(config_dialog->alarm_timeout_label), value);

+ gtk_widget_set_sensitive(GTK_WIDGET(config_dialog->alarm_timeout_spinbutton), value);

+ gtk_widget_set_sensitive(GTK_WIDGET(config_dialog->low_alarm_command_label), value);

+ gtk_widget_set_sensitive(GTK_WIDGET(config_dialog->low_alarm_command_entry), value);

+ gtk_widget_set_sensitive(GTK_WIDGET(config_dialog->high_alarm_command_label), value);

+ gtk_widget_set_sensitive(GTK_WIDGET(config_dialog->high_alarm_command_entry), value);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ ALARM_ENABLE_COLUMN, value,

+ -1);

+

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_alarm_timeout_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+ gint value;

+

+ value = gtk_spin_button_get_value_as_int(spinbutton);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+

+ sensors_applet_all_alarms_off(config_dialog->sensors_applet, path);

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ ALARM_TIMEOUT_COLUMN, value,

+ -1);

+

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_alarm_command_edited(GtkEntry *command_entry, SensorConfigDialog *config_dialog, NotifType notif_type) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+

+ gchar *value;

+ g_object_get(command_entry, "text", &value, NULL);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+

+ sensors_applet_alarm_off(config_dialog->sensors_applet, path, notif_type);

+

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ (notif_type == LOW_ALARM ?

+ LOW_ALARM_COMMAND_COLUMN : HIGH_ALARM_COMMAND_COLUMN),

+ value,

+ -1);

+ g_free(value);

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+static void sensor_config_dialog_low_alarm_command_edited(GtkEntry *command_entry, SensorConfigDialog *config_dialog) {

+ sensor_config_dialog_alarm_command_edited(command_entry,

+ config_dialog,

+ LOW_ALARM);

+}

+

+static void sensor_config_dialog_high_alarm_command_edited(GtkEntry *command_entry, SensorConfigDialog *config_dialog) {

+ sensor_config_dialog_alarm_command_edited(command_entry,

+ config_dialog,

+ HIGH_ALARM);

+}

+

+static void sensor_config_dialog_icon_type_changed(GtkComboBox *icon_type_combo_box,

+ SensorConfigDialog *config_dialog) {

+ GtkTreeModel *icons_model;

+ GtkTreeIter icons_iter;

+

+ GtkTreeModel *model;

+ GtkTreeIter iter;

+ GtkTreePath *path;

+

+ GdkPixbuf *new_icon;

+ IconType icon_type;

+

+ icons_model = gtk_combo_box_get_model(icon_type_combo_box);

+ if (gtk_combo_box_get_active_iter(icon_type_combo_box,

+ &icons_iter)) {

+

+ gtk_tree_model_get(icons_model, &icons_iter,

+ 0, &new_icon,

+ -1);

+

+ icon_type = gtk_combo_box_get_active(icon_type_combo_box);

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+

+ path = gtk_tree_model_get_path(model, &iter);

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ ICON_TYPE_COLUMN, icon_type,

+ ICON_PIXBUF_COLUMN, new_icon,

+ -1);

+ g_object_unref(new_icon);

+ sensors_applet_icon_changed(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+ }

+}

+

+static void sensor_config_dialog_graph_color_set(GtkColorButton *color_button,

+ SensorConfigDialog *config_dialog) {

+ GtkTreeModel *model;

+ GtkTreePath *path;

+ GtkTreeIter iter;

+ GdkColor color;

+ gchar *color_string;

+

+ gtk_color_button_get_color(color_button,

+ &color);

+

+ color_string = g_strdup_printf("#%02X%02X%02X", color.red / 256,

+ color.green / 256, color.blue / 256);

+

+ gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection,

+ &model,

+ &iter);

+

+ gtk_tree_store_set(config_dialog->sensors_applet->sensors,

+ &iter,

+ GRAPH_COLOR_COLUMN, color_string,

+ -1);

+

+ g_free(color_string);

+

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors),

+ &iter);

+ sensors_applet_update_sensor(config_dialog->sensors_applet, path);

+ gtk_tree_path_free(path);

+}

+

+void sensor_config_dialog_create(SensorsApplet *sensors_applet) {

+ GtkTreeModel *model;

+ GtkTreeIter iter;

+

+ SensorConfigDialog *config_dialog;

+

+ GtkListStore *icon_store;

+ IconType count;

+ GdkPixbuf *pixbuf;

+

+ GdkColor graph_color;

+ gchar *sensor_label;

+ gchar *header_text;

+

+ /* instance variables for data */

+ gdouble low_value, high_value, multiplier, offset;

+ gboolean alarm_enable;

+ gchar *low_alarm_command, *high_alarm_command;

+ gint alarm_timeout;

+ IconType icon_type;

+ gchar *graph_color_string;

+

+ config_dialog = g_new0(SensorConfigDialog, 1);

+ config_dialog->sensors_applet = sensors_applet;

+

+ gtk_tree_selection_get_selected(sensors_applet->selection,

+ &model,

+ &iter);

+ /* get current values of alarm and its enable */

+ gtk_tree_model_get(model, &iter,

+ LOW_VALUE_COLUMN, &low_value,

+ HIGH_VALUE_COLUMN, &high_value,

+ ALARM_ENABLE_COLUMN, &alarm_enable,

+ LOW_ALARM_COMMAND_COLUMN, &low_alarm_command,

+ HIGH_ALARM_COMMAND_COLUMN, &high_alarm_command,

+ ALARM_TIMEOUT_COLUMN, &alarm_timeout,

+ MULTIPLIER_COLUMN, &multiplier,

+ OFFSET_COLUMN, &offset,

+ ICON_TYPE_COLUMN, &icon_type,

+ GRAPH_COLOR_COLUMN, &graph_color_string,

+ LABEL_COLUMN, &sensor_label,

+ -1);

+ header_text = g_strdup_printf("%s - %s", _("Sensor Properties"), sensor_label);

+

+ config_dialog->dialog = gtk_dialog_new_with_buttons(header_text,

+ GTK_WINDOW(sensors_applet->prefs_dialog->dialog),

+ GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,

+ GTK_STOCK_HELP,

+ GTK_RESPONSE_HELP,

+ GTK_STOCK_CLOSE,

+ GTK_RESPONSE_CLOSE,

+ NULL);

+

+ g_free(header_text);

+ g_free(sensor_label);

+

+ g_object_set(config_dialog->dialog,

+ "border-width", 12,

+ NULL);

+

+ g_signal_connect(config_dialog->dialog,

+ "response",

+ G_CALLBACK(sensor_config_dialog_response),

+ config_dialog);

+

+

+ /* graph stuff */

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Graph"));

+ config_dialog->graph_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+

+ gdk_color_parse(graph_color_string,

+ &graph_color);

+

+ config_dialog->graph_color_button = GTK_COLOR_BUTTON(gtk_color_button_new_with_color(&graph_color));

+ config_dialog->graph_color_button_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->graph_color_button,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ gtk_color_button_set_title(config_dialog->graph_color_button, _("Graph Color"));

+

+ config_dialog->graph_color_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Graph _color"),

+ "mnemonic-widget", config_dialog->graph_color_button,

+ "use-underline", TRUE,

+ "xalign", 0.0,

+ NULL);

+

+ g_signal_connect(config_dialog->graph_color_button, "color-set",

+ G_CALLBACK(sensor_config_dialog_graph_color_set),

+ config_dialog);

+

+ /* icon stuff */

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Icon"));

+ config_dialog->icon_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+ /* icon type */

+ icon_store = gtk_list_store_new(1, GDK_TYPE_PIXBUF);

+

+ /* populate list with icons */

+ for (count = CPU_ICON; count < NUM_ICONS; count++) {

+ pixbuf = sensors_applet_load_icon(count);

+ if (pixbuf) {

+ gtk_list_store_insert(icon_store, &iter, count);

+ gtk_list_store_set(icon_store, &iter,

+ 0, pixbuf,

+ -1);

+ /* let list hold icons */

+ g_object_unref(pixbuf);

+ }

+ }

+

+ config_dialog->icon_type_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(icon_store)));

+

+ config_dialog->icon_type_combo_box_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->icon_type_combo_box,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ config_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();

+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(config_dialog->icon_type_combo_box),

+ GTK_CELL_RENDERER(config_dialog->icon_renderer),

+ FALSE);

+

+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(config_dialog->icon_type_combo_box),

+ GTK_CELL_RENDERER(config_dialog->icon_renderer),

+ "pixbuf", 0);

+

+ gtk_combo_box_set_active(config_dialog->icon_type_combo_box,

+ icon_type);

+

+ g_signal_connect(config_dialog->icon_type_combo_box, "changed",

+ G_CALLBACK(sensor_config_dialog_icon_type_changed),

+ config_dialog);

+

+

+

+ config_dialog->icon_type_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Sensor _icon"),

+ "mnemonic-widget", config_dialog->icon_type_combo_box,

+ "use-underline", TRUE,

+ "xalign", 0.0,

+ NULL);

+

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Scaling Parameters"));

+ config_dialog->scale_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+ /* do multiplier and offset widgets */

+ config_dialog->multiplier_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", 1.0,

+ "lower", 0.001,

+ "upper", 1000.0,

+ "step-increment", 0.1,

+ "page-increment", 1.0,

+ "page-size", 1.0,

+ NULL);

+

+

+ config_dialog->multiplier_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", config_dialog->multiplier_adjust,

+ "digits", VALUE_DECIMAL_PLACES,

+ "value", multiplier,

+ "width-chars", SPINBUTTON_WIDTH_CHARS,

+ NULL);

+

+ config_dialog->multiplier_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->multiplier_spinbutton,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ config_dialog->multiplier_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Sensor value _multiplier"),

+ "mnemonic-widget", config_dialog->multiplier_spinbutton,

+ "use-underline", TRUE,

+ "xalign", 0.0,

+ NULL);

+

+

+ g_signal_connect(config_dialog->multiplier_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_multiplier_changed), config_dialog);

+

+

+ config_dialog->offset_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", 0.0,

+ "lower", -1000.000,

+ "upper", 1000.000,

+ "step-increment", 0.01,

+ "page-increment", 1.0,

+ "page-size", 1.0,

+ NULL);

+

+ config_dialog->offset_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", config_dialog->offset_adjust,

+ "digits", VALUE_DECIMAL_PLACES,

+ "value", (gdouble)offset,

+ "width-chars", SPINBUTTON_WIDTH_CHARS,

+ NULL);

+

+ config_dialog->offset_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->offset_spinbutton,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ config_dialog->offset_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Sensor value _offset"),

+ "mnemonic-widget", config_dialog->offset_spinbutton,

+ "use-underline", TRUE,

+ "xalign", 0.0,

+ NULL);

+

+ g_signal_connect(config_dialog->offset_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_offset_changed), config_dialog);

+

+

+ /* now do alarm widgets */

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Sensor Limits"));

+ config_dialog->limits_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+ config_dialog->low_value_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", 0.0,

+ "lower", -100000.0,

+ "upper", 100000.0,

+ "step-increment", 1.0,

+ "page-increment", 10.0,

+ "page-size", 100.0,

+ NULL);

+

+

+ config_dialog->low_value_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", config_dialog->low_value_adjust,

+ "digits", VALUE_DECIMAL_PLACES,

+ "value", low_value,

+ "width-chars", SPINBUTTON_WIDTH_CHARS,

+

+ NULL);

+

+ config_dialog->low_value_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->low_value_spinbutton,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ config_dialog->low_value_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Sensor _low value"),

+ "mnemonic-widget", config_dialog->low_value_spinbutton,

+ "use-underline", TRUE,

+ "xalign", 0.0,

+

+ NULL);

+

+

+ g_signal_connect(config_dialog->low_value_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_low_value_changed), config_dialog);

+

+ config_dialog->high_value_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", 0.0,

+ "lower", -100000.0,

+ "upper", 100000.0,

+ "step-increment", 1.0,

+ "page-increment", 10.0,

+ "page-size", 100.0,

+ NULL);

+

+

+ config_dialog->high_value_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", config_dialog->high_value_adjust,

+ "digits", VALUE_DECIMAL_PLACES,

+ "value", high_value,

+ "width-chars", SPINBUTTON_WIDTH_CHARS,

+

+ NULL);

+

+ config_dialog->high_value_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->high_value_spinbutton,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ config_dialog->high_value_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Sensor _high value"),

+ "mnemonic-widget", config_dialog->high_value_spinbutton,

+ "use-underline", TRUE,

+ "xalign", 0.0,

+

+ NULL);

+

+

+ g_signal_connect(config_dialog->high_value_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_high_value_changed), config_dialog);

+

+

+ header_text = g_markup_printf_escaped("<b>%s</b>", _("Alarm"));

+ config_dialog->alarm_header = g_object_new(GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", header_text,

+ "xalign", 0.0,

+ NULL);

+ g_free(header_text);

+

+ config_dialog->alarm_timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,

+ "value", 0.0,

+ "lower", 0.0,

+ "upper", 10000.0,

+ "step-increment", 1.0,

+ "page-increment", 10.0,

+ "page-size", 100.0,

+ NULL);

+

+ config_dialog->alarm_timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,

+ "adjustment", config_dialog->alarm_timeout_adjust,

+ "digits", 0,

+ "value", (gdouble)alarm_timeout,

+ "width-chars", SPINBUTTON_WIDTH_CHARS,

+ "sensitive", alarm_enable,

+

+ NULL);

+ config_dialog->alarm_timeout_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->alarm_timeout_spinbutton,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ config_dialog->alarm_timeout_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("Alarm _repeat interval (secs)"),

+ "mnemonic-widget", config_dialog->alarm_timeout_spinbutton,

+

+ "use-underline", TRUE,

+ "xalign", 0.0,

+ "sensitive", alarm_enable,

+ NULL);

+

+ g_signal_connect(config_dialog->alarm_timeout_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_alarm_timeout_changed), config_dialog);

+

+ config_dialog->low_alarm_command_entry = g_object_new(GTK_TYPE_ENTRY,

+ "text", low_alarm_command,

+ "width-chars", 25,

+ "sensitive", alarm_enable,

+ NULL);

+

+ g_free(low_alarm_command);

+

+ config_dialog->low_alarm_command_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("Lo_w alarm command"),

+ "mnemonic-widget", config_dialog->low_alarm_command_entry,

+ "xalign", 0.0,

+ "sensitive", alarm_enable,

+

+ NULL);

+

+ g_signal_connect(config_dialog->low_alarm_command_entry,

+ "changed",

+ G_CALLBACK(sensor_config_dialog_low_alarm_command_edited),

+ config_dialog);

+

+ config_dialog->high_alarm_command_entry = g_object_new(GTK_TYPE_ENTRY,

+ "text", high_alarm_command,

+ "width-chars", 25,

+ "sensitive", alarm_enable,

+ NULL);

+

+ g_free(high_alarm_command);

+

+ config_dialog->high_alarm_command_label = g_object_new(GTK_TYPE_LABEL,

+ "use-underline", TRUE,

+ "label", _("Hi_gh alarm command"),

+ "mnemonic-widget", config_dialog->high_alarm_command_entry,

+ "xalign", 0.0,

+ "sensitive", alarm_enable,

+

+ NULL);

+

+ g_signal_connect(config_dialog->high_alarm_command_entry,

+ "changed",

+ G_CALLBACK(sensor_config_dialog_high_alarm_command_edited),

+ config_dialog);

+

+ config_dialog->alarm_enable_checkbutton = g_object_new(GTK_TYPE_CHECK_BUTTON,

+ "use-underline", TRUE,

+ "label", _("_Enable alarm"),

+ "active", alarm_enable,

+ "xalign", 0.0,

+ NULL);

+

+ config_dialog->alarm_enable_aligner = g_object_new(GTK_TYPE_ALIGNMENT,

+ "child", config_dialog->alarm_enable_checkbutton,

+ "xalign", 0.0,

+ "xscale", 0.0,

+ NULL);

+

+ g_signal_connect(config_dialog->alarm_enable_checkbutton, "toggled", G_CALLBACK(sensor_config_dialog_alarm_toggled), config_dialog);

+

+

+

+ config_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->multiplier_spinbutton));

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->offset_spinbutton));

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->low_value_spinbutton));

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->high_value_spinbutton));

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->alarm_timeout_spinbutton));

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->icon_type_combo_box));

+ gtk_size_group_add_widget(config_dialog->size_group,

+ GTK_WIDGET(config_dialog->graph_color_button));

+ g_object_unref(config_dialog->size_group);

+

+ config_dialog->table = g_object_new(GTK_TYPE_TABLE,

+ "column-spacing", 5,

+ "homogeneous", FALSE,

+ "n-columns", 3,

+ "n-rows", 15,

+ "row-spacing", 6,

+ "column-spacing", 12,

+ NULL);

+

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->scale_header),

+ 0, 2,

+ 0, 1);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->multiplier_label),

+ 1, 2,

+ 1, 2);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->multiplier_spinbutton_aligner),

+ 2, 3,

+ 1, 2);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->offset_label),

+ 1, 2,

+ 2, 3);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->offset_spinbutton_aligner),

+ 2, 3,

+ 2, 3);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->limits_header),

+ 0, 2,

+ 3, 4);

+

+ /* now pack alarm widgets */

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->low_value_label),

+ 1, 2,

+ 4, 5);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->low_value_spinbutton_aligner),

+ 2, 3,

+ 4, 5);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->high_value_label),

+ 1, 2,

+ 5, 6);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->high_value_spinbutton_aligner),

+ 2, 3,

+ 5, 6);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->alarm_header),

+ 0, 2,

+ 6, 7);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->alarm_enable_aligner),

+ 1, 2,

+ 7, 8);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->alarm_timeout_label),

+ 1, 2,

+ 8, 9);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->alarm_timeout_spinbutton_aligner),

+ 2, 3,

+ 8, 9);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->low_alarm_command_label),

+ 1, 2,

+ 9, 10);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->low_alarm_command_entry),

+ 2, 3,

+ 9, 10);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->high_alarm_command_label),

+ 1, 2,

+ 10, 11);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->high_alarm_command_entry),

+ 2, 3,

+ 10, 11);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->icon_header),

+ 0, 2,

+ 11, 12);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->icon_type_label),

+ 1, 2,

+ 12, 13);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->icon_type_combo_box_aligner),

+ 2, 3,

+ 12, 13);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->graph_header),

+ 0, 2,

+ 13, 14);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->graph_color_label),

+ 1, 2,

+ 14, 15);

+

+ gtk_table_attach_defaults(config_dialog->table,

+ GTK_WIDGET(config_dialog->graph_color_button_aligner),

+ 2, 3,

+ 14, 15);

+

+ gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(config_dialog->dialog)->vbox), GTK_WIDGET(config_dialog->table));

+ gtk_widget_show_all(config_dialog->dialog);

+

+}

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSOR_CONFIG_DIALOG_H

+#define SENSOR_CONFIG_DIALOG_H

+

+#include "sensors-applet.h"

+

+/* function definition */

+

+void sensor_config_dialog_create(SensorsApplet *sensors_applet);

+

+#endif /* SENSOR_CONFIG_DIALOG_H */

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#include "sensors-applet.h"

+#include "sensors-applet-gconf.h"

+

+#define DEFAULT_TIMEOUT 2000

+#define DEFAULT_GRAPH_SIZE 42

+

+static const gchar * const compatible_versions[] = {

+ PACKAGE_VERSION, /* always list current version */

+ "2.2.6",

+ "2.2.5",

+ "2.2.4",

+ "2.2.3",

+ "2.2.2",

+};

+

+#define NUM_COMPATIBLE_VERSIONS G_N_ELEMENTS(compatible_versions)

+

+typedef enum {

+ SENSORS_APPLET_GCONF_ERROR = 0,

+ SENSORS_APPLET_VERSION_ERROR,

+} SensorsAppletGConfError;

+

+static const gchar * const error_titles[] = {

+ N_("An error occurred loading the stored sensors data"),

+ N_("Incompatible sensors configuration found")

+};

+

+static const gchar * const error_messages[] = {

+ N_("An error has occurred when loading the stored sensors data. "

+ "The default values will be used to recover from this error."),

+

+ N_("Unfortunately the previous configuration for GNOME Sensors Applet "

+ "is not compatible with this version. The existing sensors data "

+ "will be overwritten with the default values for this new version.")

+};

+

+/* function to be called if an error occurs

+ when loading values from gconf */

+static void sensors_applet_gconf_error_occurred(SensorsAppletGConfError error) {

+ GtkWidget *dialog;

+ gchar *markup;

+

+ g_debug("Error occurred: %s", error_titles[error]);

+ markup = g_markup_printf_escaped("<span size=\"large\" weight=\"bold\">%s</span>\n\n%s", _(error_titles[error]), _(error_messages[error]));

+

+ dialog = gtk_message_dialog_new_with_markup(NULL, /* no parent window */

+ GTK_DIALOG_MODAL,

+ GTK_MESSAGE_WARNING,

+ GTK_BUTTONS_OK,

+ "%s", markup);

+

+ g_free(markup);

+

+ /* runs dialog as modal and doesn't return until user clicks

+ * button */

+ gtk_dialog_run(GTK_DIALOG(dialog));

+ gtk_widget_destroy(GTK_WIDGET(dialog));

+}

+

+

+static void sensors_applet_gconf_set_defaults(SensorsApplet *sensors_applet) {

+ panel_applet_gconf_set_int(sensors_applet->applet, DISPLAY_MODE, DISPLAY_ICON_WITH_VALUE, NULL);

+ panel_applet_gconf_set_int(sensors_applet->applet, LAYOUT_MODE, VALUE_BESIDE_LABEL, NULL);

+ panel_applet_gconf_set_int(sensors_applet->applet, TEMPERATURE_SCALE, CELSIUS, NULL);

+ panel_applet_gconf_set_int(sensors_applet->applet, TIMEOUT, DEFAULT_TIMEOUT, NULL);

+ panel_applet_gconf_set_int(sensors_applet->applet, GRAPH_SIZE, DEFAULT_GRAPH_SIZE, NULL);

+#ifdef HAVE_LIBNOTIFY

+ panel_applet_gconf_set_bool(sensors_applet->applet, DISPLAY_NOTIFICATIONS, TRUE, NULL);

+#endif

+ panel_applet_gconf_set_bool(sensors_applet->applet, IS_SETUP, FALSE, NULL);

+

+}

+

+/**

+ * Returns TRUE is old_version is one of the compatible versions

+ */

+static gboolean sensors_applet_gconf_is_compatible(const gchar *old_version) {

+ guint i;

+ for (i = 0; i < NUM_COMPATIBLE_VERSIONS; i++) {

+ if (g_ascii_strcasecmp(old_version, compatible_versions[i]) == 0) {

+ return TRUE;

+ }

+ }

+ return FALSE;

+}

+

+

+void sensors_applet_gconf_setup(SensorsApplet *sensors_applet) {

+ gboolean setup = FALSE;

+ gchar *old_version;

+ GError *error = NULL;

+

+ /* need to convert old num_samples value to new GRAPH_SIZE

+ * parameter */

+ gint num_samples;

+ if ((num_samples = panel_applet_gconf_get_int(sensors_applet->applet,

+ "num_samples",

+ NULL))) {

+ g_debug("Convering old num_samples value %d into graph_size", num_samples);

+ panel_applet_gconf_set_int(sensors_applet->applet,

+ GRAPH_SIZE,

+ (num_samples + GRAPH_FRAME_EXTRA_WIDTH),

+ NULL);

+ /* reset num_samples to zero */

+ panel_applet_gconf_set_int(sensors_applet->applet,

+ "num_samples",

+ 0,

+ NULL);

+

+ }

+

+ /* convert old alarm_commands to high and low if exist */

+ GSList *alarm_commands;

+ if ((alarm_commands = panel_applet_gconf_get_list(sensors_applet->applet,

+ "alarm_commands",

+ GCONF_VALUE_STRING,

+ NULL))) {

+

+ g_debug("Converting old alarm commands to new high and low commands");

+

+ panel_applet_gconf_set_list(sensors_applet->applet,

+ LOW_ALARM_COMMANDS,

+ GCONF_VALUE_STRING,

+ alarm_commands,

+ NULL);

+ panel_applet_gconf_set_list(sensors_applet->applet,

+ HIGH_ALARM_COMMANDS,

+ GCONF_VALUE_STRING,

+ alarm_commands,

+ NULL);

+ /* reset old list to null */

+ panel_applet_gconf_set_list(sensors_applet->applet,

+ "alarm_commands",

+ GCONF_VALUE_STRING,

+ NULL,

+ NULL);

+ g_slist_foreach(alarm_commands, (GFunc)g_free, NULL);

+ g_slist_free(alarm_commands);

+

+ }

+

+ setup = panel_applet_gconf_get_bool(sensors_applet->applet,

+ IS_SETUP, &error);

+ if (error) {

+ g_debug("Previous configuration not found: %s, setting up manually", error->message);

+ g_error_free(error);

+ error = NULL;

+ setup = FALSE;

+ }

+

+

+ if (setup) {

+ /* see if setup version matches */

+ old_version = panel_applet_gconf_get_string(sensors_applet->applet,

+ SENSORS_APPLET_VERSION,

+ &error);

+ /* if versions don't match or there is no saved

+ * version string then need to overwrite old config */

+ if (error) {

+ g_debug("Error getting old version string: %s", error->message);

+ g_error_free(error);

+ error = NULL;

+ old_version = NULL;

+ }

+

+ if (old_version) {

+ if (sensors_applet_gconf_is_compatible(old_version)) {

+ /* previously setup and versions match so use

+ * old values */

+ g_debug("GConf data is compatible. Trying to set up sensors from gconf data");

+ if (sensors_applet_gconf_setup_sensors(sensors_applet)) {

+ g_debug("done setting up from gconf");

+ } else {

+ g_debug("Setting gconf defaults only");

+ sensors_applet_gconf_set_defaults(sensors_applet);

+ }

+ g_free(old_version);

+

+ return;

+

+

+ }

+ g_free(old_version);

+

+ }

+ sensors_applet_notify(sensors_applet, GCONF_READ_ERROR);

+

+

+ sensors_applet_gconf_error_occurred(SENSORS_APPLET_VERSION_ERROR);

+ }

+

+ /* use defaults */

+ g_debug("Setting gconf defaults only");

+ sensors_applet_gconf_set_defaults(sensors_applet);

+}

+

+enum {

+ PATHS_INDEX = 0,

+ IDS_INDEX,

+ LABELS_INDEX,

+ INTERFACES_INDEX,

+ SENSOR_TYPES_INDEX,

+ ENABLES_INDEX,

+ LOW_VALUES_INDEX,

+ HIGH_VALUES_INDEX,

+ ALARM_ENABLES_INDEX,

+ LOW_ALARM_COMMANDS_INDEX,

+ HIGH_ALARM_COMMANDS_INDEX,

+ ALARM_TIMEOUTS_INDEX,

+ MULTIPLIERS_INDEX,

+ OFFSETS_INDEX,

+ ICON_TYPES_INDEX,

+ GRAPH_COLORS_INDEX,

+ NUM_KEYS

+};

+

+const gchar * const keys[NUM_KEYS] = {

+ PATHS,

+ IDS,

+ LABELS,

+ INTERFACES,

+ SENSOR_TYPES,

+ ENABLES,

+ LOW_VALUES,

+ HIGH_VALUES,

+ ALARM_ENABLES,

+ LOW_ALARM_COMMANDS,

+ HIGH_ALARM_COMMANDS,

+ ALARM_TIMEOUTS,

+ MULTIPLIERS,

+ OFFSETS,

+ ICON_TYPES,

+ GRAPH_COLORS,

+};

+

+/* MUST CORRESPOND TO ABOVE KEYS */

+const GConfValueType key_types[NUM_KEYS] = {

+ GCONF_VALUE_STRING, /* PATHS */

+ GCONF_VALUE_STRING, /* IDS, */

+ GCONF_VALUE_STRING, /* LABELS */

+ GCONF_VALUE_STRING, /* INTERFACES, */

+ GCONF_VALUE_INT, /* SENSOR_TYPES, */

+ GCONF_VALUE_BOOL, /* ENABLES, */

+ GCONF_VALUE_INT, /* LOW_VALUES, */

+ GCONF_VALUE_INT, /* HIGH_VALUES, */

+ GCONF_VALUE_BOOL, /* ALARM_ENABLES, */

+ GCONF_VALUE_STRING, /* LOW_ALARM_COMMANDS, */

+ GCONF_VALUE_STRING, /* HIGH_ALARM_COMMANDS, */

+ GCONF_VALUE_INT, /* ALARM_TIMEOUTS, */

+ GCONF_VALUE_INT, /* MULTIPLIERS, */

+ GCONF_VALUE_INT, /* OFFSETS, */

+ GCONF_VALUE_INT, /* ICON_TYPES, */

+ GCONF_VALUE_STRING /* GRAPH_COLORS, */

+};

+

+void sensors_applet_gconf_set_current_to_lists(GSList *current[],

+ GSList *lists[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ current[len] = lists[len];

+ }

+}

+

+int sensors_applet_gconf_current_not_null(GSList *current[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ if (NULL == current[len]) {

+ return FALSE;

+ }

+ }

+ return TRUE;

+}

+void sensors_applet_gconf_current_get_next(GSList *current[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ current[len] = g_slist_next(current[len]);

+ }

+}

+

+void sensors_applet_gconf_free_lists(GSList *lists[],

+ int len) {

+ for (len--; len >= 0; len--) {

+ if (key_types[len] == GCONF_VALUE_STRING) {

+ g_slist_foreach(lists[len], (GFunc)g_free, NULL);

+ }

+ g_slist_free(lists[len]);

+ }

+

+}

+

+/* gets called if are already setup so we don't have to manually go

+ through and find sensors etc again */

+gboolean sensors_applet_gconf_setup_sensors(SensorsApplet *sensors_applet) {

+ /* everything gets stored except alarm timeout indexes, which

+ we set to -1, and visible which we set to false for all

+ parent nodes and true for all child nodes */

+ int i;

+ GSList *lists[NUM_KEYS] = {NULL};

+

+ GSList *current[NUM_KEYS] = {NULL};

+

+ GError *error = NULL;

+

+ for (i = 0; i < NUM_KEYS; i++) {

+ lists[i] = panel_applet_gconf_get_list(sensors_applet->applet,

+ keys[i],

+ key_types[i],

+ &error);

+ if (error || NULL == lists[i]) {

+ sensors_applet_notify(sensors_applet, GCONF_READ_ERROR);

+

+ sensors_applet_gconf_error_occurred(SENSORS_APPLET_GCONF_ERROR);

+ if (error) {

+ g_error_free(error);

+ }

+ return FALSE;

+ }

+ }

+

+ for (sensors_applet_gconf_set_current_to_lists(current,

+ lists,

+ NUM_KEYS);

+ sensors_applet_gconf_current_not_null(current,

+ NUM_KEYS);

+ sensors_applet_gconf_current_get_next(current,

+ NUM_KEYS)) {

+

+

+ g_debug("trying to add sensor from gconf data: %s\n", (gchar *)(current[IDS_INDEX]->data));

+ /* need to ensure correct order */

+ sensors_applet_add_sensor(sensors_applet,

+ (gchar *)(current[PATHS_INDEX]->data),

+ (gchar *)(current[IDS_INDEX]->data),

+ (gchar *)(current[LABELS_INDEX]->data),

+ (gchar *)(current[INTERFACES_INDEX]->data),

+ GPOINTER_TO_UINT(current[SENSOR_TYPES_INDEX]->data),

+ GPOINTER_TO_INT(current[ENABLES_INDEX]->data),

+ (gdouble)(GPOINTER_TO_INT(current[LOW_VALUES_INDEX]->data) / 1000.0),

+ (gdouble)(GPOINTER_TO_INT(current[HIGH_VALUES_INDEX]->data) / 1000.0),

+ GPOINTER_TO_INT(current[ALARM_ENABLES_INDEX]->data),

+ (gchar *)(current[LOW_ALARM_COMMANDS_INDEX]->data),

+ (gchar *)(current[HIGH_ALARM_COMMANDS_INDEX]->data),

+ GPOINTER_TO_INT(current[ALARM_TIMEOUTS_INDEX]->data),

+ (gdouble)(GPOINTER_TO_INT(current[MULTIPLIERS_INDEX]->data) / 1000.0),

+ (gdouble)(GPOINTER_TO_INT(current[OFFSETS_INDEX]->data) / 1000.0),

+ (SensorType)GPOINTER_TO_UINT(current[ICON_TYPES_INDEX]->data),

+ (gchar *)(current[GRAPH_COLORS_INDEX]->data)

+

+ );

+

+ }

+ sensors_applet_gconf_free_lists(lists,

+ NUM_KEYS);

+

+ return TRUE;

+}

+

+

+gboolean sensors_applet_gconf_save_sensors(SensorsApplet *sensors_applet) {

+ /* write everything to gconf except VISIBLE and

+ ALARM_TIMEOUT_INDEX */

+ /* for stepping through GtkTreeStore data structure */

+ GtkTreeIter interfaces_iter, sensors_iter;

+ gboolean not_end_of_interfaces = TRUE, not_end_of_sensors = TRUE;

+

+ /* make sure all are initialized to null - since list of

+ * intializers is horter than number of element, rest get set

+ * to 0 (ie NULL) */

+ GSList *lists[NUM_KEYS] = {NULL};

+ int i;

+ gchar *current_path, *current_id, *current_label, *current_interface,

+ *current_low_alarm_command, *current_high_alarm_command,

+ *current_graph_color;

+ gboolean current_enable, current_alarm_enable;

+ gdouble current_low_value, current_high_value, current_multiplier,

+ current_offset;

+ guint current_alarm_timeout, current_sensor_type,

+ current_icon_type;

+

+ GError *error = NULL;

+

+ /* now step through the GtkTreeStore sensors to

+ find which sensors are enabled */

+ for (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter); not_end_of_interfaces; not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) {

+ // store a gconf key for this interface

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &interfaces_iter,

+ ID_COLUMN, &current_id,

+ -1);

+

+ panel_applet_gconf_set_bool(sensors_applet->applet, current_id, TRUE, NULL);

+ g_free(current_id);

+

+ /* reset sensors sentinel */

+ not_end_of_sensors = TRUE;

+

+ for (gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, &interfaces_iter); not_end_of_sensors; not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &sensors_iter,

+ PATH_COLUMN, &current_path,

+ ID_COLUMN, &current_id,

+ LABEL_COLUMN, &current_label,

+ INTERFACE_COLUMN, &current_interface,

+ SENSOR_TYPE_COLUMN, &current_sensor_type,

+ ENABLE_COLUMN, &current_enable,

+ LOW_VALUE_COLUMN, &current_low_value,

+ HIGH_VALUE_COLUMN, &current_high_value,

+ ALARM_ENABLE_COLUMN, &current_alarm_enable,

+ LOW_ALARM_COMMAND_COLUMN, &current_low_alarm_command,

+ HIGH_ALARM_COMMAND_COLUMN, &current_high_alarm_command,

+ ALARM_TIMEOUT_COLUMN, &current_alarm_timeout,

+ MULTIPLIER_COLUMN, &current_multiplier,

+ OFFSET_COLUMN, &current_offset,

+ ICON_TYPE_COLUMN, &current_icon_type,

+ GRAPH_COLOR_COLUMN, &current_graph_color,

+ -1);

+

+ /* prepend values as this is faster then just

+ reverse list when finished */

+ lists[PATHS_INDEX] = g_slist_prepend(lists[PATHS_INDEX], current_path);

+ lists[IDS_INDEX] = g_slist_prepend(lists[IDS_INDEX], current_id);

+ lists[LABELS_INDEX] = g_slist_prepend(lists[LABELS_INDEX], current_label);

+ lists[INTERFACES_INDEX] = g_slist_prepend(lists[INTERFACES_INDEX], current_interface);

+ lists[ENABLES_INDEX] = g_slist_prepend(lists[ENABLES_INDEX], GINT_TO_POINTER(current_enable));

+ lists[LOW_VALUES_INDEX] = g_slist_prepend(lists[LOW_VALUES_INDEX], GINT_TO_POINTER((gint)(current_low_value * 1000)));

+ lists[HIGH_VALUES_INDEX] = g_slist_prepend(lists[HIGH_VALUES_INDEX], GINT_TO_POINTER((gint)(current_high_value * 1000)));

+ lists[ALARM_ENABLES_INDEX] = g_slist_prepend(lists[ALARM_ENABLES_INDEX], GINT_TO_POINTER(current_alarm_enable));

+ lists[LOW_ALARM_COMMANDS_INDEX] = g_slist_prepend(lists[LOW_ALARM_COMMANDS_INDEX], current_low_alarm_command);

+ lists[HIGH_ALARM_COMMANDS_INDEX] = g_slist_prepend(lists[HIGH_ALARM_COMMANDS_INDEX], current_high_alarm_command);

+ lists[ALARM_TIMEOUTS_INDEX] = g_slist_prepend(lists[ALARM_TIMEOUTS_INDEX], GINT_TO_POINTER(current_alarm_timeout));

+ lists[SENSOR_TYPES_INDEX] = g_slist_prepend(lists[SENSOR_TYPES_INDEX], GUINT_TO_POINTER(current_sensor_type));

+ lists[MULTIPLIERS_INDEX] = g_slist_prepend(lists[MULTIPLIERS_INDEX], GINT_TO_POINTER((gint)(current_multiplier * 1000)));

+ lists[OFFSETS_INDEX] = g_slist_prepend(lists[OFFSETS_INDEX], GINT_TO_POINTER((gint)(current_offset * 1000)));

+ lists[ICON_TYPES_INDEX] = g_slist_prepend(lists[ICON_TYPES_INDEX], GUINT_TO_POINTER(current_icon_type));

+ lists[GRAPH_COLORS_INDEX] = g_slist_prepend(lists[GRAPH_COLORS_INDEX], current_graph_color);

+ }

+ }

+

+ /* keep lists in original order */

+ for (i = 0; i < NUM_KEYS; i++) {

+ if (lists[i] != NULL) {

+ lists[i] = g_slist_reverse(lists[i]);

+

+ panel_applet_gconf_set_list(sensors_applet->applet,

+ keys[i],

+ key_types[i],

+ lists[i], &error);

+ if (error) {

+ sensors_applet_notify(sensors_applet, GCONF_WRITE_ERROR);

+

+ g_error_free(error);

+ return FALSE;

+ }

+ } else {

+ g_debug("list %s is NULL", keys[i]);

+ }

+

+ }

+

+ sensors_applet_gconf_free_lists(lists,

+ NUM_KEYS);

+

+ /* store current version to identify config data */

+ panel_applet_gconf_set_string(sensors_applet->applet,

+ SENSORS_APPLET_VERSION,

+ PACKAGE_VERSION, &error);

+

+ return TRUE;

+}

+

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSORS_APPLET_GCONF_H

+#define SENSORS_APPLET_GCONF_H

+

+#include "sensors-applet.h"

+#include <panel-applet-gconf.h>

+

+#define FONT_SIZE "font-size" /* hidden gconf option specifying font

+ * size in points */

+

+#define HIDE_UNITS "hide-units" /* hidden gconf option specifying not to

+ * show sensor units */

+

+#define IS_SETUP "setup" /* have we actually set up this instance of

+ * the applet (gets set to true after

+ * closing prefences dialog) */

+

+#define DISPLAY_MODE "display_mode" /* display icons or text labels?*/

+

+#define LAYOUT_MODE "layout_mode" /* value beside or below label */

+#define TEMPERATURE_SCALE "temperature_scale" /* Kelvin,

+ Celsius or

+ Fahrenheit */

+#define DISPLAY_NOTIFICATIONS "display_notifications" /* whether to

+ * display

+ * notifications */

+#define TIMEOUT "timeout_delay" /* delay (in ms) between refreshes */

+#define GRAPH_SIZE "graph_size" /* the size of the graph in pixels -

+ * either width if horizontal, or

+ * height if vertical */

+#define PATHS "paths" /* full paths to filenames */

+#define IDS "ids" /* a list of the sensor device ids */

+#define INTERFACES "interfaces" /* a list of the sensor device

+ * interface for each sensor */

+#define LABELS "labels" /* user defined labels for each sensor */

+#define ENABLES "sensor_enables" /* list of booleans corresponding to

+ * the filenames of whether a sensor

+ * is enabled or not */

+#define LOW_VALUES "low_values" /* stored as ints (1000 * double

+ * value) for accuracy, since can

+ * only do ints easily */

+#define HIGH_VALUES "high_values" /* stored as ints (1000 * double

+ * value) for accuracy, since can

+ * only do ints easily */

+#define ALARM_ENABLES "alarm_enables" /* list of whether each sensor

+ * has its alarm enabled */

+#define LOW_ALARM_COMMANDS "low_alarm_commands" /* list of commands to execute

+ * when each alarm is

+ * activated */

+#define HIGH_ALARM_COMMANDS "high_alarm_commands" /* list of commands to execute

+ * when each alarm is

+ * activated */

+

+#define ALARM_TIMEOUTS "alarm_timeouts" /* list of how often each

+ alarm should be sounded (in

+ seconds) */

+

+#define SENSOR_TYPES "sensor_types" /* used to identify a sensor in a

+ list */

+

+#define MULTIPLIERS "multipliers"

+#define OFFSETS "offsets"

+#define ICON_TYPES "icon_types"

+#define GRAPH_COLORS "graph_colors"

+

+#define SENSORS_APPLET_VERSION "sensors_applet_version" /* version of

+ * config

+ * data */

+

+gboolean sensors_applet_gconf_save_sensors(SensorsApplet *sensors_applet);

+gboolean sensors_applet_gconf_setup_sensors(SensorsApplet *sensors_applet);

+void sensors_applet_gconf_setup(SensorsApplet *sensors_applet);

+

+#endif /* SENSORS_APPLET_GCONF_H*/

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSORS_APPLET_PLUGIN_H

+#define SENSORS_APPLET_PLUGIN_H

+

+#include <sensors-applet/sensors-applet-sensor.h>

+

+GQuark sensors_applet_plugin_error_quark(void);

+

+/* for error handling */

+#define SENSORS_APPLET_PLUGIN_ERROR (sensors_applet_plugin_error_quark())

+

+

+/**

+ * Initialises the plugin, and returns the list of SensorsAppletSensorInfo

+ * structs to create the sensors for this plugin from

+ */

+GList *sensors_applet_plugin_init(void);

+gdouble sensors_applet_plugin_get_sensor_value(const gchar *path,

+ const gchar *id,

+ SensorType type,

+ GError **error);

+

+typedef void SensorsAppletPluginTestSensorFunc(GList **sensors,

+ const gchar *path);

+void sensors_applet_plugin_find_sensors(GList **sensors,

+ const gchar *path,

+ SensorsAppletPluginTestSensorFunc);

+

+void sensors_applet_plugin_default_sensor_limits(SensorType type,

+ gdouble *low_value,

+ gdouble *high_value);

+

+void sensors_applet_plugin_add_sensor(GList **sensors,

+ const gchar *path,

+ const gchar *id,

+ const gchar *label,

+ SensorType type,

+ gboolean enable,

+ IconType icon,

+ const gchar *graph_color);

+

+

+void sensors_applet_plugin_add_sensor_with_limits(GList **sensors,

+ const gchar *path,

+ const gchar *id,

+ const gchar *label,

+ SensorType type,

+ gboolean enable,

+ gdouble low_value,

+ gdouble high_value,

+ IconType icon,

+ const gchar *graph_color);

+

+

+#endif // SENSORS_APPLET_PLUGIN_H

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#ifdef HAVE_DLFCN_H

+#include <dlfcn.h>

+#endif /* HAVE_DLFCN_H */

+

+#include "sensors-applet-plugins.h"

+#include "sensors-applet-sensor.h"

+

+#define SENSORS_APPLET_USER_PLUGIN_DIR ".gnome2/sensors-applet/plugins"

+

+static void load_all_plugins(SensorsApplet *sensors_applet,

+ const gchar *path)

+{

+ if (g_file_test(path,

+ G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {

+ GDir *dir;

+ if ((dir = g_dir_open(path, 0, NULL)) != NULL) {

+ const gchar *file;

+ while ((file = g_dir_read_name(dir)) != NULL) {

+ // try and open plugin

+ gchar *plugin_file;

+ void *handle;

+ SensorsAppletPluginName name_fn;

+ SensorsAppletPluginInit init_fn;

+ SensorsAppletPluginGetSensorValue get_value_fn;

+

+ plugin_file = g_strdup_printf("%s/%s", path, file);

+ g_debug("found %s in plugin directory", plugin_file);

+ if ((handle = dlopen(plugin_file, RTLD_NOW)) != NULL) {

+

+ if ((name_fn = dlsym(handle, "sensors_applet_plugin_name")) != NULL &&

+ (init_fn = dlsym(handle, "sensors_applet_plugin_init")) != NULL &&

+ (get_value_fn = dlsym(handle, "sensors_applet_plugin_get_sensor_value")) != NULL) {

+ GList *sensors;

+ g_debug("calling init function for plugin file %s", plugin_file);

+

+ if ((sensors = init_fn()) != NULL) {

+ GList *sensor;

+

+ g_debug("registering plugin %s", name_fn());

+ g_hash_table_insert(sensors_applet->plugins,

+ g_strdup(name_fn()),

+ get_value_fn);

+ for (sensor = g_list_first(sensors);

+ sensor != NULL;

+ sensor = g_list_next(sensor)) {

+ SensorsAppletSensorInfo *sensor_info = (SensorsAppletSensorInfo *)sensor->data;

+ sensors_applet_add_sensor(sensors_applet,

+ sensor_info->path,

+ sensor_info->id,

+ sensor_info->label,

+ name_fn(),

+ sensor_info->type,

+ sensor_info->enable,

+ sensor_info->low_value,

+ sensor_info->high_value,

+ FALSE, // ALARM OFF

+ "", // no alarm commands

+ "", // no alarm commands

+ 0, // alarm_timeout

+ sensor_info->multiplier,

+ sensor_info->offset,

+ sensor_info->icon,

+ sensor_info->graph_color);

+

+ g_free(sensor_info->path);

+ g_free(sensor_info->id);

+ g_free(sensor_info->label);

+ g_free(sensor_info->graph_color);

+ g_free(sensor_info);

+ }

+ g_list_free(sensors);

+ } else {

+ g_debug("plugin could not find any sensors");

+ if (g_hash_table_lookup(sensors_applet->required_plugins,

+ name_fn()))

+ {

+ g_debug("plugin is required - registering even though no sensors detected");

+ g_debug("registering plugin %s", name_fn());

+ g_hash_table_insert(sensors_applet->plugins,

+ g_strdup(name_fn()),

+ get_value_fn);

+ } else {

+ g_debug("unloading plugin");

+ }

+ }

+

+

+

+ } else {

+ g_debug("plugin file %s does not contain the required interface", plugin_file);

+ if (dlclose(handle) != 0) {

+ g_debug("error closing plugin file %s", plugin_file);

+ }

+ }

+ } else {

+ g_debug("Could not dlopen: %s: %s", plugin_file, dlerror());

+ }

+ g_free(plugin_file);

+ }

+ g_dir_close(dir);

+ } else {

+ g_debug("error opening plugin dir %s", path);

+ }

+ } else {

+ g_debug("path %s is not a valid directory", path);

+ }

+}

+

+void sensors_applet_plugins_load_all(SensorsApplet *sensors_applet)

+{

+ const gchar *home;

+

+ if ((home = g_get_home_dir()) != NULL) {

+ gchar *path;

+ path = g_build_filename(home,

+ SENSORS_APPLET_USER_PLUGIN_DIR,

+ NULL);

+ load_all_plugins(sensors_applet, path);

+ g_free(path);

+ } else {

+ g_warning("could not get home dir of user");

+ }

+

+

+ load_all_plugins(sensors_applet, SENSORS_APPLET_PLUGIN_DIR);

+}

+

+SensorsAppletPluginGetSensorValue sensors_applet_plugins_get_sensor_value_func(SensorsApplet *sensors_applet,

+ const gchar *plugin)

+{

+ return g_hash_table_lookup(sensors_applet->plugins,

+ plugin);

+}

+

+

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSORS_APPLET_PLUGINS_H

+#define SENSORS_APPLET_PLUGINS_H

+

+#include "sensors-applet.h"

+

+typedef const gchar *(*SensorsAppletPluginName)(void);

+typedef GList *(*SensorsAppletPluginInit)(void);

+typedef gdouble (*SensorsAppletPluginGetSensorValue)(const gchar *path,

+ const gchar *id,

+ SensorType type,

+ GError **error);

+

+void sensors_applet_plugins_load_all(SensorsApplet *sensors_applet);

+void sensors_applet_plugins_unload_all(SensorsApplet *sensors_applet);

+SensorsAppletPluginGetSensorValue sensors_applet_plugins_get_sensor_value_func(SensorsApplet *sensors_applet,

+ const gchar *plugin);

+

+#endif // SENSORS_APPLET_PLUGINS_H

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSORS_APPLET_SENSOR_H

+#define SENSORS_APPLET_SENSOR_H

+

+#include <glib.h>

+

+// forward declare for plugins to use

+typedef struct _SensorsApplet SensorsApplet;

+

+#define DEFAULT_GRAPH_COLOR "#ff0000"

+

+/* device icons */

+typedef enum {

+ CPU_ICON = 0,

+ HDD_ICON,

+ BATTERY_ICON,

+ MEMORY_ICON,

+ GPU_ICON,

+ GENERIC_ICON,

+ FAN_ICON,

+ CASE_ICON,

+ NUM_ICONS,

+} IconType;

+

+typedef enum {

+ CURRENT_SENSOR = 0,

+ FAN_SENSOR,

+ TEMP_SENSOR,

+ VOLTAGE_SENSOR

+} SensorType;

+

+typedef struct _SensorsAppletSensorInfo {

+ gchar *path; // must be dynamically allocated

+ gchar *id; // must be dynamically allocated

+ gchar *label; // must be dynamically allocated

+ SensorType type;

+ gboolean enable;

+ gdouble low_value;

+ gdouble high_value;

+ gdouble multiplier;

+ gdouble offset;

+ IconType icon;

+ gchar *graph_color; // must be dynamically allocated

+} SensorsAppletSensorInfo;

+

+

+#endif // SENSORS_APPLET_SENSOR_H

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+/** Contain the functions for operating on the SensorsApplet structure

+ * (represents the applet itself, and its associated variables.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif /* HAVE_UNISTD_H */

+

+#include <gnome.h>

+#include <glib/gprintf.h>

+#include "sensors-applet.h"

+#include "active-sensor.h"

+#include "sensors-applet-gconf.h"

+#include "sensors-applet-plugins.h"

+

+#ifdef HAVE_LIBNOTIFY

+#include "active-sensor-libnotify.h"

+#define DEFAULT_NOTIFY_TIMEOUT 3000

+#endif

+

+#include "prefs-dialog.h"

+#include "about-dialog.h"

+

+#define SENSORS_APPLET_MENU_FILE "SensorsApplet.xml"

+#define DEFAULT_APPLET_SIZE 24 /* initially set as

+ * sensors_applet->size to ensure a

+ * real value is stored */

+#define COLUMN_SPACING 2

+#define ROW_SPACING 0

+

+/* callbacks for panel menu */

+static void prefs_cb(BonoboUIComponent *uic,

+ gpointer *data,

+ const gchar *verbname) {

+

+ SensorsApplet *sensors_applet;

+ sensors_applet = (SensorsApplet *)data;

+

+ if (sensors_applet->prefs_dialog) {

+ gtk_window_present(GTK_WINDOW(sensors_applet->prefs_dialog->dialog));

+ return;

+ }

+ prefs_dialog_open(sensors_applet);

+}

+

+static void about_cb(BonoboUIComponent *uic,

+ gpointer data,

+ const gchar *verbname) {

+ SensorsApplet *sensors_applet;

+ sensors_applet = (SensorsApplet *)data;

+

+ about_dialog_open(sensors_applet);

+}

+

+static void help_cb(BonoboUIComponent *uic,

+ gpointer data,

+ const gchar *verbname) {

+

+ GError *error = NULL;

+

+ gtk_show_uri(NULL, "ghelp:sensors-applet",

+ gtk_get_current_event_time(),

+ &error);

+

+ if (error) {

+ g_debug("Could not open help document: %s ",error->message);

+ g_error_free(error);

+ }

+}

+

+static void destroy_cb(GtkWidget *widget, gpointer data) {

+ SensorsApplet *sensors_applet;

+ sensors_applet = (SensorsApplet *)data;

+

+ /* destory dialogs, remove timeout and clear sensors tree and finally

+ * the applet */

+ if (sensors_applet->prefs_dialog != NULL) {

+ // destroy's dialog too

+ prefs_dialog_close(sensors_applet);

+ }

+

+ if (sensors_applet->timeout_id) {

+ g_source_remove(sensors_applet->timeout_id);

+ }

+

+ // destroy all active sensors

+ g_list_foreach(sensors_applet->active_sensors,

+ (GFunc)active_sensor_destroy,

+ NULL);

+

+ if (sensors_applet->sensors != NULL) {

+ gtk_tree_store_clear(sensors_applet->sensors);

+ }

+

+ gtk_widget_destroy(GTK_WIDGET(sensors_applet->applet));

+

+ g_free(sensors_applet);

+ return;

+}

+

+static void change_background_cb(PanelApplet *applet,

+ PanelAppletBackgroundType type,

+ GdkColor *color,

+ GdkPixmap *pixmap,

+ gpointer *data) {

+ GtkRcStyle *rc_style;

+ GtkStyle *style;

+

+ g_debug("change-background occurred");

+

+ /* reset style */

+ gtk_widget_set_style(GTK_WIDGET(applet), NULL);

+ rc_style = gtk_rc_style_new();

+ gtk_widget_modify_style(GTK_WIDGET(applet), rc_style);

+ gtk_rc_style_unref(rc_style);

+

+ switch(type) {

+ case PANEL_COLOR_BACKGROUND:

+ gtk_widget_modify_bg(GTK_WIDGET(applet),

+ GTK_STATE_NORMAL, color);

+ break;

+

+ case PANEL_PIXMAP_BACKGROUND:

+ style = gtk_style_copy(GTK_WIDGET(applet)->style);

+ if (style->bg_pixmap[GTK_STATE_NORMAL]) {

+ g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]);

+ }

+ style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);

+ gtk_widget_set_style(GTK_WIDGET(applet), style);

+ g_object_unref(style);

+ break;

+

+ case PANEL_NO_BACKGROUND:

+ /* fall through */

+ default:

+ break;

+ }

+}

+

+static void change_orient_cb (PanelApplet *applet,

+ PanelAppletOrient orient,

+ gpointer data) {

+ SensorsApplet *sensors_applet;

+ sensors_applet = (SensorsApplet *)data;

+

+ sensors_applet_display_layout_changed(sensors_applet);

+}

+

+static void size_allocate_cb(PanelApplet *applet,

+ GtkAllocation *allocation,

+ gpointer data) {

+ SensorsApplet *sensors_applet;

+ PanelAppletOrient orient;

+

+ g_debug("size-allocate occurred");

+ sensors_applet = (SensorsApplet *)data;

+ orient = panel_applet_get_orient(sensors_applet->applet);

+

+ if ((orient == PANEL_APPLET_ORIENT_LEFT) ||

+ (orient == PANEL_APPLET_ORIENT_RIGHT)) {

+ if (sensors_applet->size == allocation->width)

+ return;

+ sensors_applet->size = allocation->width;

+ } else {

+ if (sensors_applet->size == allocation->height)

+ return;

+ sensors_applet->size = allocation->height;

+ }

+ /* update if new value */

+ sensors_applet_graph_size_changed(sensors_applet);

+ sensors_applet_display_layout_changed(sensors_applet);

+}

+

+static void style_set_cb(GtkWidget *widget,

+ GtkStyle *old_style,

+ gpointer data) {

+

+ /* update all icons in the sensors tree and update all active

+ * sensors */

+ GtkTreeIter interfaces_iter, sensors_iter;

+ GtkTreePath *path;

+ gboolean not_end_of_interfaces = TRUE, not_end_of_sensors = TRUE;

+ IconType icon_type;

+ GdkPixbuf *new_icon;

+ gboolean enabled;

+ SensorsApplet *sensors_applet;

+ DisplayMode display_mode;

+

+ sensors_applet = (SensorsApplet *)data;

+

+ g_debug("set-style occurred");

+

+ display_mode = panel_applet_gconf_get_int(sensors_applet->applet,

+ DISPLAY_MODE,

+ NULL);

+ if (sensors_applet->sensors) {

+ for (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter); not_end_of_interfaces; not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) {

+

+ /* reset sensors sentinel */

+ not_end_of_sensors = TRUE;

+

+ for (gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, &interfaces_iter); not_end_of_sensors; not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),

+ &sensors_iter,

+ ENABLE_COLUMN, &enabled,

+ ICON_TYPE_COLUMN, &icon_type,

+ -1);

+ /* update icons */

+ new_icon = sensors_applet_load_icon(icon_type);

+

+ gtk_tree_store_set(sensors_applet->sensors,

+ &sensors_iter,

+ ICON_PIXBUF_COLUMN, new_icon,

+ -1);

+ g_object_unref(new_icon);

+

+ /* update icons only if currently being

+ * displayed */

+ if (enabled &&

+ (display_mode == DISPLAY_ICON ||

+ display_mode == DISPLAY_ICON_WITH_VALUE)) {

+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(sensors_applet->sensors),

+ &sensors_iter);

+ sensors_applet_icon_changed(sensors_applet,

+ path);

+ gtk_tree_path_free(path);

+ }

+ }

+ }

+ /* now update layout as size may have changed */

+ sensors_applet_display_layout_changed(sensors_applet);

+ }

+

+}

+

+static const BonoboUIVerb sensors_applet_menu_verbs[] = {

+ BONOBO_UI_UNSAFE_VERB("Preferences", prefs_cb),

+ BONOBO_UI_UNSAFE_VERB ("Help", help_cb),

+ BONOBO_UI_UNSAFE_VERB("About", about_cb),

+ BONOBO_UI_VERB_END

+};

+

+#ifdef HAVE_LIBNOTIFY

+static void notif_closed_cb(NotifyNotification *notification,

+ SensorsApplet *sensors_applet)

+{

+ g_assert(sensors_applet);

+

+ sensors_applet->notification = NULL;

+}

+#endif // HAVE_LIBNOTIFY

+

+void sensors_applet_notify(SensorsApplet *sensors_applet,

+ NotifType notif_type)

+{

+#ifdef HAVE_LIBNOTIFY

+ gchar *message;

+ gchar *summary;

+ GError *error = NULL;

+ g_assert(sensors_applet);

+

+ if (!notify_is_initted()) {

+ if (!notify_init(PACKAGE)) {

+ return;

+ }

+ }

+

+ if (sensors_applet->notification) {

+ g_debug("notification already shown, not showing another one...");

+ return;

+ }

+

+ switch (notif_type) {

+ case GCONF_READ_ERROR:

+ summary = g_strdup_printf(_("Error restoring saved sensor configuration."));

+ message = g_strdup_printf(_("An error occurred while trying to restore the saved sensor configuration. The previous configuration has been lost and will need to be re-entered."));

+ break;

+

+ case GCONF_WRITE_ERROR:

+ summary = g_strdup_printf(_("Error saving sensor configuration."));

+ message = g_strdup_printf(_("An error occurred while trying to save the current sensor configuration. "));

+ break;

+ }

+

+ sensors_applet->notification = notify_notification_new(summary,

+ message,

+ GTK_STOCK_DIALOG_WARNING,

+ GTK_WIDGET(sensors_applet->applet));

+ g_free(summary);

+ g_free(message);

+

+ g_signal_connect(sensors_applet->notification,

+ "closed",

+ G_CALLBACK(notif_closed_cb),

+ sensors_applet);

+ g_debug("showing notification");

+ if (!notify_notification_show(sensors_applet->notification, &error)) {

+ g_debug("Error showing notification: %s", error->message);

+ g_error_free(error);

+ }

+#endif // HAVE_LIBNOTIFY

+}

+

+

+void sensors_applet_notify_active_sensor(ActiveSensor *active_sensor, NotifType notif_type) {

+#ifdef HAVE_LIBNOTIFY

+

+ SensorsApplet *sensors_applet;

+ GList *table_children;

+ GtkWidget *attach = NULL;

+ gchar *summary, *message;

+ gint timeout_msecs;

+ gchar *sensor_label;

+ gchar *sensor_path;

+ SensorType sensor_type;

+ TemperatureScale temp_scale;

+ GtkTreeIter iter;

+ GtkTreePath *path;

+ const gchar *unit_type = NULL;

+ const gchar *unit_type_title = NULL;

+ const gchar *relation = NULL;

+ const gchar *limit_type = NULL;

+ const gchar *units = NULL;

+ gdouble limit_value;

+

+ sensors_applet = active_sensor->sensors_applet;

+

+ if (!panel_applet_gconf_get_bool(sensors_applet->applet,

+ DISPLAY_NOTIFICATIONS,

+ NULL)) {

+ g_debug("Wanted to display notification, but user has disabled them");

+ return;

+ }

+

+ table_children = gtk_container_get_children(GTK_CONTAINER(sensors_applet->table));

+

+ if (g_list_find(table_children, active_sensor->icon)) {

+ attach = GTK_WIDGET(active_sensor->icon);

+ } else if (g_list_find(table_children, active_sensor->label)) {

+ attach = GTK_WIDGET(active_sensor->label);

+ } else if (g_list_find(table_children, active_sensor->value)) {

+ attach = GTK_WIDGET(active_sensor->value);

+ } else if (g_list_find(table_children, active_sensor->graph)) {

+ attach = GTK_WIDGET(active_sensor->graph);

+ } else {

+ g_warning("Wanted to do notify for a sensor which has no elements in the table!!!");

+ return;

+ }

+ g_list_free(table_children);

+

+ path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);

+ if (gtk_tree_model_get_iter(GTK_TREE_MODEL(sensors_applet->sensors),

+ &iter, path)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &iter,

+ LABEL_COLUMN, &sensor_label,

+ PATH_COLUMN, &sensor_path,

+ SENSOR_TYPE_COLUMN, &sensor_type,

+ -1);

+ } else {

+ g_warning("Error getting data from tree for notification...");

+ gtk_tree_path_free(path);

+ return;

+ }

+ gtk_tree_path_free(path);

+

+ // do different stuff for different notif types

+ switch (notif_type) {

+ case LOW_ALARM: // fall thru

+ case HIGH_ALARM:

+ if (active_sensor->sensor_values[0] <= active_sensor->sensor_low_value &&

+ notif_type == LOW_ALARM) {

+ relation = _("is very low");

+ limit_type = _("lower limit");

+ limit_value = active_sensor->sensor_low_value;

+ } else if (active_sensor->sensor_values[0] >= active_sensor->sensor_high_value &&

+ notif_type == HIGH_ALARM) {

+ /* assume high alarm condition */

+ relation = _("is very high");

+ limit_type = _("upper limit");

+ limit_value = active_sensor->sensor_high_value;

+ } else {

+ g_warning("Alarm notify called when no alarm condition!");

+ g_free(sensor_path);

+ g_free(sensor_label);

+ return;

+ }

+

+ switch ((SensorType)sensor_type) {

+ case TEMP_SENSOR:

+ unit_type_title = _("Temperature");

+ unit_type = _("temperature");

+ temp_scale = (TemperatureScale)panel_applet_gconf_get_int(active_sensor->sensors_applet->applet,

+ TEMPERATURE_SCALE,

+ NULL);

+

+ switch (temp_scale) {

+ case CELSIUS:

+ units = UNITS_CELSIUS;

+ break;

+ case FAHRENHEIT:

+ units = UNITS_FAHRENHEIT;

+ break;

+ case KELVIN:

+ units = UNITS_KELVIN;

+ break;

+ default:

+ units = NULL;

+ }

+

+ break;

+ case VOLTAGE_SENSOR:

+ unit_type_title = _("Voltage");

+ unit_type = _("voltage");

+ units = UNITS_VOLTAGE;

+ break;

+ case FAN_SENSOR:

+ unit_type_title = _("Fan Speed");

+ unit_type = _("fan speed");

+ units = UNITS_RPM;

+ break;

+ case CURRENT_SENSOR:

+ unit_type_title = _("Current");

+ unit_type = _("current");

+ units = UNITS_CURRENT;

+ break;

+ }

+

+ timeout_msecs = (active_sensor->alarm_timeout ? MIN(DEFAULT_NOTIFY_TIMEOUT, (active_sensor->alarm_timeout * 1000)) : DEFAULT_NOTIFY_TIMEOUT);

+

+ summary = g_strdup_printf("%s %s %s", sensor_label, unit_type_title, _("Alarm"));

+ message = g_strdup_printf("%s %s %s (%s %2.0f%s)", sensor_label, unit_type,

+ relation, limit_type, limit_value, units);

+ break;

+

+ case SENSOR_INTERFACE_ERROR:

+ summary = g_strdup_printf(_("Error updating sensor %s"), sensor_label);

+ message = g_strdup_printf(_("An error occurred while trying to update the value of the sensor %s located at %s."), sensor_label, sensor_path);

+ timeout_msecs = panel_applet_gconf_get_int(active_sensor->sensors_applet->applet,

+ TIMEOUT,

+ NULL);

+

+ break;

+

+ default:

+ g_assert_not_reached();

+ }

+

+ active_sensor_libnotify_notify(active_sensor,

+ notif_type,

+ summary,

+ message,

+ GTK_STOCK_DIALOG_WARNING,

+ timeout_msecs,

+ attach);

+

+ g_free(sensor_path);

+ g_free(sensor_label);

+ g_free(summary);

+ g_free(message);

+#endif

+}

+

+void sensors_applet_notify_end(ActiveSensor *active_sensor,

+ NotifType notif_type) {

+#ifdef HAVE_LIBNOTIFY

+ active_sensor_libnotify_notify_end(active_sensor, notif_type);

+#endif

+}

+

+#ifdef HAVE_LIBNOTIFY

+static void sensors_applet_notify_end_all_gfunc(ActiveSensor *active_sensor,

+ gpointer data) {

+ active_sensor_libnotify_notify_end(active_sensor, LOW_ALARM);

+ active_sensor_libnotify_notify_end(active_sensor, HIGH_ALARM);

+}

+#endif

+

+void sensors_applet_notify_end_all(SensorsApplet *sensors_applet) {

+#ifdef HAVE_LIBNOTIFY

+ g_list_foreach(sensors_applet->active_sensors,

+ (GFunc)sensors_applet_notify_end_all_gfunc,

+ NULL);

+#endif

+}

+

+/* internal helper functions for updating display etc*/

+

+

+/* should be called as a g_container_foreach at the start of

+ * pack_display if ythe table already exists to remove but keep alive

+ * all children of the table before repacking it */

+static void sensors_applet_pack_display_empty_table_cb(GtkWidget *widget,

+ gpointer data) {

+ GtkContainer *container;

+

+ container = GTK_CONTAINER(data);

+

+ /* ref then remove widget */

+ g_object_ref(widget);

+ gtk_container_remove(container, widget);

+}

+

+/* should be called as a g_container_foreach at the end of

+ * pack_display to unref any of the old children that we have readdded

+ * to the table to stop reference creep from the g_object_ref called

+ * on each child at the start of pack labels */

+static void sensors_applet_pack_display_cleanup_refs_cb(GtkWidget *widget,

+ gpointer data) {

+

+ GList *old_children;

+

+ old_children = (GList *)data;

+ if (g_list_find(old_children, widget)) {

+ g_object_unref(widget);

+ }

+}

+

+static void sensors_applet_pack_display(SensorsApplet *sensors_applet) {

+ /* note the if () around each widget is to ensure we only

+ * operate on those that actually exist */

+ GtkLabel *no_sensors_enabled_label = NULL;

+ gint num_active_sensors = 0, num_sensors_per_group, rows, cols, i, j;

+ GList *old_table_children = NULL;

+

+ GList *current_sensor;

+

+ DisplayMode display_mode;

+ LayoutMode layout_mode;

+

+ gboolean horizontal;

+ gint label_width, icon_width, value_width;

+ gint label_height, icon_height, value_height;

+

+ GtkRequisition req;

+

+ ActiveSensor *first_sensor;

+

+ /* it is possible that there could be no active sensors so

+ * handle that case first - make sure we dont do a NULL

+ * pointer access first though */

+ if (sensors_applet->active_sensors == NULL ||

+ g_list_length(sensors_applet->active_sensors) == 0) {

+ g_debug("no active sensors to pack in table");

+ no_sensors_enabled_label = g_object_new(GTK_TYPE_LABEL,

+ "label", _("No sensors enabled!"),

+ NULL);

+

+ if (sensors_applet->table == NULL) {

+ /* only need 1 row and 1 col */

+ sensors_applet->table = gtk_table_new(1, 1, FALSE);

+ gtk_table_set_col_spacings(GTK_TABLE(sensors_applet->table), COLUMN_SPACING);

+ gtk_table_set_row_spacings(GTK_TABLE(sensors_applet->table), ROW_SPACING);

+ /* add table to applet */

+ gtk_container_add(GTK_CONTAINER(sensors_applet->applet), sensors_applet->table);

+

+ } else {

+ /* destroy existing widgets - could be an

+ * existing version of no sensors label - okay

+ * to just add again though if destory fist */

+ g_debug("destorying any existing widgets in container");

+ gtk_container_foreach(GTK_CONTAINER(sensors_applet->table),

+ (GtkCallback)gtk_widget_destroy,

+ NULL);

+ /* make sure only 1x1 table */

+ gtk_table_resize(GTK_TABLE(sensors_applet->table),

+ 1, 1);

+ }

+ g_debug("packing no sensors enabled label");

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ GTK_WIDGET(no_sensors_enabled_label),

+ 0, 1,

+ 0, 1);

+ gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet));

+ return;

+

+ }

+ /* otherwise can acess active_sensors without any worries */

+ num_active_sensors = g_list_length(sensors_applet->active_sensors);

+

+ display_mode = (DisplayMode)panel_applet_gconf_get_int(sensors_applet->applet,

+ DISPLAY_MODE, NULL);

+ layout_mode = (LayoutMode)panel_applet_gconf_get_int(sensors_applet->applet,

+ LAYOUT_MODE, NULL);

+

+

+ horizontal = (((panel_applet_get_orient(sensors_applet->applet) == PANEL_APPLET_ORIENT_UP) ||

+ (panel_applet_get_orient(sensors_applet->applet) == PANEL_APPLET_ORIENT_DOWN)));

+

+ /* figure out num rows / cols by how high / wide sensors

+ * labels / icons are and how much size we have to put them

+ * in */

+

+ /* get the first active sensor */

+ first_sensor = (ActiveSensor *)sensors_applet->active_sensors->data;

+

+

+ switch (display_mode) {

+ case DISPLAY_VALUE:

+ gtk_widget_size_request(GTK_WIDGET(first_sensor->value),

+ &req);

+ value_width = req.width + COLUMN_SPACING;

+ value_height = req.height + ROW_SPACING;

+

+ /* make sure all widths and heights are non zero,

+ * otherwise will get a divide by zero exception below

+ * - is a non critical error since can happen when

+ * elements first added to list, so simply return - is

+ * not a programming error */

+ if (value_width == 0 && value_height == 0) {

+ return;

+ }

+

+ num_sensors_per_group = (sensors_applet->size /

+ (horizontal ? value_height :

+ value_width));

+ break;

+

+ case DISPLAY_LABEL_WITH_VALUE:

+ /* even though we end up packing the event boxes into the

+ * panel, these dont give back request sizes, so need to ask

+ * widgets directly */

+ gtk_widget_size_request(GTK_WIDGET(first_sensor->value),

+ &req);

+ value_width = req.width + COLUMN_SPACING;

+ value_height = req.height + ROW_SPACING;

+

+ gtk_widget_size_request(GTK_WIDGET(first_sensor->label),

+ &req);

+ label_width = req.width + COLUMN_SPACING;

+ label_height = req.height + ROW_SPACING;

+

+ /* make sure all widths and heights are non zero, otherwise

+ * will get a divide by zero exception below

+ * - is a non critical error since can happen when

+ * elements first added to list, so simply return - is

+ * not a programming error */

+ if (!(label_width && label_height &&

+ value_width && value_height)) {

+ return;

+ }

+

+ switch (layout_mode) {

+ case VALUE_BESIDE_LABEL:

+ num_sensors_per_group = (sensors_applet->size /

+ (horizontal ? MAX(label_height, value_height) :

+ (label_width + value_width)));

+ break;

+ case VALUE_BELOW_LABEL:

+ num_sensors_per_group = (sensors_applet->size /

+ (horizontal ? (label_height + value_height) :

+ MAX(label_width, value_width)));

+

+

+ break;

+ }

+ break;

+

+ case DISPLAY_ICON_WITH_VALUE:

+ gtk_widget_size_request(GTK_WIDGET(first_sensor->value),

+ &req);

+ value_width = req.width + COLUMN_SPACING;

+ value_height = req.height + ROW_SPACING;

+

+ gtk_widget_size_request(GTK_WIDGET(first_sensor->icon),

+ &req);

+ icon_width = req.width + COLUMN_SPACING;

+ icon_height = req.height + ROW_SPACING;

+

+ if (!(icon_width && icon_height &&

+ value_width && value_height)) {

+ return;

+ }

+

+ switch (layout_mode) {

+ case VALUE_BESIDE_LABEL:

+ num_sensors_per_group = (sensors_applet->size /

+ (horizontal ? MAX(icon_height, value_height) :

+ (icon_width + value_width)));

+ break;

+ case VALUE_BELOW_LABEL:

+ num_sensors_per_group = (sensors_applet->size /

+ (horizontal ? (icon_height + value_height) :

+ MAX(icon_width, value_width)));

+

+

+ break;

+ }

+ break;

+

+ case DISPLAY_ICON:

+ gtk_widget_size_request(GTK_WIDGET(first_sensor->icon),

+ &req);

+ icon_width = req.width + COLUMN_SPACING;

+ icon_height = req.height + ROW_SPACING;

+ if (!(icon_width && icon_height)) {

+ return;

+ }

+

+ num_sensors_per_group = (sensors_applet->size /

+ (horizontal ? icon_height :

+ icon_width));

+ break;

+

+ case DISPLAY_GRAPH:

+ /* only show graphs in a line like System Monitor

+ * applet */

+ num_sensors_per_group = 1;

+ break;

+ }

+ /* ensure always atleast 1 sensor per group */

+ if (num_sensors_per_group < 1) {

+ /* force a better layout */

+ if (horizontal && layout_mode == VALUE_BELOW_LABEL) {

+ layout_mode = VALUE_BESIDE_LABEL;

+ } else if (!horizontal && layout_mode == VALUE_BESIDE_LABEL) {

+ layout_mode = VALUE_BELOW_LABEL;

+ }

+ num_sensors_per_group = 1;

+ }

+

+ if (horizontal) {

+ /* if oriented horizontally, want as many

+ sensors per column as user has defined, then

+ enough columns to hold all the widgets */

+ rows = num_sensors_per_group;

+ cols = num_active_sensors / num_sensors_per_group;

+ while (rows * cols < num_active_sensors || cols == 0) {

+ cols++;

+ }

+

+ } else {

+ /* if oriented vertically, want as many

+ sensors per row as user has defined, then

+ enough rows to hold all the widgets*/

+ cols = num_sensors_per_group;

+ rows = num_active_sensors / num_sensors_per_group;

+ while (rows * cols < num_active_sensors || rows == 0) {

+ rows++;

+ }

+

+ }

+

+ /* if displaying labels / icons and values need to modify

+ number of rows / colums to accomodate this */

+ if (display_mode == DISPLAY_LABEL_WITH_VALUE ||

+ display_mode == DISPLAY_ICON_WITH_VALUE) {

+ if (layout_mode == VALUE_BESIDE_LABEL) {

+ /* to display labels next to values need twice

+ as many columns */

+ cols *= 2;

+ } else {

+ /* to display labels above values, we need

+ * twice as many rows as without */

+ rows *= 2;

+ }

+ }

+

+ if (sensors_applet->table == NULL) {

+ /* create table and add to applet */

+ sensors_applet->table = gtk_table_new(rows, cols, FALSE);

+ gtk_table_set_col_spacings(GTK_TABLE(sensors_applet->table), COLUMN_SPACING);

+ gtk_table_set_row_spacings(GTK_TABLE(sensors_applet->table), ROW_SPACING);

+ gtk_container_add(GTK_CONTAINER(sensors_applet->applet), sensors_applet->table);

+ } else {

+ /* remove all children if table already exists so we can start

+ * again */

+ /* save a list of the old children for later */

+ old_table_children = gtk_container_get_children(GTK_CONTAINER(sensors_applet->table));

+

+ gtk_container_foreach(GTK_CONTAINER(sensors_applet->table),

+ sensors_applet_pack_display_empty_table_cb,

+ sensors_applet->table);

+

+ /* then resize table */

+ gtk_table_resize(GTK_TABLE(sensors_applet->table), rows, cols);

+ }

+

+ /* pack icons / labels and values into table */

+ current_sensor = sensors_applet->active_sensors;

+

+ /* if showing labels / icons and values, need to pack labels /

+ * icons these first */

+ if (display_mode == DISPLAY_ICON_WITH_VALUE ||

+ display_mode == DISPLAY_LABEL_WITH_VALUE) {

+ /* loop through columns */

+ for (i = 0; current_sensor != NULL && i < cols; /* increments depends on how we lay them out - see below */) {

+

+ /* loop through rows in a column */

+ for (j = 0; current_sensor && j < rows; /* see bottom of for loop*/) {

+ /* attach label / icon at this point */

+ if (display_mode == DISPLAY_ICON_WITH_VALUE) {

+ if (((ActiveSensor *)(current_sensor->data))->icon) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->icon,

+ i, i + 1,

+ j, j + 1);

+ }

+ } else {

+ if (((ActiveSensor *)(current_sensor->data))->label) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->label,

+ i, i + 1,

+ j, j + 1);

+ }

+ }

+ /* now attach sensor value to either

+ row below or column next to */

+ if (layout_mode == VALUE_BESIDE_LABEL) {

+ /* left align labels */

+ if (((ActiveSensor *)(current_sensor->data))->icon) {

+ gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->icon), 0.0, 0.5);

+ }

+ if (((ActiveSensor *)(current_sensor->data))->label) {

+ gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->label), 0.0, 0.5);

+ }

+ if (((ActiveSensor *)(current_sensor->data))->value) {

+ gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->value), 0.0, 0.5);

+ }

+

+

+ /* place value next to label */

+ if (((ActiveSensor *)(current_sensor->data))->value) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->value,

+ i + 1, i + 2,

+ j, j + 1);

+ }

+ j++;

+ } else { /* place value below label */

+ /* center align labels */

+ if (((ActiveSensor *)(current_sensor->data))->icon) {

+ gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->icon), 0.5, 0.5);

+ }

+ if (((ActiveSensor *)(current_sensor->data))->label) {

+ gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->label), 0.5, 0.5);

+ }

+ if (((ActiveSensor *)(current_sensor->data))->value) {

+ gtk_misc_set_alignment(GTK_MISC(((ActiveSensor *)(current_sensor->data))->value), 0.5, 0.5);

+ }

+

+ if (((ActiveSensor *)(current_sensor->data))->value) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->value,

+ i, i + 1,

+ j + 1, j + 2);

+ }

+ j += 2;

+ }

+ current_sensor = g_list_next(current_sensor);

+

+ } /* end row loop */

+ /* now increment column index as needed */

+ if (layout_mode == VALUE_BESIDE_LABEL) { /* place value next to label */

+ i += 2;

+ } else {

+ i++;

+ }

+

+

+ } /* end column loop */

+

+

+ } else { /* not showing labels and icons with values, so just

+ * pack either only icons or values */

+ for (i = 0; current_sensor != NULL && i < cols; ++i) {

+ for (j = 0; current_sensor!= NULL && j < rows; ++j) {

+ if (display_mode == DISPLAY_VALUE) {

+

+ if (((ActiveSensor *)(current_sensor->data))->value) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->value,

+ i, i + 1,

+ j, j + 1);

+ }

+ } else if (display_mode == DISPLAY_ICON) {

+ if (((ActiveSensor *)(current_sensor->data))->value) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->icon,

+ i, i + 1,

+ j, j + 1);

+ }

+ } else if (display_mode == DISPLAY_GRAPH) {

+ if (((ActiveSensor *)(current_sensor->data))->graph) {

+ gtk_table_attach_defaults(GTK_TABLE(sensors_applet->table),

+ ((ActiveSensor *)(current_sensor->data))->graph_frame,

+ i, i + 1,

+ j, j + 1);

+ }

+ }

+

+

+ current_sensor = g_list_next(current_sensor);

+ }

+ }

+

+ }

+ if (old_table_children != NULL) {

+ gtk_container_foreach(GTK_CONTAINER(sensors_applet->table),

+ sensors_applet_pack_display_cleanup_refs_cb,

+ old_table_children);

+ g_list_free(old_table_children);

+ }

+ gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet));

+

+}

+

+/* must unref when done with returned pixbuf */

+GdkPixbuf *sensors_applet_load_icon(IconType icon_type) {

+ GtkIconTheme *icon_theme;

+ GdkPixbuf *icon = NULL;

+ GError *error = NULL;

+

+ /* try to load the icon */

+

+ /* not allowed to unref or ref icon_theme once we have it */

+ icon_theme = gtk_icon_theme_get_default();

+ icon = gtk_icon_theme_load_icon(icon_theme,

+ stock_icons[icon_type],

+ DEFAULT_ICON_SIZE,

+ GTK_ICON_LOOKUP_USE_BUILTIN,

+ &error);

+ if (error) {

+ g_warning ("Could not load icon: %s", error->message);

+ g_error_free(error);

+ error = NULL;

+

+ /* try again with default icon */

+ icon = gtk_icon_theme_load_icon(icon_theme,

+ GTK_STOCK_MISSING_IMAGE,

+ DEFAULT_ICON_SIZE,

+ GTK_ICON_LOOKUP_USE_BUILTIN,

+ &error);

+ if (error) {

+ /* this will quit sensors-applet but

+ * it is a pretty major error so may

+ * as well */

+

+ g_error("Could not load GTK_STOCK_MISSING_IMAGE - major error!!!: %s", error->message);

+

+ g_error_free(error);

+ error = NULL;

+ }

+

+ }

+ return icon;

+}

+

+gboolean sensors_applet_add_sensor(SensorsApplet *sensors_applet,

+ const gchar *path,

+ const gchar *id,

+ const gchar *label,

+ const gchar *interface,

+ SensorType type,

+ gboolean enable,

+ gdouble low_value,

+ gdouble high_value,

+ gboolean alarm_enable,

+ const gchar *low_alarm_command,

+ const gchar *high_alarm_command,

+ gint alarm_timeout,

+ gdouble multiplier,

+ gdouble offset,

+ IconType icon_type,

+ const gchar *graph_color) {

+

+

+ GtkTreeIter interfaces_iter, sensors_iter;

+ gboolean not_empty_tree;

+

+ gchar *node_interface;

+ gboolean not_end_of_interfaces = TRUE, interface_exists = FALSE;

+ gboolean not_end_of_sensors = TRUE;

+ gchar *sensor_id;

+ gchar *sensor_path;

+ SensorType sensor_type;

+ GdkPixbuf *icon;

+ GtkTreePath *tree_path;

+

+ g_assert(sensors_applet);

+

+ /* assume tree is not empty */

+ not_empty_tree = TRUE;

+

+

+ if (NULL == sensors_applet->sensors) {

+

+ sensors_applet->sensors = gtk_tree_store_new(N_COLUMNS,

+ G_TYPE_STRING, /* path */

+ G_TYPE_STRING, /* id */

+ G_TYPE_STRING, /* label */

+ G_TYPE_STRING, /* interface */

+ G_TYPE_UINT, /* sensor

+ * type */

+ G_TYPE_BOOLEAN, /* enable */

+ G_TYPE_BOOLEAN, /* visible */

+ G_TYPE_DOUBLE, /* low value */

+ G_TYPE_DOUBLE, /* high type */

+ G_TYPE_BOOLEAN, /* alarm enable */

+ G_TYPE_STRING, /* low alarm command */

+ G_TYPE_STRING, /* high alarm command */

+ G_TYPE_UINT, /* alarm timeout */

+ G_TYPE_DOUBLE, /* multiplier */

+ G_TYPE_DOUBLE, /* offset */

+ G_TYPE_UINT, /* icon type */

+ GDK_TYPE_PIXBUF, /* icon pixbuf */

+ G_TYPE_STRING); /* graph color */

+

+

+ g_debug("Sensor tree created.");

+

+ /* we know tree is actually empty since we just created it */

+ not_empty_tree = FALSE;

+ }

+

+ /* search sensor tree for the parent interface to place this

+ * sensor under */

+ for (not_empty_tree = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter); not_empty_tree && not_end_of_interfaces && !interface_exists; not_end_of_interfaces = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &interfaces_iter,

+ INTERFACE_COLUMN, &node_interface,

+ -1);

+ if (g_ascii_strcasecmp(interface, node_interface) == 0) {

+ /* found interface in tree */

+ interface_exists = TRUE;

+

+ /* now see if this actual sensor already

+ * exists within this interface - don't want

+ * to add duplicates */

+ /* see if have children */

+ for (not_end_of_sensors = gtk_tree_model_iter_children(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter, &interfaces_iter); not_end_of_sensors; not_end_of_sensors = gtk_tree_model_iter_next(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter)) {

+ gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter,

+ PATH_COLUMN, &sensor_path,

+ ID_COLUMN, &sensor_id,

+ SENSOR_TYPE_COLUMN, &sensor_type,

+ -1);

+ if (g_ascii_strcasecmp(sensor_id, id) == 0 &&

+ g_ascii_strcasecmp(sensor_path, path) == 0 &&

+ sensor_type == type) {

+ /* sensor already exists so

+ * dont add a second time */

+ g_debug("sensor with path: %s, id: %s already exists in tree, not adding a second time", sensor_path, sensor_id);

+ g_free(sensor_id);

+ g_free(sensor_path);

+ g_free(node_interface);

+ return FALSE;

+ }

+ g_free(sensor_id);

+ g_free(sensor_path);

+ }

+ g_free(node_interface);

+ break;

+ }

+ g_free(node_interface);

+ }

+

+

+

+ if (!interface_exists) {

+ /* add to required plugins hash table so we ensure this

+ plugin stays loaded to make sure we have a get sensor

+ value function if possible */

+ g_hash_table_insert(sensors_applet->required_plugins,

+ g_strdup(interface),

+ GINT_TO_POINTER(TRUE));

+ g_debug("added interface %s to required plugins", interface);

+

+ /* wasn't able to find interface root node so create it */

+ gtk_tree_store_append(sensors_applet->sensors,

+ &interfaces_iter,

+ NULL);

+

+ gtk_tree_store_set(sensors_applet->sensors,

+ &interfaces_iter,

+ ID_COLUMN, interface,

+ INTERFACE_COLUMN, interface,

+ VISIBLE_COLUMN, FALSE,

+ -1);

+ g_debug("Added sensor interface %s to tree", interface);

+ }

+

+ icon = sensors_applet_load_icon(icon_type);

+

+

+ /* then add sensor as a child under interface node - ie assume

+ * we either found it or created it - the inteface node that

+ * is */

+

+ /* for now just add sensors all in a single list */

+ gtk_tree_store_append(sensors_applet->sensors,

+ &sensors_iter,

+ &interfaces_iter);

+

+ gtk_tree_store_set(sensors_applet->sensors,

+ &sensors_iter,

+ PATH_COLUMN, path,

+ ID_COLUMN, id,

+ LABEL_COLUMN, label,

+ INTERFACE_COLUMN, interface,

+ SENSOR_TYPE_COLUMN, type,

+ ENABLE_COLUMN, enable,

+ VISIBLE_COLUMN, TRUE,

+ LOW_VALUE_COLUMN, low_value,

+ HIGH_VALUE_COLUMN, high_value,

+ ALARM_ENABLE_COLUMN, alarm_enable,

+ ALARM_TIMEOUT_COLUMN, alarm_timeout,

+ LOW_ALARM_COMMAND_COLUMN, low_alarm_command,

+ HIGH_ALARM_COMMAND_COLUMN, high_alarm_command,

+ MULTIPLIER_COLUMN, multiplier,

+ OFFSET_COLUMN, offset,

+ ICON_TYPE_COLUMN, icon_type,

+ ICON_PIXBUF_COLUMN, icon,

+ GRAPH_COLOR_COLUMN, graph_color,

+ -1);

+ g_debug("added sensor %s to tree", path);

+

+ /* remove reference to icon as tree now has ref */

+ g_object_unref(icon);

+

+ /* create the active sensor */

+ if (enable) {

+ tree_path = gtk_tree_model_get_path(GTK_TREE_MODEL(sensors_applet->sensors), &sensors_iter);

+ sensors_applet_sensor_enabled(sensors_applet, tree_path);

+ gtk_tree_path_free(tree_path);

+ }

+ return TRUE;

+}

+

+

+static ActiveSensor *sensors_applet_find_active_sensor(SensorsApplet *sensors_applet,

+ GtkTreePath *path) {

+ GtkTreePath *sensor_tree_path;

+ GList *current_sensor;

+

+ for (current_sensor = sensors_applet->active_sensors; current_sensor != NULL; current_sensor = g_list_next(current_sensor)) {

+ sensor_tree_path = gtk_tree_row_reference_get_path(((ActiveSensor *)(current_sensor->data))->sensor_row);

+

+ if (gtk_tree_path_compare(path, sensor_tree_path) == 0) {

+ gtk_tree_path_free(sensor_tree_path);

+ return ((ActiveSensor *)(current_sensor->data));

+ }

+ gtk_tree_path_free(sensor_tree_path);

+ }

+ return NULL;

+}

+

+

+/* path should be the full path to a file representing the sensor (eg

+ * /dev/hda or /sys/devices/platform/i2c-0/0-0290/temp1_input) */

+

+void sensors_applet_display_layout_changed(SensorsApplet *sensors_applet) {

+ /* update sensors since will need to update icons / graphs etc

+ * if weren't displayed before */

+ GList *list = NULL;

+ for (list = sensors_applet->active_sensors;

+ list != NULL;

+ list = list->next) {

+ ActiveSensor *as = (ActiveSensor *)list->data;

+ as->updated = FALSE;

+ }

+ sensors_applet_update_active_sensors(sensors_applet);

+ sensors_applet_pack_display(sensors_applet);

+}

+

+void sensors_applet_alarm_off(SensorsApplet *sensors_applet,

+ GtkTreePath *path,

+ NotifType notif_type) {

+ ActiveSensor *active_sensor;

+

+ if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet,

+ path)) != NULL) {

+ active_sensor_alarm_off(active_sensor, notif_type);

+ }

+}

+

+void sensors_applet_all_alarms_off(SensorsApplet *sensors_applet,

+ GtkTreePath *path) {

+ sensors_applet_alarm_off(sensors_applet, path, LOW_ALARM);

+ sensors_applet_alarm_off(sensors_applet, path, HIGH_ALARM);

+}

+

+

+void sensors_applet_sensor_enabled(SensorsApplet *sensors_applet,

+ GtkTreePath *path) {

+ ActiveSensor *active_sensor;

+

+ g_assert(sensors_applet);

+ g_assert(path);

+

+ active_sensor = active_sensor_new(sensors_applet,

+ gtk_tree_row_reference_new(GTK_TREE_MODEL(sensors_applet->sensors), path));

+

+ active_sensor_update(active_sensor, sensors_applet);

+

+ /* keep list sorted */

+ sensors_applet->active_sensors = g_list_insert_sorted(sensors_applet->active_sensors,

+ active_sensor,

+ (GCompareFunc)active_sensor_compare);

+

+ sensors_applet_pack_display(sensors_applet);

+}

+

+void sensors_applet_reorder_sensors(SensorsApplet *sensors_applet) {

+ sensors_applet->active_sensors = g_list_sort(sensors_applet->active_sensors, (GCompareFunc)active_sensor_compare);

+

+ sensors_applet_pack_display(sensors_applet);

+}

+

+void sensors_applet_sensor_disabled(SensorsApplet *sensors_applet,

+ GtkTreePath *path) {

+

+ ActiveSensor *active_sensor;

+

+ g_assert(sensors_applet);

+ g_assert(path);

+

+ if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet,

+ path)) != NULL) {

+ g_debug("Destroying active sensor...");

+

+ g_debug("-- removing from list...");

+ sensors_applet->active_sensors = g_list_remove(sensors_applet->active_sensors,

+ active_sensor);

+ g_debug("-- repacking display....");

+ sensors_applet_pack_display(sensors_applet);

+

+ active_sensor_destroy(active_sensor);

+ }

+}

+

+

+void sensors_applet_update_sensor(SensorsApplet *sensors_applet,

+ GtkTreePath *path) {

+ ActiveSensor *active_sensor;

+

+ g_assert(sensors_applet);

+ g_assert(path);

+

+ if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet,

+ path)) != NULL) {

+ active_sensor_update(active_sensor,

+ sensors_applet);

+ }

+}

+

+void sensors_applet_icon_changed(SensorsApplet *sensors_applet,

+ GtkTreePath *path) {

+ ActiveSensor *active_sensor;

+

+ g_assert(sensors_applet);

+ g_assert(path);

+

+ if ((active_sensor = sensors_applet_find_active_sensor(sensors_applet,

+ path)) != NULL) {

+ active_sensor_icon_changed(active_sensor,

+ sensors_applet);

+ }

+}

+

+/**

+ * Cycle thru ActiveSensors and update them all

+ */

+gboolean sensors_applet_update_active_sensors(SensorsApplet *sensors_applet) {

+ g_assert(sensors_applet);

+

+ if (sensors_applet->active_sensors) {

+ g_list_foreach(sensors_applet->active_sensors,

+ (GFunc)active_sensor_update,

+ sensors_applet);

+ return TRUE;

+ }

+ return FALSE;

+}

+

+/**

+ * Cycle thru ActiveSensors and set new graph dimensions

+ */

+void sensors_applet_graph_size_changed(SensorsApplet *sensors_applet) {

+ gint dimensions[2];

+ gint graph_size;

+ g_assert(sensors_applet);

+

+ if (sensors_applet->active_sensors) {

+

+ graph_size = panel_applet_gconf_get_int(sensors_applet->applet,

+ GRAPH_SIZE,

+ NULL);

+ if (panel_applet_get_orient(sensors_applet->applet) ==

+ PANEL_APPLET_ORIENT_UP ||

+ panel_applet_get_orient(sensors_applet->applet) ==

+ PANEL_APPLET_ORIENT_DOWN) {

+ /* is horizontal so set graph_size as width */

+ dimensions[0] = graph_size;

+ dimensions[1] = sensors_applet->size;

+ } else {

+ dimensions[0] = sensors_applet->size;

+ dimensions[1] = graph_size;

+ }

+

+ g_list_foreach(sensors_applet->active_sensors,

+ (GFunc)active_sensor_update_graph_dimensions,

+ &dimensions);

+ }

+

+}

+

+gdouble sensors_applet_convert_temperature(gdouble value,

+ TemperatureScale old,

+ TemperatureScale new) {

+

+ switch (old) {

+ case KELVIN:

+ switch (new) {

+ case CELSIUS:

+ value = value - 273.0;

+ break;

+ case FAHRENHEIT:

+ value = (9.0 * (value - 273) / 5.0) + 32.0;

+ break;

+ case KELVIN:

+ break;

+ }

+ break;

+ case CELSIUS:

+ switch (new) {

+ case FAHRENHEIT:

+ value = (9.0 * value / 5.0) + 32.0;

+ break;

+ case KELVIN:

+ value = value + 273.0;

+ break;

+ case CELSIUS:

+ break;

+ }

+ break;

+

+ case FAHRENHEIT:

+ switch (new) {

+ case CELSIUS:

+ value = (5.0 * (value - 32.0) / 9.0);

+ break;

+ case KELVIN:

+ value = (5.0 * (value - 32.0) / 9.0) + 273.0;

+ break;

+ case FAHRENHEIT:

+ break;

+ }

+ break;

+ }

+ return value;

+}

+

+void sensors_applet_init(SensorsApplet *sensors_applet) {

+

+ g_assert(sensors_applet);

+ g_assert(sensors_applet->applet);

+

+ /* plugin functions are stored as name -> get_value_function pairs so

+ * use standard string functions on hash table */

+ sensors_applet->plugins = g_hash_table_new(g_str_hash,

+ g_str_equal);

+

+ sensors_applet->required_plugins = g_hash_table_new_full(g_str_hash,

+ g_str_equal,

+ g_free,

+ NULL);

+

+ /* initialise size */

+ sensors_applet->size = DEFAULT_APPLET_SIZE;

+

+ panel_applet_set_flags(sensors_applet->applet,

+ PANEL_APPLET_EXPAND_MINOR);

+

+ g_signal_connect(sensors_applet->applet, "destroy",

+ G_CALLBACK(destroy_cb),

+ sensors_applet);

+

+

+ /* if not setup, write defaults to gconf */

+ sensors_applet_gconf_setup(sensors_applet);

+

+ /* now do any setup needed manually */

+ sensors_applet_plugins_load_all(sensors_applet);

+

+ /* should have created sensors tree above, but if have

+ not was because we couldn't find any sensors */

+ if (NULL == sensors_applet->sensors) {

+ GtkWidget *label;

+ label = gtk_label_new(_("No sensors found!"));

+ gtk_container_add(GTK_CONTAINER(sensors_applet->applet), label);

+ gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet));

+ return;

+ }

+

+ /* only do menu and signal connections if sensors are found */

+ panel_applet_setup_menu_from_file(sensors_applet->applet,

+ DATADIR,

+ SENSORS_APPLET_MENU_FILE,

+ NULL,

+ sensors_applet_menu_verbs,

+ sensors_applet);

+

+ g_signal_connect(sensors_applet->applet, "style-set",

+ G_CALLBACK(style_set_cb),

+ sensors_applet);

+

+ g_signal_connect(sensors_applet->applet, "change_background",

+ G_CALLBACK(change_background_cb),

+ sensors_applet);

+

+ g_signal_connect(G_OBJECT(sensors_applet->applet), "change_orient",

+ G_CALLBACK(change_orient_cb),

+ sensors_applet);

+

+ g_signal_connect(G_OBJECT(sensors_applet->applet), "size_allocate",

+ G_CALLBACK(size_allocate_cb),

+ sensors_applet);

+

+

+

+ sensors_applet_update_active_sensors(sensors_applet);

+ sensors_applet_pack_display(sensors_applet);

+

+ sensors_applet->timeout_id = g_timeout_add_seconds(panel_applet_gconf_get_int(sensors_applet->applet, TIMEOUT, NULL) / 1000,

+ (GSourceFunc)sensors_applet_update_active_sensors,

+ sensors_applet);

+ gtk_widget_show_all(GTK_WIDGET(sensors_applet->applet));

+}

+

+

+

+/*

+ * Copyright (C) 2005-2009 Alex Murray <[email protected]>

+ *

+ * This program 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 program 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 program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+ */

+

+#ifndef SENSORS_APPLET_H

+#define SENSORS_APPLET_H

+

+#include <gtk/gtk.h>

+#include <panel-applet.h>

+#include "sensors-applet-sensor.h"

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif /* HAVE_CONFIG_H */

+

+#ifdef HAVE_LIBNOTIFY

+#include <libnotify/notify.h>

+#endif

+

+typedef struct _ActiveSensor ActiveSensor;

+

+#include "prefs-dialog.h"

+

+#define GRAPH_FRAME_EXTRA_WIDTH 6

+#define SENSORS_APPLET_ICON "sensors-applet"

+

+static const gchar * const stock_icons[NUM_ICONS] = {

+ "sensors-applet-cpu",

+ "sensors-applet-drive-harddisk",

+ "sensors-applet-battery",

+ "sensors-applet-memory",

+ "sensors-applet-gpu",

+ "sensors-applet-chip",

+ "sensors-applet-fan",

+ "sensors-applet-case"

+};

+

+#define DEFAULT_ICON_SIZE 22

+

+#define UNITS_CELSIUS "\302\260C"

+#define UNITS_FAHRENHEIT "\302\260F"

+#define UNITS_KELVIN ""

+#define UNITS_RPM _("RPM")

+#define UNITS_VOLTAGE _("V")

+#define UNITS_CURRENT _("A")

+

+

+/* enumeration used to identify columns in the GtkTreeStore data

+ * structure and to access specific gconf keys too.

+ */

+enum {

+ PATH_COLUMN = 0,

+ ID_COLUMN,

+ LABEL_COLUMN,

+ INTERFACE_COLUMN,

+ SENSOR_TYPE_COLUMN,

+ ENABLE_COLUMN,

+ VISIBLE_COLUMN,

+ LOW_VALUE_COLUMN,

+ HIGH_VALUE_COLUMN,

+ ALARM_ENABLE_COLUMN,

+ LOW_ALARM_COMMAND_COLUMN,

+ HIGH_ALARM_COMMAND_COLUMN,

+ ALARM_TIMEOUT_COLUMN,

+ MULTIPLIER_COLUMN,

+ OFFSET_COLUMN,

+ ICON_TYPE_COLUMN,

+ ICON_PIXBUF_COLUMN,

+ GRAPH_COLOR_COLUMN,

+ N_COLUMNS

+};

+

+

+/* for display mode */

+typedef enum {

+ DISPLAY_LABEL_WITH_VALUE = 0,

+ DISPLAY_ICON_WITH_VALUE,

+ DISPLAY_VALUE,

+ DISPLAY_ICON,

+ DISPLAY_GRAPH

+} DisplayMode;

+

+typedef enum {

+ VALUE_BESIDE_LABEL = 0,

+ VALUE_BELOW_LABEL

+} LayoutMode;

+

+typedef enum {

+ KELVIN = 0,

+ CELSIUS,

+ FAHRENHEIT

+} TemperatureScale;

+

+/* types of Notifs - low and high alarm warnings and error conditions*/

+typedef enum {

+ LOW_ALARM = 0,

+ HIGH_ALARM,

+ SENSOR_INTERFACE_ERROR,

+ GCONF_READ_ERROR,

+ GCONF_WRITE_ERROR,

+ NUM_NOTIFS

+} NotifType;

+

+/* only always two type of alarms - may have more notif types */

+#define NUM_ALARMS 2

+

+struct _SensorsApplet {

+ /* the actual applet for this instance */

+ PanelApplet* applet;

+ gint size;

+

+ GtkTreeStore *sensors;

+ GtkTreeSelection *selection;

+

+ GHashTable *required_plugins;

+ GHashTable *plugins;

+

+ guint timeout_id;

+ /* preferences and about windows (if Gtk < 2.6)*/

+ PrefsDialog *prefs_dialog;

+

+ /* primary table to contain the panel dispay - we pack the

+ * list of labels and sensor values into this container */

+ GtkWidget *table;

+ GList *active_sensors;

+#ifdef HAVE_LIBNOTIFY

+ NotifyNotification *notification;

+#endif // HAVE_LIBNOTIFY

+};

+

+

+

+/* non-static function prototypes */

+void sensors_applet_init(SensorsApplet *sensors_applet);

+void sensors_applet_sensor_enabled(SensorsApplet *sensors_applet,

+ GtkTreePath *path);

+void sensors_applet_sensor_disabled(SensorsApplet *sensors_applet,

+ GtkTreePath *path);

+gboolean sensors_applet_update_active_sensors(SensorsApplet *sensors_applet);

+/**

+ * to be called by things like prefs dialog to turn off a sensor alarm

+ */

+void sensors_applet_alarm_off(SensorsApplet *sensors_applet,

+ GtkTreePath *path,

+ NotifType notif_type);

+void sensors_applet_all_alarms_off(SensorsApplet *sensors_applet,

+ GtkTreePath *path);

+void sensors_applet_icon_changed(SensorsApplet *sensors_applet,

+ GtkTreePath *path);

+void sensors_applet_update_sensor(SensorsApplet *sensors_applet,

+ GtkTreePath *path);

+

+void sensors_applet_display_layout_changed(SensorsApplet *sensors_applet);

+void sensors_applet_reorder_sensors(SensorsApplet *sensors_applet);

+gdouble sensors_applet_convert_temperature(gdouble value,

+ TemperatureScale old,

+ TemperatureScale new);

+void sensors_applet_notify(SensorsApplet *sensors_applet,

+ NotifType notif_type);

+void sensors_applet_notify_end(ActiveSensor *active_sensor, NotifType notif_type);

+void sensors_applet_notify_end_all(SensorsApplet *sensors_applet);

+void sensors_applet_notify_active_sensor(ActiveSensor *active_sensor, NotifType notif_type);

+GdkPixbuf *sensors_applet_load_icon(IconType icon_type);

+void sensors_applet_graph_size_changed(SensorsApplet *sensors_applet);

+

+typedef void SensorsInterfaceTestSensorFunc(SensorsApplet *sensors_applet,

+ const gchar *path);

+void sensors_applet_find_sensors(SensorsApplet *sensors_applet,

+ const gchar *path,

+ SensorsInterfaceTestSensorFunc test_sensor);

+

+#endif /* SENSORS_APPLET_H */