static void
update_plugin()
{
gint w_scroll, w_decal;
static gint x_scroll;
#if defined(GKRELLM_HAVE_DECAL_SCROLL_TEXT)
/* Gkrellm version 2.2.0 adds a scrolling text mode to a text decal so
| that inherently slow Pango text draws can be avoided at each scroll
| step as long as the sroll text string is unchanged.
*/
gkrellm_decal_scroll_text_set_text(panel, text1_decal, scroll_text);
gkrellm_decal_scroll_text_get_size(text1_decal, &w_scroll, NULL);
gkrellm_decal_get_size(text1_decal, &w_decal, NULL);
x_scroll -= 1;
if (x_scroll <= -w_scroll)
x_scroll = scroll_loop_mode ? 0 : w_decal;
gkrellm_decal_text_set_offset(text1_decal, x_scroll, 0);
#else
w_decal = text1_decal->w;
w_scroll = gdk_string_width(text1_decal->text_style.font, scroll_text);
x_scroll -= 1;
if (x_scroll <= -w_scroll)
x_scroll = w_decal;
text1_decal->x_off = x_scroll;
gkrellm_draw_decal_text(panel, text1_decal, scroll_text, x_scroll);
#endif
gkrellm_draw_panel_layers(panel);
}
static void
update_plugin()
{
gint w_scroll, w_decal;
static gint x_scroll;
if (command_pipe)
{
command_done();
}
if(GK.timer_ticks % 6 == 0)
{
run_command();
}
#if defined(GKRELLM_HAVE_DECAL_SCROLL_TEXT)
gkrellm_decal_scroll_text_set_text(panel, text1_btc, btc_text);
gkrellm_decal_scroll_text_get_size(text1_btc, &w_scroll, NULL);
gkrellm_decal_get_size(text1_btc, &w_decal, NULL);
x_scroll -= 1;
if (x_scroll <= -w_scroll)
x_scroll = scroll_loop_mode ? 0 : w_decal;
gkrellm_decal_text_set_offset(text1_btc, x_scroll, 0);
#else
w_decal = text1_btc->w;
w_scroll = gdk_string_width(text1_btc->text_style.font, scroll_text);
x_scroll -= 1;
if (x_scroll <= -w_scroll)
x_scroll = w_decal;
text1_btc->x_off = x_scroll;
gkrellm_draw_decal_text(panel, text1_btc, scroll_text, x_scroll);
#endif
gkrellm_draw_panel_layers(panel);
}
static void update_plugin() {
if(!pGK->second_tick) {
return;
}
if (gov_enable_current) {
read_governors();
}
read_khz();
unsigned int cpu;
if (slider_enable_current) {
for( cpu=0; cpu<ncpu; ++cpu ) {
if (!slider_in_motion[cpu]) {
int krellpos = slider_krell[cpu]->w_scale*khz[cpu]/khz_max;
gkrellm_update_krell(panel, slider_krell[cpu], krellpos);
}
}
}
char theText[length];
for ( cpu=0; cpu<ncpu; ++cpu ) {
sprintf(theText, "%d MHz", (int)((khz[cpu]+500)/1000));
text_decal_freq[cpu]->x_off = 0;
gkrellm_draw_decal_text(panel, text_decal_freq[cpu], theText, -1);
text_decal_gov[cpu]->x_off = 0;
gkrellm_draw_decal_text(panel, text_decal_gov[cpu], governor_text[cpu], -1);
}
gkrellm_draw_panel_layers(panel);
}
void set_onoff_button(int on) {
int imgid;
if (on)
imgid = D_MISC_BUTTON_ON;
else
imgid = D_MISC_BUTTON_OUT;
gkrellm_set_decal_button_index(onoff_button, imgid);
gkrellm_draw_panel_layers(panel);
}
void
do_switch_station(int nr) {
gchar *text_utf8 = NULL, *text_locale = NULL;
nr %= nstations;
currentstation = nr;
start_mute_timer();
radio_setfreq(stations[nr].freq);
gkrellm_locale_dup_string(&text_utf8, stations[nr].station_name, &text_locale);
gkrellm_draw_decal_text(panel, station_text,
text_locale, -1);
gkrellm_draw_panel_layers(panel);
gkrellm_config_modified();
}
void
gkrellm_draw_panel_layers_force(GkrellmPanel *p)
{
GList *list;
if (!p)
return;
for (list = p->decal_list; list; list = list->next)
((GkrellmDecal *) list->data)->modified = TRUE;
for (list = p->krell_list; list; list = list->next)
((GkrellmKrell *) list->data)->modified = TRUE;
gkrellm_draw_panel_layers(p);
}
static void
cb_button(GkrellmDecalbutton *button, gpointer data)
{
if (GPOINTER_TO_INT(data) == 0)
{
printf("Large scaled button pressed.\n");
#if defined(GKRELLM_HAVE_DECAL_SCROLL_TEXT)
/* Demonstrate the scroll looping mode.
*/
printf("Toggling horizontal loop mode.\n");
scroll_loop_mode = !scroll_loop_mode;
scroll_text = scroll_loop_mode
? "Some scrolling text -- "
: "Some scrolling text";
gkrellm_decal_scroll_text_horizontal_loop(text1_decal,
scroll_loop_mode);
#endif
}
else if (GPOINTER_TO_INT(data) == 1)
printf("Small auto-hiding scaled button pressed\n");
else if (GPOINTER_TO_INT(data) == 2)
{
printf("button for text2_decal pressed\n");
button_state = !button_state;
/* Draw new text on the button. For gkrellm versions < 2.2.0, decal
| drawing occurs only if the decal "value" (the last argument)
| changes. The "value" is ignored in gkrellm versions >= 2.2.0
| and text is internally checked for changes before being redrawn.
| To be compatible with all versions, just pass the index of the
| text string we draw because it will change each time a different
| string is drawn.
*/
gkrellm_draw_decal_text(panel, text2_decal,
button_text[button_state], button_state);
/* Decal draws don't show up until gkrellm_draw_panel_layers() is
| called. This is done in update_plugin(), so doing it here is only
| useful if the update_plugin() updates infrequently and we don't
| want a delay before the change is seen. So for this demo, it does
| not need to be done here, but I do it anyway for emphasis.
*/
gkrellm_draw_panel_layers(panel);
}
else if (GPOINTER_TO_INT(data) == 3)
printf("button for pixmap_decal pressed\n");
}
static void update_slider_position(GkrellmKrell *k,
gint x_ev,
unsigned int cpu) {
if (k) {
gint x;
/* Consider only x_ev values that are inside the dynamic range of the
krell.
*/
x = x_ev - k->x0;
if (x < 0)
x = 0;
if (x > k->w_scale)
x = k->w_scale;
gkrellm_update_krell(panel, k, x);
gkrellm_draw_panel_layers(panel);
slider_value[cpu] = (double) x / (double) k->w_scale; /* ranges 0.0-1.0 */
}
}
static void
update_proc(void)
{
GkrellmChart *cp;
GkrellmPanel *p;
gint load;
if (!proc.enabled)
return;
(*read_proc_data)();
if (GK.five_second_tick)
{
(*read_user_data)();
gkrellm_check_alert(users_alert, proc.n_users);
}
cp = proc.chart;
p = cp->panel;
gkrellm_update_krell(p, KRELL(p), proc.n_forks);
gkrellm_draw_panel_layers(p);
if (GK.second_tick)
{
/* Scale load since it is a small real and charts are integer only.
| Scale the forks number by fork_scaling. See setup_proc_scaling().
*/
load = (int) (LOAD_SCALING * proc.fload);
gkrellm_store_chartdata(cp, 0, load, fork_scaling * proc.n_forks);
refresh_proc_chart(cp);
gkrellm_check_alert(load_alert, proc.fload);
gkrellm_check_alert(processes_alert, proc.n_processes);
gkrellm_panel_label_on_top_of_decals(p,
gkrellm_alert_decal_visible(load_alert) ||
gkrellm_alert_decal_visible(users_alert) ||
gkrellm_alert_decal_visible(processes_alert));
}
if ( (GK.two_second_tick && !sensor_separate_mode)
|| (GK.five_second_tick && sensor_separate_mode)
)
draw_sensor_decals();
}
static void
update_plugin()
{
Reader *reader;
gchar *text;
u_long val, since_last;
gint clock_style_id;
// GkrellmKrell *k;
// gint i;
/* See if we recieved SNMP responses */
simpleSNMPupdate();
/* Send new SNMP requests */
for (reader = readers; reader ; reader = reader->next)
{
// k = KRELL(panel);
// k->previous = 0;
if ( (! reader->session) && (! reader->old_error) ) {
reader->session = simpleSNMPopen(reader->peer,
reader->port,
reader->community,
reader);
if (! reader->session) {
text = reader->old_error;
reader->old_error = render_error(reader);
g_free(text);
}
}
/* Send new SNMP requests */
if ( (reader->session) && ((GK.timer_ticks % reader->delay) == 0))
simpleSNMPsend(reader->session,
reader->objid,
reader->objid_length);
if ( (reader->session) && (reader->sample) ) {
if ((reader->error) && (reader->panel != NULL)) {
if (!reader->old_error ||
strcmp(reader->error,
reader->old_error) ) {
text = reader->old_error;
reader->old_error = g_strdup(reader->error);
g_free(text);
reader->panel->textstyle = gkrellm_panel_alt_textstyle(DEFAULT_STYLE_ID);
text = render_error(reader);
gtk_tooltips_set_tip(reader->tooltip, reader->panel->drawing_area, text, "");
gtk_tooltips_enable(reader->tooltip);
g_free(text);
}
} else {
if ((GK.timer_ticks % reader->delay) == 0)
if (reader->chart != NULL)
{
/* 100: turn TimeTicks into seconds */
since_last = (reader->sample_time - reader->old_sample_time) / 100;
if (reader->delta)
val = (reader->sample_n - reader->old_sample_n) /
( (since_last < 1) ? 1 : since_last ) /
( (reader->divisor == 0) ? 1 : reader->divisor );
else
val = reader->sample_n /
( (reader->divisor == 0) ? 1 : reader->divisor );
gkrellm_store_chartdata(reader->chart, 0, val);
cb_draw_chart(reader);
text = render_info(reader);
gtk_tooltips_set_tip(reader->tooltip, reader->chart->drawing_area, text, "");
gtk_tooltips_enable(reader->tooltip);
g_free(text);
reader->old_sample_n = reader->sample_n;
reader->old_sample_time = reader->sample_time;
}
/* if there are changes update label */
if (reader->panel != NULL)
{
reader->panel->textstyle = gkrellm_panel_textstyle(DEFAULT_STYLE_ID);
if ( !reader->old_sample || strcmp(reader->sample,
reader->old_sample) ||
(reader->sample_n != reader->old_sample_n) ) {
g_free(reader->old_sample);
reader->old_sample = g_strdup(reader->sample);
text = render_label(reader);
gkrellm_dup_string(&reader->panel->label->string, text);
g_free(text);
// i = atoi(text);
text = render_info(reader);
gtk_tooltips_set_tip(reader->tooltip, reader->panel->drawing_area, text, "");
gtk_tooltips_enable(reader->tooltip);
g_free(text);
reader->old_sample_n = reader->sample_n;
reader->old_sample_time = reader->sample_time;
}
}
}
} else {
if (reader->panel != NULL)
reader->panel->textstyle = gkrellm_panel_alt_textstyle(DEFAULT_STYLE_ID);
if (reader->panel != NULL)
gtk_tooltips_disable(reader->tooltip);
// i = -1;
}
// gkrellm_update_krell(panel, k, i);
clock_style_id = gkrellm_lookup_meter_style_id(CLOCK_STYLE_NAME);
if (reader->panel != NULL)
gkrellm_draw_panel_label( reader->panel );
//GTK2 gkrellm_bg_panel_piximage(clock_style_id) );
if (reader->panel != NULL)
gkrellm_draw_panel_layers(reader->panel);
}
}
static void
create_plugin(GtkWidget *vbox, gint first_create) {
GkrellmStyle *style;
GkrellmTextstyle *ts, *ts_alt;
GkrellmMargin *margin;
GdkPixmap *pixmap;
GdkBitmap *mask;
gint y;
gint x;
gchar *text_utf8 = NULL, *text_locale = NULL;
if (first_create) {
panel = gkrellm_panel_new0();
gkrellm_disable_plugin_connect(plugin_monitor,close_radio);
/* create the frequency menu */
create_freq_menu();
} else
gkrellm_destroy_decal_list(panel);
style = gkrellm_meter_style(style_id);
/* Each GkrellmStyle has two text styles. The theme designer has picked the
| colors and font sizes, presumably based on knowledge of what you draw
| on your panel. You just do the drawing. You probably could assume
| the ts font is larger than the ts_alt font, but again you can be
| overridden by the theme designer.
*/
ts = gkrellm_meter_textstyle(style_id);
ts_alt = gkrellm_meter_alt_textstyle(style_id);
panel->textstyle = ts; /* would be used for a panel label */
y = 2; /* some border */
station_text = gkrellm_create_decal_text(panel, _("Hello World"), ts_alt, style, 2, y, 40);
/* Create a pixmap decal and place it to the right of station_text. Use
| decals from the builtin decal_misc.xpm.
*/
pixmap = gkrellm_decal_misc_pixmap();
mask = gkrellm_decal_misc_mask();
x = station_text->x + station_text->w + 4;
decal_onoff_pix = gkrellm_create_decal_pixmap(panel, pixmap, mask,
N_MISC_DECALS, NULL, x, y);
/* Configure the panel to hold the above created decals, add in a little
| bottom margin for looks, and create the panel.
*/
gkrellm_panel_configure(panel, NULL, style);
gkrellm_panel_create(vbox, plugin_monitor,panel);
/* After the panel is created, the decals can be converted into buttons.
| First draw the initial text into the text decal button and then
| put the text decal into a meter button. But for the decal_onoff_pix,
| we can directly convert it into a decal button since it is a pixmap
| decal. Just pass the frame we want to be the out image and the
| frame for the in or pressed image.
*/
gkrellm_locale_dup_string(&text_utf8, station_name(radio_getfreq()), &text_locale);
gkrellm_draw_decal_text(panel, station_text, text_locale,
button_state);
margin = gkrellm_get_style_margins(style);
gkrellm_put_decal_in_meter_button(panel, station_text, cb_button,
GINT_TO_POINTER(1),margin);
onoff_button =
gkrellm_make_decal_button(panel, decal_onoff_pix, cb_button,
GINT_TO_POINTER(2),
onoff_state ? D_MISC_BUTTON_ON : D_MISC_BUTTON_OUT,
D_MISC_BUTTON_IN);
/* Note: all of the above gkrellm_draw_decal_XXX() calls will not
| appear on the panel until a gkrellm_draw_layers(panel); call is
| made. This will be done in update_plugin(), otherwise we would
| make the call here and anytime the decals are changed.
*/
if (first_create) {
g_signal_connect(GTK_OBJECT (panel->drawing_area), "expose_event",
(GtkSignalFunc) panel_expose_event, NULL);
g_signal_connect(GTK_OBJECT (panel->drawing_area), "button_release_event",
GTK_SIGNAL_FUNC(button_release_event), NULL);
g_signal_connect(GTK_OBJECT (panel->drawing_area), "scroll_event",
GTK_SIGNAL_FUNC(scroll_event), NULL);
reopen_radio();
}
gkrellm_draw_panel_layers(panel);
}
static void set_text_freq(float freq) {
gchar *text_utf8 = NULL, *text_locale = NULL;
gkrellm_locale_dup_string(&text_utf8, station_name(freq), &text_locale);
gkrellm_draw_decal_text(panel, station_text, text_locale, -1);
gkrellm_draw_panel_layers(panel);
}
/* How to decide when to make the sensor_decal and fan_decal visible.
| The sensor_decal can show temp values, fan values, or alternating
| temp/fan values. The fan_decal only shows fan values when non
| alternating mode is selected. The sensors are mapped in sensors.c
|
| Sensor and fan decal display truth table:
| |-----decals visible----||--sensors mapped--| separate |
| |sensor_decal fan_decal|| temp fan | mode |
| |-----------------------||--------------------------------|
| | 0 0 || 0 0 0 |
| | 1 0 || 1 0 0 |
| | 1 0 || 0 1 0 |
| | 1 0 || 1 1 0 |
| | 0 0 || 0 0 1 |
| | 1 0 || 1 0 1 |
| | 1 0 || 0 1 1 |
| | 1 1 || 1 1 1 |
| |----------------------------------------------------------
*/
static gboolean
adjust_sensors_display(gint force)
{
GkrellmPanel *p;
GkrellmDecal *ds, *df;
GkrellmAlert *alert;
gint position = 0;
ds = proc.sensor_decal;
df = proc.fan_decal;
if (!ds || !df)
return FALSE;
/* The test for state change is decal state vs success at reading
| a temperature.
*/
p = proc.chart->panel;
show_temperature = show_fan = FALSE;
if (!_GK.demo)
{
gkrellm_sensor_alert_connect(proc.sensor_temp,
cb_mb_temp_alert_trigger, &proc);
gkrellm_sensor_alert_connect(proc.sensor_fan,
cb_mb_fan_alert_trigger, &proc);
}
/* If a fan alert is triggered, turn it off in case fan decal being used
| is changed. The alert will just retrigger at next fan update.
*/
alert = gkrellm_sensor_alert(proc.sensor_fan);
gkrellm_reset_alert_soft(alert);
if (proc.sensor_temp || _GK.demo)
show_temperature = TRUE;
if (proc.sensor_fan || _GK.demo)
show_fan = TRUE;
if (show_temperature || show_fan)
{
if (! gkrellm_is_decal_visible(ds) || force)
gkrellm_make_decal_visible(p, ds);
position = 0;
}
else
{
if (gkrellm_is_decal_visible(ds) || force)
gkrellm_make_decal_invisible(p, ds);
position = proc.save_label_position;
}
if (show_fan && show_temperature && sensor_separate_mode)
{
if (! gkrellm_is_decal_visible(df) || force)
gkrellm_make_decal_visible(p, df);
position = -1;
}
else
{
if (gkrellm_is_decal_visible(df) || force)
gkrellm_make_decal_invisible(p, df);
}
if (position != p->label->position || force)
{
if (proc.save_label_position >= 0) /* Reassign position only if the */
p->label->position = position; /* original label was visible. */
gkrellm_draw_panel_label(p);
draw_sensor_decals();
gkrellm_draw_panel_layers(p);
}
return TRUE;
}
