snow/dockapps
1
0
Fork 0
Code Issues Releases Activity
dockapps/wmhdplop/gkrellm_hdplop.c

388 lines
14 KiB
C
Raw Permalink Blame History

/*
*
* gkrellm_hdplop.c
* dae (jolly.frederic@fnac.net)
*
* gkrellm plugin for wmhdplop:
* http://hules.free.fr/wmhdplop/
*
* 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.
*
*/
#include <libgen.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include "config.h"
#include "global.h"
#include "wmhdplop.h"
#define PLUGIN_VERSION VERSION
#define PLUGIN_NAME "gkhdplop"
#define PLUGIN_DESC "wmhdplop gkrellm port"
#define PLUGIN_URL "http://hules.free.fr/wmhdplop/"
#define PLUGIN_STYLE PLUGIN_NAME
#define PLUGIN_KEYWORD PLUGIN_NAME
static GkrellmMonitor *mon = NULL;
static GkrellmChart *chart = NULL;
static GkrellmChartconfig *chart_config = NULL;
#define TIMER1 50 /* main updates every 40 ms */
#define TIMER2 50 * TIMER1 /* small updates every 1600 ms */
#define PLUGIN_HEIGHT 64
static gint timeout_id;
static int option_timer = 0;
/* Options stuffs */
GtkWidget *swap_check = NULL;
GtkWidget *io_check = NULL;
GtkWidget *leds_check = NULL;
GtkWidget *colormap = NULL;
GtkWidget *hdlist_check = NULL;
GtkWidget *throughput_threshold = NULL;
GtkWidget *hddtemp_check = NULL;
GtkWidget *entry_smallfont = NULL, *entry_bigfont = NULL;
static gboolean update_plugin(void)
{
GdkEventExpose event;
gint ret_val;
gtk_signal_emit_by_name(GTK_OBJECT(chart->drawing_area), "expose_event", &event, &ret_val);
return TRUE; /* restart timer */
}
static gint chart_expose_event(GtkWidget *widget UNUSED, GdkEventExpose *ev UNUSED)
{
int update_options = 0;
option_timer++;
if (option_timer == TIMER2 / TIMER1) {
option_timer = 0;
update_options = 1;
}
gkrellm_hdplop_update(update_options);
gkrellm_draw_chart_to_screen(chart);
return TRUE;
}
static gint wheel_event(GtkWidget *widget UNUSED, GdkEventScroll *ev)
{
if (ev->direction == GDK_SCROLL_UP)
next_displayed_hd(); //change_displayed_hd(+1);
else if (ev->direction == GDK_SCROLL_DOWN)
prev_displayed_hd(); //change_displayed_hd(-1);
return TRUE;
}
static gint button_release_event(GtkWidget *widget UNUSED, GdkEventButton *ev, gpointer data UNUSED)
{
if (ev->button == 3) {
gkrellm_open_config_window(mon);
} else if (ev->button == 1) {
change_displayed_hd(+1);
}
return TRUE;
}
static void disable_plugin(void)
{
if (timeout_id)
gtk_timeout_remove(timeout_id);
timeout_id = 0;
}
static void create_plugin(GtkWidget *vbox, gint first_create)
{
if(first_create) {
chart = gkrellm_chart_new0();
}
gkrellm_set_chart_height_default(chart, PLUGIN_HEIGHT);
gkrellm_chart_create(vbox, mon, chart, &chart_config);
if (first_create) {
hdplop_main(chart->w, chart->h, chart->drawing_area->window);
} else {
dockimlib2_gkrellm_xinit(app->dock, chart->drawing_area->window);
reshape(chart->w, chart->h);
}
if (first_create) {
//printf("chart : w=%d, h=%d\n", chart->w, chart->h);
gtk_signal_connect(GTK_OBJECT(chart->drawing_area),
"expose_event", (GtkSignalFunc) chart_expose_event, NULL);
gtk_signal_connect(GTK_OBJECT(chart->drawing_area),
"button_release_event", GTK_SIGNAL_FUNC(button_release_event), NULL);
g_signal_connect(G_OBJECT(chart->drawing_area),
"scroll_event", G_CALLBACK(wheel_event), NULL);
}
/* Update plugin every TIMER1 ms */
if (!timeout_id)
timeout_id = g_timeout_add(TIMER1, (GtkFunction) update_plugin, NULL);
gkrellm_disable_plugin_connect(mon, disable_plugin);
}
static void option_toggled_cb(GtkToggleButton *button, gpointer user_data UNUSED)
{
gboolean active = gtk_toggle_button_get_active(button);
GtkWidget *togglebutton = GTK_WIDGET(button);
if (togglebutton == swap_check) {
Prefs.disable_swap_matrix = !active;
}
else if (togglebutton == io_check) {
Prefs.disable_io_matrix = !active;
}
else if (togglebutton == hdlist_check) {
if (active) {
Prefs.hdlist_pos = AL_BOTTOM + AL_LEFT;
gtk_widget_set_sensitive(leds_check, TRUE);
gtk_widget_set_sensitive(hddtemp_check, TRUE);
}
else {
Prefs.hdlist_pos = AL_NONE;
gtk_widget_set_sensitive(leds_check, FALSE);
gtk_widget_set_sensitive(hddtemp_check, FALSE);
}
}
else if (togglebutton == leds_check) {
Prefs.disable_hd_leds = !active;
}
else if (togglebutton == hddtemp_check) {
Prefs.enable_hddtemp = active;
app->displayed_hd_changed = 1;
}
}
static void cb_colormap_modified(GtkWidget *widget UNUSED, GtkSpinButton *spin)
{
Prefs.iomatrix_colormap = gtk_spin_button_get_value_as_int(spin);
}
static void cb_spinbutton_modified(GtkWidget *widget UNUSED, GtkSpinButton *spin)
{
if (GTK_WIDGET(spin) == throughput_threshold) {
Prefs.popup_throughput_threshold = gtk_spin_button_get_value_as_float(spin);
}
}
static void cb_reload_fonts(GtkWidget *widget) {
(void) widget;
if (strcmp(gtk_entry_get_text(GTK_ENTRY(entry_smallfont)), app->current_smallfont_name) ||
strcmp(gtk_entry_get_text(GTK_ENTRY(entry_bigfont)), app->current_bigfont_name)) {
ASSIGN_STRING(Prefs.smallfontname, gtk_entry_get_text(GTK_ENTRY(entry_smallfont)));
ASSIGN_STRING(Prefs.bigfontname, gtk_entry_get_text(GTK_ENTRY(entry_bigfont)));
init_fonts(app);
if (app->smallfont == NULL) {
gkrellm_config_message_dialog("font problem..", "could not load the small font");
} else gtk_entry_set_text(GTK_ENTRY(entry_smallfont), app->current_smallfont_name);
if (app->bigfont == NULL) {
gkrellm_config_message_dialog("font problem..", "could not load the big font");
} else gtk_entry_set_text(GTK_ENTRY(entry_bigfont), app->current_bigfont_name);
/* force recomputations of some dimensions */
app->displayed_hd_changed = 1; app->reshape_cnt++;
}
}
static void create_plugin_tab(GtkWidget *tab_vbox)
{
GtkWidget *tabs = NULL;
GtkWidget *options_tab = NULL;
GtkWidget *info_tab = NULL;
GtkWidget *info = NULL;
GtkWidget *about_tab = NULL;
GtkWidget *about = NULL;
GtkWidget *main_box;
static gchar *info_text[] =
{
"<b>" PLUGIN_NAME "\n\n",
PLUGIN_DESC "\n\n",
"improve your productivity with " PLUGIN_NAME ":\n",
"It monitors your hard-drives by sending visual stimuli to your cortex\n",
"each time your /dev/hdx writes or reads anything.\n",
"Try to launch openoffice and enjoy the gkhdplop show!\n\n",
"<i>Usage:\n\n",
"- Change the hard drive with the mouse wheel\n",
"- Animation reflecting swap activity...\n",
"- Background animation reflecting disk activity...\n",
"- Small led indicating disk activity...\n",
"- Several glittering color schemes...\n",
"- Popup display with the io throughput...\n",
};
static gchar *about_text =
_(
PLUGIN_NAME " " PLUGIN_VERSION "\n"
"a " PLUGIN_DESC "\n\n"
"Copyright (c) 2004 dae\n"
"jolly.frederic@fnac.net\n"
"http://quadaemon.free.fr\n\n"
"Based on wmhdplop\nCopyright (c) 2003,2004 pouaite\n"
PLUGIN_URL "\n\n"
"Released under the GNU Public Licence"
);
tabs = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(tab_vbox), tabs, TRUE, TRUE, 0);
/* Options tab */
options_tab = gkrellm_gtk_notebook_page(tabs, _("Options"));
main_box = gtk_vbox_new(FALSE, 0);
gtk_widget_set_name(main_box, "main_box");
gtk_widget_ref(main_box);
gtk_object_set_data_full(GTK_OBJECT (options_tab), "main_box", main_box,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(main_box);
gtk_container_add(GTK_CONTAINER (options_tab), main_box);
/* io button */
gkrellm_gtk_check_button_connected(main_box, &io_check, !Prefs.disable_io_matrix, 1, 1, 0,
option_toggled_cb, NULL, _("Show disk activity"));
/* swap button */
gkrellm_gtk_check_button_connected(main_box, &swap_check, !Prefs.disable_swap_matrix, 1, 1, 0,
option_toggled_cb, NULL, _("Show swap activity"));
/* hdlist button */
gkrellm_gtk_check_button_connected(main_box, &hdlist_check,
(Prefs.hdlist_pos == AL_NONE)?FALSE:TRUE, 1, 1, 0,
option_toggled_cb, NULL, _("Show disk name"));
/* leds button */
gkrellm_gtk_check_button_connected(main_box, &leds_check, !Prefs.disable_hd_leds, 1, 1, 0,
option_toggled_cb, NULL, _("Led indicating disk activity"));
gtk_widget_set_sensitive(leds_check, (Prefs.hdlist_pos == AL_NONE)?FALSE:TRUE);
/* hddtemp button */
gkrellm_gtk_check_button_connected(main_box, &hddtemp_check, Prefs.enable_hddtemp, 1, 1, 0,
option_toggled_cb, NULL,
_("Display hd temperature (requires hddtemp daemon running on port 7634)"));
gtk_widget_set_sensitive(hddtemp_check, (Prefs.hdlist_pos == AL_NONE)?FALSE:TRUE);
/* colormap spin button */
gkrellm_gtk_spin_button(main_box, NULL, Prefs.iomatrix_colormap, 0, 4, 1, 1, 0, 0,
cb_colormap_modified, NULL, FALSE, _("Colormap"));
/* threshold spin button */
gkrellm_gtk_spin_button(main_box, &throughput_threshold, Prefs.popup_throughput_threshold, 0., 500, 0.1, 1, 1, 0,
cb_spinbutton_modified, NULL, FALSE, _("minimum io throughput (MB/s)"));
{
GtkWidget *frame = gtk_frame_new("Fonts");
gtk_box_pack_start(GTK_BOX(main_box), frame, TRUE, FALSE, 0);
GtkWidget *hbox0 = gtk_hbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(frame), hbox0);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox0), vbox, TRUE, FALSE, 0);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 0);
entry_smallfont = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry_smallfont, TRUE, FALSE, 0);
GtkWidget *pLabel = gtk_label_new("Small font (without .ttf extension):");
gtk_entry_set_text(GTK_ENTRY(entry_smallfont), app->current_smallfont_name);
gtk_box_pack_start(GTK_BOX(hbox), pLabel, TRUE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 0);
entry_bigfont = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry_bigfont, TRUE, FALSE, 0);
gtk_entry_set_text(GTK_ENTRY(entry_bigfont), app->current_bigfont_name);
pLabel = gtk_label_new("Big font (without .ttf extension)");
gtk_box_pack_start(GTK_BOX(hbox), pLabel, TRUE, FALSE, 0);
gkrellm_gtk_button_connected(hbox0, NULL, TRUE/* expand*/, TRUE /* fill*/, 0 /*pad*/,
G_CALLBACK(cb_reload_fonts), NULL, "reload fonts");
}
/* Info tab */
info_tab = gkrellm_gtk_framed_notebook_page(tabs, _("Info"));
info = gkrellm_gtk_scrolled_text_view(info_tab, NULL, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gkrellm_gtk_text_view_append_strings(info, info_text, sizeof(info_text) / sizeof(gchar *));
/* About tab */
about_tab = gkrellm_gtk_notebook_page(tabs, _("About"));
about = gtk_label_new(about_text);
gtk_box_pack_start(GTK_BOX(about_tab), about, TRUE, TRUE, 0);
}
static void save_plugin_config(FILE *f)
{
fprintf(f, "%s options %d %d %d %d %d %d %f smallfont=%s bigfont=%s\n", PLUGIN_KEYWORD,
Prefs.disable_swap_matrix,
Prefs.disable_io_matrix,
Prefs.disable_hd_leds,
Prefs.hdlist_pos,
Prefs.enable_hddtemp,
Prefs.iomatrix_colormap,
Prefs.popup_throughput_threshold,
app->current_smallfont_name, app->current_bigfont_name);
}
static void load_plugin_config(gchar *config_line)
{
char sf[1000], bf[1000]; sf[0] = bf[0] = 0;
int n =sscanf(config_line, "options %d %d %d %d %d %d %f smallfont=%1000s bigfont=%1000s",
&Prefs.disable_swap_matrix,
&Prefs.disable_io_matrix,
&Prefs.disable_hd_leds,
&Prefs.hdlist_pos,
&Prefs.enable_hddtemp,
&Prefs.iomatrix_colormap,
&Prefs.popup_throughput_threshold,
sf, bf);
if (n>= 8) Prefs.smallfontname = strdup(sf);
if (n>= 9) Prefs.bigfontname = strdup(bf);
}
static GkrellmMonitor hdplop_mon =
{
PLUGIN_NAME, /* Name, for config tab. */
0, /* Id, 0 if a plugin */
create_plugin, /* The create_plugin() function */
NULL, /* The update_plugin() function */
create_plugin_tab, /* The create_plugin_tab() config function */
NULL, /* The apply_plugin_config() function */
save_plugin_config, /* The save_plugin_config() function */
load_plugin_config, /* The load_plugin_config() function */
PLUGIN_KEYWORD, /* config keyword */
NULL, /* Undefined 2 */
NULL, /* Undefined 1 */
NULL, /* private */
MON_CPU, /* Insert plugin before this monitor. */
NULL, /* Handle if a plugin, filled in by GKrellM */
NULL /* path if a plugin, filled in by GKrellM */
};
GkrellmMonitor *gkrellm_init_plugin(void)
{
gkrellm_add_meter_style(&hdplop_mon, PLUGIN_STYLE);
return (mon = &hdplop_mon);
}
Reference in a new issue View git blame Copy permalink