diff options
Diffstat (limited to '')
| -rw-r--r-- | src/load-graph.cpp | 1119 |
1 files changed, 1119 insertions, 0 deletions
diff --git a/src/load-graph.cpp b/src/load-graph.cpp new file mode 100644 index 0000000..377623f --- /dev/null +++ b/src/load-graph.cpp @@ -0,0 +1,1119 @@ +/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +#include <config.h> + +#include <math.h> + +#include <glib/gi18n.h> + +#include <glibtop.h> +#include <glibtop/cpu.h> +#include <glibtop/mem.h> +#include <glibtop/swap.h> +#include <glibtop/netload.h> +#include <glibtop/netlist.h> + +#include "application.h" +#include "load-graph.h" +#include "util.h" +#include "legacy/gsm_color_button.h" + +gchar* format_duration(unsigned seconds); + +void LoadGraph::clear_background() +{ + if (background) { + cairo_surface_destroy (background); + background = NULL; + } +} + +bool LoadGraph::is_logarithmic_scale() const +{ + // logarithmic scale is used only for memory graph + return this->type == LOAD_GRAPH_MEM && GsmApplication::get()->config.logarithmic_scale; +} + +unsigned LoadGraph::num_bars() const +{ + unsigned n; + + // keep 100 % num_bars == 0 + switch (static_cast<int>(draw_height / (fontsize + 14))) + { + case 0: + case 1: + n = 1; + break; + case 2: + case 3: + n = 2; + break; + case 4: + n = 4; + break; + case 5: + n = 5; + if (this->is_logarithmic_scale()) + n = 4; + break; + default: + n = 5; + if (this->is_logarithmic_scale()) + n = 6; + } + + return n; +} + +/* + Returns Y scale caption based on give index of the label. + Takes into account whether the scale should be logarithmic for memory graph. + */ +char* LoadGraph::get_caption(guint index) +{ + char *caption; + unsigned num_bars = this->num_bars(); + guint64 max_value; + if (this->type == LOAD_GRAPH_NET) + max_value = this->net.max; + else + max_value = 100; + + // operation orders matters so it's 0 if index == num_bars + float caption_percentage = (float)max_value - index * (float)max_value / num_bars; + + if (this->is_logarithmic_scale()) { + float caption_value = caption_percentage == 0 ? 0 : pow(100, caption_percentage / max_value); + // Translators: loadgraphs y axis percentage labels: 0 %, 50%, 100% + caption = g_strdup_printf(_("%.0f %%"), caption_value); + } else if (this->type == LOAD_GRAPH_NET) { + const std::string captionstr(procman::format_network_rate((guint64)caption_percentage)); + caption = g_strdup(captionstr.c_str()); + } else { + // Translators: loadgraphs y axis percentage labels: 0 %, 50%, 100% + caption = g_strdup_printf(_("%.0f %%"), caption_percentage); + } + + return caption; +} + +/* + Translates y partial position to logarithmic position if set to logarithmic scale. +*/ +float LoadGraph::translate_to_log_partial_if_needed(float position_partial) +{ + if (this->is_logarithmic_scale()) + position_partial = position_partial == 0 ? 0 : log10(position_partial * 100) / 2; + + return position_partial; +} + +gchar* format_duration(unsigned seconds) { + gchar* caption = NULL; + + unsigned minutes = seconds / 60; + unsigned hours = seconds / 3600; + + if (hours != 0) { + if (minutes % 60 == 0) { + // If minutes mod 60 is 0 set it to 0, to prevent it from showing full hours in + // minutes in addition to hours. + minutes = 0; + } else { + // Round minutes as seconds wont get shown if neither hours nor minutes are 0. + minutes = int(rint(seconds / 60.0)) % 60; + if (minutes == 0) { + // Increase hours if rounding minutes results in 0, because that would be + // what it would be rounded to. + hours++; + // Set seconds to hours * 3600 to prevent seconds from being drawn. + seconds = hours * 3600; + } + } + + } + + gchar* captionH = g_strdup_printf(dngettext(GETTEXT_PACKAGE, "%u hr", "%u hrs", hours), hours); + gchar* captionM = g_strdup_printf(dngettext(GETTEXT_PACKAGE, "%u min", "%u mins", minutes), + minutes); + gchar* captionS = g_strdup_printf(dngettext(GETTEXT_PACKAGE, "%u sec", "%u secs", seconds % 60), + seconds % 60); + + caption = g_strjoin (" ", hours > 0 ? captionH : "", + minutes > 0 ? captionM : "", + seconds % 60 > 0 ? captionS : "", + NULL); + g_free (captionH); + g_free (captionM); + g_free (captionS); + + return caption; +} + +const int FRAME_WIDTH = 4; +static void draw_background(LoadGraph *graph) { + GtkAllocation allocation; + cairo_t *cr; + guint i; + double label_x_offset_modifier, label_y_offset_modifier; + unsigned num_bars; + gchar *caption; + PangoLayout* layout; + PangoAttrList *attrs = NULL; + PangoFontDescription* font_desc; + PangoRectangle extents; + cairo_surface_t *surface; + GdkRGBA fg; + GdkRGBA fg_grid; + double const border_alpha = 0.7; + double const grid_alpha = border_alpha / 2.0; + + num_bars = graph->num_bars(); + graph->graph_dely = (graph->draw_height - 15) / num_bars; /* round to int to avoid AA blur */ + graph->real_draw_height = graph->graph_dely * num_bars; + graph->graph_delx = (graph->draw_width - 2.0 - graph->indent) / (graph->num_points - 3); + graph->graph_buffer_offset = (int) (1.5 * graph->graph_delx) + FRAME_WIDTH; + + gtk_widget_get_allocation (GTK_WIDGET (graph->disp), &allocation); + surface = gdk_window_create_similar_surface (gtk_widget_get_window (GTK_WIDGET (graph->disp)), + CAIRO_CONTENT_COLOR_ALPHA, + allocation.width, + allocation.height); + cr = cairo_create (surface); + + GtkStyleContext *context = gtk_widget_get_style_context (GTK_WIDGET (GsmApplication::get()->stack)); + + gtk_style_context_get_color (context, gtk_widget_get_state_flags (GTK_WIDGET (GsmApplication::get()->stack)), &fg); + + cairo_paint_with_alpha (cr, 0.0); + layout = pango_cairo_create_layout (cr); + + attrs = make_tnum_attr_list (); + pango_layout_set_attributes (layout, attrs); + g_clear_pointer (&attrs, pango_attr_list_unref); + + gtk_style_context_get (context, gtk_widget_get_state_flags (GTK_WIDGET (GsmApplication::get()->stack)), GTK_STYLE_PROPERTY_FONT, &font_desc, NULL); + pango_font_description_set_size (font_desc, 0.8 * graph->fontsize * PANGO_SCALE); + pango_layout_set_font_description (layout, font_desc); + pango_font_description_free (font_desc); + + /* draw frame */ + cairo_translate (cr, FRAME_WIDTH, FRAME_WIDTH); + + /* Draw background rectangle */ + /* When a user uses a dark theme, the hard-coded + * white background in GSM is a lone white on the + * display, which makes the user unhappy. To fix + * this, here we offer the user a chance to set + * his favorite background color. */ + gtk_style_context_save (context); + + /* Here we specify the name of the class. Now in + * the theme's CSS we can specify the own colors + * for this class. */ + gtk_style_context_add_class (context, "loadgraph"); + + /* And in case the user does not care, we add + * classes that usually have a white background. */ + gtk_style_context_add_class (context, GTK_STYLE_CLASS_PAPER); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_ENTRY); + + /* And, as a bonus, the user can choose the color of the grid. */ + gtk_style_context_get_color (context, gtk_widget_get_state_flags (GTK_WIDGET (GsmApplication::get()->stack)), &fg_grid); + + /* Why not use the new features of the + * GTK instead of cairo_rectangle ?! :) */ + gtk_render_background (context, cr, graph->indent, 0.0, + graph->draw_width - graph->rmargin - graph->indent, + graph->real_draw_height); + + gtk_style_context_restore (context); + + cairo_set_line_width (cr, 1.0); + + for (i = 0; i <= num_bars; ++i) { + double y; + + if (i == 0) + y = 0.5 + graph->fontsize / 2.0; + else if (i == num_bars) + y = i * graph->graph_dely + 0.5; + else + y = i * graph->graph_dely + graph->fontsize / 2.0; + + gdk_cairo_set_source_rgba (cr, &fg); + caption = graph->get_caption(i); + pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT); + pango_layout_set_text (layout, caption, -1); + pango_layout_get_extents (layout, NULL, &extents); + label_y_offset_modifier = i == 0 ? 0.5 + : i == num_bars + ? 1.0 + : 0.85; + cairo_move_to (cr, graph->draw_width - graph->indent - 23, + y - label_y_offset_modifier * extents.height / PANGO_SCALE); + pango_cairo_show_layout (cr, layout); + g_free(caption); + + if (i==0 || i==num_bars) + fg_grid.alpha = border_alpha; + else + fg_grid.alpha = grid_alpha; + + gdk_cairo_set_source_rgba (cr, &fg_grid); + cairo_move_to (cr, graph->indent, i * graph->graph_dely + 0.5); + cairo_line_to (cr, graph->draw_width - graph->rmargin + 0.5 + 4, i * graph->graph_dely + 0.5); + cairo_stroke (cr); + } + + + const unsigned total_seconds = graph->speed * (graph->num_points - 2) / 1000 * graph->frames_per_unit; + + for (unsigned int i = 0; i < 7; i++) { + double x = (i) * (graph->draw_width - graph->rmargin - graph->indent) / 6; + + if (i==0 || i==6) + fg_grid.alpha = border_alpha; + else + fg_grid.alpha = grid_alpha; + + gdk_cairo_set_source_rgba (cr, &fg_grid); + cairo_move_to (cr, (ceil(x) + 0.5) + graph->indent, 0.5); + cairo_line_to (cr, (ceil(x) + 0.5) + graph->indent, graph->real_draw_height + 4.5); + cairo_stroke(cr); + + caption = format_duration(total_seconds - i * total_seconds / 6); + + pango_layout_set_text (layout, caption, -1); + pango_layout_get_extents (layout, NULL, &extents); + label_x_offset_modifier = i == 0 ? 0 + : i == 6 + ? 1.0 + : 0.5; + cairo_move_to (cr, + (ceil(x) + 0.5 + graph->indent) - label_x_offset_modifier * extents.width / PANGO_SCALE + 1.0, + graph->draw_height - 1.0 * extents.height / PANGO_SCALE); + gdk_cairo_set_source_rgba (cr, &fg); + pango_cairo_show_layout (cr, layout); + g_free (caption); + } + g_object_unref(layout); + cairo_stroke (cr); + cairo_destroy (cr); + graph->background = surface; +} + +/* Redraws the backing buffer for the load graph and updates the window */ +void +load_graph_queue_draw (LoadGraph *graph) +{ + /* repaint */ + gtk_widget_queue_draw (GTK_WIDGET (graph->disp)); +} + +void load_graph_update_data (LoadGraph *graph); +static int load_graph_update (gpointer user_data); // predeclare load_graph_update so we can compile ;) + +static void +load_graph_rescale (LoadGraph *graph) { + ///org/gnome/desktop/interface/text-scaling-factor + graph->fontsize = 8 * graph->font_settings->get_double ("text-scaling-factor"); + graph->clear_background(); + + load_graph_queue_draw (graph); +} + +static gboolean +load_graph_configure (GtkWidget *widget, + GdkEventConfigure *event, + gpointer data_ptr) +{ + GtkAllocation allocation; + LoadGraph * const graph = static_cast<LoadGraph*>(data_ptr); + + load_graph_rescale (graph); + + gtk_widget_get_allocation (widget, &allocation); + graph->draw_width = allocation.width - 2 * FRAME_WIDTH; + graph->draw_height = allocation.height - 2 * FRAME_WIDTH; + + graph->clear_background(); + + load_graph_queue_draw (graph); + + return TRUE; +} + +static void force_refresh (LoadGraph * const graph) +{ + graph->clear_background(); + load_graph_queue_draw (graph); +} + +static void +load_graph_style_updated (GtkWidget *widget, + gpointer data_ptr) +{ + LoadGraph * const graph = static_cast<LoadGraph*>(data_ptr); + force_refresh (graph); +} + +static gboolean +load_graph_state_changed (GtkWidget *widget, + GtkStateFlags *flags, + gpointer data_ptr) +{ + LoadGraph * const graph = static_cast<LoadGraph*>(data_ptr); + force_refresh (graph); + graph->draw = gtk_widget_is_visible (widget); + return TRUE; +} + +static gboolean +load_graph_draw (GtkWidget *widget, + cairo_t * cr, + gpointer data_ptr) +{ + LoadGraph * const graph = static_cast<LoadGraph*>(data_ptr); + + guint i; + gint j; + gdouble sample_width, x_offset; + + /* Number of pixels wide for one sample point */ + sample_width = (double)(graph->draw_width - graph->rmargin - graph->indent) / (double)graph->num_points; + /* Lines start at the right edge of the drawing, + * a bit outside the clip rectangle. */ + x_offset = graph->draw_width - graph->rmargin + sample_width + 2; + /* Adjustment for smooth movement between samples */ + x_offset -= sample_width * graph->render_counter / (double)graph->frames_per_unit; + + /* draw the graph */ + + if (graph->background == NULL) { + draw_background(graph); + } + cairo_set_source_surface (cr, graph->background, 0, 0); + cairo_paint (cr); + + cairo_set_line_width (cr, 1); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); + cairo_rectangle (cr, graph->indent + FRAME_WIDTH + 1, FRAME_WIDTH - 1, + graph->draw_width - graph->rmargin - graph->indent - 1, + graph->real_draw_height + FRAME_WIDTH - 1); + cairo_clip(cr); + + bool drawStacked = graph->type == LOAD_GRAPH_CPU && GsmApplication::get()->config.draw_stacked; + bool drawSmooth = GsmApplication::get()->config.draw_smooth; + for (j = graph->n-1; j >= 0; j--) { + gdk_cairo_set_source_rgba (cr, &(graph->colors [j])); + // Start drawing on the right at the correct height. + cairo_move_to (cr, x_offset, (1.0f - graph->data[0][j]) * graph->real_draw_height + 3); + // then draw the path of the line. + // Loop starts at 1 because the curve accesses the 0th data point. + for (i = 1; i < graph->num_points; ++i) { + if (graph->data[i][j] == -1.0f) + continue; + if (drawSmooth) { + cairo_curve_to (cr, + x_offset - ((i - 0.5f) * graph->graph_delx), + (1.0 - graph->data[i-1][j]) * graph->real_draw_height + 3, + x_offset - ((i - 0.5f) * graph->graph_delx), + (1.0 - graph->data[i][j]) * graph->real_draw_height + 3, + x_offset - (i * graph->graph_delx), + (1.0 - graph->data[i][j]) * graph->real_draw_height + 3); + } else { + cairo_line_to (cr, x_offset - (i * graph->graph_delx), + (1.0 - graph->data[i][j]) * graph->real_draw_height + 3); + } + + } + if (drawStacked) { + // Draw the remaining outline of the area: + // Left bottom corner + cairo_rel_line_to (cr, 0, graph->real_draw_height + 3); + // Right bottom corner. It's drawn far outside the visible area + // to avoid a weird bug where it's not filling the area it should completely. + cairo_rel_line_to (cr, x_offset * 2, 0); + + //cairo_stroke_preserve(cr); + cairo_close_path(cr); + cairo_fill(cr); + } else { + cairo_stroke (cr); + } + } + + return TRUE; +} + +void +load_graph_reset (LoadGraph *graph) +{ + std::fill(graph->data_block.begin(), graph->data_block.end(), -1.0); +} + +static void +get_load (LoadGraph *graph) +{ + guint i; + glibtop_cpu cpu; + + glibtop_get_cpu (&cpu); + + auto NOW = [&]() -> guint64 (&)[GLIBTOP_NCPU][N_CPU_STATES] { return graph->cpu.times[graph->cpu.now]; }; + auto LAST = [&]() -> guint64 (&)[GLIBTOP_NCPU][N_CPU_STATES] { return graph->cpu.times[graph->cpu.now ^ 1]; }; + + if (graph->n == 1) { + NOW()[0][CPU_TOTAL] = cpu.total; + NOW()[0][CPU_USED] = cpu.user + cpu.nice + cpu.sys; + } else { + for (i = 0; i < graph->n; i++) { + NOW()[i][CPU_TOTAL] = cpu.xcpu_total[i]; + NOW()[i][CPU_USED] = cpu.xcpu_user[i] + cpu.xcpu_nice[i] + + cpu.xcpu_sys[i]; + } + } + + // on the first call, LAST is 0 + // which means data is set to the average load since boot + // that value has no meaning, we just want all the + // graphs to be aligned, so the CPU graph needs to start + // immediately + bool drawStacked = graph->type == LOAD_GRAPH_CPU && GsmApplication::get()->config.draw_stacked; + + for (i = 0; i < graph->n; i++) { + float load; + float total, used; + gchar *text; + + total = NOW()[i][CPU_TOTAL] - LAST()[i][CPU_TOTAL]; + used = NOW()[i][CPU_USED] - LAST()[i][CPU_USED]; + + load = used / MAX(total, 1.0f); + graph->data[0][i] = load; + if (drawStacked) { + graph->data[0][i] /= graph->n; + if (i > 0) { + graph->data[0][i] += graph->data[0][i-1]; + } + } + + /* Update label */ + // Translators: CPU usage percentage label: 95.7% + text = g_strdup_printf(_("%.1f%%"), load * 100.0f); + gtk_label_set_text(GTK_LABEL(graph->labels.cpu[i]), text); + g_free(text); + } + + graph->cpu.now ^= 1; +} + + +namespace +{ + + void set_memory_label_and_picker(GtkLabel* label, GsmColorButton* picker, + guint64 used, guint64 cached, guint64 total, double percent) + { + char* used_text; + char* cached_text; + char* cached_label; + char* total_text; + char* text; + + used_text = format_byte_size(used, GsmApplication::get()->config.resources_memory_in_iec); + cached_text = format_byte_size(cached, GsmApplication::get()->config.resources_memory_in_iec); + total_text = format_byte_size(total, GsmApplication::get()->config.resources_memory_in_iec); + if (total == 0) { + text = g_strdup(_("not available")); + } else { + // xgettext: "540MiB (53 %) of 1.0 GiB" or "540MB (53 %) of 1.0 GB" + text = g_strdup_printf(_("%s (%.1f%%) of %s"), used_text, 100.0 * percent, total_text); + + if (cached != 0) { + // xgettext: Used cache string, e.g.: "Cache 2.4GiB" or "Cache 2.4GB" + cached_label = g_strdup_printf(_("Cache %s"), cached_text); + text = g_strdup_printf("%s\n%s", text, cached_label); + g_free (cached_label); + } + } + gtk_label_set_text(label, text); + g_free(used_text); + g_free(cached_text); + g_free(total_text); + g_free(text); + + if (picker) + gsm_color_button_set_fraction(picker, percent); + } +} + +static void +get_memory (LoadGraph *graph) +{ + float mempercent, swappercent; + + glibtop_mem mem; + glibtop_swap swap; + + glibtop_get_mem (&mem); + glibtop_get_swap (&swap); + + /* There's no swap on LiveCD : 0.0f is better than NaN :) */ + swappercent = (swap.total ? (float)swap.used / (float)swap.total : 0.0f); + mempercent = (float)mem.user / (float)mem.total; + set_memory_label_and_picker(GTK_LABEL(graph->labels.memory), + GSM_COLOR_BUTTON(graph->mem_color_picker), + mem.user, mem.cached, mem.total, mempercent); + + set_memory_label_and_picker(GTK_LABEL(graph->labels.swap), + GSM_COLOR_BUTTON(graph->swap_color_picker), + swap.used, 0, swap.total, swappercent); + + gtk_widget_set_sensitive (GTK_WIDGET (graph->swap_color_picker), swap.total > 0); + + graph->data[0][0] = graph->translate_to_log_partial_if_needed(mempercent); + graph->data[0][1] = swap.total>0 ? graph->translate_to_log_partial_if_needed(swappercent) : -1.0; +} + +/* Nice Numbers for Graph Labels after Paul Heckbert + nicenum: find a "nice" number approximately equal to x. + Round the number if round=1, take ceiling if round=0 */ + +static double +nicenum (double x, int round) +{ + int expv; /* exponent of x */ + double f; /* fractional part of x */ + double nf; /* nice, rounded fraction */ + + expv = floor(log10(x)); + f = x/pow(10.0, expv); /* between 1 and 10 */ + if (round) { + if (f < 1.5) + nf = 1.0; + else if (f < 3.0) + nf = 2.0; + else if (f < 7.0) + nf = 5.0; + else + nf = 10.0; + } else { + if (f <= 1.0) + nf = 1.0; + else if (f <= 2.0) + nf = 2.0; + else if (f <= 5.0) + nf = 5.0; + else + nf = 10.0; + } + return nf * pow(10.0, expv); +} + +static void +net_scale (LoadGraph *graph, guint64 din, guint64 dout) +{ + graph->data[0][0] = 1.0f * din / graph->net.max; + graph->data[0][1] = 1.0f * dout / graph->net.max; + + guint64 dmax = std::max(din, dout); + if (graph->latest == 0) { + graph->net.values[graph->num_points - 1] = dmax; + } else { + graph->net.values[graph->latest - 1] = dmax; + } + + guint64 new_max; + // both way, new_max is the greatest value + if (dmax >= graph->net.max) + new_max = dmax; + else + new_max = *std::max_element(&graph->net.values[0], + &graph->net.values[graph->num_points - 1]); + + // + // Round network maximum + // + + const guint64 bak_max(new_max); + + if (GsmApplication::get()->config.network_in_bits) { + // nice number is for the ticks + unsigned ticks = graph->num_bars(); + + // gets messy at low values due to division by 8 + guint64 bit_max = std::max( new_max*8, G_GUINT64_CONSTANT(10000) ); + + // our tick size leads to max + double d = nicenum(bit_max/ticks, 0); + bit_max = ticks * d; + new_max = bit_max / 8; + + procman_debug("bak*8 %" G_GUINT64_FORMAT ", ticks %d, d %f" + ", bit_max %" G_GUINT64_FORMAT ", new_max %" G_GUINT64_FORMAT, + bak_max*8, ticks, d, bit_max, new_max ); + } else { + // round up to get some extra space + // yes, it can overflow + new_max = 1.1 * new_max; + // make sure max is not 0 to avoid / 0 + // default to 1 KiB + new_max = std::max(new_max, G_GUINT64_CONSTANT(1024)); + + // decompose new_max = coef10 * 2**(base10 * 10) + // where coef10 and base10 are integers and coef10 < 2**10 + // + // e.g: ceil(100.5 KiB) = 101 KiB = 101 * 2**(1 * 10) + // where base10 = 1, coef10 = 101, pow2 = 16 + + guint64 pow2 = std::floor(log2(new_max)); + guint64 base10 = pow2 / 10.0; + guint64 coef10 = std::ceil(new_max / double(G_GUINT64_CONSTANT(1) << (base10 * 10))); + g_assert(new_max <= (coef10 * (G_GUINT64_CONSTANT(1) << (base10 * 10)))); + + // then decompose coef10 = x * 10**factor10 + // where factor10 is integer and x < 10 + // so we new_max has only 1 significant digit + + guint64 factor10 = std::pow(10.0, std::floor(std::log10(coef10))); + coef10 = std::ceil(coef10 / double(factor10)) * factor10; + + new_max = coef10 * (G_GUINT64_CONSTANT(1) << guint64(base10 * 10)); + procman_debug("bak %" G_GUINT64_FORMAT " new_max %" G_GUINT64_FORMAT + "pow2 %" G_GUINT64_FORMAT " coef10 %" G_GUINT64_FORMAT, + bak_max, new_max, pow2, coef10); + } + + if (bak_max > new_max) { + procman_debug("overflow detected: bak=%" G_GUINT64_FORMAT + " new=%" G_GUINT64_FORMAT, + bak_max, new_max); + new_max = bak_max; + } + + // if max is the same or has decreased but not so much, don't + // do anything to avoid rescaling + if ((0.8 * graph->net.max) < new_max && new_max <= graph->net.max) + return; + + const double scale = 1.0f * graph->net.max / new_max; + + for (size_t i = 0; i < graph->num_points; i++) { + if (graph->data[i][0] >= 0.0f) { + graph->data[i][0] *= scale; + graph->data[i][1] *= scale; + } + } + + procman_debug("rescale dmax = %" G_GUINT64_FORMAT + " max = %" G_GUINT64_FORMAT + " new_max = %" G_GUINT64_FORMAT, + dmax, graph->net.max, new_max); + + graph->net.max = new_max; + + // force the graph background to be redrawn now that scale has changed + graph->clear_background(); +} + +static void +get_net (LoadGraph *graph) +{ + glibtop_netlist netlist; + char **ifnames; + guint32 i; + guint64 in = 0, out = 0; + guint64 time; + guint64 din, dout; + ifnames = glibtop_get_netlist(&netlist); + + for (i = 0; i < netlist.number; ++i) + { + glibtop_netload netload; + glibtop_get_netload (&netload, ifnames[i]); + + if (netload.if_flags & (1 << GLIBTOP_IF_FLAGS_LOOPBACK)) + continue; + + /* Skip interfaces without any IPv4/IPv6 address (or + those with only a LINK ipv6 addr) However we need to + be able to exclude these while still keeping the + value so when they get online (with NetworkManager + for example) we don't get a sudden peak. Once we're + able to get this, ignoring down interfaces will be + possible too. */ + if (not (netload.flags & (1 << GLIBTOP_NETLOAD_ADDRESS6) + and netload.scope6 != GLIBTOP_IF_IN6_SCOPE_LINK) + and not (netload.flags & (1 << GLIBTOP_NETLOAD_ADDRESS))) + continue; + + /* Don't skip interfaces that are down (GLIBTOP_IF_FLAGS_UP) + to avoid spikes when they are brought up */ + + in += netload.bytes_in; + out += netload.bytes_out; + } + + g_strfreev(ifnames); + + time = g_get_monotonic_time (); + + if (in >= graph->net.last_in && out >= graph->net.last_out && graph->net.time != 0) { + float dtime; + dtime = ((double) (time - graph->net.time)) / G_USEC_PER_SEC; + din = static_cast<guint64>((in - graph->net.last_in) / dtime); + dout = static_cast<guint64>((out - graph->net.last_out) / dtime); + } else { + /* Don't calc anything if new data is less than old (interface + removed, counters reset, ...) or if it is the first time */ + din = 0; + dout = 0; + } + + graph->net.last_in = in; + graph->net.last_out = out; + graph->net.time = time; + + net_scale(graph, din, dout); + + gtk_label_set_text (GTK_LABEL (graph->labels.net_in), procman::format_network_rate(din).c_str()); + gtk_label_set_text (GTK_LABEL (graph->labels.net_in_total), procman::format_network(in).c_str()); + + gtk_label_set_text (GTK_LABEL (graph->labels.net_out), procman::format_network_rate(dout).c_str()); + gtk_label_set_text (GTK_LABEL (graph->labels.net_out_total), procman::format_network(out).c_str()); +} + + + +void +load_graph_update_data (LoadGraph *graph) +{ + // Rotate data one element down. + std::rotate(graph->data.begin(), + graph->data.end() - 1, + graph->data.end()); + + // Update rotation counter. + graph->latest = (graph->latest + 1) % graph->num_points; + + // Replace the 0th element + switch (graph->type) { + case LOAD_GRAPH_CPU: + get_load(graph); + break; + case LOAD_GRAPH_MEM: + get_memory(graph); + break; + case LOAD_GRAPH_NET: + get_net(graph); + break; + default: + g_assert_not_reached(); + } +} + + + +/* Updates the load graph when the timeout expires */ +static gboolean +load_graph_update (gpointer user_data) +{ + LoadGraph * const graph = static_cast<LoadGraph*>(user_data); + + if (graph->render_counter == graph->frames_per_unit - 1) + load_graph_update_data(graph); + + if (graph->draw) + load_graph_queue_draw (graph); + + graph->render_counter++; + + if (graph->render_counter >= graph->frames_per_unit) + graph->render_counter = 0; + + return TRUE; +} + + + +LoadGraph::~LoadGraph() +{ + load_graph_stop(this); + + if (timer_index) + g_source_remove(timer_index); + + clear_background(); +} + + + +static gboolean +load_graph_destroy (GtkWidget *widget, gpointer data_ptr) +{ + LoadGraph * const graph = static_cast<LoadGraph*>(data_ptr); + + delete graph; + + return FALSE; +} + + +LoadGraph::LoadGraph(guint type) + : fontsize(8.0), + rmargin(6 * fontsize), + indent(18.0), + n(0), + type(type), + speed(0), + num_points(0), + latest(0), + draw_width(0), + draw_height(0), + render_counter(0), + frames_per_unit(10), // this will be changed but needs initialising + graph_dely(0), + real_draw_height(0), + graph_delx(0.0), + graph_buffer_offset(0), + colors(), + data_block(), + data(), + main_widget(NULL), + disp(NULL), + background(NULL), + timer_index(0), + draw(FALSE), + labels(), + mem_color_picker(NULL), + swap_color_picker(NULL), + font_settings(Gio::Settings::create (FONT_SETTINGS_SCHEMA)), + cpu(), + net() +{ + LoadGraph * const graph = this; + font_settings->signal_changed(FONT_SETTING_SCALING).connect([this](const Glib::ustring&) { load_graph_rescale (this); } ); + // FIXME: + // on configure, graph->frames_per_unit = graph->draw_width/(LoadGraph::NUM_POINTS); + // knock FRAMES down to 5 until cairo gets faster + + switch (type) { + case LOAD_GRAPH_CPU: + cpu = CPU {}; + n = GsmApplication::get()->config.num_cpus; + + for(guint i = 0; i < G_N_ELEMENTS(labels.cpu); ++i) + labels.cpu[i] = make_tnum_label (); + + break; + + case LOAD_GRAPH_MEM: + n = 2; + labels.memory = make_tnum_label (); + gtk_widget_set_valign (GTK_WIDGET (labels.memory), GTK_ALIGN_CENTER); + gtk_widget_set_halign (GTK_WIDGET (labels.memory), GTK_ALIGN_START); + gtk_widget_show (GTK_WIDGET (labels.memory)); + labels.swap = make_tnum_label (); + gtk_widget_set_valign (GTK_WIDGET (labels.swap), GTK_ALIGN_CENTER); + gtk_widget_set_halign (GTK_WIDGET (labels.swap), GTK_ALIGN_START); + gtk_widget_show (GTK_WIDGET (labels.swap)); + break; + + case LOAD_GRAPH_NET: + net = NET {}; + n = 2; + net.max = 1; + labels.net_in = make_tnum_label (); + gtk_label_set_width_chars(labels.net_in, 10); + gtk_widget_set_valign (GTK_WIDGET (labels.net_in), GTK_ALIGN_CENTER); + gtk_widget_set_halign (GTK_WIDGET (labels.net_in), GTK_ALIGN_END); + gtk_widget_show (GTK_WIDGET (labels.net_in)); + + labels.net_in_total = make_tnum_label (); + gtk_widget_set_valign (GTK_WIDGET (labels.net_in_total), GTK_ALIGN_CENTER); + gtk_widget_set_halign (GTK_WIDGET (labels.net_in_total), GTK_ALIGN_END); + gtk_label_set_width_chars(labels.net_in_total, 10); + gtk_widget_show (GTK_WIDGET (labels.net_in_total)); + + labels.net_out = make_tnum_label (); + gtk_widget_set_valign (GTK_WIDGET (labels.net_out), GTK_ALIGN_CENTER); + gtk_widget_set_halign (GTK_WIDGET (labels.net_out), GTK_ALIGN_END); + gtk_label_set_width_chars(labels.net_out, 10); + gtk_widget_show (GTK_WIDGET (labels.net_out)); + + labels.net_out_total = make_tnum_label (); + gtk_widget_set_valign (GTK_WIDGET (labels.net_out_total), GTK_ALIGN_CENTER); + gtk_widget_set_halign (GTK_WIDGET (labels.net_out), GTK_ALIGN_END); + gtk_label_set_width_chars(labels.net_out_total, 10); + gtk_widget_show (GTK_WIDGET (labels.net_out_total)); + + break; + } + + speed = GsmApplication::get()->config.graph_update_interval; + + num_points = GsmApplication::get()->config.graph_data_points + 2; + + colors.resize(n); + + switch (type) { + case LOAD_GRAPH_CPU: + memcpy(&colors[0], GsmApplication::get()->config.cpu_color, + n * sizeof colors[0]); + break; + case LOAD_GRAPH_MEM: + colors[0] = GsmApplication::get()->config.mem_color; + colors[1] = GsmApplication::get()->config.swap_color; + mem_color_picker = gsm_color_button_new (&colors[0], + GSMCP_TYPE_PIE); + swap_color_picker = gsm_color_button_new (&colors[1], + GSMCP_TYPE_PIE); + break; + case LOAD_GRAPH_NET: + net.values = std::vector<unsigned>(num_points); + colors[0] = GsmApplication::get()->config.net_in_color; + colors[1] = GsmApplication::get()->config.net_out_color; + break; + } + + timer_index = 0; + render_counter = (frames_per_unit - 1); + draw = FALSE; + + main_widget = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6)); + gtk_widget_set_size_request(GTK_WIDGET (main_widget), -1, LoadGraph::GRAPH_MIN_HEIGHT); + gtk_widget_show (GTK_WIDGET (main_widget)); + + disp = GTK_DRAWING_AREA (gtk_drawing_area_new ()); + gtk_widget_show (GTK_WIDGET (disp)); + g_signal_connect (G_OBJECT (disp), "draw", + G_CALLBACK (load_graph_draw), graph); + g_signal_connect (G_OBJECT(disp), "configure_event", + G_CALLBACK (load_graph_configure), graph); + g_signal_connect (G_OBJECT(disp), "destroy", + G_CALLBACK (load_graph_destroy), graph); + g_signal_connect (G_OBJECT(disp), "state-flags-changed", + G_CALLBACK (load_graph_state_changed), graph); + g_signal_connect (G_OBJECT(disp), "style-updated", + G_CALLBACK (load_graph_style_updated), graph); + + gtk_widget_set_events (GTK_WIDGET (disp), GDK_EXPOSURE_MASK); + + gtk_box_pack_start (main_widget, GTK_WIDGET (disp), TRUE, TRUE, 0); + + data = std::vector<double*>(num_points); + /* Allocate data in a contiguous block */ + data_block = std::vector<double>(n * num_points, -1.0); + + for (guint i = 0; i < num_points; ++i) + data[i] = &data_block[0] + i * n; + + gtk_widget_show_all (GTK_WIDGET (main_widget)); +} + +void +load_graph_start (LoadGraph *graph) +{ + if (!graph->timer_index) { + // Update the data two times so the graph + // doesn't wait one cycle to start drawing. + load_graph_update_data(graph); + load_graph_update(graph); + + graph->timer_index = g_timeout_add (graph->speed, + load_graph_update, + graph); + } + + graph->draw = TRUE; +} + +void +load_graph_stop (LoadGraph *graph) +{ + /* don't draw anymore, but continue to poll */ + graph->draw = FALSE; +} + +void +load_graph_change_speed (LoadGraph *graph, + guint new_speed) +{ + if (graph->speed == new_speed) + return; + + graph->speed = new_speed; + + if (graph->timer_index) { + g_source_remove (graph->timer_index); + graph->timer_index = g_timeout_add (graph->speed, + load_graph_update, + graph); + } + + graph->clear_background(); +} + +void +load_graph_change_num_points(LoadGraph *graph, + guint new_num_points) +{ + // Don't do anything if the value didn't change. + if (graph->num_points == new_num_points) + return; + + // Sort the values in the data_block vector in the order they were accessed in by the pointers in data. + std::rotate(graph->data_block.begin(), + graph->data_block.begin() + (graph->num_points - graph->latest) * graph->n, + graph->data_block.end()); + + // Reset rotation counter. + graph->latest = 0; + + // Resize the vectors to the new amount of data points. + // Fill the new values with -1. + graph->data.resize(new_num_points); + graph->data_block.resize(graph->n * new_num_points, -1.0); + if (graph->type == LOAD_GRAPH_NET) { + graph->net.values.resize(new_num_points); + } + + // Replace the pointers in data, to match the new data_block values. + for (guint i = 0; i < new_num_points; ++i) { + graph->data[i] = &graph->data_block[0] + i * graph->n; + } + + // Set the actual number of data points to be used by the graph. + graph->num_points = new_num_points; + + // Force the scale to be redrawn. + graph->clear_background(); +} + + +LoadGraphLabels* +load_graph_get_labels (LoadGraph *graph) +{ + return &graph->labels; +} + +GtkBox* +load_graph_get_widget (LoadGraph *graph) +{ + return graph->main_widget; +} + +GsmColorButton* +load_graph_get_mem_color_picker(LoadGraph *graph) +{ + return graph->mem_color_picker; +} + +GsmColorButton* +load_graph_get_swap_color_picker(LoadGraph *graph) +{ + return graph->swap_color_picker; +} |