Adding upstream version 42.0.upstream/42.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

59 files changed, 12489 insertions, 0 deletions

diff --git a/src/application.cpp b/src/application.cpp
new file mode 100644
index 0000000..f23d29a
--- /dev/null
+++ b/src/application.cpp
@@ -0,0 +1,545 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <glibtop.h>
+#include <glibtop/close.h>
+#include <glibtop/cpu.h>
+#include <glibtop/sysinfo.h>
+#include <handy.h>
+#include <signal.h>
+#include <stdlib.h>
+
+#include "application.h"
+#include "procdialogs.h"
+#include "prefsdialog.h"
+#include "interface.h"
+#include "proctable.h"
+#include "load-graph.h"
+#include "settings-keys.h"
+#include "argv.h"
+#include "util.h"
+#include "lsof.h"
+#include "disks.h"
+
+static void
+cb_solaris_mode_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.solaris_mode = settings.get_boolean(key);
+    app->cpu_graph->clear_background();
+    if (app->timeout) {
+        proctable_update (app);
+    }
+}
+
+static void
+cb_process_memory_in_iec_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app) {
+    app->config.process_memory_in_iec = settings.get_boolean(key);
+    app->cpu_graph->clear_background();
+    if (app->timeout) {
+        proctable_update(app);
+    }
+}
+
+static void
+cb_logarithmic_scale_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.logarithmic_scale = settings.get_boolean(key);
+    app->mem_graph->clear_background();
+    load_graph_reset(app->mem_graph);
+}
+
+static void
+cb_draw_stacked_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.draw_stacked = settings.get_boolean(key);
+    app->cpu_graph->clear_background();
+    load_graph_reset(app->cpu_graph);
+}
+
+static void
+cb_draw_smooth_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.draw_smooth = settings.get_boolean(key);
+    app->cpu_graph->clear_background();
+    app->mem_graph->clear_background();
+    app->net_graph->clear_background();
+    load_graph_reset(app->cpu_graph);
+    load_graph_reset(app->mem_graph);
+    load_graph_reset(app->net_graph);
+}
+
+static void
+cb_resources_memory_in_iec_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.resources_memory_in_iec = settings.get_boolean(key);
+    app->cpu_graph->clear_background();
+    if (app->timeout) {
+        proctable_update (app);
+    }
+}
+
+static void
+cb_network_in_bits_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.network_in_bits = settings.get_boolean(key);
+    if (app->config.network_total_unit == FALSE) {
+        app->config.network_total_in_bits = app->config.network_in_bits;
+    }
+    // force scale to be redrawn
+    app->net_graph->clear_background();
+}
+
+static void
+cb_network_total_in_unit_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.network_total_unit = settings.get_boolean(key);
+    if (app->config.network_total_unit == FALSE) {
+        app->config.network_total_in_bits = app->config.network_in_bits;
+    } else {
+        app->config.network_total_in_bits = app->settings->get_boolean (GSM_SETTING_NETWORK_TOTAL_IN_BITS);
+    }
+    // force scale to be redrawn
+    app->net_graph->clear_background();
+}
+
+static void
+cb_network_total_in_bits_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    app->config.network_total_in_bits = settings.get_boolean(key);
+    // force scale to be redrawn
+    app->net_graph->clear_background();
+}
+
+static void
+cb_timeouts_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    if (key == GSM_SETTING_PROCESS_UPDATE_INTERVAL) {
+        app->config.update_interval = settings.get_int (key);
+
+        app->smooth_refresh->reset();
+        if (app->timeout) {
+            proctable_reset_timeout (app);
+        }
+    } else if (key == GSM_SETTING_GRAPH_UPDATE_INTERVAL) {
+        app->config.graph_update_interval = settings.get_int (key);
+        load_graph_change_speed(app->cpu_graph,
+                                app->config.graph_update_interval);
+        load_graph_change_speed(app->mem_graph,
+                                app->config.graph_update_interval);
+        load_graph_change_speed(app->net_graph,
+                                app->config.graph_update_interval);
+    } else if (key == GSM_SETTING_DISKS_UPDATE_INTERVAL) {
+        app->config.disks_update_interval = settings.get_int (key);
+        disks_reset_timeout (app);
+    }
+}
+
+static void
+cb_data_points_changed(Gio::Settings& settings, Glib::ustring key, GsmApplication* app) {
+    app->config.graph_data_points = settings.get_int (key);
+    unsigned points = app->config.graph_data_points + 2;
+    load_graph_change_num_points(app->cpu_graph, points);
+    load_graph_change_num_points(app->mem_graph, points);
+    load_graph_change_num_points(app->net_graph, points);
+}
+
+static void
+apply_cpu_color_settings(Gio::Settings& settings, GsmApplication* app)
+{
+    GVariant *cpu_colors_var = g_settings_get_value (settings.gobj (), GSM_SETTING_CPU_COLORS);
+    gsize n = g_variant_n_children(cpu_colors_var);
+
+    gchar *color;
+
+    // Create builder to add the new colors if user has more than the number of cores with defaults.
+    GVariantBuilder builder;
+    GVariant* child;
+    GVariant* full;
+
+    g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+
+    std::vector<std::string> random_colors = procman::generate_colors(app->config.num_cpus);
+
+    for (guint i = 0; i < static_cast<guint>(app->config.num_cpus); i++) {
+        if(i < n) {
+            child = g_variant_get_child_value ( cpu_colors_var, i );
+            g_variant_get_child( child, 1, "s", &color);
+            g_variant_builder_add_value ( &builder, child);
+            g_variant_unref (child);
+        } else {
+            color = g_strdup (random_colors[i].c_str());
+            g_variant_builder_add(&builder, "(us)", i, color);
+        }
+        gdk_rgba_parse(&app->config.cpu_color[i], color);
+        g_free (color);
+    }
+    full = g_variant_builder_end(&builder);
+    // if the user has more cores than colors stored in the gsettings, store the newly built gvariant in gsettings
+    if (n < static_cast<guint>(app->config.num_cpus)) {
+        g_settings_set_value(settings.gobj (), GSM_SETTING_CPU_COLORS, full);
+    } else {
+        g_variant_unref(full);
+    }
+
+    g_variant_unref(cpu_colors_var);
+}
+
+static void
+cb_color_changed (Gio::Settings& settings, Glib::ustring key, GsmApplication* app)
+{
+    if (key == GSM_SETTING_CPU_COLORS) {
+        apply_cpu_color_settings(settings, app);
+        for (int i = 0; i < app->config.num_cpus; i++) {
+            if(!gdk_rgba_equal(&app->cpu_graph->colors[i], &app->config.cpu_color[i])) {
+                app->cpu_graph->colors[i] = app->config.cpu_color[i];
+                break;
+            }
+        }
+        return;
+    }
+
+    auto color = settings.get_string (key);
+    if (key == GSM_SETTING_MEM_COLOR) {
+        gdk_rgba_parse (&app->config.mem_color, color.c_str ());
+        app->mem_graph->colors.at(0) = app->config.mem_color;
+    } else if (key == GSM_SETTING_SWAP_COLOR) {
+        gdk_rgba_parse (&app->config.swap_color, color.c_str ());
+        app->mem_graph->colors.at(1) = app->config.swap_color;
+    } else if (key == GSM_SETTING_NET_IN_COLOR) {
+        gdk_rgba_parse (&app->config.net_in_color, color.c_str ());
+        app->net_graph->colors.at(0) = app->config.net_in_color;
+    } else if (key == GSM_SETTING_NET_OUT_COLOR) {
+        gdk_rgba_parse (&app->config.net_out_color, color.c_str ());
+        app->net_graph->colors.at(1) = app->config.net_out_color;
+    }
+}
+
+void
+GsmApplication::load_settings()
+{
+    glibtop_cpu cpu;
+
+    this->settings = Gio::Settings::create (GSM_GSETTINGS_SCHEMA);
+
+    config.solaris_mode = this->settings->get_boolean (GSM_SETTING_SOLARIS_MODE);
+    this->settings->signal_changed(GSM_SETTING_SOLARIS_MODE).connect ([this](const Glib::ustring& key) {
+        cb_solaris_mode_changed (*this->settings.operator->(), key, this);
+    });
+
+    config.process_memory_in_iec = this->settings->get_boolean (GSM_SETTING_PROCESS_MEMORY_IN_IEC);
+    this->settings->signal_changed (GSM_SETTING_PROCESS_MEMORY_IN_IEC).connect ([this](const Glib::ustring& key) {
+        cb_process_memory_in_iec_changed (*this->settings.operator->(), key, this);
+	});
+
+    config.logarithmic_scale = this->settings->get_boolean (GSM_SETTING_LOGARITHMIC_SCALE);
+    this->settings->signal_changed(GSM_SETTING_LOGARITHMIC_SCALE).connect ([this](const Glib::ustring& key) {
+        cb_logarithmic_scale_changed (*this->settings.operator->(), key, this);
+    });
+
+    config.draw_stacked = this->settings->get_boolean (GSM_SETTING_DRAW_STACKED);
+    this->settings->signal_changed(GSM_SETTING_DRAW_STACKED).connect ([this](const Glib::ustring& key) {
+        cb_draw_stacked_changed (*this->settings.operator->(), key, this);
+    });
+
+    config.draw_smooth = this->settings->get_boolean (GSM_SETTING_DRAW_SMOOTH);
+    this->settings->signal_changed(GSM_SETTING_DRAW_SMOOTH).connect ([this](const Glib::ustring& key) {
+        cb_draw_smooth_changed (*this->settings.operator->(), key, this);
+    });
+
+    config.resources_memory_in_iec = this->settings->get_boolean (GSM_SETTING_RESOURCES_MEMORY_IN_IEC);
+    this->settings->signal_changed (GSM_SETTING_RESOURCES_MEMORY_IN_IEC).connect ([this](const Glib::ustring& key) {
+        cb_resources_memory_in_iec_changed (*this->settings.operator->(), key, this);
+    });
+
+    config.network_in_bits = this->settings->get_boolean (GSM_SETTING_NETWORK_IN_BITS);
+    this->settings->signal_changed (GSM_SETTING_NETWORK_IN_BITS).connect ([this](const Glib::ustring& key) {
+        cb_network_in_bits_changed (*this->settings.operator->(), key, this);
+    });
+
+    config.network_total_unit = this->settings->get_boolean (GSM_SETTING_NETWORK_TOTAL_UNIT);
+    this->settings->signal_changed (GSM_SETTING_NETWORK_TOTAL_UNIT).connect ([this](const Glib::ustring& key) {
+        cb_network_total_in_unit_changed (*this->settings.operator->(), key, this);
+    });
+
+    if (config.network_total_unit == FALSE) {
+        config.network_total_in_bits = config.network_in_bits;
+        this->settings->set_boolean (GSM_SETTING_NETWORK_TOTAL_IN_BITS, config.network_in_bits);
+    } else {
+        config.network_total_in_bits = this->settings->get_boolean (GSM_SETTING_NETWORK_TOTAL_IN_BITS);
+    }
+    this->settings->signal_changed (GSM_SETTING_NETWORK_TOTAL_IN_BITS).connect ([this](const Glib::ustring& key) {
+        cb_network_total_in_bits_changed (*this->settings.operator->(), key, this);
+    });
+
+    auto cbtc = [this](const Glib::ustring& key) { cb_timeouts_changed(*this->settings.operator->(), key, this); };
+    config.update_interval = this->settings->get_int (GSM_SETTING_PROCESS_UPDATE_INTERVAL);
+    this->settings->signal_changed (GSM_SETTING_PROCESS_UPDATE_INTERVAL).connect (cbtc);
+    config.graph_update_interval = this->settings->get_int (GSM_SETTING_GRAPH_UPDATE_INTERVAL);
+    this->settings->signal_changed (GSM_SETTING_GRAPH_UPDATE_INTERVAL).connect (cbtc);
+    config.disks_update_interval = this->settings->get_int (GSM_SETTING_DISKS_UPDATE_INTERVAL);
+    this->settings->signal_changed (GSM_SETTING_DISKS_UPDATE_INTERVAL).connect (cbtc);
+
+    config.graph_data_points = this->settings->get_int (GSM_SETTING_GRAPH_DATA_POINTS);
+    this->settings->signal_changed (GSM_SETTING_GRAPH_DATA_POINTS).connect ([this](const Glib::ustring& key) {
+        cb_data_points_changed (*this->settings.operator->(), key, this);
+    });
+
+    glibtop_get_cpu (&cpu);
+    frequency = cpu.frequency;
+
+    config.num_cpus = glibtop_get_sysinfo()->ncpu; // or server->ncpu + 1
+
+    apply_cpu_color_settings (*this->settings.operator->(), this);
+
+    auto mem_color = this->settings->get_string (GSM_SETTING_MEM_COLOR);
+    gdk_rgba_parse (&config.mem_color, mem_color.empty () ? "#000000ff0082" : mem_color.c_str ());
+
+    auto swap_color = this->settings->get_string (GSM_SETTING_SWAP_COLOR);
+    gdk_rgba_parse (&config.swap_color, swap_color.empty () ? "#00b6000000ff" : swap_color.c_str ());
+
+    auto net_in_color = this->settings->get_string (GSM_SETTING_NET_IN_COLOR);
+    gdk_rgba_parse (&config.net_in_color, net_in_color.empty () ? "#000000f200f2" : net_in_color.c_str ());
+
+    auto net_out_color = this->settings->get_string (GSM_SETTING_NET_OUT_COLOR);
+    gdk_rgba_parse (&config.net_out_color, net_out_color.empty () ? "#00f2000000c1" : net_out_color.c_str ());
+
+    auto cbcc = [this](const Glib::ustring& key) { cb_color_changed(*this->settings.operator->(), key, this); };
+    for (auto k : {GSM_SETTING_CPU_COLORS, GSM_SETTING_MEM_COLOR, GSM_SETTING_SWAP_COLOR, GSM_SETTING_NET_IN_COLOR, GSM_SETTING_NET_OUT_COLOR}) {
+        this->settings->signal_changed (k).connect(cbcc);
+    }
+}
+
+
+GsmApplication::GsmApplication()
+    : Gtk::Application("org.gnome.SystemMonitor", Gio::APPLICATION_HANDLES_COMMAND_LINE),
+      tree(NULL),
+      proc_actionbar_revealer(NULL),
+      popup_menu(NULL),
+      disk_list(NULL),
+      stack(NULL),
+      refresh_button(NULL),
+      process_menu_button(NULL),
+      window_menu_button(NULL),
+      end_process_button(NULL),
+      search_button(NULL),
+      search_entry(NULL),
+      search_bar(NULL),
+      config(),
+      cpu_graph(NULL),
+      mem_graph(NULL),
+      net_graph(NULL),
+      cpu_label_fixed_width(0),
+      net_label_fixed_width(0),
+      selection(NULL),
+      timeout(0U),
+      disk_timeout(0U),
+      top_of_tree(NULL),
+      last_vscroll_max(0.0),
+      last_vscroll_value(0.0),
+      pretty_table(NULL),
+      settings(NULL),
+      main_window(NULL),
+      frequency(0U),
+      smooth_refresh(NULL),
+      cpu_total_time(0ULL),
+      cpu_total_time_last(0ULL)
+{
+    Glib::set_application_name(_("System Monitor"));
+}
+
+Glib::RefPtr<GsmApplication> GsmApplication::get ()
+{
+    static Glib::RefPtr<GsmApplication> singleton;
+
+    if (!singleton) {
+        singleton = Glib::RefPtr<GsmApplication>(new GsmApplication());
+    }
+    return singleton;
+}
+
+void GsmApplication::on_activate()
+{
+    gtk_window_present (GTK_WINDOW (main_window));
+}
+
+void
+GsmApplication::save_config ()
+{
+    int width, height, xpos, ypos;
+    gboolean maximized;
+
+    gtk_window_get_size (GTK_WINDOW (main_window), &width, &height);
+    gtk_window_get_position (GTK_WINDOW (main_window), &xpos, &ypos);
+
+    maximized = gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (main_window))) & GDK_WINDOW_STATE_MAXIMIZED;
+
+    g_settings_set (settings->gobj (), GSM_SETTING_WINDOW_STATE, "(iiii)",
+                    width, height, xpos, ypos);
+
+    settings->set_boolean (GSM_SETTING_MAXIMIZED, maximized);
+}
+
+int GsmApplication::on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>& command_line)
+{
+    int argc = 0;
+    char** argv = command_line->get_arguments(argc);
+
+    Glib::OptionContext context;
+    context.set_summary(_("A simple process and system monitor."));
+    context.set_ignore_unknown_options(true);
+
+    Glib::OptionGroup gtkgroup(gtk_get_option_group(true));
+    procman::OptionGroup option_group;
+
+    context.set_main_group(option_group);
+    context.add_group (gtkgroup);
+
+    try {
+        context.parse(argc, argv);
+    } catch (const Glib::Error& ex) {
+        g_error("Arguments parse error : %s", ex.what().c_str());
+    }
+
+    g_strfreev(argv);
+
+    if (option_group.print_version) {
+        g_print("%s %s\n", _("GNOME System Monitor"), VERSION);
+        exit (EXIT_SUCCESS);
+    }
+
+    if (option_group.show_processes_tab)
+        this->settings->set_string (GSM_SETTING_CURRENT_TAB, "processes");
+    else if (option_group.show_resources_tab)
+        this->settings->set_string (GSM_SETTING_CURRENT_TAB, "resources");
+    else if (option_group.show_file_systems_tab)
+        this->settings->set_string (GSM_SETTING_CURRENT_TAB, "disks");
+    else if (option_group.print_version)
+
+    on_activate ();
+
+    return 0;
+}
+
+void
+GsmApplication::on_help_activate(const Glib::VariantBase&)
+{
+    GError* error = 0;
+    if (!g_app_info_launch_default_for_uri("help:gnome-system-monitor", NULL, &error)) {
+        g_warning("Could not display help : %s", error->message);
+        g_error_free(error);
+    }
+}
+
+void
+GsmApplication::on_lsof_activate(const Glib::VariantBase&)
+{
+    procman_lsof(this);
+}
+
+void
+GsmApplication::on_preferences_activate(const Glib::VariantBase&)
+{
+    create_preferences_dialog (this);
+}
+
+void
+GsmApplication::on_quit_activate(const Glib::VariantBase&)
+{
+    shutdown ();
+}
+
+void
+GsmApplication::shutdown()
+{
+    save_config ();
+
+    if (timeout)
+        g_source_remove (timeout);
+    if (disk_timeout)
+        g_source_remove (disk_timeout);
+
+    proctable_free_table (this);
+    delete smooth_refresh;
+    delete pretty_table;
+
+    glibtop_close();
+
+    quit();
+}
+
+void GsmApplication::on_startup()
+{
+    HdyStyleManager *style_manager;
+
+    Gtk::Application::on_startup();
+
+    hdy_init();
+
+    load_resources ();
+
+    style_manager = hdy_style_manager_get_default ();
+    hdy_style_manager_set_color_scheme (style_manager, HDY_COLOR_SCHEME_PREFER_LIGHT);
+
+    Glib::RefPtr<Gio::SimpleAction> action;
+
+    action = Gio::SimpleAction::create("quit");
+    action->signal_activate().connect(sigc::mem_fun(*this, &GsmApplication::on_quit_activate));
+    add_action(action);
+
+    action = Gio::SimpleAction::create("help");
+    action->signal_activate().connect(sigc::mem_fun(*this, &GsmApplication::on_help_activate));
+    add_action(action);
+
+    action = Gio::SimpleAction::create("lsof");
+    action->signal_activate().connect(sigc::mem_fun(*this, &GsmApplication::on_lsof_activate));
+    add_action(action);
+
+    action = Gio::SimpleAction::create("preferences");
+    action->signal_activate().connect(sigc::mem_fun(*this, &GsmApplication::on_preferences_activate));
+    add_action(action);
+
+    Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_resource("/org/gnome/gnome-system-monitor/data/menus.ui");
+
+    Glib::RefPtr<Gio::Menu> menu = Glib::RefPtr<Gio::Menu>::cast_static(builder->get_object ("app-menu"));
+    set_app_menu (menu);
+
+    add_accelerator("<Primary>d", "win.show-dependencies", NULL);
+    add_accelerator("<Primary>q", "app.quit", NULL);
+    add_accelerator("<Primary>s", "win.send-signal-stop", g_variant_new_int32 (SIGSTOP));
+    add_accelerator("<Primary>c", "win.send-signal-cont", g_variant_new_int32 (SIGCONT));
+    add_accelerator("<Primary>e", "win.send-signal-end", g_variant_new_int32 (SIGTERM));
+    add_accelerator("<Primary>k", "win.send-signal-kill", g_variant_new_int32 (SIGKILL));
+    add_accelerator("<Alt>s", "win.set-affinity", NULL);
+    add_accelerator("<Primary>m", "win.memory-maps", NULL);
+    add_accelerator("<Primary>o", "win.open-files", NULL);
+    add_accelerator("<Alt>Return", "win.process-properties", NULL);
+    add_accelerator("<Primary>f", "win.search", g_variant_new_boolean (TRUE));
+    add_accelerator("F1", "app.help", NULL);
+
+    Gtk::Window::set_default_icon_name ("org.gnome.SystemMonitor");
+
+    glibtop_init ();
+
+    load_settings ();
+
+    pretty_table = new PrettyTable();
+    smooth_refresh = new SmoothRefresh(settings);
+
+    create_main_window (this);
+
+    add_accelerator ("<Alt>1", "win.show-page", g_variant_new_string ("processes"));
+    add_accelerator ("<Alt>2", "win.show-page", g_variant_new_string ("resources"));
+    add_accelerator ("<Alt>3", "win.show-page", g_variant_new_string ("disks"));
+    add_accelerator ("<Primary>r", "win.refresh", NULL);
+
+    gtk_widget_show (GTK_WIDGET (main_window));
+}
+
+
+void GsmApplication::load_resources()
+{
+    auto res = Gio::Resource::create_from_file(GSM_RESOURCE_FILE);
+    res->register_global();
+}
+
diff --git a/src/application.h b/src/application.h
new file mode 100644
index 0000000..455a699
--- /dev/null
+++ b/src/application.h
@@ -0,0 +1,258 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_APPLICATION_H_
+#define _GSM_APPLICATION_H_
+
+#include <gtkmm.h>
+#include <glibtop/cpu.h>
+#include <handy.h>
+
+#include <algorithm>
+
+struct LoadGraph;
+
+#include "smooth_refresh.h"
+#include "prettytable.h"
+#include "legacy/treeview.h"
+#include "util.h"
+
+static const unsigned MIN_UPDATE_INTERVAL =   1 * 1000;
+static const unsigned MAX_UPDATE_INTERVAL = 100 * 1000;
+
+
+enum ProcmanTab
+{
+    PROCMAN_TAB_PROCESSES,
+    PROCMAN_TAB_RESOURCES,
+    PROCMAN_TAB_DISKS
+};
+
+
+struct ProcConfig
+  : private procman::NonCopyable
+{
+    ProcConfig()
+      : update_interval(0),
+	graph_update_interval(0),
+	disks_update_interval(0),
+	graph_data_points(0),
+	mem_color(),
+	swap_color(),
+	net_in_color(),
+	net_out_color(),
+	bg_color(),
+	frame_color(),
+	num_cpus(0),
+	solaris_mode(false),
+	process_memory_in_iec(true),
+	logarithmic_scale(false),
+	draw_stacked(false),
+	draw_smooth(true),
+	resources_memory_in_iec(true),
+	network_in_bits(false),
+	network_total_unit(false),
+	network_total_in_bits(false)
+    {
+      std::fill(&this->cpu_color[0], &this->cpu_color[GLIBTOP_NCPU], GdkRGBA());
+    }
+
+    int             update_interval;
+    int             graph_update_interval;
+    int             disks_update_interval;
+    int             graph_data_points;
+    GdkRGBA         cpu_color[GLIBTOP_NCPU];
+    GdkRGBA         mem_color;
+    GdkRGBA         swap_color;
+    GdkRGBA         net_in_color;
+    GdkRGBA         net_out_color;
+    GdkRGBA         bg_color;
+    GdkRGBA         frame_color;
+    gint            num_cpus;
+    bool solaris_mode;
+    bool process_memory_in_iec;
+    bool logarithmic_scale;
+    bool draw_stacked;
+    bool draw_smooth;
+    bool resources_memory_in_iec;
+    bool network_in_bits;
+    bool network_total_unit;
+    bool network_total_in_bits;
+};
+
+
+
+struct MutableProcInfo
+  : private procman::NonCopyable
+{
+
+MutableProcInfo()
+  : vmsize(0UL),
+    memres(0UL),
+    memshared(0UL),
+    memwritable(0UL),
+    mem(0UL),
+#ifdef HAVE_WNCK
+    memxserver(0UL),
+#endif
+    start_time(0UL),
+    cpu_time(0ULL),
+    disk_read_bytes_total(0ULL),
+    disk_write_bytes_total(0ULL),
+    disk_read_bytes_current(0ULL),
+    disk_write_bytes_current(0ULL),
+    status(0U),
+    pcpu(0),
+    nice(0)
+    {
+    }
+
+    std::string user;
+
+    std::string wchan;
+
+    // all these members are filled with libgtop which uses
+    // guint64 (to have fixed size data) but we don't need more
+    // than an unsigned long (even for 32bit apps on a 64bit
+    // kernel) as these data are amounts, not offsets.
+    gulong vmsize;
+    gulong memres;
+    gulong memshared;
+    gulong memwritable;
+    gulong mem;
+
+#ifdef HAVE_WNCK
+    // wnck gives an unsigned long
+    gulong memxserver;
+#endif
+
+    gulong start_time;
+    guint64 cpu_time;
+    guint64 disk_read_bytes_total;
+    guint64 disk_write_bytes_total;
+    guint64 disk_read_bytes_current;
+    guint64 disk_write_bytes_current;
+    guint status;
+    gdouble pcpu;
+    gint nice;
+    std::string cgroup_name;
+
+    std::string unit;
+    std::string session;
+    std::string seat;
+
+    std::string owner;
+};
+
+
+class ProcInfo
+: public MutableProcInfo
+{
+  public:
+    ProcInfo& operator=(const ProcInfo&) = delete;
+    ProcInfo(const ProcInfo&) = delete;
+    ProcInfo(pid_t pid);
+    // adds one more ref to icon
+    void set_icon(Glib::RefPtr<Gdk::Pixbuf> icon);
+    void set_user(guint uid);
+    std::string lookup_user(guint uid);
+
+    GtkTreeIter     node;
+    Glib::RefPtr<Gdk::Pixbuf> pixbuf;
+    std::string     tooltip;
+    std::string     name;
+    std::string     arguments;
+
+    std::string     security_context;
+
+    const pid_t     pid;
+    pid_t           ppid;
+    guint           uid;
+};
+
+class ProcList {
+    // TODO: use a set instead
+    // sorted by pid. The map has a nice property : it is sorted
+    // by pid so this helps a lot when looking for the parent node
+    // as ppid is nearly always < pid.
+    typedef std::map<pid_t, ProcInfo> List;
+    List data;
+    std::mutex data_lock;
+public:
+    std::map<pid_t, unsigned long> cpu_times;
+    typedef List::iterator Iterator;
+    Iterator begin() { return std::begin(data); }
+    Iterator end() { return std::end(data); }
+    Iterator erase(Iterator it) {
+        std::lock_guard<std::mutex> lg(data_lock);
+        return data.erase(it);
+    }
+    ProcInfo* add(pid_t pid) { return &data.emplace(std::piecewise_construct, std::forward_as_tuple(pid), std::forward_as_tuple(pid)).first->second; }
+    void clear() { return data.clear(); }
+
+    ProcInfo* find(pid_t pid);
+};
+
+class GsmApplication : public Gtk::Application, private procman::NonCopyable
+
+{
+private:
+    void load_settings();
+    void load_resources();
+
+    void on_preferences_activate(const Glib::VariantBase&);
+    void on_lsof_activate(const Glib::VariantBase&);
+    void on_help_activate(const Glib::VariantBase&);
+    void on_quit_activate(const Glib::VariantBase&);
+protected:
+    GsmApplication();
+public:
+    static Glib::RefPtr<GsmApplication> get ();
+
+    void save_config();
+    void shutdown();
+
+    ProcList         processes;
+    GsmTreeView      *tree;
+    GtkRevealer      *proc_actionbar_revealer;
+    GtkMenu          *popup_menu;
+    GsmTreeView      *disk_list;
+    GtkStack         *stack;
+    GtkButton        *refresh_button;
+    GtkMenuButton    *process_menu_button;
+    GtkMenuButton    *window_menu_button;
+    GtkButton        *end_process_button;
+    GtkButton        *search_button;
+    GtkSearchEntry   *search_entry;
+    GtkSearchBar     *search_bar;
+    ProcConfig        config;
+    LoadGraph        *cpu_graph;
+    LoadGraph        *mem_graph;
+    LoadGraph        *net_graph;
+    gint              cpu_label_fixed_width;
+    gint              net_label_fixed_width;
+    GtkTreeSelection *selection;
+    guint             timeout;
+    guint             disk_timeout;
+
+    GtkTreePath      *top_of_tree;
+    gdouble          last_vscroll_max;
+    gdouble          last_vscroll_value;
+
+    PrettyTable      *pretty_table;
+
+    Glib::RefPtr<Gio::Settings> settings;
+    HdyApplicationWindow *main_window;
+
+    unsigned         frequency;
+
+    SmoothRefresh    *smooth_refresh;
+
+    guint64           cpu_total_time;
+    guint64           cpu_total_time_last;
+
+protected:
+    virtual void on_activate();
+    virtual int on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>& command_line);
+    virtual void on_startup();
+};
+
+#endif /* _GSM_APPLICATION_H_ */
diff --git a/src/argv.cpp b/src/argv.cpp
new file mode 100644
index 0000000..b439071
--- /dev/null
+++ b/src/argv.cpp
@@ -0,0 +1,44 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <glibmm/optionentry.h>
+
+#include "argv.h"
+
+namespace procman
+{
+    OptionGroup::OptionGroup()
+        : Glib::OptionGroup("", ""),
+          show_system_tab(false),
+          show_processes_tab(false),
+          show_resources_tab(false),
+          show_file_systems_tab(false),
+          print_version(false)
+    {
+        Glib::OptionEntry proc_tab;
+        proc_tab.set_long_name("show-processes-tab");
+        proc_tab.set_short_name('p');
+        proc_tab.set_description(_("Show the Processes tab"));
+
+        Glib::OptionEntry res_tab;
+        res_tab.set_long_name("show-resources-tab");
+        res_tab.set_short_name('r');
+        res_tab.set_description(_("Show the Resources tab"));
+
+        Glib::OptionEntry fs_tab;
+        fs_tab.set_long_name("show-file-systems-tab");
+        fs_tab.set_short_name('f');
+        fs_tab.set_description(_("Show the File Systems tab"));
+
+        Glib::OptionEntry show_version;
+        show_version.set_long_name("version");
+        show_version.set_description(_("Show the application’s version"));
+
+        this->add_entry(proc_tab, this->show_processes_tab);
+        this->add_entry(res_tab, this->show_resources_tab);
+        this->add_entry(fs_tab, this->show_file_systems_tab);
+        this->add_entry(show_version, this->print_version);
+    }
+}
+
diff --git a/src/argv.h b/src/argv.h
new file mode 100644
index 0000000..a1a8dd2
--- /dev/null
+++ b/src/argv.h
@@ -0,0 +1,23 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_ARGV_H_
+#define _GSM_ARGV_H_
+
+#include <glibmm/optiongroup.h>
+
+namespace procman
+{
+    class OptionGroup
+        : public Glib::OptionGroup
+    {
+      public:
+        OptionGroup();
+
+        bool show_system_tab;
+        bool show_processes_tab;
+        bool show_resources_tab;
+        bool show_file_systems_tab;
+        bool print_version;
+    };
+}
+
+#endif /* _GSM_ARGV_H_ */
diff --git a/src/cgroups.cpp b/src/cgroups.cpp
new file mode 100644
index 0000000..8091195
--- /dev/null
+++ b/src/cgroups.cpp
@@ -0,0 +1,117 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+#include "cgroups.h"
+#include "util.h"
+
+#include <map>
+#include <unordered_map>
+#include <utility>
+
+bool
+cgroups_enabled(void)
+{
+    static bool initialized = false;
+    static bool has_cgroups;
+
+    if (not initialized) {
+        initialized = true;
+        has_cgroups = Glib::file_test("/proc/cgroups", Glib::FileTest::FILE_TEST_EXISTS);
+    }
+
+    return has_cgroups;
+}
+
+
+
+static const std::pair<std::string, std::string> &
+parse_cgroup_line(const std::string& line) {
+
+    static std::unordered_map<std::string, std::pair<std::string, std::string>> line_cache;
+
+    auto it = line_cache.insert({line, {"", ""} });
+    if (it.second) { // inserted new
+        std::string::size_type cat_start, name_start;
+
+        if ((cat_start = line.find(':')) != std::string::npos
+            && (name_start = line.find(':', cat_start + 1)) != std::string::npos) {
+
+            // printf("%s %lu %lu\n", line.c_str(), cat_start, name_start);
+            auto cat = line.substr(cat_start + 1, name_start - cat_start - 1);
+            auto name = line.substr(name_start + 1);
+
+            // strip the name= prefix
+            if (cat.find("name=") == 0) {
+                cat.erase(0, 5);
+            }
+
+            if (!name.empty() && name != "/") {
+                it.first->second = {name, cat};
+            }
+        }
+    }
+
+    return it.first->second;
+}
+
+
+static const std::string&
+get_process_cgroup_string(pid_t pid) {
+
+    static std::unordered_map<std::string, std::string> file_cache{ {"", ""} };
+
+    /* read out of /proc/pid/cgroup */
+    auto path = "/proc/" + std::to_string(pid) + "/cgroup";
+    std::string text;
+
+    try {
+        text = Glib::file_get_contents(path);
+    } catch (...) {
+        return file_cache[""];
+    }
+
+    auto it = file_cache.insert({ text, "" });
+
+    if (it.second) { // inserted new
+
+        // name -> [cat...], sorted by name;
+        std::map<std::string, std::vector<std::string>> names;
+
+        std::string::size_type last = 0, eol;
+
+        // for each line in the file
+        while ((eol = text.find('\n', last)) != std::string::npos) {
+            auto line = text.substr(last, eol - last);
+            last = eol + 1;
+
+            const auto& p = parse_cgroup_line(line);
+            if (!p.first.empty()) {
+                names[p.first].push_back(p.second);
+            }
+        }
+
+
+        // name (cat1, cat2), ...
+        // sorted by name, categories
+        std::vector<std::string> groups;
+
+        for (auto& i : names) {
+            std::sort(begin(i.second), end(i.second));
+            std::string cats = procman::join(i.second, ", ");
+            groups.push_back(i.first + " (" + cats + ')');
+        }
+
+        it.first->second = procman::join(groups, ", ");
+    }
+
+    return it.first->second;
+}
+
+
+void get_process_cgroup_info(ProcInfo& info) {
+    if (not cgroups_enabled())
+        return;
+
+    const auto& cgroup_string = get_process_cgroup_string(info.pid);
+    info.cgroup_name = cgroup_string;
+}
+
diff --git a/src/cgroups.h b/src/cgroups.h
new file mode 100644
index 0000000..7ddafea
--- /dev/null
+++ b/src/cgroups.h
@@ -0,0 +1,10 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_CGROUPS_H_
+#define _GSM_CGROUPS_H_
+
+#include "application.h"
+
+void get_process_cgroup_info (ProcInfo& info);
+bool cgroups_enabled ();
+
+#endif /* _GSM_CGROUPS_H_ */
diff --git a/src/defaulttable.h b/src/defaulttable.h
new file mode 100644
index 0000000..9328212
--- /dev/null
+++ b/src/defaulttable.h
@@ -0,0 +1,53 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_DEFAULT_TABLE_H_
+#define _GSM_DEFAULT_TABLE_H_
+
+#include <string>
+#include <glibmm/refptr.h>
+#include <glibmm/regex.h>
+
+/* This file contains prettynames and icons for well-known applications, that by default has no .desktop entry */
+
+struct PrettyTableItem
+{
+    Glib::RefPtr<Glib::Regex> command;
+    std::string icon;
+
+PrettyTableItem(const std::string& a_command, const std::string& a_icon)
+: command(Glib::Regex::create("^(" + a_command + ")$")),
+        icon(a_icon)
+    { }
+};
+
+#define ITEM PrettyTableItem
+
+static const PrettyTableItem default_table[] = {
+    /* GNOME services */
+    ITEM(".*applet(-?2)?|gnome-panel", "gnome-panel"),
+    ITEM("evolution.*", "emblem-mail"),
+    ITEM("gconfd-2|dconf-service", "preferences-desktop"),
+    ITEM("metacity|gnome-shell", "gnome-window-manager"),
+    ITEM("vino.*", "gnome-remote-desktop"),
+    /* Other processes */
+    ITEM("(ba|z|tc|c|k)?sh", "utilities-terminal"),
+    ITEM("(k|sys|u)logd|logger", "internet-news-reader"),
+    ITEM("X(org)?", "display"),
+    ITEM("apache2?|httpd|lighttpd", "internet-web-browser"),
+    ITEM("atd|cron|CRON|ntpd", "date"),
+    ITEM("cupsd|lpd?", "printer"),
+    ITEM("cvsd|mtn|git|svn", "file-manager"),
+    ITEM("emacs(server|\\d+)?", "gnome-emacs"),
+    ITEM("famd|gam_server", "file-manager"),
+    ITEM("getty", "input-keyboard"),
+    ITEM("gdb|((gcc|g\\+\\+)(-.*)?)|ar|ld|make", "applications-development"),
+    ITEM("sendmail|exim\\d?", "internet-mail"),
+    ITEM("squid", "proxy"),
+    ITEM("ssh(d|-agent)", "ssh-askpass-gnome"),
+    ITEM("top|vmstat", "system-monitor"),
+    ITEM("vim?", "vim"),
+    ITEM("x?inetd", "internet-web-browser")
+};
+
+#undef ITEM
+
+#endif /* _GSM_DEFAULT_TABLE_H_ */
diff --git a/src/disks.cpp b/src/disks.cpp
new file mode 100644
index 0000000..fe79fae
--- /dev/null
+++ b/src/disks.cpp
@@ -0,0 +1,491 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <gtk/gtk.h>
+#include <glibtop/mountlist.h>
+#include <glibtop/fsusage.h>
+#include <glib/gi18n.h>
+
+#include "disks.h"
+#include "application.h"
+#include "util.h"
+#include "settings-keys.h"
+#include "legacy/treeview.h"
+
+enum DiskColumns
+{
+    /* string columns* */
+    DISK_DEVICE,
+    DISK_DIR,
+    DISK_TYPE,
+    DISK_TOTAL,
+    DISK_FREE,
+    DISK_AVAIL,
+    /* USED has to be the last column */
+    DISK_USED,
+    // then invisible columns
+    /* PixBuf column */
+    DISK_ICON,
+    /* numeric columns */
+    DISK_USED_PERCENTAGE,
+    DISK_N_COLUMNS
+};
+
+static void
+cb_sort_changed (GtkTreeSortable *model, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    gsm_tree_view_save_state (GSM_TREE_VIEW (app->disk_list));
+}
+
+static void
+fsusage_stats(const glibtop_fsusage *buf,
+              guint64 *bused, guint64 *bfree, guint64 *bavail, guint64 *btotal,
+              gint *percentage)
+{
+    guint64 total = buf->blocks * buf->block_size;
+
+    if (!total) {
+        /* not a real device */
+        *btotal = *bfree = *bavail = *bused = 0ULL;
+        *percentage = 0;
+    } else {
+        int percent;
+        *btotal = total;
+        *bfree = buf->bfree * buf->block_size;
+        *bavail = buf->bavail * buf->block_size;
+        *bused = *btotal - *bfree;
+        /* percent = 100.0f * *bused / *btotal; */
+        percent = 100 * *bused / (*bused + *bavail);
+        *percentage = CLAMP(percent, 0, 100);
+    }
+}
+
+static const char* get_icon_for_path(const char* path)
+{
+    GVolumeMonitor *monitor;
+    GList *mounts;
+    uint i;
+    GMount *mount;
+    GIcon *icon;
+    const char* name = "";
+
+    monitor = g_volume_monitor_get ();
+    mounts = g_volume_monitor_get_mounts (monitor);
+
+    for (i = 0; i < g_list_length (mounts); i++) {
+        mount = G_MOUNT (g_list_nth_data(mounts, i));
+        if (strcmp(g_mount_get_name(mount), path))
+            continue;
+
+        icon = g_mount_get_icon (mount);
+
+        if (!icon)
+            continue;
+        name = g_icon_to_string (icon);
+        g_object_unref (icon);
+    }
+
+    g_list_free_full (mounts, g_object_unref);
+    return name;
+
+}
+
+static GdkPixbuf*
+get_icon_for_device(const char *mountpoint)
+{
+    const char* icon_name = get_icon_for_path(mountpoint);
+    if (!strcmp(icon_name, ""))
+        // FIXME: defaults to a safe value
+        icon_name = "drive-harddisk"; // get_icon_for_path("/");
+    return gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), icon_name, 24, GTK_ICON_LOOKUP_USE_BUILTIN, NULL);
+}
+
+
+static gboolean
+find_disk_in_model(GtkTreeModel *model, const char *mountpoint,
+                   GtkTreeIter *result)
+{
+    GtkTreeIter iter;
+    gboolean found = FALSE;
+
+    if (gtk_tree_model_get_iter_first(model, &iter)) {
+        do {
+            char *dir;
+
+            gtk_tree_model_get(model, &iter,
+                               DISK_DIR, &dir,
+                               -1);
+
+            if (dir && !strcmp(dir, mountpoint)) {
+                *result = iter;
+                found = TRUE;
+            }
+
+            g_free(dir);
+
+        } while (!found && gtk_tree_model_iter_next(model, &iter));
+    }
+
+    return found;
+}
+
+
+
+static void
+remove_old_disks(GtkTreeModel *model, const glibtop_mountentry *entries, guint n)
+{
+    GtkTreeIter iter;
+
+    if (!gtk_tree_model_get_iter_first(model, &iter))
+        return;
+
+    while (true) {
+        char *dir;
+        guint i;
+        gboolean found = FALSE;
+
+        gtk_tree_model_get(model, &iter,
+                           DISK_DIR, &dir,
+                           -1);
+
+        for (i = 0; i != n; ++i) {
+            if (!strcmp(dir, entries[i].mountdir)) {
+                found = TRUE;
+                break;
+            }
+        }
+
+        g_free(dir);
+
+        if (!found) {
+            if (!gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
+                break;
+            else
+                continue;
+        }
+
+        if (!gtk_tree_model_iter_next(model, &iter))
+            break;
+    }
+}
+
+
+
+static void
+add_disk(GtkListStore *list, const glibtop_mountentry *entry, bool show_all_fs)
+{
+    GdkPixbuf* pixbuf;
+    GtkTreeIter iter;
+    glibtop_fsusage usage;
+    guint64 bused, bfree, bavail, btotal;
+    gint percentage;
+
+    glibtop_get_fsusage(&usage, entry->mountdir);
+
+    if (not show_all_fs and usage.blocks == 0) {
+        if (find_disk_in_model(GTK_TREE_MODEL(list), entry->mountdir, &iter))
+            gtk_list_store_remove(list, &iter);
+        return;
+    }
+
+    fsusage_stats(&usage, &bused, &bfree, &bavail, &btotal, &percentage);
+    pixbuf = get_icon_for_device(entry->mountdir);
+
+    /* if we can find a row with the same mountpoint, we get it but we
+       still need to update all the fields.
+       This makes selection persistent.
+    */
+    if (!find_disk_in_model(GTK_TREE_MODEL(list), entry->mountdir, &iter))
+        gtk_list_store_append(list, &iter);
+
+    gtk_list_store_set(list, &iter,
+                       DISK_ICON, pixbuf,
+                       DISK_DEVICE, entry->devname,
+                       DISK_DIR, entry->mountdir,
+                       DISK_TYPE, entry->type,
+                       DISK_USED_PERCENTAGE, percentage,
+                       DISK_TOTAL, btotal,
+                       DISK_FREE, bfree,
+                       DISK_AVAIL, bavail,
+                       DISK_USED, bused,
+                       -1);
+}
+
+static void
+mount_changed (GVolumeMonitor *monitor, GMount *mount, GsmApplication *app)
+{
+    disks_update(app);
+}
+
+static gboolean
+cb_timeout (gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    disks_update (app);
+
+    return G_SOURCE_CONTINUE;
+}
+
+void
+disks_update(GsmApplication *app)
+{
+    GtkListStore *list;
+    glibtop_mountentry * entries;
+    glibtop_mountlist mountlist;
+    guint i;
+    gboolean show_all_fs;
+
+    list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(app->disk_list)));
+    show_all_fs = app->settings->get_boolean (GSM_SETTING_SHOW_ALL_FS);
+    entries = glibtop_get_mountlist (&mountlist, show_all_fs);
+
+    remove_old_disks(GTK_TREE_MODEL(list), entries, mountlist.number);
+
+    for (i = 0; i < mountlist.number; i++)
+        add_disk(list, &entries[i], show_all_fs);
+
+    g_free(entries);
+}
+
+static void
+init_volume_monitor (GsmApplication *app)
+{
+    GVolumeMonitor *monitor = g_volume_monitor_get ();
+
+    g_signal_connect (monitor, "mount-added", G_CALLBACK (mount_changed), app);
+    g_signal_connect (monitor, "mount-changed", G_CALLBACK (mount_changed), app);
+    g_signal_connect (monitor, "mount-removed", G_CALLBACK (mount_changed), app);
+}
+
+void
+disks_freeze (GsmApplication *app)
+{
+  if (app->disk_timeout) {
+      g_source_remove (app->disk_timeout);
+      app->disk_timeout = 0;
+  }
+}
+
+void
+disks_thaw (GsmApplication *app)
+{
+  if (app->disk_timeout)
+      return;
+
+  app->disk_timeout = g_timeout_add (app->config.disks_update_interval,
+                                     cb_timeout,
+                                     app);
+}
+
+void
+disks_reset_timeout (GsmApplication *app)
+{
+    disks_freeze (app);
+    disks_thaw (app);
+}
+
+static void
+cb_disk_columns_changed(GtkTreeView *treeview, gpointer data)
+{
+    gsm_tree_view_save_state (GSM_TREE_VIEW (treeview));
+}
+
+
+static void open_dir(GtkTreeView       *tree_view,
+                     GtkTreePath       *path,
+                     GtkTreeViewColumn *column,
+                     gpointer          user_data)
+{
+    GtkTreeIter iter;
+    GtkTreeModel *model;
+    char *dir, *url;
+
+    model = gtk_tree_view_get_model(tree_view);
+
+    if (!gtk_tree_model_get_iter(model, &iter, path)) {
+        char *p;
+        p = gtk_tree_path_to_string(path);
+        g_warning("Cannot get iter for path '%s'\n", p);
+        g_free(p);
+        return;
+    }
+
+    gtk_tree_model_get(model, &iter, DISK_DIR, &dir, -1);
+
+    url = g_strdup_printf("file://%s", dir);
+
+    GError* error = 0;
+    if (!g_app_info_launch_default_for_uri(url, NULL, &error)) {
+        g_warning("Cannot open '%s' : %s\n", url, error->message);
+        g_error_free(error);
+    }
+
+    g_free(url);
+    g_free(dir);
+}
+
+static void
+cb_disk_list_destroying (GtkWidget *self, gpointer data)
+{
+    g_signal_handlers_disconnect_by_func(self, (gpointer) cb_disk_columns_changed, data);
+    
+    g_signal_handlers_disconnect_by_func (gtk_tree_view_get_model (GTK_TREE_VIEW(self)),
+                                          (gpointer) cb_sort_changed,
+                                          data);
+}
+
+
+void
+create_disk_view(GsmApplication *app, GtkBuilder *builder)
+{
+    GtkScrolledWindow *scrolled;
+    GsmTreeView *disk_tree;
+    GtkListStore *model;
+    GtkTreeViewColumn *col;
+    GtkCellRenderer *cell;
+    PangoAttrList *attrs = NULL;
+    guint i;
+
+    init_volume_monitor (app);
+    const gchar * const titles[] = {
+        N_("Device"),
+        N_("Directory"),
+        N_("Type"),
+        N_("Total"),
+        N_("Free"),
+        N_("Available"),
+        N_("Used")
+    };
+
+    scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "disks_scrolled"));
+
+    model = gtk_list_store_new(DISK_N_COLUMNS,      /* n columns */
+                               G_TYPE_STRING,       /* DISK_DEVICE */
+                               G_TYPE_STRING,       /* DISK_DIR */
+                               G_TYPE_STRING,       /* DISK_TYPE */
+                               G_TYPE_UINT64,       /* DISK_TOTAL */
+                               G_TYPE_UINT64,       /* DISK_FREE */
+                               G_TYPE_UINT64,       /* DISK_AVAIL */
+                               G_TYPE_UINT64,       /* DISK_USED */
+                               GDK_TYPE_PIXBUF,     /* DISK_ICON */
+                               G_TYPE_INT           /* DISK_USED_PERCENTAGE */
+        );
+    disk_tree = gsm_tree_view_new (g_settings_get_child (app->settings->gobj(), GSM_SETTINGS_CHILD_DISKS), TRUE);
+    gtk_tree_view_set_model (GTK_TREE_VIEW (disk_tree), GTK_TREE_MODEL (model));
+
+    g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
+    app->disk_list = disk_tree;
+    gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET (disk_tree));
+    g_object_unref(G_OBJECT(model));
+
+    /* icon + device */
+
+    col = gtk_tree_view_column_new();
+    cell = gtk_cell_renderer_pixbuf_new();
+    
+    gtk_tree_view_column_pack_start(col, cell, FALSE);
+    gtk_tree_view_column_set_min_width(col, 30);
+    gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
+                                        NULL);
+
+    cell = gtk_cell_renderer_text_new();
+    gtk_tree_view_column_pack_start(col, cell, FALSE);
+    gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
+                                        NULL);
+    gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
+    gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
+    gtk_tree_view_column_set_reorderable(col, TRUE);
+    gtk_tree_view_column_set_resizable(col, TRUE);
+    gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
+    gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
+
+
+    /* sizes - used */
+
+    for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
+        cell = gtk_cell_renderer_text_new();
+        col = gtk_tree_view_column_new();
+        gtk_tree_view_column_pack_start(col, cell, TRUE);
+        gtk_tree_view_column_set_title(col, _(titles[i]));
+        gtk_tree_view_column_set_resizable(col, TRUE);
+        gtk_tree_view_column_set_sort_column_id(col, i);
+        gtk_tree_view_column_set_reorderable(col, TRUE);
+        gtk_tree_view_column_set_min_width(col, i == DISK_TYPE ? 40 : 72);
+        gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
+        gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
+        switch (i) {
+            case DISK_TOTAL:
+            case DISK_FREE:
+            case DISK_AVAIL:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::size_si_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+
+                attrs = make_tnum_attr_list ();
+                g_object_set (cell,
+                              "attributes", attrs,
+                              "xalign", 1.0f,
+                              NULL);
+                g_clear_pointer (&attrs, pango_attr_list_unref);
+
+                break;
+
+            default:
+                gtk_tree_view_column_set_attributes(col, cell,
+                                                    "text", i,
+                                                    NULL);
+                break;
+        }
+    }
+
+    /* used + percentage */
+
+    col = gtk_tree_view_column_new();
+    cell = gtk_cell_renderer_text_new();
+
+    attrs = make_tnum_attr_list ();
+    g_object_set (cell,
+                  "attributes", attrs,
+                  "xalign", 1.0f,
+                  NULL);
+    g_clear_pointer (&attrs, pango_attr_list_unref);
+
+    gtk_tree_view_column_set_min_width(col, 72);
+    gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_pack_start(col, cell, FALSE);
+    gtk_tree_view_column_set_cell_data_func(col, cell,
+                                            &procman::size_si_cell_data_func,
+                                            GUINT_TO_POINTER(DISK_USED),
+                                            NULL);
+    gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
+
+    cell = gtk_cell_renderer_progress_new();
+    gtk_cell_renderer_set_padding(cell, 4.0f, 4.0f);
+    gtk_tree_view_column_pack_start(col, cell, TRUE);
+    gtk_tree_view_column_set_attributes(col, cell, "value",
+                                        DISK_USED_PERCENTAGE, NULL);
+    gtk_tree_view_column_set_resizable(col, TRUE);
+    gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
+    gtk_tree_view_column_set_reorderable(col, TRUE);
+    gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
+
+    /* numeric sort */
+
+    gsm_tree_view_load_state (GSM_TREE_VIEW (disk_tree));
+    g_signal_connect (G_OBJECT(disk_tree), "destroy",
+                      G_CALLBACK(cb_disk_list_destroying),
+                      app);
+
+    g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
+                      G_CALLBACK(cb_disk_columns_changed), app);
+                      
+    g_signal_connect (G_OBJECT (model), "sort-column-changed",
+                      G_CALLBACK (cb_sort_changed), app);
+
+    app->settings->signal_changed(GSM_SETTING_SHOW_ALL_FS).connect ([app](const Glib::ustring&) { disks_update (app); disks_reset_timeout (app); });
+
+    gtk_widget_show (GTK_WIDGET (disk_tree));
+}
diff --git a/src/disks.h b/src/disks.h
new file mode 100644
index 0000000..36feb1c
--- /dev/null
+++ b/src/disks.h
@@ -0,0 +1,14 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_DISKS_H_
+#define _GSM_DISKS_H_
+
+#include "application.h"
+
+void create_disk_view(GsmApplication *app, GtkBuilder *builder);
+
+void disks_update (GsmApplication *app);
+void disks_freeze (GsmApplication *app);
+void disks_thaw (GsmApplication *app);
+void disks_reset_timeout (GsmApplication *app);
+
+#endif /* _GSM_DISKS_H_ */
diff --git a/src/gsm.gresource.xml b/src/gsm.gresource.xml
new file mode 100644
index 0000000..a8abf39
--- /dev/null
+++ b/src/gsm.gresource.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gnome/gnome-system-monitor">
+    <file preprocess="xml-stripblanks">data/interface.ui</file>
+    <file preprocess="xml-stripblanks">data/lsof.ui</file>
+    <file preprocess="xml-stripblanks">data/openfiles.ui</file>
+    <file preprocess="xml-stripblanks">data/preferences.ui</file>
+    <file preprocess="xml-stripblanks">data/renice.ui</file>
+    <file preprocess="xml-stripblanks">data/menus.ui</file>
+    <file preprocess="xml-stripblanks">pixmaps/download.svg</file>
+    <file preprocess="xml-stripblanks">pixmaps/upload.svg</file>
+    <file preprocess="xml-stripblanks" alias="gtk/help-overlay.ui">data/help-overlay.ui</file>
+  </gresource>
+</gresources>
diff --git a/src/gsm_gksu.cpp b/src/gsm_gksu.cpp
new file mode 100644
index 0000000..d2146dd
--- /dev/null
+++ b/src/gsm_gksu.cpp
@@ -0,0 +1,55 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include "application.h"
+#include "gsm_gksu.h"
+#include "util.h"
+
+static gboolean (*gksu_run)(const char *, GError **);
+
+
+static void load_gksu(void)
+{
+    static gboolean init;
+
+    if (init)
+        return;
+
+    init = TRUE;
+
+    load_symbols("libgksu2.so",
+                 "gksu_run", &gksu_run,
+                 NULL);
+}
+
+
+
+
+
+gboolean gsm_gksu_create_root_password_dialog(const char *command)
+{
+    GError *e = NULL;
+
+    /* Returns FALSE or TRUE on success, depends on version ... */
+    gksu_run(command, &e);
+
+    if (e) {
+        g_critical("Could not run gksu_run(\"%s\") : %s\n",
+                   command, e->message);
+        g_error_free(e);
+        return FALSE;
+    }
+
+    g_message("gksu_run did fine\n");
+    return TRUE;
+}
+
+
+
+gboolean
+procman_has_gksu(void)
+{
+    load_gksu();
+    return gksu_run != NULL;
+}
+
diff --git a/src/gsm_gksu.h b/src/gsm_gksu.h
new file mode 100644
index 0000000..d7c4787
--- /dev/null
+++ b/src/gsm_gksu.h
@@ -0,0 +1,13 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_GSM_GKSU_H_
+#define _GSM_GSM_GKSU_H_
+
+#include <glib.h>
+
+gboolean
+gsm_gksu_create_root_password_dialog(const char * command);
+
+gboolean
+procman_has_gksu(void) G_GNUC_CONST;
+
+#endif /* _GSM_GSM_GKSU_H_ */
diff --git a/src/gsm_gnomesu.cpp b/src/gsm_gnomesu.cpp
new file mode 100644
index 0000000..31b8645
--- /dev/null
+++ b/src/gsm_gnomesu.cpp
@@ -0,0 +1,41 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib.h>
+
+#include "application.h"
+#include "gsm_gnomesu.h"
+#include "util.h"
+
+gboolean (*gnomesu_exec)(const char *commandline);
+
+
+static void
+load_gnomesu(void)
+{
+    static gboolean init;
+
+    if (init)
+        return;
+
+    init = TRUE;
+
+    load_symbols("libgnomesu.so.0",
+                 "gnomesu_exec", &gnomesu_exec,
+                 NULL);
+}
+
+
+gboolean
+gsm_gnomesu_create_root_password_dialog(const char *command)
+{
+    return gnomesu_exec(command);
+}
+
+
+gboolean
+procman_has_gnomesu(void)
+{
+    load_gnomesu();
+    return gnomesu_exec != NULL;
+}
diff --git a/src/gsm_gnomesu.h b/src/gsm_gnomesu.h
new file mode 100644
index 0000000..323059b
--- /dev/null
+++ b/src/gsm_gnomesu.h
@@ -0,0 +1,13 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_GSM_GNOMESU_H_
+#define _GSM_GSM_GNOMESU_H_
+
+#include <glib.h>
+
+gboolean
+gsm_gnomesu_create_root_password_dialog(const char * message);
+
+gboolean
+procman_has_gnomesu(void) G_GNUC_CONST;
+
+#endif /* _GSM_GSM_GNOMESU_H_ */
diff --git a/src/gsm_pkexec.cpp b/src/gsm_pkexec.cpp
new file mode 100644
index 0000000..868969b
--- /dev/null
+++ b/src/gsm_pkexec.cpp
@@ -0,0 +1,38 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include "application.h"
+#include "gsm_pkexec.h"
+#include "util.h"
+
+gboolean gsm_pkexec_create_root_password_dialog(const char *command)
+{
+    gboolean ret = FALSE;
+    gint *exit_status = NULL;
+    GError *error = NULL;
+    gchar *command_line = g_strdup_printf("pkexec --disable-internal-agent %s/gsm-%s",
+                                          GSM_LIBEXEC_DIR, command);
+    if (!g_spawn_command_line_sync(command_line, NULL, NULL, exit_status, &error)) {
+        g_critical("Could not run pkexec(\"%s\") : %s\n",
+                   command, error->message);
+        g_error_free(error);
+    }
+    else
+    {
+        g_debug("pkexec did fine\n");
+        ret = TRUE;
+    }
+
+    g_free (command_line);
+
+    return ret;
+}
+
+
+
+gboolean
+procman_has_pkexec(void)
+{
+    return g_file_test("/usr/bin/pkexec", G_FILE_TEST_EXISTS);
+}
+
diff --git a/src/gsm_pkexec.h b/src/gsm_pkexec.h
new file mode 100644
index 0000000..0aec1a7
--- /dev/null
+++ b/src/gsm_pkexec.h
@@ -0,0 +1,13 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_GSM_PKEXEC_H_
+#define _GSM_GSM_PKEXEC_H_
+
+#include <glib.h>
+
+gboolean
+gsm_pkexec_create_root_password_dialog(const char *command);
+
+gboolean
+procman_has_pkexec(void) G_GNUC_CONST;
+
+#endif /* _GSM_PKEXEC_H_ */
diff --git a/src/interface.cpp b/src/interface.cpp
new file mode 100644
index 0000000..5b8ac6b
--- /dev/null
+++ b/src/interface.cpp
@@ -0,0 +1,887 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman - main window
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <handy.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <gdk/gdkkeysyms.h>
+#include <math.h>
+
+#include "interface.h"
+#include "proctable.h"
+#include "procactions.h"
+#include "procdialogs.h"
+#include "setaffinity.h"
+#include "memmaps.h"
+#include "openfiles.h"
+#include "procproperties.h"
+#include "load-graph.h"
+#include "util.h"
+#include "disks.h"
+#include "settings-keys.h"
+#include "legacy/gsm_color_button.h"
+
+static const char* LOAD_GRAPH_CSS = "\
+.loadgraph {\
+    background: linear-gradient(to bottom,\
+                      @theme_bg_color,\
+                      @theme_base_color\
+                      );\
+    color: mix (@theme_fg_color, @theme_bg_color, 0.5);\
+}\
+";
+
+static gboolean
+cb_window_key_press_event (GtkWidget *widget, GdkEvent *event, gpointer user_data)
+{
+    const char *current_page = gtk_stack_get_visible_child_name (GTK_STACK (GsmApplication::get()->stack));
+
+    if (strcmp (current_page, "processes") == 0)
+        return gtk_search_bar_handle_event (GTK_SEARCH_BAR (user_data), event);
+    
+    return FALSE;
+}
+
+static void
+search_text_changed (GtkEditable *entry, gpointer data)
+{
+    GsmApplication * const app = static_cast<GsmApplication *>(data);
+    gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (gtk_tree_model_sort_get_model (
+                                    GTK_TREE_MODEL_SORT (gtk_tree_view_get_model(
+                                    GTK_TREE_VIEW (app->tree))))));
+}
+
+static void
+set_affinity_visiblity (GtkWidget *widget, gpointer user_data)
+{
+#ifndef __linux__
+    GtkMenuItem *item = GTK_MENU_ITEM (widget);
+    const gchar *name = gtk_menu_item_get_label (item);
+
+    if (strcmp (name, "Set _Affinity") == 0) {
+        gtk_widget_set_visible (widget, false);
+    }
+#endif
+}
+
+static void 
+create_proc_view(GsmApplication *app, GtkBuilder * builder)
+{
+    GsmTreeView *proctree;
+    GtkScrolledWindow *scrolled;
+
+    proctree = proctable_new (app);
+    scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "processes_scrolled"));
+
+    gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (proctree));
+
+    app->proc_actionbar_revealer = GTK_REVEALER (gtk_builder_get_object (builder, "proc_actionbar_revealer"));
+
+    /* create popup_menu for the processes tab */
+    GMenuModel *menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-popup-menu"));
+    app->popup_menu = GTK_MENU (gtk_menu_new_from_model (menu_model));
+    gtk_menu_attach_to_widget (app->popup_menu, GTK_WIDGET (app->main_window), NULL);
+
+    gtk_container_foreach (GTK_CONTAINER (app->popup_menu), set_affinity_visiblity, NULL);
+
+    app->search_bar = GTK_SEARCH_BAR (gtk_builder_get_object (builder, "proc_searchbar"));
+    app->search_entry = GTK_SEARCH_ENTRY (gtk_builder_get_object (builder, "proc_searchentry"));
+    
+    gtk_search_bar_connect_entry (app->search_bar, GTK_ENTRY (app->search_entry));
+    g_signal_connect (app->main_window, "key-press-event",
+                      G_CALLBACK (cb_window_key_press_event), app->search_bar);
+                  
+    g_signal_connect (app->search_entry, "changed", G_CALLBACK (search_text_changed), app);
+
+    g_object_bind_property (app->search_bar, "search-mode-enabled", app->search_button, "active", (GBindingFlags)(G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE));
+}
+
+static void
+cb_cpu_color_changed (GsmColorButton *cp, gpointer data)
+{
+    guint cpu_i = GPOINTER_TO_UINT (data);
+    auto settings = Gio::Settings::create (GSM_GSETTINGS_SCHEMA);
+
+    /* Get current values */
+    GVariant *cpu_colors_var = g_settings_get_value (settings->gobj(), GSM_SETTING_CPU_COLORS);
+    gsize children_n = g_variant_n_children(cpu_colors_var);
+
+    /* Create builder to construct new setting with updated value for cpu i */
+    GVariantBuilder builder;
+    g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
+
+    for (guint i = 0; i < children_n; i++) {
+        if(cpu_i == i) {
+            gchar *color;
+            GdkRGBA button_color;
+            gsm_color_button_get_color(cp, &button_color);
+            color = gdk_rgba_to_string (&button_color);
+            g_variant_builder_add(&builder, "(us)", i, color);
+            g_free (color);
+        } else {
+            g_variant_builder_add_value(&builder,
+                                        g_variant_get_child_value(cpu_colors_var, i));
+        }
+    }
+
+    /* Just set the value and let the changed::cpu-colors signal callback do the rest. */
+    settings->set_value (GSM_SETTING_CPU_COLORS, Glib::wrap (g_variant_builder_end(&builder)));
+}
+
+static void change_settings_color(Gio::Settings& settings, const char *key,
+                                  GsmColorButton *cp)
+{
+    GdkRGBA c;
+    char *color;
+
+    gsm_color_button_get_color(cp, &c);
+    color = gdk_rgba_to_string (&c);
+    settings.set_string (key, color);
+    g_free (color);
+}
+
+static void
+cb_mem_color_changed (GsmColorButton *cp, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    change_settings_color (*app->settings.operator->(), GSM_SETTING_MEM_COLOR, cp);
+}
+
+
+static void
+cb_swap_color_changed (GsmColorButton *cp, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    change_settings_color (*app->settings.operator->(), GSM_SETTING_SWAP_COLOR, cp);
+}
+
+static void
+cb_net_in_color_changed (GsmColorButton *cp, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    change_settings_color (*app->settings.operator->(), GSM_SETTING_NET_IN_COLOR, cp);
+}
+
+static void
+cb_net_out_color_changed (GsmColorButton *cp, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    change_settings_color(*app->settings.operator->(), GSM_SETTING_NET_OUT_COLOR, cp);
+}
+
+static void
+create_sys_view (GsmApplication *app, GtkBuilder * builder)
+{
+    GtkBox *cpu_graph_box, *mem_graph_box, *net_graph_box;
+    GtkExpander *cpu_expander, *mem_expander, *net_expander;
+    GtkLabel *label,*cpu_label;
+    GtkGrid *table;
+    GsmColorButton *color_picker;
+    GtkCssProvider *provider;
+
+    LoadGraph *cpu_graph, *mem_graph, *net_graph;
+
+    gint i;
+    gchar *title_text;
+    gchar *label_text;
+    gchar *title_template;
+
+    provider = gtk_css_provider_new ();
+    gtk_css_provider_load_from_data (provider, LOAD_GRAPH_CSS, -1, NULL);
+    gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+    // Translators: color picker title, %s is CPU, Memory, Swap, Receiving, Sending
+    title_template = g_strdup(_("Pick a Color for “%s”"));
+
+    /* The CPU BOX */
+    
+    cpu_graph_box = GTK_BOX (gtk_builder_get_object (builder, "cpu_graph_box"));
+    cpu_expander = GTK_EXPANDER (gtk_builder_get_object (builder, "cpu_expander"));
+    g_object_bind_property (cpu_expander, "expanded", cpu_expander, "vexpand", G_BINDING_DEFAULT);
+
+    cpu_graph = new LoadGraph(LOAD_GRAPH_CPU);
+    gtk_widget_set_size_request (GTK_WIDGET(load_graph_get_widget(cpu_graph)), -1, 70);
+    gtk_box_pack_start (cpu_graph_box,
+                        GTK_WIDGET (load_graph_get_widget(cpu_graph)),
+                        TRUE,
+                        TRUE,
+                        0);
+
+    GtkGrid* cpu_table = GTK_GRID (gtk_builder_get_object (builder, "cpu_table"));
+    gint cols = 4;
+    for (i=0;i<app->config.num_cpus; i++) {
+        GtkBox *temp_hbox;
+
+        temp_hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0));
+        gtk_widget_show (GTK_WIDGET (temp_hbox));
+        if (i < cols) {
+            gtk_grid_insert_column(cpu_table, i%cols);
+        }
+        if ((i+1)%cols ==cols) {
+            gtk_grid_insert_row(cpu_table, (i+1)/cols);
+        }
+        gtk_grid_attach(cpu_table, GTK_WIDGET (temp_hbox), i%cols, i/cols, 1, 1);
+        color_picker = gsm_color_button_new (&cpu_graph->colors.at(i), GSMCP_TYPE_CPU);
+        g_signal_connect (G_OBJECT (color_picker), "color-set",
+                          G_CALLBACK (cb_cpu_color_changed), GINT_TO_POINTER (i));
+        gtk_box_pack_start (temp_hbox, GTK_WIDGET (color_picker), FALSE, TRUE, 0);
+        gtk_widget_set_size_request(GTK_WIDGET(color_picker), 32, -1);
+        if(app->config.num_cpus == 1) {
+            label_text = g_strdup (_("CPU"));
+        } else {
+            label_text = g_strdup_printf (_("CPU%d"), i+1);
+        }
+        title_text = g_strdup_printf(title_template, label_text);
+        label = GTK_LABEL (gtk_label_new (label_text));
+        gtk_label_set_xalign(label, 0.0);
+        if(app->config.num_cpus >=10) {
+            gtk_label_set_width_chars(label, log10(app->config.num_cpus)+1+4);
+        }
+        gsm_color_button_set_title(color_picker, title_text);
+        g_free(title_text);
+        gtk_box_pack_start (temp_hbox, GTK_WIDGET (label), FALSE, FALSE, 6);
+        gtk_widget_show (GTK_WIDGET (label));
+        g_free (label_text);
+
+        cpu_label = make_tnum_label ();
+
+        /* Reserve some space to avoid the layout changing with the values. */
+        gtk_label_set_width_chars(cpu_label, 6);
+        gtk_label_set_xalign(cpu_label, 1.0);
+        gtk_widget_set_valign (GTK_WIDGET (cpu_label), GTK_ALIGN_CENTER);
+        gtk_widget_set_halign (GTK_WIDGET (cpu_label), GTK_ALIGN_START);
+        gtk_box_pack_start (temp_hbox, GTK_WIDGET (cpu_label), FALSE, FALSE, 0);
+        gtk_widget_show (GTK_WIDGET (cpu_label));
+        load_graph_get_labels(cpu_graph)->cpu[i] = cpu_label;
+
+    }
+
+    app->cpu_graph = cpu_graph;
+
+    /** The memory box */
+    
+    mem_graph_box = GTK_BOX (gtk_builder_get_object (builder, "mem_graph_box"));
+    mem_expander = GTK_EXPANDER (gtk_builder_get_object (builder, "mem_expander"));
+    g_object_bind_property (mem_expander, "expanded", mem_expander, "vexpand", G_BINDING_DEFAULT);
+
+    mem_graph = new LoadGraph(LOAD_GRAPH_MEM);
+    gtk_widget_set_size_request (GTK_WIDGET(load_graph_get_widget(mem_graph)), -1, 70);
+    gtk_box_pack_start (mem_graph_box,
+                        GTK_WIDGET (load_graph_get_widget(mem_graph)),
+                        TRUE,
+                        TRUE,
+                        0);
+
+    table = GTK_GRID (gtk_builder_get_object (builder, "mem_table"));
+
+    color_picker = load_graph_get_mem_color_picker(mem_graph);
+    g_signal_connect (G_OBJECT (color_picker), "color-set",
+                      G_CALLBACK (cb_mem_color_changed), app);
+    title_text = g_strdup_printf(title_template, _("Memory"));
+    gsm_color_button_set_title(color_picker, title_text);
+    g_free(title_text);
+
+    label = GTK_LABEL (gtk_builder_get_object(builder, "memory_label"));
+
+    gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 3);
+    gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(mem_graph)->memory), GTK_WIDGET (label), GTK_POS_BOTTOM, 1, 2);
+
+    color_picker = load_graph_get_swap_color_picker(mem_graph);
+    g_signal_connect (G_OBJECT (color_picker), "color-set",
+                      G_CALLBACK (cb_swap_color_changed), app);
+    title_text = g_strdup_printf(title_template, _("Swap"));
+    gsm_color_button_set_title(GSM_COLOR_BUTTON(color_picker), title_text);
+    g_free(title_text);
+
+    label = GTK_LABEL (gtk_builder_get_object(builder, "swap_label"));
+
+    gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 3);
+    gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(mem_graph)->swap), GTK_WIDGET (label), GTK_POS_BOTTOM, 1, 2);
+
+    app->mem_graph = mem_graph;
+
+    /* The net box */
+    
+    net_graph_box = GTK_BOX (gtk_builder_get_object (builder, "net_graph_box"));
+    net_expander = GTK_EXPANDER (gtk_builder_get_object (builder, "net_expander"));
+    g_object_bind_property (net_expander, "expanded", net_expander, "vexpand", G_BINDING_DEFAULT);
+
+    net_graph = new LoadGraph(LOAD_GRAPH_NET);
+    gtk_widget_set_size_request (GTK_WIDGET(load_graph_get_widget(net_graph)), -1, 70);
+    gtk_box_pack_start (net_graph_box,
+                        GTK_WIDGET (load_graph_get_widget(net_graph)),
+                        TRUE,
+                        TRUE,
+                        0);
+
+    table = GTK_GRID (gtk_builder_get_object (builder, "net_table"));
+
+    color_picker = gsm_color_button_new (
+        &net_graph->colors.at(0), GSMCP_TYPE_NETWORK_IN);
+    gtk_widget_set_valign (GTK_WIDGET(color_picker), GTK_ALIGN_CENTER);
+    g_signal_connect (G_OBJECT (color_picker), "color-set",
+                      G_CALLBACK (cb_net_in_color_changed), app);
+    title_text = g_strdup_printf(title_template, _("Receiving"));
+    gsm_color_button_set_title(color_picker, title_text);
+    g_free(title_text);
+
+    label = GTK_LABEL (gtk_builder_get_object(builder, "receiving_label"));
+    gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 2);
+    gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_in), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
+    label = GTK_LABEL (gtk_builder_get_object(builder, "total_received_label"));
+    gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_in_total), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
+
+    color_picker = gsm_color_button_new (
+        &net_graph->colors.at(1), GSMCP_TYPE_NETWORK_OUT);
+    gtk_widget_set_valign (GTK_WIDGET(color_picker), GTK_ALIGN_CENTER);
+    gtk_widget_set_hexpand (GTK_WIDGET(color_picker), true);
+    gtk_widget_set_halign (GTK_WIDGET(color_picker), GTK_ALIGN_END);
+
+    g_signal_connect (G_OBJECT (color_picker), "color-set",
+                      G_CALLBACK (cb_net_out_color_changed), app);
+    title_text = g_strdup_printf(title_template, _("Sending"));
+    gsm_color_button_set_title(color_picker, title_text);
+    g_free(title_text);
+
+    label = GTK_LABEL (gtk_builder_get_object(builder, "sending_label"));
+    gtk_grid_attach_next_to (table, GTK_WIDGET (color_picker), GTK_WIDGET (label), GTK_POS_LEFT, 1, 2);
+    gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_out), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
+    label = GTK_LABEL (gtk_builder_get_object(builder, "total_sent_label"));
+    gtk_grid_attach_next_to (table, GTK_WIDGET (load_graph_get_labels(net_graph)->net_out_total), GTK_WIDGET (label), GTK_POS_RIGHT, 1, 1);
+    gtk_widget_set_hexpand (GTK_WIDGET(load_graph_get_labels(net_graph)->net_out_total), true);
+    gtk_widget_set_halign (GTK_WIDGET(load_graph_get_labels(net_graph)->net_out_total), GTK_ALIGN_START);
+
+    gtk_widget_set_hexpand (GTK_WIDGET(load_graph_get_labels(net_graph)->net_out), true);
+    gtk_widget_set_halign (GTK_WIDGET(load_graph_get_labels(net_graph)->net_out), GTK_ALIGN_START);
+
+
+    app->net_graph = net_graph;
+    g_free (title_template);
+
+}
+
+static void
+on_activate_about (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    const gchar * const authors[] = {
+        "Kevin Vandersloot",
+        "Erik Johnsson",
+        "Jorgen Scheibengruber",
+        "Benoît Dejean",
+        "Paolo Borelli",
+        "Karl Lattimer",
+        "Chris Kühl",
+        "Robert Roth",
+        "Stefano Facchini",
+        "Jacob Barkdull",
+        NULL
+    };
+
+    const gchar * const documenters[] = {
+        "Bill Day",
+        "Sun Microsystems",
+        NULL
+    };
+
+    const gchar * const artists[] = {
+        "Baptiste Mille-Mathias",
+        NULL
+    };
+
+    gtk_show_about_dialog (
+        GTK_WINDOW (app->main_window),
+        "name",                 _("System Monitor"),
+        "comments",             _("View current processes and monitor "
+                                  "system state"),
+        "version",              VERSION,
+        "website",              "https://wiki.gnome.org/Apps/SystemMonitor",
+        "copyright",            "Copyright \xc2\xa9 2001-2004 Kevin Vandersloot\n"
+                                "Copyright \xc2\xa9 2005-2007 Benoît Dejean\n"
+                                "Copyright \xc2\xa9 2011 Chris Kühl",
+        "logo-icon-name",       "org.gnome.SystemMonitor",
+        "authors",              authors,
+        "artists",              artists,
+        "documenters",          documenters,
+        "translator-credits",   _("translator-credits"),
+		"license-type", 		GTK_LICENSE_GPL_2_0,
+        NULL
+        );
+}
+
+static void
+on_activate_keyboard_shortcuts (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    gtk_widget_show (GTK_WIDGET (gtk_application_window_get_help_overlay (GTK_APPLICATION_WINDOW (app->main_window))));
+}
+
+static void
+on_activate_refresh (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    proctable_update (app);
+}
+
+static void
+kill_process_with_confirmation (GsmApplication *app, int signal) {
+    gboolean kill_dialog = app->settings->get_boolean(GSM_SETTING_SHOW_KILL_DIALOG);
+
+    if (kill_dialog)
+        procdialog_create_kill_dialog (app, signal);
+    else
+        kill_process (app, signal);
+}
+
+static void
+on_activate_send_signal (GSimpleAction *, GVariant *parameter, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    /* no confirmation */
+    gint32 signal = g_variant_get_int32(parameter);
+    switch (signal) {
+        case SIGCONT:
+            kill_process (app, signal);
+            break;
+        case SIGSTOP:
+        case SIGTERM:
+        case SIGKILL:
+            kill_process_with_confirmation (app, signal);
+            break;
+    }
+}
+
+static void
+on_activate_set_affinity (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    create_set_affinity_dialog (app);
+}
+
+static void
+on_activate_memory_maps (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    create_memmaps_dialog (app);
+}
+
+static void
+on_activate_open_files (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    create_openfiles_dialog (app);
+}
+
+static void
+on_activate_process_properties (GSimpleAction *, GVariant *, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    create_procproperties_dialog (app);
+}
+
+static void
+on_activate_radio (GSimpleAction *action, GVariant *parameter, gpointer data)
+{
+    g_action_change_state (G_ACTION (action), parameter);
+}
+
+static void
+on_activate_toggle (GSimpleAction *action, GVariant *parameter, gpointer data)
+{
+    GVariant *state = g_action_get_state (G_ACTION (action));
+    g_action_change_state (G_ACTION (action), g_variant_new_boolean (!g_variant_get_boolean (state)));    
+    g_variant_unref (state);
+}
+
+static void
+on_activate_search (GSimpleAction *action, GVariant *parameter, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    GVariant *state = g_action_get_state (G_ACTION (action));
+    gboolean is_search_shortcut = g_variant_get_boolean (parameter);
+    gboolean is_search_bar = gtk_search_bar_get_search_mode (app->search_bar);
+    gtk_widget_set_visible (GTK_WIDGET (app->search_bar), is_search_bar || is_search_shortcut);
+    if (is_search_shortcut && is_search_bar) {
+        gtk_widget_grab_focus (GTK_WIDGET (app->search_entry));
+    } else {
+        g_action_change_state (G_ACTION (action), g_variant_new_boolean (!g_variant_get_boolean (state)));
+    }
+    g_variant_unref (state);
+}
+
+static void
+change_show_page_state (GSimpleAction *action, GVariant *state, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    auto state_var = Glib::wrap(state, true);
+    g_simple_action_set_state (action, state);
+    app->settings->set_value (GSM_SETTING_CURRENT_TAB, state_var);
+}
+
+static void
+change_show_processes_state (GSimpleAction *action, GVariant *state, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    auto state_var = Glib::wrap(state, true);
+    g_simple_action_set_state (action, state);
+    app->settings->set_value (GSM_SETTING_SHOW_WHOSE_PROCESSES, state_var);
+}
+
+static void
+change_show_dependencies_state (GSimpleAction *action, GVariant *state, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    auto state_var = Glib::wrap(state, true);
+    g_simple_action_set_state (action, state);
+    app->settings->set_value (GSM_SETTING_SHOW_DEPENDENCIES, state_var);
+}
+
+static void
+on_activate_priority (GSimpleAction *action, GVariant *parameter, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    g_action_change_state (G_ACTION (action), parameter);
+
+    const gint32 priority = g_variant_get_int32 (parameter);
+    switch (priority) {
+        case 32: 
+            procdialog_create_renice_dialog (app);
+            break;
+        default:
+            renice (app, priority);
+            break;
+    }
+
+}
+
+static void
+change_priority_state (GSimpleAction *action, GVariant *state, gpointer data)
+{
+    g_simple_action_set_state (action, state);
+}
+
+static void
+update_page_activities (GsmApplication *app)
+{
+    const char *current_page = gtk_stack_get_visible_child_name (app->stack);
+
+    if (strcmp (current_page, "processes") == 0) {
+        GAction *search_action = g_action_map_lookup_action (G_ACTION_MAP (app->main_window),
+                                                             "search");
+        proctable_update (app);
+        proctable_thaw (app);
+
+        gtk_widget_show (GTK_WIDGET (app->end_process_button));
+        gtk_widget_show (GTK_WIDGET (app->search_button));
+        gtk_widget_show (GTK_WIDGET (app->process_menu_button));
+        gtk_widget_hide (GTK_WIDGET (app->window_menu_button));
+
+        update_sensitivity (app);
+
+        if (g_variant_get_boolean (g_action_get_state (search_action)))
+            gtk_widget_grab_focus (GTK_WIDGET (app->search_entry));
+        else
+            gtk_widget_grab_focus (GTK_WIDGET (app->tree));
+    } else {
+        proctable_freeze (app);
+
+        gtk_widget_hide (GTK_WIDGET (app->end_process_button));
+        gtk_widget_hide (GTK_WIDGET (app->search_button));
+        gtk_widget_hide (GTK_WIDGET (app->process_menu_button));
+        gtk_widget_show (GTK_WIDGET (app->window_menu_button));
+
+        update_sensitivity (app);
+    }
+
+    if (strcmp (current_page, "resources") == 0) {
+        load_graph_start (app->cpu_graph);
+        load_graph_start (app->mem_graph);
+        load_graph_start (app->net_graph);
+    } else {
+        load_graph_stop (app->cpu_graph);
+        load_graph_stop (app->mem_graph);
+        load_graph_stop (app->net_graph);
+    }
+
+    if (strcmp (current_page, "disks") == 0) {
+        disks_update (app);
+        disks_thaw (app);
+    } else {
+        disks_freeze (app);
+    }
+}
+
+static void
+cb_change_current_page (GtkStack *stack, GParamSpec *pspec, gpointer data)
+{
+    update_page_activities ((GsmApplication *)data);
+}
+
+static gboolean
+cb_main_window_delete (GtkWidget *window, GdkEvent *event, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    app->shutdown ();
+
+    return TRUE;
+}
+
+static gboolean
+cb_main_window_state_changed (GtkWidget *window, GdkEventWindowState *event, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    auto current_page = app->settings->get_string (GSM_SETTING_CURRENT_TAB);
+    if (event->new_window_state & GDK_WINDOW_STATE_BELOW ||
+        event->new_window_state & GDK_WINDOW_STATE_ICONIFIED ||
+        event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN)
+    {
+        if (current_page == "processes") {
+            proctable_freeze (app);
+        } else if (current_page == "resources") {
+            load_graph_stop (app->cpu_graph);
+            load_graph_stop (app->mem_graph);
+            load_graph_stop (app->net_graph);
+        } else if (current_page == "disks") {
+            disks_freeze (app);
+        }
+    } else  {
+        if (current_page == "processes") {
+            proctable_update (app);
+            proctable_thaw (app);
+        } else if (current_page == "resources") {
+            load_graph_start (app->cpu_graph);
+            load_graph_start (app->mem_graph);
+            load_graph_start (app->net_graph);
+        } else if (current_page == "disks") {
+            disks_update (app);
+            disks_thaw (app);
+        }
+    }
+    return FALSE;
+}
+
+void
+create_main_window (GsmApplication *app)
+{
+    HdyApplicationWindow *main_window;
+    GtkStack *stack;
+    GMenuModel *window_menu_model;
+    GMenuModel *process_menu_model;
+    GdkDisplay *display;
+    GdkMonitor *monitor;
+    GdkRectangle monitor_geometry;
+
+    int width, height, xpos, ypos;
+
+    GtkBuilder *builder = gtk_builder_new();
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/interface.ui", NULL);
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/menus.ui", NULL);
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/gtk/help-overlay.ui", NULL);
+
+    main_window = HDY_APPLICATION_WINDOW (gtk_builder_get_object (builder, "main_window"));
+    gtk_window_set_application (GTK_WINDOW (main_window), app->gobj());
+    gtk_widget_set_name (GTK_WIDGET (main_window), "gnome-system-monitor");
+    app->main_window = main_window;
+
+    gtk_application_window_set_help_overlay (GTK_APPLICATION_WINDOW (app->main_window),
+                                             GTK_SHORTCUTS_WINDOW (gtk_builder_get_object (builder, "help_overlay")));
+
+    g_settings_get (app->settings->gobj(), GSM_SETTING_WINDOW_STATE, "(iiii)",
+                    &width, &height, &xpos, &ypos);
+    
+    display = gdk_display_get_default ();
+    monitor = gdk_display_get_monitor_at_point (display, xpos, ypos);
+    if (monitor == NULL) {
+        monitor = gdk_display_get_monitor (display, 0);
+    }
+    gdk_monitor_get_geometry (monitor, &monitor_geometry);
+
+    width = CLAMP (width, 50, monitor_geometry.width);
+    height = CLAMP (height, 50, monitor_geometry.height);
+    xpos = CLAMP (xpos, 0, monitor_geometry.width - width);
+    ypos = CLAMP (ypos, 0, monitor_geometry.height - height);
+
+    gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
+    gtk_window_move (GTK_WINDOW (main_window), xpos, ypos);
+    if (app->settings->get_boolean (GSM_SETTING_MAXIMIZED))
+        gtk_window_maximize (GTK_WINDOW (main_window));
+
+    app->process_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "process_menu_button"));
+    process_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-window-menu"));
+    gtk_menu_button_set_menu_model (app->process_menu_button, process_menu_model);
+
+    app->window_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "window_menu_button"));
+    window_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "generic-window-menu"));
+    gtk_menu_button_set_menu_model (app->window_menu_button, window_menu_model);
+
+    app->end_process_button = GTK_BUTTON (gtk_builder_get_object (builder, "end_process_button"));
+
+    app->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "search_button"));
+
+    GActionEntry win_action_entries[] = {
+        { "about", on_activate_about, NULL, NULL, NULL },
+        { "show-help-overlay", on_activate_keyboard_shortcuts,  NULL, NULL, NULL},
+        { "search", on_activate_search, "b", "false", NULL },
+        { "send-signal-stop", on_activate_send_signal, "i", NULL, NULL },
+        { "send-signal-cont", on_activate_send_signal, "i", NULL, NULL },
+        { "send-signal-end", on_activate_send_signal, "i", NULL, NULL },
+        { "send-signal-kill", on_activate_send_signal, "i", NULL, NULL },
+        { "priority", on_activate_priority, "i", "@i 0", change_priority_state },
+        { "set-affinity", on_activate_set_affinity, NULL, NULL, NULL },
+        { "memory-maps", on_activate_memory_maps, NULL, NULL, NULL },
+        { "open-files", on_activate_open_files, NULL, NULL, NULL },
+        { "process-properties", on_activate_process_properties, NULL, NULL, NULL },
+        { "refresh", on_activate_refresh, NULL, NULL, NULL },
+        { "show-page", on_activate_radio, "s", "'resources'", change_show_page_state },
+        { "show-whose-processes", on_activate_radio, "s", "'all'", change_show_processes_state },
+        { "show-dependencies", on_activate_toggle, NULL, "false", change_show_dependencies_state }
+    };
+
+    g_action_map_add_action_entries (G_ACTION_MAP (main_window),
+                                     win_action_entries,
+                                     G_N_ELEMENTS (win_action_entries),
+                                     app);
+
+    GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET (main_window));
+    GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
+
+    /* use visual, if available */
+    if (visual)
+        gtk_widget_set_visual(GTK_WIDGET (main_window), visual);
+
+    /* create the main stack */
+    app->stack = stack = GTK_STACK (gtk_builder_get_object (builder, "stack"));
+
+    create_proc_view(app, builder);
+
+    create_sys_view (app, builder);
+    
+    create_disk_view (app, builder);
+
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_CURRENT_TAB, stack, "visible-child-name", G_SETTINGS_BIND_DEFAULT);
+
+    g_signal_connect (G_OBJECT (stack), "notify::visible-child",
+                      G_CALLBACK (cb_change_current_page), app);
+
+    g_signal_connect (G_OBJECT (main_window), "delete_event",
+                      G_CALLBACK (cb_main_window_delete),
+                      app);
+    g_signal_connect (G_OBJECT (main_window), "window-state-event",
+                      G_CALLBACK (cb_main_window_state_changed),
+                      app);
+
+    GAction *action;
+    action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
+                                         "show-dependencies");
+    g_action_change_state (action,
+                           g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_DEPENDENCIES));
+
+
+    action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
+                                         "show-whose-processes");
+    g_action_change_state (action,
+                           g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_WHOSE_PROCESSES));
+
+    gtk_widget_show (GTK_WIDGET (main_window));
+    
+    update_page_activities (app);
+
+    g_object_unref (G_OBJECT (builder));
+}
+
+static gboolean
+scroll_to_selection (gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    GList* paths = gtk_tree_selection_get_selected_rows (app->selection, NULL);
+    guint length = g_list_length(paths);
+    if (length > 0) {
+        GtkTreePath* last_path = (GtkTreePath*) g_list_nth_data(paths, length - 1);
+        gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (app->tree), last_path, NULL, FALSE, 0.0, 0.0);
+    }
+
+    g_list_free_full (paths, (GDestroyNotify) gtk_tree_path_free);
+    return FALSE;
+}
+
+void
+update_sensitivity(GsmApplication *app)
+{
+    const char * const selected_actions[] = { "send-signal-stop",
+                                              "send-signal-cont",
+                                              "send-signal-end",
+                                              "send-signal-kill",
+                                              "priority",
+                                              "set-affinity",
+                                              "memory-maps",
+                                              "open-files",
+                                              "process-properties" };
+
+    const char * const processes_actions[] = { "refresh",
+                                               "search",
+                                               "show-whose-processes",
+                                               "show-dependencies" };
+
+    size_t i;
+    gboolean processes_sensitivity, selected_sensitivity;
+    GAction *action;
+
+    processes_sensitivity = (strcmp (gtk_stack_get_visible_child_name (GTK_STACK (app->stack)), "processes") == 0);
+    selected_sensitivity = gtk_tree_selection_count_selected_rows (app->selection) > 0;
+
+    for (i = 0; i != G_N_ELEMENTS (processes_actions); ++i) {
+        action = g_action_map_lookup_action (G_ACTION_MAP (app->main_window),
+                                             processes_actions[i]);
+        g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
+                                     processes_sensitivity);
+    }
+
+    for (i = 0; i != G_N_ELEMENTS (selected_actions); ++i) {
+        action = g_action_map_lookup_action (G_ACTION_MAP (app->main_window),
+                                             selected_actions[i]);
+        g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
+                                     processes_sensitivity & selected_sensitivity);
+    }
+
+    gtk_revealer_set_reveal_child (GTK_REVEALER (app->proc_actionbar_revealer),
+                                   selected_sensitivity);
+
+    // Scrolls the table to selected row. Useful when the last row is obstructed by the revealer
+    guint duration_ms = gtk_revealer_get_transition_duration (GTK_REVEALER (app->proc_actionbar_revealer));
+    g_timeout_add (duration_ms, scroll_to_selection, app);
+}
+
diff --git a/src/interface.h b/src/interface.h
new file mode 100644
index 0000000..0520760
--- /dev/null
+++ b/src/interface.h
@@ -0,0 +1,30 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman - main window
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _GSM_INTERFACE_H_
+#define _GSM_INTERFACE_H_
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include "application.h"
+
+void            create_main_window (GsmApplication *app);
+void            update_sensitivity (GsmApplication *app);
+
+#endif /* _GSM_INTERFACE_H_ */
diff --git a/src/legacy/e_date.c b/src/legacy/e_date.c
new file mode 100644
index 0000000..2697e89
--- /dev/null
+++ b/src/legacy/e_date.c
@@ -0,0 +1,215 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <string.h>
+
+#include "e_date.h"
+
+/*
+  all this code comes from evolution
+  - e-util.c
+  - message-list.c
+*/
+
+
+static size_t e_strftime(char *s, size_t max, const char *fmt, const struct tm *tm)
+{
+#ifdef HAVE_LKSTRFTIME
+    return strftime(s, max, fmt, tm);
+#else
+    char *c, *ffmt, *ff;
+    size_t ret;
+
+    ffmt = g_strdup(fmt);
+    ff = ffmt;
+    while ((c = strstr(ff, "%l")) != NULL) {
+        c[1] = 'I';
+        ff = c;
+    }
+
+    ff = ffmt;
+    while ((c = strstr(ff, "%k")) != NULL) {
+        c[1] = 'H';
+        ff = c;
+    }
+
+    ret = strftime(s, max, ffmt, tm);
+    g_free(ffmt);
+    return ret;
+#endif
+}
+
+
+/**
+ * Function to do a last minute fixup of the AM/PM stuff if the locale
+ * and gettext haven't done it right. Most English speaking countries
+ * except the USA use the 24 hour clock (UK, Australia etc). However
+ * since they are English nobody bothers to write a language
+ * translation (gettext) file. So the locale turns off the AM/PM, but
+ * gettext does not turn on the 24 hour clock. Leaving a mess.
+ *
+ * This routine checks if AM/PM are defined in the locale, if not it
+ * forces the use of the 24 hour clock.
+ *
+ * The function itself is a front end on strftime and takes exactly
+ * the same arguments.
+ *
+ * TODO: Actually remove the '%p' from the fixed up string so that
+ * there isn't a stray space.
+ **/
+
+static size_t e_strftime_fix_am_pm(char *s, size_t max, const char *fmt, const struct tm *tm)
+{
+    char buf[10];
+    char *sp;
+    char *ffmt;
+    size_t ret;
+
+    if (strstr(fmt, "%p")==NULL && strstr(fmt, "%P")==NULL) {
+        /* No AM/PM involved - can use the fmt string directly */
+        ret=e_strftime(s, max, fmt, tm);
+    } else {
+        /* Get the AM/PM symbol from the locale */
+        e_strftime (buf, 10, "%p", tm);
+
+        if (buf[0]) {
+            /**
+             * AM/PM have been defined in the locale
+             * so we can use the fmt string directly
+             **/
+            ret=e_strftime(s, max, fmt, tm);
+        } else {
+            /**
+             * No AM/PM defined by locale
+             * must change to 24 hour clock
+             **/
+            ffmt=g_strdup(fmt);
+            for (sp=ffmt; (sp=strstr(sp, "%l")); sp++) {
+                /**
+                 * Maybe this should be 'k', but I have never
+                 * seen a 24 clock actually use that format
+                 **/
+                sp[1]='H';
+            }
+            for (sp=ffmt; (sp=strstr(sp, "%I")); sp++) {
+                sp[1]='H';
+            }
+            ret=e_strftime(s, max, ffmt, tm);
+            g_free(ffmt);
+        }
+    }
+    return(ret);
+}
+
+static size_t
+e_utf8_strftime_fix_am_pm(char *s, size_t max, const char *fmt, const struct tm *tm)
+{
+    size_t sz, ret;
+    char *locale_fmt, *buf;
+
+    locale_fmt = g_locale_from_utf8(fmt, -1, NULL, &sz, NULL);
+    if (!locale_fmt)
+        return 0;
+
+    ret = e_strftime_fix_am_pm(s, max, locale_fmt, tm);
+    if (!ret) {
+        g_free (locale_fmt);
+        return 0;
+    }
+
+    buf = g_locale_to_utf8(s, ret, NULL, &sz, NULL);
+    if (!buf) {
+        g_free (locale_fmt);
+        return 0;
+    }
+
+    if (sz >= max) {
+        char *tmp = buf + max - 1;
+        tmp = g_utf8_find_prev_char(buf, tmp);
+        if (tmp)
+            sz = tmp - buf;
+        else
+            sz = 0;
+    }
+    memcpy(s, buf, sz);
+    s[sz] = '\0';
+    g_free(locale_fmt);
+    g_free(buf);
+    return sz;
+}
+
+
+static char *
+filter_date (time_t date)
+{
+    time_t nowdate = time(NULL);
+    time_t yesdate;
+    struct tm then, now, yesterday;
+    char buf[26];
+    gboolean done = FALSE;
+
+    if (date == 0)
+        // xgettext: ? stands for unknown
+        return g_strdup (_("?"));
+
+    localtime_r (&date, &then);
+    localtime_r (&nowdate, &now);
+    if (then.tm_mday == now.tm_mday &&
+        then.tm_mon == now.tm_mon &&
+        then.tm_year == now.tm_year) {
+        e_utf8_strftime_fix_am_pm (buf, 26, _("Today %l∶%M %p"), &then);
+        done = TRUE;
+    }
+    if (!done) {
+        yesdate = nowdate - 60 * 60 * 24;
+        localtime_r (&yesdate, &yesterday);
+        if (then.tm_mday == yesterday.tm_mday &&
+            then.tm_mon == yesterday.tm_mon &&
+            then.tm_year == yesterday.tm_year) {
+            e_utf8_strftime_fix_am_pm (buf, 26, _("Yesterday %l∶%M %p"), &then);
+            done = TRUE;
+        }
+    }
+    if (!done) {
+        int i;
+        for (i = 2; i < 7; i++) {
+            yesdate = nowdate - 60 * 60 * 24 * i;
+            localtime_r (&yesdate, &yesterday);
+            if (then.tm_mday == yesterday.tm_mday &&
+                then.tm_mon == yesterday.tm_mon &&
+                then.tm_year == yesterday.tm_year) {
+                e_utf8_strftime_fix_am_pm (buf, 26, _("%a %l∶%M %p"), &then);
+                done = TRUE;
+                break;
+            }
+        }
+    }
+    if (!done) {
+        if (then.tm_year == now.tm_year) {
+            e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %l∶%M %p"), &then);
+        } else {
+            e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %Y"), &then);
+        }
+    }
+#if 0
+#ifdef CTIME_R_THREE_ARGS
+    ctime_r (&date, buf, 26);
+#else
+    ctime_r (&date, buf);
+#endif
+#endif
+
+    return g_strdup (buf);
+}
+
+
+
+
+char *
+procman_format_date_for_display(time_t d)
+{
+    return filter_date(d);
+}
diff --git a/src/legacy/e_date.h b/src/legacy/e_date.h
new file mode 100644
index 0000000..05ab097
--- /dev/null
+++ b/src/legacy/e_date.h
@@ -0,0 +1,15 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_E_DATE_H_
+#define _GSM_E_DATE_H_
+
+#include <time.h>
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+char *
+procman_format_date_for_display(time_t d);
+
+G_END_DECLS
+
+#endif /* _GSM_E_DATE_H_ */
diff --git a/src/legacy/gsm_color_button.c b/src/legacy/gsm_color_button.c
new file mode 100644
index 0000000..02a8ad3
--- /dev/null
+++ b/src/legacy/gsm_color_button.c
@@ -0,0 +1,859 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Gnome system monitor colour pickers
+ * Copyright (C) 2007 Karl Lattimer <karl@qdh.org.uk>
+ * All rights reserved.
+ *
+ * This Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This software 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 the software; see the file COPYING. If not,
+ * see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <librsvg/rsvg.h>
+
+#include "gsm_color_button.h"
+
+typedef struct
+{
+  GtkColorChooserDialog *cc_dialog;	/* Color chooser dialog */
+
+  gchar *title;			/* Title for the color selection window */
+
+  GdkRGBA color;
+  gdouble fraction;		/* Only used by GSMCP_TYPE_PIE */
+  guint type;
+  cairo_surface_t *image_buffer;
+  gdouble highlight;
+  gboolean button_down;
+  gboolean in_button;
+} GsmColorButtonPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (GsmColorButton, gsm_color_button, GTK_TYPE_DRAWING_AREA);
+
+/* Properties */
+enum
+{
+  PROP_0,
+  PROP_PERCENTAGE,
+  PROP_TITLE,
+  PROP_COLOR,
+  PROP_TYPE, 
+};
+
+/* Signals */
+enum
+{
+  COLOR_SET,
+  LAST_SIGNAL
+};
+
+#define GSMCP_MIN_WIDTH 15
+#define GSMCP_MIN_HEIGHT 15
+
+static void gsm_color_button_class_init (GsmColorButtonClass * klass);
+static void gsm_color_button_init (GsmColorButton * color_button);
+static void gsm_color_button_finalize (GObject * object);
+static void gsm_color_button_set_property (GObject * object, guint param_id,
+					   const GValue * value,
+					   GParamSpec * pspec);
+static void gsm_color_button_get_property (GObject * object, guint param_id,
+					   GValue * value,
+					   GParamSpec * pspec);
+static gboolean gsm_color_button_draw (GtkWidget *widget,
+                                       cairo_t   *cr);
+static void gsm_color_button_get_preferred_width (GtkWidget * widget,
+                                                  gint * minimum,
+                                                  gint * natural);
+static void gsm_color_button_get_preferred_height (GtkWidget * widget,
+                                                   gint * minimum,
+                                                   gint * natural);
+static gint gsm_color_button_pressed (GtkWidget * widget,
+				      GdkEventButton * event);
+static gint gsm_color_button_released (GtkWidget * widget,
+				      GdkEventButton * event);
+static gboolean gsm_color_button_enter_notify (GtkWidget * widget,
+					       GdkEventCrossing * event);
+static gboolean gsm_color_button_leave_notify (GtkWidget * widget,
+					       GdkEventCrossing * event);
+/* source side drag signals */
+static void gsm_color_button_drag_begin (GtkWidget * widget,
+					 GdkDragContext * context,
+					 gpointer data);
+static void gsm_color_button_drag_data_get (GtkWidget * widget,
+					    GdkDragContext * context,
+					    GtkSelectionData * selection_data,
+					    guint info, guint time,
+					    GsmColorButton * color_button);
+
+/* target side drag signals */
+static void gsm_color_button_drag_data_received (GtkWidget * widget,
+						 GdkDragContext * context,
+						 gint x,
+						 gint y,
+						 GtkSelectionData *
+						 selection_data, guint info,
+						 guint32 time,
+						 GsmColorButton *
+						 color_button);
+
+
+static guint color_button_signals[LAST_SIGNAL] = { 0 };
+
+static const GtkTargetEntry drop_types[] = { {"application/x-color", 0, 0} };
+
+static void
+gsm_color_button_class_init (GsmColorButtonClass * klass)
+{
+  GObjectClass *gobject_class;
+  GtkWidgetClass *widget_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  widget_class = GTK_WIDGET_CLASS (klass);
+
+  gobject_class->get_property = gsm_color_button_get_property;
+  gobject_class->set_property = gsm_color_button_set_property;
+  gobject_class->finalize = gsm_color_button_finalize;
+  widget_class->draw = gsm_color_button_draw;
+  widget_class->get_preferred_width  = gsm_color_button_get_preferred_width;
+  widget_class->get_preferred_height = gsm_color_button_get_preferred_height;
+  widget_class->button_release_event = gsm_color_button_released;
+  widget_class->button_press_event = gsm_color_button_pressed;
+  widget_class->enter_notify_event = gsm_color_button_enter_notify;
+  widget_class->leave_notify_event = gsm_color_button_leave_notify;
+
+  g_object_class_install_property (gobject_class,
+				   PROP_PERCENTAGE,
+				   g_param_spec_double ("fraction",
+							_("Fraction"),
+                            // TRANSLATORS: description of the pie color picker's (mem, swap) filled percentage property
+							_("Percentage full for pie color pickers"),
+							0, 1, 0.5,
+							G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+				   PROP_TITLE,
+				   g_param_spec_string ("title",
+							_("Title"),
+							_("The title of the color selection dialog"),
+							_("Pick a Color"),
+							G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+				   PROP_COLOR,
+				   g_param_spec_boxed ("color",
+						       _("Current Color"),
+						       _("The selected color"),
+						       GDK_TYPE_RGBA,
+						       G_PARAM_READWRITE));
+                               
+  g_object_class_install_property (gobject_class,
+				   PROP_TYPE,
+				   g_param_spec_uint ("type", _("Type"),
+						      _("Type of color picker"),
+						      0, 4, 0,
+						      G_PARAM_READWRITE));
+
+  color_button_signals[COLOR_SET] = g_signal_new ("color-set",
+                                                  G_TYPE_FROM_CLASS
+                                                  (gobject_class),
+                                                  G_SIGNAL_RUN_FIRST,
+                                                  0, NULL, NULL,
+                                                  g_cclosure_marshal_VOID__VOID,
+                                                  G_TYPE_NONE, 0);
+}
+
+
+static cairo_surface_t *
+fill_image_buffer_from_resource (cairo_t *cr, const char *path)
+{
+  GBytes *bytes;
+  const guint8 *data;
+  gsize len;
+  GError *error = NULL;
+  RsvgHandle *handle;
+  cairo_surface_t *tmp_surface;
+  cairo_t *tmp_cr;
+
+  bytes = g_resources_lookup_data (path, 0 , NULL);
+  data = g_bytes_get_data (bytes, &len);
+
+  handle = rsvg_handle_new_from_data (data, len, &error);
+
+  if (handle == NULL) {
+    g_warning("rsvg_handle_new_from_data(\"%s\") failed: %s",
+	      path, (error ? error->message : "unknown error"));
+    if (error)
+      g_error_free(error);
+    g_bytes_unref(bytes);
+    return NULL;
+  }
+
+  tmp_surface = cairo_surface_create_similar (cairo_get_target (cr),
+					      CAIRO_CONTENT_COLOR_ALPHA,
+					      32, 32);
+  tmp_cr = cairo_create (tmp_surface);
+  rsvg_handle_render_cairo (handle, tmp_cr);
+  cairo_destroy (tmp_cr);
+  g_object_unref (handle);
+  g_bytes_unref(bytes);
+  return tmp_surface;
+}
+
+static gboolean
+gsm_color_button_draw (GtkWidget *widget, cairo_t * cr)
+{
+  GsmColorButton *color_button = GSM_COLOR_BUTTON (widget);
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+  GdkRGBA *color = gdk_rgba_copy(&priv->color);
+  cairo_path_t *path = NULL;
+  gint width, height;
+  gdouble radius, arc_start, arc_end;
+  gdouble highlight_factor;
+  gboolean sensitive = gtk_widget_get_sensitive (widget);
+
+  if (sensitive && priv->highlight > 0) {
+    highlight_factor = 0.125 * priv->highlight;
+
+    color->red = MIN (1.0, color->red + highlight_factor);
+    
+    color->blue = MIN (1.0, color->blue + highlight_factor) ;
+    
+    color->green = MIN (1.0, color->green + highlight_factor);
+  } else if (!sensitive) {
+    GtkStyleContext *context = gtk_widget_get_style_context (widget);
+    gtk_style_context_get_color (context, gtk_widget_get_state_flags (widget), color);
+  }
+  gdk_cairo_set_source_rgba (cr, color);
+  gdk_rgba_free(color);
+  width  = gdk_window_get_width (gtk_widget_get_window (widget));
+  height = gdk_window_get_height(gtk_widget_get_window (widget));
+
+  switch (priv->type)
+    {
+    case GSMCP_TYPE_CPU:
+      //gtk_widget_set_size_request (widget, GSMCP_MIN_WIDTH, GSMCP_MIN_HEIGHT);
+      cairo_paint (cr);
+      cairo_set_line_width (cr, 1);
+      cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
+      cairo_rectangle (cr, 0.5, 0.5, width - 1, height - 1);
+      cairo_stroke (cr);
+      cairo_set_line_width (cr, 1);
+      cairo_set_source_rgba (cr, 1, 1, 1, 0.4);
+      cairo_rectangle (cr, 1.5, 1.5, width - 3, height - 3);
+      cairo_stroke (cr);
+      break;
+    case GSMCP_TYPE_PIE:
+      if (width < 32)		// 32px minimum size
+	gtk_widget_set_size_request (widget, 32, 32);
+      if (width < height)
+	radius = width / 2;
+      else
+	radius = height / 2;
+
+      arc_start = -G_PI_2 + 2 * G_PI * priv->fraction;
+      arc_end = -G_PI_2;
+
+      cairo_set_line_width (cr, 1);
+      
+      // Draw external stroke and fill
+      if (priv->fraction < 0.01) {
+        cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, 4.5,
+		   0, 2 * G_PI);
+      } else if (priv->fraction > 0.99) { 
+        cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
+		   0, 2 * G_PI);
+      } else {
+        cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
+		   arc_start, arc_end);
+        cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, 4.5,
+		   arc_end, arc_start);
+        cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
+		   arc_start, arc_start);
+      }
+      cairo_fill_preserve (cr);
+      cairo_set_source_rgba (cr, 0, 0, 0, 0.7);
+      cairo_stroke (cr);
+
+      // Draw internal highlight
+      cairo_set_source_rgba (cr, 1, 1, 1, 0.45);
+      cairo_set_line_width (cr, 1);
+
+      if (priv->fraction < 0.03) {
+        cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, 3.25,
+			    0, 2 * G_PI);
+      } else if (priv->fraction > 0.99) {
+        cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
+			    0, 2 * G_PI);
+      } else {
+        cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
+		 arc_start + (1 / (radius - 3.75)), 
+		 arc_end - (1 / (radius - 3.75)));
+        cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, 3.25,
+		   arc_end - (1 / (radius - 3.75)),
+                   arc_start + (1 / (radius - 3.75)));
+        cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
+		 arc_start + (1 / (radius - 3.75)), 
+		 arc_start + (1 / (radius - 3.75)));
+      }
+      cairo_stroke (cr);
+
+      // Draw external shape
+      cairo_set_line_width (cr, 1);
+      cairo_set_source_rgba (cr, 0, 0, 0, 0.2);
+      cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 1.25, 0,
+		 G_PI * 2);
+      cairo_stroke (cr);
+
+      break;
+    case GSMCP_TYPE_NETWORK_IN:
+      if (priv->image_buffer == NULL)
+          priv->image_buffer =
+	  fill_image_buffer_from_resource (cr, "/org/gnome/gnome-system-monitor/pixmaps/download.svg");
+      gtk_widget_set_size_request (widget, 32, 32);
+      cairo_move_to (cr, 8.5, 1.5);
+      cairo_line_to (cr, 23.5, 1.5);
+      cairo_line_to (cr, 23.5, 11.5);
+      cairo_line_to (cr, 29.5, 11.5);
+      cairo_line_to (cr, 16.5, 27.5);
+      cairo_line_to (cr, 15.5, 27.5);
+      cairo_line_to (cr, 2.5, 11.5);
+      cairo_line_to (cr, 8.5, 11.5);
+      cairo_line_to (cr, 8.5, 1.5);
+      cairo_close_path (cr);
+      path = cairo_copy_path (cr);
+      cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+      cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
+      cairo_set_line_width (cr, 1);
+      cairo_fill_preserve (cr);
+      cairo_set_miter_limit (cr, 5.0);
+      cairo_stroke (cr);
+      cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
+      cairo_append_path (cr, path);
+      cairo_path_destroy(path);
+      cairo_stroke (cr);
+      cairo_set_source_surface (cr, priv->image_buffer, 0.0,
+				0.0);
+      cairo_paint (cr);
+
+      break;
+    case GSMCP_TYPE_NETWORK_OUT:
+      if (priv->image_buffer == NULL)
+          priv->image_buffer =
+	  fill_image_buffer_from_resource (cr, "/org/gnome/gnome-system-monitor/pixmaps/upload.svg");
+      gtk_widget_set_size_request (widget, 32, 32);
+      cairo_move_to (cr, 16.5, 1.5);
+      cairo_line_to (cr, 29.5, 17.5);
+      cairo_line_to (cr, 23.5, 17.5);
+      cairo_line_to (cr, 23.5, 27.5);
+      cairo_line_to (cr, 8.5, 27.5);
+      cairo_line_to (cr, 8.5, 17.5);
+      cairo_line_to (cr, 2.5, 17.5);
+      cairo_line_to (cr, 15.5, 1.5);
+      cairo_line_to (cr, 16.5, 1.5);
+      cairo_close_path (cr);
+      path = cairo_copy_path (cr);
+      cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+      cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
+      cairo_set_line_width (cr, 1);
+      cairo_fill_preserve (cr);
+      cairo_set_miter_limit (cr, 5.0);
+      cairo_stroke (cr);
+      cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
+      cairo_append_path (cr, path);
+      cairo_path_destroy(path);
+      cairo_stroke (cr);
+      cairo_set_source_surface (cr, priv->image_buffer, 0.0,
+				0.0);
+      cairo_paint (cr);
+
+      break;
+    }
+
+  return FALSE;
+}
+
+static void
+gsm_color_button_get_preferred_width (GtkWidget * widget,
+                                      gint      * minimum,
+                                      gint      * natural)
+{
+  if (minimum)
+    *minimum = GSMCP_MIN_WIDTH;
+  if (natural)
+    *natural = GSMCP_MIN_WIDTH;
+}
+
+static void
+gsm_color_button_get_preferred_height (GtkWidget * widget,
+                                       gint      * minimum,
+                                       gint      * natural)
+{
+  if (minimum)
+    *minimum = GSMCP_MIN_HEIGHT;
+  if (natural)
+    *natural = GSMCP_MIN_HEIGHT;
+}
+
+static void
+gsm_color_button_drag_data_received (GtkWidget * widget,
+				     GdkDragContext * context,
+				     gint x,
+				     gint y,
+				     GtkSelectionData * selection_data,
+				     guint info,
+				     guint32 time,
+				     GsmColorButton * color_button)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+
+  gint length;
+  guint16 *dropped;
+
+  length = gtk_selection_data_get_length (selection_data);
+
+  if (length < 0)
+    return;
+
+  /* We accept drops with the wrong format, since the KDE color
+   * chooser incorrectly drops application/x-color with format 8.
+   */
+  if (length != 8)
+    {
+      g_warning (_("Received invalid color data\n"));
+      return;
+    }
+
+
+  dropped = (guint16 *) gtk_selection_data_get_data (selection_data);
+
+  priv->color.red   = (gdouble)dropped[0] / 0xffff;
+  priv->color.green = (gdouble)dropped[1] / 0xffff;
+  priv->color.blue  = (gdouble)dropped[2] / 0xffff;
+
+  gtk_widget_queue_draw (GTK_WIDGET (color_button));
+
+  g_signal_emit (color_button, color_button_signals[COLOR_SET], 0);
+
+  g_object_freeze_notify (G_OBJECT (color_button));
+  g_object_notify (G_OBJECT (color_button), "color");
+  g_object_thaw_notify (G_OBJECT (color_button));
+}
+
+
+static void
+set_color_icon (GdkDragContext * context, GdkRGBA * color)
+{
+  GdkPixbuf *pixbuf;
+  guint32 pixel;
+
+  pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 48, 32);
+
+  pixel = ((guint32)(color->red * 0xff) << 24) |
+          ((guint32)(color->green * 0xff) << 16) |
+          ((guint32)(color->blue * 0xff) << 8);
+
+  gdk_pixbuf_fill (pixbuf, pixel);
+
+  gtk_drag_set_icon_pixbuf (context, pixbuf, -2, -2);
+  g_object_unref (pixbuf);
+}
+
+static void
+gsm_color_button_drag_begin (GtkWidget * widget,
+			     GdkDragContext * context, gpointer data)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (GSM_COLOR_BUTTON (data));
+  set_color_icon (context, &priv->color);
+}
+
+static void
+gsm_color_button_drag_data_get (GtkWidget * widget,
+				GdkDragContext * context,
+				GtkSelectionData * selection_data,
+				guint info,
+				guint time, GsmColorButton * color_button)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+  guint16 dropped[4];
+
+  dropped[0] = priv->color.red * 0xffff;
+  dropped[1] = priv->color.green * 0xffff;
+  dropped[2] = priv->color.blue * 0xffff;
+  dropped[3] = 65535;		// This widget doesn't care about alpha
+
+  gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data),
+			  16, (guchar *) dropped, 8);
+}
+
+
+static void
+gsm_color_button_init (GsmColorButton * color_button)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+
+  priv->color.red = 0;
+  priv->color.green = 0;
+  priv->color.blue = 0;
+  priv->fraction = 0.5;
+  priv->type = GSMCP_TYPE_CPU;
+  priv->image_buffer = NULL;
+  priv->title = g_strdup (_("Pick a Color")); 	/* default title */
+  priv->in_button = FALSE;
+  priv->button_down = FALSE;
+  
+  gtk_drag_dest_set (GTK_WIDGET (color_button),
+		     GTK_DEST_DEFAULT_MOTION |
+		     GTK_DEST_DEFAULT_HIGHLIGHT |
+		     GTK_DEST_DEFAULT_DROP, drop_types, 1, GDK_ACTION_COPY);
+  gtk_drag_source_set (GTK_WIDGET (color_button),
+		       GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
+		       drop_types, 1, GDK_ACTION_COPY);
+  g_signal_connect (color_button, "drag_begin",
+		    G_CALLBACK (gsm_color_button_drag_begin), color_button);
+  g_signal_connect (color_button, "drag_data_received",
+		    G_CALLBACK (gsm_color_button_drag_data_received),
+		    color_button);
+  g_signal_connect (color_button, "drag_data_get",
+		    G_CALLBACK (gsm_color_button_drag_data_get),
+		    color_button);
+
+  gtk_widget_add_events (GTK_WIDGET(color_button), GDK_ENTER_NOTIFY_MASK
+			 			 | GDK_LEAVE_NOTIFY_MASK);
+
+  gtk_widget_set_tooltip_text (GTK_WIDGET(color_button), _("Click to set graph colors"));
+}
+
+static void
+gsm_color_button_finalize (GObject * object)
+{
+  GsmColorButton *color_button = GSM_COLOR_BUTTON (object);
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+
+  if (priv->cc_dialog != NULL)
+    gtk_widget_destroy (GTK_WIDGET (priv->cc_dialog));
+  priv->cc_dialog = NULL;
+
+  g_free (priv->title);
+  priv->title = NULL;
+
+  cairo_surface_destroy (priv->image_buffer);
+  priv->image_buffer = NULL;
+
+  G_OBJECT_CLASS (gsm_color_button_parent_class)->finalize (object);
+}
+
+GsmColorButton *
+gsm_color_button_new (const GdkRGBA * color, guint type)
+{
+  return g_object_new (GSM_TYPE_COLOR_BUTTON, "color", color, "type", type,
+		               "visible", TRUE, NULL);
+}
+
+static void
+dialog_response (GtkWidget * widget, GtkResponseType response, gpointer data)
+{
+  GsmColorButton *color_button = GSM_COLOR_BUTTON (data);
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+  GtkColorChooser *color_chooser;
+
+  if (response == GTK_RESPONSE_OK) {
+    color_chooser = GTK_COLOR_CHOOSER (priv->cc_dialog);
+
+    gtk_color_chooser_get_rgba (color_chooser, &priv->color);
+
+    gtk_widget_hide (GTK_WIDGET (priv->cc_dialog));
+
+    gtk_widget_queue_draw (GTK_WIDGET (color_button));
+
+    g_signal_emit (color_button, color_button_signals[COLOR_SET], 0);
+
+    g_object_freeze_notify (G_OBJECT (color_button));
+    g_object_notify (G_OBJECT (color_button), "color");
+    g_object_thaw_notify (G_OBJECT (color_button));
+  }
+  else  /* (response == GTK_RESPONSE_CANCEL) */
+    gtk_widget_hide (GTK_WIDGET (priv->cc_dialog));
+}
+
+static gboolean
+dialog_destroy (GtkWidget * widget, gpointer data)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (GSM_COLOR_BUTTON (data));
+
+  priv->cc_dialog = NULL;
+
+  return FALSE;
+}
+
+static gint
+gsm_color_button_clicked (GtkWidget * widget, GdkEventButton * event)
+{
+  GsmColorButton *color_button = GSM_COLOR_BUTTON (widget);
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (color_button);
+
+  /* if dialog already exists, make sure it's shown and raised */
+  if (!priv->cc_dialog)
+    {
+      /* Create the dialog and connects its buttons */
+      GtkColorChooserDialog *cc_dialog;
+      GtkWidget *parent;
+
+      parent = gtk_widget_get_toplevel (GTK_WIDGET (color_button));
+      if (!gtk_widget_is_toplevel (parent))
+        parent = NULL;
+
+      cc_dialog = GTK_COLOR_CHOOSER_DIALOG (gtk_color_chooser_dialog_new (priv->title, GTK_WINDOW (parent)));
+
+      gtk_window_set_modal (GTK_WINDOW (cc_dialog), TRUE);
+
+      g_signal_connect (cc_dialog, "response",
+                        G_CALLBACK (dialog_response), color_button);
+
+      g_signal_connect (cc_dialog, "destroy",
+                        G_CALLBACK (dialog_destroy), color_button);
+
+      priv->cc_dialog = cc_dialog;
+    }
+
+  gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (priv->cc_dialog),
+                              &priv->color);
+
+  gtk_window_present (GTK_WINDOW (priv->cc_dialog));
+  return 0;
+}
+
+static gint
+gsm_color_button_pressed (GtkWidget * widget, GdkEventButton * event)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (GSM_COLOR_BUTTON (widget));
+
+  if ((event->type == GDK_BUTTON_PRESS) && (event->button == 1))
+    priv->button_down = TRUE;
+  return 0;
+}
+
+static gint
+gsm_color_button_released (GtkWidget * widget, GdkEventButton * event)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (GSM_COLOR_BUTTON (widget));
+  if (priv->button_down && priv->in_button)
+    gsm_color_button_clicked (widget, event);
+  priv->button_down = FALSE;
+  return 0;
+}
+
+
+static gboolean
+gsm_color_button_enter_notify (GtkWidget * widget, GdkEventCrossing * event)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (GSM_COLOR_BUTTON (widget));
+  priv->highlight = 1.0;
+  priv->in_button = TRUE;
+  gtk_widget_queue_draw(widget);
+  return FALSE;
+}
+
+static gboolean
+gsm_color_button_leave_notify (GtkWidget * widget, GdkEventCrossing * event)
+{
+  GsmColorButtonPrivate *priv = gsm_color_button_get_instance_private (GSM_COLOR_BUTTON (widget));
+  priv->highlight = 0;
+  priv->in_button = FALSE;
+  gtk_widget_queue_draw(widget);
+  return FALSE;
+}
+
+guint
+gsm_color_button_get_cbtype (GsmColorButton * color_button)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_val_if_fail (GSM_IS_COLOR_BUTTON (color_button), 0);
+
+  priv = gsm_color_button_get_instance_private (color_button);
+  return priv->type;
+}
+
+void
+gsm_color_button_set_cbtype (GsmColorButton * color_button, guint type)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_if_fail (GSM_IS_COLOR_BUTTON (color_button));
+
+  priv = gsm_color_button_get_instance_private (color_button);
+  priv->type = type;
+
+  gtk_widget_queue_draw (GTK_WIDGET (color_button));
+
+  g_object_notify (G_OBJECT (color_button), "type");
+}
+
+gdouble
+gsm_color_button_get_fraction (GsmColorButton * color_button)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_val_if_fail (GSM_IS_COLOR_BUTTON (color_button), 0);
+
+  priv = gsm_color_button_get_instance_private (color_button);
+  return priv->fraction;
+}
+
+void
+gsm_color_button_set_fraction (GsmColorButton * color_button,
+			       gdouble fraction)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_if_fail (GSM_IS_COLOR_BUTTON (color_button));
+ 
+  priv = gsm_color_button_get_instance_private (color_button);
+
+  priv->fraction = fraction;
+
+  gtk_widget_queue_draw (GTK_WIDGET (color_button));
+
+  g_object_notify (G_OBJECT (color_button), "fraction");
+}
+
+void
+gsm_color_button_get_color (GsmColorButton * color_button, GdkRGBA * color)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_if_fail (GSM_IS_COLOR_BUTTON (color_button));
+
+  priv = gsm_color_button_get_instance_private (color_button);
+
+  color->red = priv->color.red;
+  color->green = priv->color.green;
+  color->blue = priv->color.blue;
+  color->alpha = priv->color.alpha;
+}
+
+void
+gsm_color_button_set_color (GsmColorButton * color_button,
+                            const GdkRGBA * color)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_if_fail (GSM_IS_COLOR_BUTTON (color_button));
+  g_return_if_fail (color != NULL);
+
+  priv = gsm_color_button_get_instance_private (color_button);
+
+  priv->color.red = color->red;
+  priv->color.green = color->green;
+  priv->color.blue = color->blue;
+  priv->color.alpha = color->alpha;
+
+  gtk_widget_queue_draw (GTK_WIDGET (color_button));
+
+  g_object_notify (G_OBJECT (color_button), "color");
+}
+
+void
+gsm_color_button_set_title (GsmColorButton * color_button,
+                            const gchar * title)
+{
+  GsmColorButtonPrivate *priv;
+  gchar *old_title;
+
+  g_return_if_fail (GSM_IS_COLOR_BUTTON (color_button));
+
+  priv = gsm_color_button_get_instance_private (color_button);
+
+  old_title = priv->title;
+  priv->title = g_strdup (title);
+  g_free (old_title);
+
+  if (priv->cc_dialog)
+    gtk_window_set_title (GTK_WINDOW (priv->cc_dialog),
+                          priv->title);
+
+  g_object_notify (G_OBJECT (color_button), "title");
+}
+
+gchar *
+gsm_color_button_get_title (GsmColorButton * color_button)
+{
+  GsmColorButtonPrivate *priv;
+
+  g_return_val_if_fail (GSM_IS_COLOR_BUTTON (color_button), NULL);
+
+  priv = gsm_color_button_get_instance_private (color_button);
+  return priv->title;
+}
+
+static void
+gsm_color_button_set_property (GObject * object,
+			       guint param_id,
+			       const GValue * value, GParamSpec * pspec)
+{
+  GsmColorButton *color_button = GSM_COLOR_BUTTON (object);
+
+  switch (param_id)
+    {
+    case PROP_PERCENTAGE:
+      gsm_color_button_set_fraction (color_button,
+				     g_value_get_double (value));
+      break;
+    case PROP_TITLE:
+      gsm_color_button_set_title (color_button, g_value_get_string (value));
+      break;
+    case PROP_COLOR:
+      gsm_color_button_set_color (color_button, g_value_get_boxed (value));
+      break;
+    case PROP_TYPE:
+      gsm_color_button_set_cbtype (color_button, g_value_get_uint (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
+
+static void
+gsm_color_button_get_property (GObject * object,
+			       guint param_id,
+			       GValue * value, GParamSpec * pspec)
+{
+  GsmColorButton *color_button = GSM_COLOR_BUTTON (object);
+  GdkRGBA color;
+
+  switch (param_id)
+    {
+    case PROP_PERCENTAGE:
+      g_value_set_double (value,
+			  gsm_color_button_get_fraction (color_button));
+      break;
+    case PROP_TITLE:
+      g_value_set_string (value, gsm_color_button_get_title (color_button));
+      break;
+    case PROP_COLOR:
+      gsm_color_button_get_color (color_button, &color);
+      g_value_set_boxed (value, &color);
+      break;
+    case PROP_TYPE:
+      g_value_set_uint (value, gsm_color_button_get_cbtype (color_button));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+      break;
+    }
+}
diff --git a/src/legacy/gsm_color_button.h b/src/legacy/gsm_color_button.h
new file mode 100644
index 0000000..385dd14
--- /dev/null
+++ b/src/legacy/gsm_color_button.h
@@ -0,0 +1,77 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Gnome system monitor colour pickers
+ * Copyright (C) 2007 Karl Lattimer <karl@qdh.org.uk>
+ * All rights reserved.
+ *
+ * This Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This software 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 the software; see the file COPYING. If not,
+ * see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _GSM_COLOR_BUTTON_H_
+#define _GSM_COLOR_BUTTON_H_
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+/* The GtkColorSelectionButton widget is a simple color picker in a button.
+ * The button displays a sample of the currently selected color. When
+ * the user clicks on the button, a color selection dialog pops up.
+ * The color picker emits the "color_set" signal when the color is set.
+ */
+#define GSM_TYPE_COLOR_BUTTON            (gsm_color_button_get_type ())
+#define GSM_COLOR_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSM_TYPE_COLOR_BUTTON, GsmColorButton))
+#define GSM_COLOR_BUTTON_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GSM_TYPE_COLOR_BUTTON, GsmColorButtonClass))
+#define GSM_IS_COLOR_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSM_TYPE_COLOR_BUTTON))
+#define GSM_IS_COLOR_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GSM_TYPE_COLOR_BUTTON))
+#define GSM_COLOR_BUTTON_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GSM_TYPE_COLOR_BUTTON, GsmColorButtonClass))
+
+typedef struct _GsmColorButton           GsmColorButton;
+typedef struct _GsmColorButtonClass      GsmColorButtonClass;
+
+struct _GsmColorButton
+{
+    GtkDrawingArea parent_instance;
+};
+
+/* Widget types */
+enum
+{
+    GSMCP_TYPE_CPU,
+    GSMCP_TYPE_PIE,
+    GSMCP_TYPE_NETWORK_IN,
+    GSMCP_TYPE_NETWORK_OUT,
+    GSMCP_TYPES
+};
+
+struct _GsmColorButtonClass
+{
+    GtkDrawingAreaClass parent_class;
+};
+
+GType       gsm_color_button_get_type      (void);
+GsmColorButton * gsm_color_button_new      (const GdkRGBA * color, guint type);
+void        gsm_color_button_set_color     (GsmColorButton * color_button, const GdkRGBA * color);
+void        gsm_color_button_set_fraction  (GsmColorButton * color_button, const gdouble fraction);
+void        gsm_color_button_set_cbtype    (GsmColorButton * color_button, guint type);
+void        gsm_color_button_get_color     (GsmColorButton * color_button, GdkRGBA * color);
+gdouble     gsm_color_button_get_fraction  (GsmColorButton * color_button);
+guint       gsm_color_button_get_cbtype    (GsmColorButton * color_button);
+void        gsm_color_button_set_title     (GsmColorButton * color_button, const gchar * title);
+gchar     * gsm_color_button_get_title     (GsmColorButton * color_button);
+
+G_END_DECLS
+
+#endif /* _GSM_COLOR_BUTTON_H_ */
diff --git a/src/legacy/meson.build b/src/legacy/meson.build
new file mode 100644
index 0000000..a66c863
--- /dev/null
+++ b/src/legacy/meson.build
@@ -0,0 +1,16 @@
+
+libgsm_legacy_sources = [
+  'e_date.c',
+  'gsm_color_button.c',
+  'treeview.c',
+]
+
+libgsm_legacy = static_library('gsm_legacy',
+  libgsm_legacy_sources,
+  include_directories: rootInclude,
+  dependencies: [
+    glib,
+    gtk3,
+    librsvg,
+  ],
+)
diff --git a/src/legacy/treeview.c b/src/legacy/treeview.c
new file mode 100644
index 0000000..b50393d
--- /dev/null
+++ b/src/legacy/treeview.c
@@ -0,0 +1,289 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include "treeview.h"
+
+typedef struct
+{
+    GSettings  *settings;
+    gboolean    store_column_order;
+    GHashTable *excluded_columns;
+} GsmTreeViewPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (GsmTreeView, gsm_tree_view, GTK_TYPE_TREE_VIEW)
+
+static void
+gsm_tree_view_finalize (GObject *object)
+{
+    GsmTreeViewPrivate *priv = gsm_tree_view_get_instance_private (GSM_TREE_VIEW (object));
+
+    g_hash_table_destroy (priv->excluded_columns);
+    priv->excluded_columns = NULL;
+
+    G_OBJECT_CLASS (gsm_tree_view_parent_class)->finalize (object);
+}
+
+static void
+gsm_tree_view_class_init (GsmTreeViewClass *klass)
+{
+    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+    gobject_class->finalize = gsm_tree_view_finalize;
+}
+
+static void
+gsm_tree_view_init (GsmTreeView *self)
+{
+    GsmTreeViewPrivate *priv = gsm_tree_view_get_instance_private (self);
+
+    priv->excluded_columns = g_hash_table_new (g_direct_hash, g_direct_equal);
+}
+
+void
+gsm_tree_view_save_state (GsmTreeView *tree_view)
+{
+    GsmTreeViewPrivate *priv;
+
+    g_return_if_fail (GSM_IS_TREE_VIEW (tree_view));
+
+    priv = gsm_tree_view_get_instance_private (tree_view);
+    GtkTreeModel *model;
+    gint sort_col;
+    GtkSortType sort_type;
+
+    model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
+    g_settings_delay (priv->settings);
+    if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
+                                              &sort_col,
+                                              &sort_type)) {
+        g_settings_set_int (priv->settings, "sort-col", sort_col);
+        g_settings_set_int (priv->settings, "sort-order", sort_type);
+    }
+
+    if (priv->store_column_order) {
+        GList *columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree_view));
+        GList *iter;
+        GVariantBuilder builder;
+
+        g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
+
+        for (iter = columns; iter != NULL; iter = iter->next) {
+            gint id = gtk_tree_view_column_get_sort_column_id (GTK_TREE_VIEW_COLUMN (iter->data));
+            g_variant_builder_add (&builder, "i", id);
+        }
+
+        g_settings_set_value (priv->settings, "columns-order",
+                              g_variant_builder_end (&builder));
+
+        g_list_free (columns);
+    }
+
+    g_settings_apply (priv->settings);
+}
+
+GtkTreeViewColumn *
+gsm_tree_view_get_column_from_id (GsmTreeView *tree_view, gint sort_id)
+{
+    GList *columns;
+    GList *iter;
+    GtkTreeViewColumn *col = NULL;
+
+    g_return_val_if_fail (GSM_IS_TREE_VIEW (tree_view), NULL);
+
+    columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree_view));
+
+    for (iter = columns; iter != NULL; iter = iter->next) {
+        col = GTK_TREE_VIEW_COLUMN (iter->data);
+        if (gtk_tree_view_column_get_sort_column_id (col) == sort_id)
+            break;
+    }
+
+    g_list_free (columns);
+
+    return col;
+}
+
+static gboolean
+cb_column_header_clicked (GtkTreeViewColumn *column, GdkEventButton *event, gpointer data)
+{
+    GtkMenu *menu = GTK_MENU (data);
+
+    if (event->button == GDK_BUTTON_SECONDARY) {
+        gtk_menu_popup_at_pointer (menu, (GdkEvent*)event);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+void
+gsm_tree_view_load_state (GsmTreeView *tree_view)
+{
+    GsmTreeViewPrivate *priv;
+    GtkTreeModel *model;
+    gint sort_col;
+    GtkSortType sort_type;
+
+    g_return_if_fail (GSM_IS_TREE_VIEW (tree_view));
+
+    priv = gsm_tree_view_get_instance_private (tree_view);
+    model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
+
+    sort_col = g_settings_get_int (priv->settings, "sort-col");
+    sort_type = g_settings_get_int (priv->settings, "sort-order");
+
+    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
+                                          sort_col,
+                                          sort_type);
+
+    if (priv->store_column_order) {
+        GtkMenu *header_menu = GTK_MENU (gtk_menu_new ());
+        GList *columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree_view));
+        GList *iter;
+        GVariantIter *var_iter;
+        GtkTreeViewColumn *col, *last;
+        gint sort_id;
+
+        for (iter = columns; iter != NULL; iter = iter->next) {
+            const char *title;
+            char *key;
+            GtkButton *button;
+            GtkCheckMenuItem *column_item;
+
+            col = GTK_TREE_VIEW_COLUMN (iter->data);
+            sort_id = gtk_tree_view_column_get_sort_column_id (col);
+
+            if (priv->excluded_columns &&
+                g_hash_table_contains (priv->excluded_columns, GINT_TO_POINTER (sort_id))) {
+                gtk_tree_view_column_set_visible (col, FALSE);
+                continue;
+            }
+
+            title = gtk_tree_view_column_get_title (col);
+
+            button = GTK_BUTTON (gtk_tree_view_column_get_button (col));
+            g_signal_connect (button, "button-press-event",
+                              G_CALLBACK (cb_column_header_clicked),
+                              header_menu);
+
+            column_item = GTK_CHECK_MENU_ITEM (gtk_check_menu_item_new_with_label (title));
+            g_object_bind_property (col, "visible",
+                                    column_item, "active",
+                                    G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
+
+            gtk_menu_shell_append (GTK_MENU_SHELL (header_menu), GTK_WIDGET (column_item));
+
+            key = g_strdup_printf ("col-%d-width", sort_id);
+            gtk_tree_view_column_set_fixed_width (col, g_settings_get_int (priv->settings, key));
+            gtk_tree_view_column_set_min_width (col, 30);
+            g_free (key);
+
+            key = g_strdup_printf ("col-%d-visible", sort_id);
+            gtk_tree_view_column_set_visible (col, g_settings_get_boolean (priv->settings, key));
+            g_free (key);
+        }
+
+        g_list_free (columns);
+
+        gtk_widget_show_all (GTK_WIDGET (header_menu));
+
+        g_settings_get (priv->settings, "columns-order", "ai", &var_iter);
+        last = NULL;
+        while (g_variant_iter_loop (var_iter, "i", &sort_id)) {
+            col = gsm_tree_view_get_column_from_id (tree_view, sort_id);
+
+            if (col != NULL && col != last) {
+                gtk_tree_view_move_column_after (GTK_TREE_VIEW (tree_view),
+                                                 col, last);
+                last = col;
+            }
+        }
+        g_variant_iter_free (var_iter);
+    }
+}
+
+void
+gsm_tree_view_add_excluded_column (GsmTreeView *tree_view, gint column_id)
+{
+    GsmTreeViewPrivate *priv;
+
+    g_return_if_fail (GSM_IS_TREE_VIEW (tree_view));
+
+    priv = gsm_tree_view_get_instance_private (tree_view);
+    g_hash_table_add (priv->excluded_columns, GINT_TO_POINTER (column_id));
+}
+
+static guint timeout_id = 0;
+static GtkTreeViewColumn *current_column;
+
+static gboolean
+save_column_state (gpointer data)
+{
+    GSettings *settings = G_SETTINGS (data);
+    gint column_id = gtk_tree_view_column_get_sort_column_id (current_column);
+    gint width = gtk_tree_view_column_get_width (current_column);
+    gboolean visible = gtk_tree_view_column_get_visible (current_column);
+
+    gchar *key;
+    g_settings_delay (settings);
+
+    key = g_strdup_printf ("col-%d-width", column_id);
+    g_settings_set_int (settings, key, width);
+    g_free (key);
+
+    key = g_strdup_printf ("col-%d-visible", column_id);
+    g_settings_set_boolean (settings, key, visible);
+    g_free (key);
+    timeout_id = 0;
+    g_settings_apply (settings);
+
+    return FALSE;
+}
+
+static void
+cb_update_column_state (GObject *object, GParamSpec *pspec, gpointer data)
+{
+    GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (object);
+
+    current_column = column;
+
+    if (timeout_id > 0)
+        g_source_remove (timeout_id);
+
+    timeout_id = g_timeout_add_seconds (1, save_column_state, data);
+}
+
+void
+gsm_tree_view_append_and_bind_column (GsmTreeView *tree_view, GtkTreeViewColumn *column)
+{
+    GsmTreeViewPrivate *priv;
+
+    g_return_if_fail (GSM_IS_TREE_VIEW (tree_view));
+    g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
+
+    priv = gsm_tree_view_get_instance_private (tree_view);
+
+    gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
+                                 column);
+
+    g_signal_connect (column, "notify::fixed-width",
+                      G_CALLBACK (cb_update_column_state),
+                      priv->settings);
+
+    g_signal_connect (column, "notify::visible",
+                      G_CALLBACK (cb_update_column_state),
+                      priv->settings);
+}
+
+
+GsmTreeView *
+gsm_tree_view_new (GSettings *settings, gboolean store_column_order)
+{
+    GsmTreeView *self = g_object_new (GSM_TYPE_TREE_VIEW, NULL);
+    GsmTreeViewPrivate *priv = gsm_tree_view_get_instance_private (self);
+
+    priv->settings = settings;
+    priv->store_column_order = store_column_order;
+
+    return self;
+}
diff --git a/src/legacy/treeview.h b/src/legacy/treeview.h
new file mode 100644
index 0000000..7223ab1
--- /dev/null
+++ b/src/legacy/treeview.h
@@ -0,0 +1,43 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_TREE_VIEW_H_
+#define _GSM_TREE_VIEW_H_
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GSM_TYPE_TREE_VIEW (gsm_tree_view_get_type ())
+#define GSM_TREE_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSM_TYPE_TREE_VIEW, GsmTreeView))
+#define GSM_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GSM_TYPE_TREE_VIEW, GsmTreeViewClass))
+#define GSM_IS_TREE_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSM_TYPE_TREE_VIEW))
+#define GSM_IS_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GSM_TYPE_TREE_VIEW))
+#define GSM_TREE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GSM_TYPE_TREE_VIEW, GsmTreeViewClass))
+
+typedef struct _GsmTreeView      GsmTreeView;
+typedef struct _GsmTreeViewClass GsmTreeViewClass;
+
+struct _GsmTreeView
+{
+    GtkTreeView parent_instance;
+};
+
+struct _GsmTreeViewClass
+{
+    GtkTreeViewClass parent_class;
+};
+
+GType               gsm_tree_view_get_type               (void) G_GNUC_CONST;
+GsmTreeView       * gsm_tree_view_new                    (GSettings *settings,
+                                                          gboolean   store_column_order);
+void                gsm_tree_view_save_state             (GsmTreeView *tree_view);
+void                gsm_tree_view_load_state             (GsmTreeView *tree_view);
+GtkTreeViewColumn * gsm_tree_view_get_column_from_id     (GsmTreeView *tree_view,
+                                                          gint         sort_id);
+void                gsm_tree_view_add_excluded_column    (GsmTreeView *tree_view,
+                                                          gint         column_id);
+void                gsm_tree_view_append_and_bind_column (GsmTreeView       *tree_view,
+                                                          GtkTreeViewColumn *column);
+
+G_END_DECLS
+
+#endif /* _GSM_TREE_VIEW_H_ */
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;
+}
diff --git a/src/load-graph.h b/src/load-graph.h
new file mode 100644
index 0000000..1a519ad
--- /dev/null
+++ b/src/load-graph.h
@@ -0,0 +1,146 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_LOAD_GRAPH_H_
+#define _GSM_LOAD_GRAPH_H_
+
+#include <glib.h>
+#include <glibtop/cpu.h>
+
+#include "legacy/gsm_color_button.h"
+#include "util.h"
+#include "settings-keys.h"
+
+enum
+{
+    LOAD_GRAPH_CPU,
+    LOAD_GRAPH_MEM,
+    LOAD_GRAPH_NET
+};
+
+enum
+{
+    CPU_TOTAL,
+    CPU_USED,
+    N_CPU_STATES
+};
+
+struct LoadGraphLabels
+{
+    GtkLabel *cpu[GLIBTOP_NCPU];
+    GtkLabel *memory;
+    GtkLabel *swap;
+    GtkLabel *net_in;
+    GtkLabel *net_in_total;
+    GtkLabel *net_out;
+    GtkLabel *net_out_total;
+};
+
+struct LoadGraph
+  : private procman::NonCopyable
+{
+    static const unsigned GRAPH_MIN_HEIGHT = 40;
+
+    LoadGraph(guint type);
+    ~LoadGraph();
+
+    unsigned num_bars() const;
+    void clear_background();
+    bool is_logarithmic_scale() const;
+    char* get_caption(guint index);
+    float translate_to_log_partial_if_needed(float position_partial);
+
+    double fontsize;
+    double rmargin;
+    /* left margin */
+    double indent;
+
+    guint n;
+    gint type;
+    guint speed;
+    guint num_points;
+    guint latest;
+    guint draw_width, draw_height;
+    guint render_counter;
+    guint frames_per_unit;
+    guint graph_dely;
+    guint real_draw_height;
+    double graph_delx;
+    guint graph_buffer_offset;
+
+    std::vector<GdkRGBA> colors;
+
+    std::vector<double> data_block;
+    std::vector<double*> data;
+
+    GtkBox *main_widget;
+    GtkDrawingArea *disp;
+
+    cairo_surface_t *background;
+
+    guint timer_index;
+
+    gboolean draw;
+
+    LoadGraphLabels labels;
+    GsmColorButton *mem_color_picker;
+    GsmColorButton *swap_color_picker;
+
+    Glib::RefPtr<Gio::Settings> font_settings;
+
+    /* union { */
+    struct CPU
+    {
+        guint now; /* 0 -> current, 1 -> last
+                      now ^ 1 each time */
+        /* times[now], times[now ^ 1] is last */
+        guint64 times[2][GLIBTOP_NCPU][N_CPU_STATES];
+    } cpu;
+
+    struct NET
+    {
+        guint64 last_in, last_out;
+        guint64 time;
+        guint64 max;
+        std::vector<unsigned> values;
+    } net;
+    /* }; */
+};
+
+/* Force a drawing update */
+void
+load_graph_queue_draw (LoadGraph *g);
+
+/* Start load graph. */
+void
+load_graph_start (LoadGraph *g);
+
+/* Stop load graph. */
+void
+load_graph_stop (LoadGraph *g);
+
+/* Change load graph speed and restart it if it has been previously started */
+void
+load_graph_change_speed (LoadGraph *g,
+                         guint new_speed);
+
+/* Change load graph data points and restart it if it has been previously started */
+void
+load_graph_change_num_points(LoadGraph *g,
+                             guint new_num_points);
+
+/* Clear the history data. */
+void
+load_graph_reset (LoadGraph *g);
+
+LoadGraphLabels*
+load_graph_get_labels (LoadGraph *g) G_GNUC_CONST;
+
+GtkBox*
+load_graph_get_widget (LoadGraph *g) G_GNUC_CONST;
+
+GsmColorButton*
+load_graph_get_mem_color_picker(LoadGraph *g) G_GNUC_CONST;
+
+GsmColorButton*
+load_graph_get_swap_color_picker(LoadGraph *g) G_GNUC_CONST;
+
+#endif /* _GSM_LOAD_GRAPH_H_ */
diff --git a/src/lsof.cpp b/src/lsof.cpp
new file mode 100644
index 0000000..15c3a59
--- /dev/null
+++ b/src/lsof.cpp
@@ -0,0 +1,316 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <gtkmm/messagedialog.h>
+#include <glib/gi18n.h>
+#include <glibtop/procopenfiles.h>
+
+#include <sys/wait.h>
+
+#include <set>
+#include <string>
+#include <sstream>
+#include <iterator>
+
+#include <glibmm/regex.h>
+
+#include "application.h"
+#include "lsof.h"
+#include "util.h"
+
+
+using std::string;
+
+
+namespace
+{
+
+    class Lsof
+    {
+        Glib::RefPtr<Glib::Regex> re;
+
+        bool matches(const string &filename) const
+        {
+            return this->re->match(filename);
+        }
+
+    public:
+
+        Lsof(const string &pattern, bool caseless)
+        {
+            Glib::RegexCompileFlags flags = static_cast<Glib::RegexCompileFlags>(0);
+
+            if (caseless)
+                flags |= Glib::REGEX_CASELESS;
+
+            this->re = Glib::Regex::create(pattern, flags);
+        }
+
+
+        template<typename OutputIterator>
+        void search(const ProcInfo &info, OutputIterator out) const
+        {
+            glibtop_open_files_entry *entries;
+            glibtop_proc_open_files buf;
+
+            entries = glibtop_get_proc_open_files(&buf, info.pid);
+
+            for (unsigned i = 0; i != buf.number; ++i) {
+                if (entries[i].type & GLIBTOP_FILE_TYPE_FILE) {
+                    const string filename(entries[i].info.file.name);
+                    if (this->matches(filename))
+                        *out++ = filename;
+                }
+            }
+
+            g_free(entries);
+        }
+    };
+
+
+
+    // GUI Stuff
+
+
+    enum ProcmanLsof {
+        PROCMAN_LSOF_COL_PIXBUF,
+        PROCMAN_LSOF_COL_PROCESS,
+        PROCMAN_LSOF_COL_PID,
+        PROCMAN_LSOF_COL_FILENAME,
+        PROCMAN_LSOF_NCOLS
+    };
+
+
+    struct GUI : private procman::NonCopyable {
+
+        GtkListStore *model;
+        GtkSearchEntry *entry;
+        GtkWindow *window;
+        GtkLabel *count;
+        GsmApplication *app;
+        bool case_insensitive;
+        bool regex_error_displayed;
+
+
+        GUI()
+            : model(NULL),
+              entry(NULL),
+              window(NULL),
+              count(NULL),
+              app(NULL),
+              case_insensitive(),
+              regex_error_displayed(false)
+        {
+            procman_debug("New Lsof GUI %p", this);
+        }
+
+
+        ~GUI()
+        {
+            procman_debug("Destroying Lsof GUI %p", this);
+        }
+
+
+        void update_count(unsigned count)
+        {
+            gchar *title;
+            if (this->pattern().length() == 0) {
+                title = g_strdup_printf (ngettext("%d open file", "%d open files", count), count);
+            } else {
+                title = g_strdup_printf (ngettext("%d matching open file", "%d matching open files", count), count);
+            }
+            gtk_window_set_title(this->window, title);
+            g_free (title);
+        }
+
+
+        string pattern() const
+        {
+            return gtk_entry_get_text(GTK_ENTRY (this->entry));
+        }
+
+
+        void search()
+        {
+            typedef std::set<string> MatchSet;
+
+            bool regex_error = false;
+
+            gtk_list_store_clear(this->model);
+            try {
+                Lsof lsof(this->pattern(), this->case_insensitive);
+
+                unsigned count = 0;
+
+                for (const auto& v : app->processes) {
+                    const auto& info = v.second;
+                    MatchSet matches;
+                    lsof.search(info, std::inserter(matches, matches.begin()));
+                    count += matches.size();
+
+                    for (const auto& match : matches) {
+                        GtkTreeIter file;
+                        gtk_list_store_append(this->model, &file);
+                        gtk_list_store_set(this->model, &file,
+                                           PROCMAN_LSOF_COL_PIXBUF, info.pixbuf->gobj(),
+                                           PROCMAN_LSOF_COL_PROCESS, info.name.c_str(),
+                                           PROCMAN_LSOF_COL_PID, info.pid,
+                                           PROCMAN_LSOF_COL_FILENAME, match.c_str(),
+                                           -1);
+                    }
+                }
+
+                this->update_count(count);
+            }
+            catch (Glib::RegexError& error) {
+                regex_error = true;
+            }
+
+            if (regex_error && !this->regex_error_displayed) {
+                this->regex_error_displayed = true;
+                gtk_style_context_add_class(gtk_widget_get_style_context(GTK_WIDGET(entry)), GTK_STYLE_CLASS_ERROR);
+            }
+            else if (!regex_error && this->regex_error_displayed) {
+                this->regex_error_displayed = false;
+                gtk_style_context_remove_class(gtk_widget_get_style_context(GTK_WIDGET(entry)), GTK_STYLE_CLASS_ERROR);
+            }
+        }
+
+
+        static void search_changed(GtkSearchEntry *, gpointer data)
+        {
+            static_cast<GUI*>(data)->search();
+        }
+
+
+        static void close_button_clicked(GtkButton *, gpointer data)
+        {
+            GUI *gui = static_cast<GUI*>(data);
+            gtk_widget_destroy(GTK_WIDGET(gui->window));
+            delete gui;
+        }
+
+
+        static void case_button_toggled(GtkToggleButton *button, gpointer data)
+        {
+            bool state = gtk_toggle_button_get_active(button);
+            static_cast<GUI*>(data)->case_insensitive = state;
+        }
+
+
+        static gboolean window_delete_event(GtkWidget *, GdkEvent *, gpointer data)
+        {
+            delete static_cast<GUI*>(data);
+            return FALSE;
+        }
+
+    };
+}
+
+
+
+
+void procman_lsof(GsmApplication *app)
+{
+    GtkListStore *model = \
+        gtk_list_store_new(PROCMAN_LSOF_NCOLS,
+                           GDK_TYPE_PIXBUF, // PROCMAN_LSOF_COL_PIXBUF
+                           G_TYPE_STRING,   // PROCMAN_LSOF_COL_PROCESS
+                           G_TYPE_UINT,     // PROCMAN_LSOF_COL_PID
+                           G_TYPE_STRING    // PROCMAN_LSOF_COL_FILENAME
+            );
+
+    GtkTreeView *tree = GTK_TREE_VIEW (gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)));
+    g_object_unref(model);
+
+    GtkTreeViewColumn *column;
+    GtkCellRenderer *renderer;
+
+    // PIXBUF / PROCESS
+
+    column = gtk_tree_view_column_new();
+
+    renderer = gtk_cell_renderer_pixbuf_new();
+    gtk_tree_view_column_pack_start(column, renderer, FALSE);
+    gtk_tree_view_column_set_attributes(column, renderer,
+                                        "pixbuf", PROCMAN_LSOF_COL_PIXBUF,
+                                        NULL);
+
+    renderer = gtk_cell_renderer_text_new();
+    gtk_tree_view_column_pack_start(column, renderer, FALSE);
+    gtk_tree_view_column_set_attributes(column, renderer,
+                                        "text", PROCMAN_LSOF_COL_PROCESS,
+                                        NULL);
+
+    gtk_tree_view_column_set_title(column, _("Process"));
+    gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_PROCESS);
+    gtk_tree_view_column_set_resizable(column, TRUE);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+    gtk_tree_view_column_set_min_width(column, 10);
+    gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), PROCMAN_LSOF_COL_PROCESS,
+                                         GTK_SORT_ASCENDING);
+
+
+    // PID
+    renderer = gtk_cell_renderer_text_new();
+    column = gtk_tree_view_column_new_with_attributes(_("PID"), renderer,
+                                                      "text", PROCMAN_LSOF_COL_PID,
+                                                      NULL);
+    gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_PID);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+    gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+
+
+    // FILENAME
+    renderer = gtk_cell_renderer_text_new();
+    column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer,
+                                                      "text", PROCMAN_LSOF_COL_FILENAME,
+                                                      NULL);
+    gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_FILENAME);
+    gtk_tree_view_column_set_resizable(column, TRUE);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+    gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+
+
+    GtkWindow *dialog;
+
+    GtkBuilder *builder = gtk_builder_new ();
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/lsof.ui", NULL);
+
+    dialog = GTK_WINDOW (gtk_builder_get_object (builder, "lsof_dialog"));
+
+    gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (app->main_window));
+
+    GtkSearchEntry *entry =  GTK_SEARCH_ENTRY (gtk_builder_get_object (builder, "entry"));
+
+    GtkCheckButton *case_button =  GTK_CHECK_BUTTON (gtk_builder_get_object (builder, "case_button"));
+
+    // Scrolled TreeView
+    GtkScrolledWindow *scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "scrolled"));
+
+    gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET (tree));
+
+    GUI *gui = new GUI; // wil be deleted by the close button or delete-event
+    gui->app = app;
+    gui->model = model;
+    gui->window = dialog;
+    gui->entry = entry;
+    gui->case_insensitive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (case_button));
+
+    g_signal_connect(G_OBJECT(entry), "search-changed",
+                     G_CALLBACK(GUI::search_changed), gui);
+    g_signal_connect(G_OBJECT(case_button), "toggled",
+                     G_CALLBACK(GUI::case_button_toggled), gui);
+    g_signal_connect(G_OBJECT(dialog), "delete-event",
+                     G_CALLBACK(GUI::window_delete_event), gui);
+
+    gtk_builder_connect_signals (builder, NULL);
+
+    gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (GsmApplication::get()->main_window));
+    gtk_widget_show_all(GTK_WIDGET (dialog));
+    gui->search ();
+    
+    g_object_unref (G_OBJECT (builder));
+}
+
diff --git a/src/lsof.h b/src/lsof.h
new file mode 100644
index 0000000..8b8111a
--- /dev/null
+++ b/src/lsof.h
@@ -0,0 +1,10 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_LSOF_H_
+#define _GSM_LSOF_H_
+
+#include <glib.h>
+#include "application.h"
+
+void procman_lsof(GsmApplication *app);
+
+#endif /* _GSM_LSOF_H_ */
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..8bd33e8
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,39 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <config.h>
+
+#include <locale.h>
+#include <glib/gi18n.h>
+
+#include "application.h"
+
+
+int
+main (int argc, char *argv[])
+{
+    bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
+    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+    textdomain (GETTEXT_PACKAGE);
+    setlocale (LC_ALL, "");
+
+    Glib::RefPtr<GsmApplication> application = GsmApplication::get();
+    return application->run (argc, argv);
+}
+
diff --git a/src/memmaps.cpp b/src/memmaps.cpp
new file mode 100644
index 0000000..8827d9f
--- /dev/null
+++ b/src/memmaps.cpp
@@ -0,0 +1,491 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glibtop/procmap.h>
+#include <glibtop/mountlist.h>
+#include <sys/stat.h>
+#include <glib/gi18n.h>
+
+#include <string>
+#include <map>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+
+using std::string;
+
+
+#include "application.h"
+#include "memmaps.h"
+#include "proctable.h"
+#include "settings-keys.h"
+#include "legacy/treeview.h"
+#include "util.h"
+
+
+/* be careful with this enum, you could break the column names */
+enum
+{
+    MMAP_COL_FILENAME,
+    MMAP_COL_VMSTART,
+    MMAP_COL_VMEND,
+    MMAP_COL_VMSZ,
+    MMAP_COL_FLAGS,
+    MMAP_COL_VMOFFSET,
+    MMAP_COL_PRIVATE_CLEAN,
+    MMAP_COL_PRIVATE_DIRTY,
+    MMAP_COL_SHARED_CLEAN,
+    MMAP_COL_SHARED_DIRTY,
+    MMAP_COL_DEVICE,
+    MMAP_COL_INODE,
+    MMAP_COL_MAX
+};
+
+
+namespace
+{
+    class OffsetFormater
+    {
+        string format;
+
+    public:
+
+        void set(const glibtop_map_entry &last_map)
+        {
+            this->format = (last_map.end <= G_MAXUINT32) ? "%08" G_GINT64_MODIFIER "x" : "%016" G_GINT64_MODIFIER "x";
+        }
+
+        string operator()(guint64 v) const
+        {
+            char buffer[17];
+            g_snprintf(buffer, sizeof buffer, this->format.c_str(), v);
+            return buffer;
+        }
+    };
+
+    class InodeDevices
+    {
+        typedef std::map<guint16, string> Map;
+        Map devices;
+
+    public:
+
+        void update()
+        {
+            this->devices.clear();
+
+            glibtop_mountlist list;
+            glibtop_mountentry *entries = glibtop_get_mountlist(&list, 1);
+
+            for (unsigned i = 0; i != list.number; ++i) {
+                struct stat buf;
+
+                if (stat(entries[i].devname, &buf) != -1)
+                    this->devices[buf.st_rdev] = entries[i].devname;
+            }
+
+            g_free(entries);
+        }
+
+        string get(guint64 dev64)
+        {
+            if (dev64 == 0)
+                return "";
+
+            guint16 dev = dev64 & 0xffff;
+
+            if (dev != dev64)
+                g_warning("weird device %" G_GINT64_MODIFIER "x", dev64);
+
+            Map::iterator it(this->devices.find(dev));
+
+            if (it != this->devices.end())
+                return it->second;
+
+            guint8 major, minor;
+            major = dev >> 8;
+            minor = dev;
+
+            std::ostringstream out;
+            out << std::hex
+                << std::setfill('0')
+                << std::setw(2) << unsigned(major)
+                << ':'
+                << std::setw(2) << unsigned(minor);
+
+            this->devices[dev] = out.str();
+            return out.str();
+        }
+    };
+
+
+    class MemMapsData
+    {
+    public:
+        guint timer;
+        GsmTreeView *tree;
+        ProcInfo *info;
+        OffsetFormater format;
+        mutable InodeDevices devices;
+
+        MemMapsData(GsmTreeView *a_tree)
+            : timer(),
+              tree(a_tree),
+              info(NULL),
+              format(),
+              devices()
+        {
+            gsm_tree_view_load_state (this->tree);
+        }
+
+        ~MemMapsData()
+        {
+            gsm_tree_view_save_state (this->tree);
+        }
+    };
+}
+
+
+struct glibtop_map_entry_cmp
+{
+    bool operator()(const glibtop_map_entry &a, const guint64 start) const
+    {
+        return a.start < start;
+    }
+
+    bool operator()(const guint64 &start, const glibtop_map_entry &a) const
+    {
+        return start < a.start;
+    }
+
+};
+
+
+static void
+update_row(GtkTreeModel *model, GtkTreeIter &row, const MemMapsData &mm, const glibtop_map_entry *memmaps)
+{
+    guint64 size;
+    string filename, device;
+    string vmstart, vmend, vmoffset;
+    char flags[5] = "----";
+
+    size = memmaps->end - memmaps->start;
+
+    if(memmaps->perm & GLIBTOP_MAP_PERM_READ)    flags [0] = 'r';
+    if(memmaps->perm & GLIBTOP_MAP_PERM_WRITE)   flags [1] = 'w';
+    if(memmaps->perm & GLIBTOP_MAP_PERM_EXECUTE) flags [2] = 'x';
+    if(memmaps->perm & GLIBTOP_MAP_PERM_SHARED)  flags [3] = 's';
+    if(memmaps->perm & GLIBTOP_MAP_PERM_PRIVATE) flags [3] = 'p';
+
+    if (memmaps->flags & (1 << GLIBTOP_MAP_ENTRY_FILENAME))
+        filename = memmaps->filename;
+
+    vmstart  = mm.format(memmaps->start);
+    vmend    = mm.format(memmaps->end);
+    vmoffset = mm.format(memmaps->offset);
+    device   = mm.devices.get(memmaps->device);
+
+    gtk_list_store_set (GTK_LIST_STORE (model), &row,
+                        MMAP_COL_FILENAME, filename.c_str(),
+                        MMAP_COL_VMSTART, vmstart.c_str(),
+                        MMAP_COL_VMEND, vmend.c_str(),
+                        MMAP_COL_VMSZ, size,
+                        MMAP_COL_FLAGS, flags,
+                        MMAP_COL_VMOFFSET, vmoffset.c_str(),
+                        MMAP_COL_PRIVATE_CLEAN, memmaps->private_clean,
+                        MMAP_COL_PRIVATE_DIRTY, memmaps->private_dirty,
+                        MMAP_COL_SHARED_CLEAN, memmaps->shared_clean,
+                        MMAP_COL_SHARED_DIRTY, memmaps->shared_dirty,
+                        MMAP_COL_DEVICE, device.c_str(),
+                        MMAP_COL_INODE, memmaps->inode,
+                        -1);
+}
+
+
+
+
+static void
+update_memmaps_dialog (MemMapsData *mmdata)
+{
+    GtkTreeModel *model;
+    glibtop_map_entry *memmaps;
+    glibtop_proc_map procmap;
+
+    memmaps = glibtop_get_proc_map (&procmap, mmdata->info->pid);
+    /* process has disappeared */
+    if(!memmaps or procmap.number == 0) return;
+
+    mmdata->format.set(memmaps[procmap.number - 1]);
+
+    model = gtk_tree_view_get_model (GTK_TREE_VIEW (mmdata->tree));
+
+    GtkTreeIter iter;
+
+    typedef std::map<guint64, GtkTreeIter> IterCache;
+    IterCache iter_cache;
+
+    /*
+      removes the old maps and
+      also fills a cache of start -> iter in order to speed
+      up add
+    */
+
+    if (gtk_tree_model_get_iter_first(model, &iter)) {
+        while (true) {
+            char *vmstart = 0;
+            guint64 start;
+            gtk_tree_model_get(model, &iter,
+                               MMAP_COL_VMSTART, &vmstart,
+                               -1);
+
+            try {
+                std::istringstream(vmstart) >> std::hex >> start;
+            } catch (std::logic_error &e) {
+                g_warning("Could not parse %s", vmstart);
+                start = 0;
+            }
+
+            g_free(vmstart);
+
+            bool found = std::binary_search(memmaps, memmaps + procmap.number,
+                                            start, glibtop_map_entry_cmp());
+
+            if (found) {
+                iter_cache[start] = iter;
+                if (!gtk_tree_model_iter_next(model, &iter))
+                    break;
+            } else {
+                if (!gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
+                    break;
+            }
+        }
+    }
+
+    mmdata->devices.update();
+
+    /*
+      add the new maps
+    */
+
+    for (guint i = 0; i != procmap.number; i++) {
+        GtkTreeIter iter;
+        IterCache::iterator it(iter_cache.find(memmaps[i].start));
+
+        if (it != iter_cache.end())
+            iter = it->second;
+        else
+            gtk_list_store_prepend(GTK_LIST_STORE(model), &iter);
+
+        update_row(model, iter, *mmdata, &memmaps[i]);
+    }
+
+    g_free (memmaps);
+}
+
+
+
+static void
+dialog_response (GtkDialog * dialog, gint response_id, gpointer data)
+{
+    MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
+
+    g_source_remove (mmdata->timer);
+
+    delete mmdata;
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
+
+static MemMapsData*
+create_memmapsdata (GsmApplication *app)
+{
+    GsmTreeView *tree;
+    GtkListStore *model;
+    guint i;
+
+    const gchar * const titles[] = {
+        N_("Filename"),
+        // xgettext: virtual memory start
+        N_("VM Start"),
+        // xgettext: virtual memory end
+        N_("VM End"),
+        // xgettext: virtual memory syze
+        N_("VM Size"),
+        N_("Flags"),
+        // xgettext: virtual memory offset
+        N_("VM Offset"),
+        // xgettext: memory that has not been modified since
+        // it has been allocated
+        N_("Private clean"),
+        // xgettext: memory that has been modified since it
+        // has been allocated
+        N_("Private dirty"),
+        // xgettext: shared memory that has not been modified
+        // since it has been allocated
+        N_("Shared clean"),
+        // xgettext: shared memory that has been modified
+        // since it has been allocated
+        N_("Shared dirty"),
+        N_("Device"),
+        N_("Inode")
+    };
+
+    model = gtk_list_store_new (MMAP_COL_MAX,
+                                G_TYPE_STRING, /* MMAP_COL_FILENAME  */
+                                G_TYPE_STRING, /* MMAP_COL_VMSTART   */
+                                G_TYPE_STRING, /* MMAP_COL_VMEND     */
+                                G_TYPE_UINT64, /* MMAP_COL_VMSZ      */
+                                G_TYPE_STRING, /* MMAP_COL_FLAGS     */
+                                G_TYPE_STRING, /* MMAP_COL_VMOFFSET  */
+                                G_TYPE_UINT64, /* MMAP_COL_PRIVATE_CLEAN */
+                                G_TYPE_UINT64, /* MMAP_COL_PRIVATE_DIRTY */
+                                G_TYPE_UINT64, /* MMAP_COL_SHARED_CLEAN */
+                                G_TYPE_UINT64, /* MMAP_COL_SHARED_DIRTY */
+                                G_TYPE_STRING, /* MMAP_COL_DEVICE    */
+                                G_TYPE_UINT64 /* MMAP_COL_INODE      */
+        );
+
+    auto settings = g_settings_get_child (app->settings->gobj (), GSM_SETTINGS_CHILD_MEMMAP);
+
+    tree = gsm_tree_view_new (settings, FALSE);
+    gtk_tree_view_set_model (GTK_TREE_VIEW (tree), GTK_TREE_MODEL (model));
+    g_object_unref (G_OBJECT (model));
+
+    auto font = get_monospace_system_font_name ();
+
+    for (i = 0; i < MMAP_COL_MAX; i++) {
+        GtkCellRenderer *cell;
+        GtkTreeViewColumn *col;
+        PangoAttrList *attrs;
+
+        cell = gtk_cell_renderer_text_new();
+        col = gtk_tree_view_column_new();
+        gtk_tree_view_column_pack_start(col, cell, TRUE);
+        gtk_tree_view_column_set_title(col, _(titles[i]));
+        gtk_tree_view_column_set_resizable(col, TRUE);
+        gtk_tree_view_column_set_sort_column_id(col, i);
+        gtk_tree_view_column_set_reorderable(col, TRUE);
+        gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col);
+
+        attrs = make_tnum_attr_list ();
+        g_object_set (cell, "attributes", attrs, NULL);
+        g_clear_pointer (&attrs, pango_attr_list_unref);
+
+        switch (i) {
+            case MMAP_COL_PRIVATE_CLEAN:
+            case MMAP_COL_PRIVATE_DIRTY:
+            case MMAP_COL_SHARED_CLEAN:
+            case MMAP_COL_SHARED_DIRTY:
+            case MMAP_COL_VMSZ:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::size_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+
+                g_object_set(cell, "xalign", 1.0f, NULL);
+                break;
+
+            default:
+                gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);
+                break;
+        }
+
+        switch (i) {
+            case MMAP_COL_VMSTART:
+            case MMAP_COL_VMEND:
+            case MMAP_COL_FLAGS:
+            case MMAP_COL_VMOFFSET:
+                g_object_set (cell, "font", font.c_str (), NULL);
+                break;
+        }
+    }
+
+    return new MemMapsData(tree);
+}
+
+
+static gboolean
+memmaps_timer (gpointer data)
+{
+    MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
+    GtkTreeModel *model;
+
+    model = gtk_tree_view_get_model (GTK_TREE_VIEW (mmdata->tree));
+    g_assert(model);
+
+    update_memmaps_dialog (mmdata);
+
+    return TRUE;
+}
+
+
+static void
+create_single_memmaps_dialog (GtkTreeModel *model, GtkTreePath *path,
+                              GtkTreeIter *iter, gpointer data)
+{
+    GsmApplication *app = static_cast<GsmApplication *>(data);
+    MemMapsData *mmdata;
+    GtkDialog  *memmapsdialog;
+    GtkBox *dialog_box;
+    GtkLabel *label;
+    GtkScrolledWindow *scrolled;
+    ProcInfo *info;
+
+    gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+
+    if (!info)
+        return;
+
+    mmdata = create_memmapsdata (app);
+    mmdata->info = info;
+    
+    memmapsdialog = GTK_DIALOG (g_object_new (GTK_TYPE_DIALOG, 
+                                              "title", _("Memory Maps"), 
+                                              "use-header-bar", TRUE, 
+                                              "destroy-with-parent", TRUE, NULL));
+
+    gtk_window_set_resizable(GTK_WINDOW(memmapsdialog), TRUE);
+    gtk_window_set_default_size(GTK_WINDOW(memmapsdialog), 620, 400);
+    gtk_container_set_border_width(GTK_CONTAINER(memmapsdialog), 5);
+
+    dialog_box = GTK_BOX (gtk_dialog_get_content_area (memmapsdialog));
+    gtk_container_set_border_width (GTK_CONTAINER (dialog_box), 5);
+
+    label = procman_make_label_for_mmaps_or_ofiles (
+        _("_Memory maps for process “%s” (PID %u):"),
+        info->name.c_str(),
+        info->pid);
+
+    gtk_box_pack_start (dialog_box, GTK_WIDGET (label), FALSE, TRUE, 0);
+
+
+    scrolled = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+                                    GTK_POLICY_AUTOMATIC,
+                                    GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+                                         GTK_SHADOW_IN);
+
+    gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (mmdata->tree));
+    gtk_label_set_mnemonic_widget (label, GTK_WIDGET (mmdata->tree));
+
+    gtk_box_pack_start (dialog_box, GTK_WIDGET (scrolled), TRUE, TRUE, 0);
+
+    g_signal_connect(G_OBJECT(memmapsdialog), "response",
+                     G_CALLBACK(dialog_response), mmdata);
+
+    gtk_window_set_transient_for (GTK_WINDOW (memmapsdialog), GTK_WINDOW (GsmApplication::get()->main_window));
+    gtk_widget_show_all (GTK_WIDGET (memmapsdialog));
+    mmdata->timer = g_timeout_add_seconds (5, memmaps_timer, mmdata);
+
+    update_memmaps_dialog (mmdata);
+}
+
+
+void
+create_memmaps_dialog (GsmApplication *app)
+{
+    /* TODO: do we really want to open multiple dialogs ? */
+    gtk_tree_selection_selected_foreach (app->selection, create_single_memmaps_dialog,
+                                         app);
+}
diff --git a/src/memmaps.h b/src/memmaps.h
new file mode 100644
index 0000000..6a9bd72
--- /dev/null
+++ b/src/memmaps.h
@@ -0,0 +1,10 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_MEMMAPS_H_
+#define _GSM_MEMMAPS_H_
+
+#include <glib.h>
+#include "application.h"
+
+void            create_memmaps_dialog (GsmApplication *app);
+
+#endif /* _GSM_MEMMAPS_H_ */
diff --git a/src/meson.build b/src/meson.build
new file mode 100644
index 0000000..6b53736
--- /dev/null
+++ b/src/meson.build
@@ -0,0 +1,110 @@
+subdir('legacy')
+
+system_monitor_sources = [
+  'application.cpp',
+  'argv.cpp',
+  'cgroups.cpp',
+  'disks.cpp',
+  'gsm_gksu.cpp',
+  'gsm_gnomesu.cpp',
+  'gsm_pkexec.cpp',
+  'interface.cpp',
+  'load-graph.cpp',
+  'lsof.cpp',
+  'main.cpp',
+  'setaffinity.cpp',
+  'memmaps.cpp',
+  'openfiles.cpp',
+  'prefsdialog.cpp',
+  'prettytable.cpp',
+  'procactions.cpp',
+  'procdialogs.cpp',
+  'procproperties.cpp',
+  'proctable.cpp',
+  'selinux.cpp',
+  'smooth_refresh.cpp',
+  'systemd.cpp',
+  'util.cpp',
+]
+
+system_monitor_headers = [
+  'prettytable.h',
+  'procdialogs.h',
+  'cgroups.h',
+  'application.h',
+  'smooth_refresh.h',
+  'gsm_gnomesu.h',
+  'openfiles.h',
+  'procproperties.h',
+  'lsof.h',
+  'proctable.h',
+  'settings-keys.h',
+  'setaffinity.h',
+  'memmaps.h',
+  'procactions.h',
+  'systemd.h',
+  'argv.h',
+  'prefsdialog.h',
+  'selinux.h',
+  'util.h',
+  'gsm_gksu.h',
+  'interface.h',
+  'load-graph.h',
+  'disks.h',
+  'gsm_pkexec.h',
+  'defaulttable.h',
+  'legacy/treeview.h',
+  'legacy/e_date.h',
+  'legacy/gsm_color_button.h',
+]
+
+gsm_resource_dir = join_paths(get_option('datadir'), meson.project_name())
+gsm_resource = gnome.compile_resources(
+  'gsm',
+  'gsm.gresource.xml',
+  gresource_bundle: true,
+  source_dir: meson.source_root(),
+  install: true,
+  install_dir: gsm_resource_dir,
+)
+
+gsm_schemas = configure_file(
+  input : 'org.gnome.gnome-system-monitor.gschema.xml.in',
+  output: 'org.gnome.gnome-system-monitor.gschema.xml',
+  configuration: dataconf,
+  install: true,
+  install_dir: join_paths(get_option('datadir'), 'glib-2.0', 'schemas'),
+)
+
+gsm_gsettings = gnome.mkenums('org.gnome.gnome-system-monitor.enums.xml',
+  sources: system_monitor_headers,
+  comments: '<!-- @comment@ -->',
+  fhead:    '<schemalist>',
+  vhead:    '  <@type@ id=\'org.gnome.gnome-system-monitor.@EnumName@\'>',
+  vprod:    '    <value nick=\'@valuenick@\' value=\'@valuenum@\'/>',
+  vtail:    '  </@type@>',
+  ftail:    '</schemalist>',
+  install_header: true,
+  install_dir: join_paths(get_option('datadir'), 'glib-2.0', 'schemas'),
+)
+
+
+executable(meson.project_name(),
+  system_monitor_sources,
+  include_directories: rootInclude,
+  dependencies: [
+    gmodule,
+    gtkmm,
+    atkmm,
+    libgtop,
+    libhandy,
+    libsystemd,
+    libwnck,
+  ],
+  link_with: libgsm_legacy,
+  cpp_args: [
+    '-DGSM_RESOURCE_FILE="@0@"'.format(join_paths(
+      get_option('prefix'), gsm_resource_dir, 'gsm.gresource')),
+  ],
+  install: true,
+)
diff --git a/src/openfiles.cpp b/src/openfiles.cpp
new file mode 100644
index 0000000..edf359b
--- /dev/null
+++ b/src/openfiles.cpp
@@ -0,0 +1,371 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <glibtop/procopenfiles.h>
+#include <sys/stat.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "application.h"
+#include "openfiles.h"
+#include "proctable.h"
+#include "util.h"
+#include "settings-keys.h"
+#include "legacy/treeview.h"
+
+#ifndef NI_IDN
+const int NI_IDN = 0;
+#endif
+
+enum
+{
+    COL_FD,
+    COL_TYPE,
+    COL_OBJECT,
+    COL_OPENFILE_STRUCT,
+    NUM_OPENFILES_COL
+};
+
+
+static const char*
+get_type_name(enum glibtop_file_type t)
+{
+    switch(t)
+    {
+        case GLIBTOP_FILE_TYPE_FILE:
+            return _("file");
+        case GLIBTOP_FILE_TYPE_PIPE:
+            return _("pipe");
+        case GLIBTOP_FILE_TYPE_INET6SOCKET:
+            return _("IPv6 network connection");
+        case GLIBTOP_FILE_TYPE_INETSOCKET:
+            return _("IPv4 network connection");
+        case GLIBTOP_FILE_TYPE_LOCALSOCKET:
+            return _("local socket");
+        default:
+            return _("unknown type");
+    }
+}
+
+
+
+static char *
+friendlier_hostname(const char *addr_str, int port)
+{
+    struct addrinfo hints = { };
+    struct addrinfo *res = NULL;
+    char hostname[NI_MAXHOST];
+    char service[NI_MAXSERV];
+    char port_str[6];
+
+    if (!addr_str[0]) return g_strdup("");
+
+    snprintf(port_str, sizeof port_str, "%d", port);
+
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    if (getaddrinfo(addr_str, port_str, &hints, &res))
+        goto failsafe;
+
+    if (getnameinfo(res->ai_addr, res->ai_addrlen, hostname,
+                    sizeof hostname, service, sizeof service, NI_IDN))
+        goto failsafe;
+
+    if (res) freeaddrinfo(res);
+    return g_strdup_printf("%s, TCP port %d (%s)", hostname, port, service);
+
+  failsafe:
+    if (res) freeaddrinfo(res);
+    return g_strdup_printf("%s, TCP port %d", addr_str, port);
+}
+
+
+
+static void
+add_new_files (gpointer key, gpointer value, gpointer data)
+{
+    glibtop_open_files_entry *openfiles = static_cast<glibtop_open_files_entry*>(value);
+
+    GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
+    GtkTreeIter row;
+
+    char *object;
+
+    switch(openfiles->type)
+    {
+        case GLIBTOP_FILE_TYPE_FILE:
+            object = g_strdup(openfiles->info.file.name);
+            break;
+
+        case GLIBTOP_FILE_TYPE_INET6SOCKET:
+        case GLIBTOP_FILE_TYPE_INETSOCKET:
+            object = friendlier_hostname(openfiles->info.sock.dest_host,
+                                         openfiles->info.sock.dest_port);
+            break;
+
+        case GLIBTOP_FILE_TYPE_LOCALSOCKET:
+            object = g_strdup(openfiles->info.localsock.name);
+            break;
+
+        default:
+            object = g_strdup("");
+    }
+
+    gtk_list_store_insert (GTK_LIST_STORE (model), &row, 0);
+    gtk_list_store_set (GTK_LIST_STORE (model), &row,
+                        COL_FD, openfiles->fd,
+                        COL_TYPE, get_type_name(static_cast<glibtop_file_type>(openfiles->type)),
+                        COL_OBJECT, object,
+                        COL_OPENFILE_STRUCT, g_memdup(openfiles, sizeof(*openfiles)),
+                        -1);
+
+    g_free(object);
+}
+
+static GList *old_maps = NULL;
+
+static gboolean
+classify_openfiles (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
+{
+    GHashTable *new_maps = static_cast<GHashTable*>(data);
+    GtkTreeIter *old_iter;
+    glibtop_open_files_entry *openfiles;
+    gchar *old_name;
+
+    gtk_tree_model_get (model, iter, 1, &old_name, -1);
+
+    openfiles = static_cast<glibtop_open_files_entry*>(g_hash_table_lookup (new_maps, old_name));
+    if (openfiles) {
+        g_hash_table_remove (new_maps, old_name);
+        g_free (old_name);
+        return FALSE;
+
+    }
+
+    old_iter = gtk_tree_iter_copy (iter);
+    old_maps = g_list_append (old_maps, old_iter);
+    g_free (old_name);
+    return FALSE;
+
+}
+
+
+static gboolean
+compare_open_files(gconstpointer a, gconstpointer b)
+{
+    const glibtop_open_files_entry *o1 = static_cast<const glibtop_open_files_entry *>(a);
+    const glibtop_open_files_entry *o2 = static_cast<const glibtop_open_files_entry *>(b);
+
+    /* Falta manejar los diferentes tipos! */
+    return (o1->fd == o2->fd) && (o1->type == o2->type); /* XXX! */
+}
+
+
+static void
+update_openfiles_dialog (GsmTreeView *tree)
+{
+    ProcInfo *info;
+    GtkTreeModel *model;
+    glibtop_open_files_entry *openfiles;
+    glibtop_proc_open_files procmap;
+    GHashTable *new_maps;
+    guint i;
+
+    pid_t pid = GPOINTER_TO_UINT(static_cast<pid_t*>(g_object_get_data (G_OBJECT (tree), "selected_info")));
+    info = GsmApplication::get()->processes.find(pid);
+
+
+    if (!info)
+        return;
+
+    model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
+
+    openfiles = glibtop_get_proc_open_files (&procmap, info->pid);
+
+    if (!openfiles)
+        return;
+
+    new_maps = static_cast<GHashTable *>(g_hash_table_new_full (g_str_hash, compare_open_files,
+                                                                NULL, NULL));
+    for (i=0; i < procmap.number; i++)
+        g_hash_table_insert (new_maps, openfiles + i, openfiles + i);
+
+    gtk_tree_model_foreach (model, classify_openfiles, new_maps);
+
+    g_hash_table_foreach (new_maps, add_new_files, model);
+
+    while (old_maps) {
+        GtkTreeIter *iter = static_cast<GtkTreeIter*>(old_maps->data);
+        glibtop_open_files_entry *openfiles = NULL;
+
+        gtk_tree_model_get (model, iter,
+                            COL_OPENFILE_STRUCT, &openfiles,
+                            -1);
+
+        gtk_list_store_remove (GTK_LIST_STORE (model), iter);
+        gtk_tree_iter_free (iter);
+        g_free (openfiles);
+
+        old_maps = g_list_next (old_maps);
+
+    }
+
+    g_hash_table_destroy (new_maps);
+    g_free (openfiles);
+}
+
+static void
+close_openfiles_dialog (GtkDialog *dialog, gint id, gpointer data)
+{
+    GsmTreeView *tree = static_cast<GsmTreeView*>(data);
+    guint timer;
+
+    gsm_tree_view_save_state (tree);
+
+    timer = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tree), "timer"));
+    g_source_remove (timer);
+
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+
+    return ;
+}
+
+
+static GsmTreeView *
+create_openfiles_tree (GsmApplication *app)
+{
+    GsmTreeView *tree;
+    GtkListStore *model;
+    GtkTreeViewColumn *column;
+    GtkCellRenderer *cell;
+    gint i;
+
+    const gchar * const titles[] = {
+        /* Translators: "FD" here means "File Descriptor". Please use
+           a very short translation if possible, and at most
+           2-3 characters for it to be able to fit in the UI. */
+        N_("FD"),
+        N_("Type"),
+        N_("Object")
+    };
+
+    model = gtk_list_store_new (NUM_OPENFILES_COL,
+                                G_TYPE_INT,         /* FD */
+                                G_TYPE_STRING,      /* Type */
+                                G_TYPE_STRING,      /* Object */
+                                G_TYPE_POINTER      /* open_files_entry */
+        );
+
+    auto settings = g_settings_get_child (app->settings->gobj (), GSM_SETTINGS_CHILD_OPEN_FILES);
+
+    tree = gsm_tree_view_new (settings, FALSE);
+    gtk_tree_view_set_model (GTK_TREE_VIEW (tree), GTK_TREE_MODEL (model));
+    g_object_unref (G_OBJECT (model));
+
+    for (i = 0; i < NUM_OPENFILES_COL-1; i++) {
+        cell = gtk_cell_renderer_text_new ();
+
+        switch (i) {
+            case COL_FD:
+                g_object_set(cell, "xalign", 1.0f, NULL);
+                break;
+        }
+
+        column = gtk_tree_view_column_new_with_attributes (_(titles[i]),
+                                                           cell,
+                                                           "text", i,
+                                                           NULL);
+        gtk_tree_view_column_set_sort_column_id (column, i);
+        gtk_tree_view_column_set_resizable (column, TRUE);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
+    }
+
+    gsm_tree_view_load_state (GSM_TREE_VIEW (tree));
+
+    return tree;
+
+}
+
+
+static gboolean
+openfiles_timer (gpointer data)
+{
+    GsmTreeView* tree = static_cast<GsmTreeView*>(data);
+    GtkTreeModel *model;
+
+    model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
+    g_assert(model);
+
+    update_openfiles_dialog (tree);
+
+    return TRUE;
+}
+
+
+static void
+create_single_openfiles_dialog (GtkTreeModel *model, GtkTreePath *path,
+                                GtkTreeIter *iter, gpointer data)
+{
+    GsmApplication *app = static_cast<GsmApplication *>(data);
+    GtkDialog *openfilesdialog;
+    GtkGrid *cmd_grid;
+    GtkLabel *label;
+    GtkScrolledWindow *scrolled;
+    GsmTreeView *tree;
+    ProcInfo *info;
+    guint timer;
+
+    gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+
+    if (!info)
+        return;
+
+    GtkBuilder *builder = gtk_builder_new();
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/openfiles.ui", NULL);
+
+    openfilesdialog = GTK_DIALOG (gtk_builder_get_object (builder, "openfiles_dialog"));
+
+    cmd_grid = GTK_GRID (gtk_builder_get_object (builder, "cmd_grid"));
+
+
+    label = procman_make_label_for_mmaps_or_ofiles (
+        _("_Files opened by process “%s” (PID %u):"),
+        info->name.c_str(),
+        info->pid);
+
+    gtk_container_add (GTK_CONTAINER (cmd_grid), GTK_WIDGET (label));
+
+    scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "scrolled"));
+
+    tree = create_openfiles_tree (app);
+    gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (tree));
+    g_object_set_data (G_OBJECT (tree), "selected_info", GUINT_TO_POINTER (info->pid));
+
+    g_signal_connect (G_OBJECT (openfilesdialog), "response",
+                      G_CALLBACK (close_openfiles_dialog), tree);
+
+    gtk_builder_connect_signals (builder, NULL);
+
+    gtk_window_set_transient_for (GTK_WINDOW (openfilesdialog), GTK_WINDOW (GsmApplication::get()->main_window));
+    gtk_widget_show_all (GTK_WIDGET (openfilesdialog));
+
+    timer = g_timeout_add_seconds (5, openfiles_timer, tree);
+    g_object_set_data (G_OBJECT (tree), "timer", GUINT_TO_POINTER (timer));
+
+    update_openfiles_dialog (tree);
+
+    g_object_unref (G_OBJECT (builder));
+}
+
+
+void
+create_openfiles_dialog (GsmApplication *app)
+{
+    gtk_tree_selection_selected_foreach (app->selection, create_single_openfiles_dialog,
+                                         app);
+}
diff --git a/src/openfiles.h b/src/openfiles.h
new file mode 100644
index 0000000..9595e8d
--- /dev/null
+++ b/src/openfiles.h
@@ -0,0 +1,11 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_OPENFILES_H_
+#define _GSM_OPENFILES_H_
+
+#include <glib.h>
+
+#include "application.h"
+
+void            create_openfiles_dialog (GsmApplication *app);
+
+#endif /* _GSM_OPENFILES_H_ */
diff --git a/src/org.gnome.gnome-system-monitor.gschema.xml.in b/src/org.gnome.gnome-system-monitor.gschema.xml.in
new file mode 100644
index 0000000..ee620ab
--- /dev/null
+++ b/src/org.gnome.gnome-system-monitor.gschema.xml.in
@@ -0,0 +1,776 @@
+<schemalist gettext-domain="@GETTEXT_PACKAGE@">
+  <schema id="org.gnome.gnome-system-monitor" path="/org/gnome/gnome-system-monitor/">
+    <key name="window-state" type="(iiii)">
+      <default>(700, 500, 50, 50)</default>
+      <summary>Main window size and position in the form (width, height, xpos, ypos)</summary>
+    </key>
+
+    <key name="maximized" type="b">
+      <default>false
+      </default>
+      <summary>Main Window should open maximized
+      </summary>
+    </key>
+
+    <key name="show-dependencies" type="b">
+      <default>false
+      </default>
+      <summary>Show process dependencies in tree form
+      </summary>
+    </key>
+
+    <key name="solaris-mode" type="b">
+      <default>true
+      </default>
+      <summary>Solaris mode for CPU percentage
+      </summary>
+      <description>If TRUE, system-monitor operates in “Solaris mode” where a task’s CPU usage is divided by the total number of CPUs. Otherwise, it operates in “Irix mode”.
+      </description>
+    </key>
+
+    <key name="process-memory-in-iec" type="b">
+      <default>false
+      </default>
+      <summary>Show memory in IEC
+      </summary>
+    </key>
+
+    <key name="smooth-refresh" type="b">
+      <default>true
+      </default>
+      <summary>Enable/Disable smooth refresh
+      </summary>
+    </key>
+
+    <key name="kill-dialog" type="b">
+      <default>true
+      </default>
+      <summary>Show warning dialog when killing processes
+      </summary>
+    </key>
+
+    <key name="update-interval" type="i">
+      <range min="1000" max="100000"/>
+      <default>3000</default>
+      <summary>Time in milliseconds between updates of the process view</summary>
+    </key>
+
+    <key name="graph-update-interval" type="i">
+      <range min="50" max="10000"/>
+      <default>100</default>
+      <summary>Time in milliseconds between updates of the graphs</summary>
+    </key>
+
+    <key name="show-all-fs" type="b">
+      <default>false
+      </default>
+      <summary>Whether information about all file systems should be displayed
+      </summary>
+      <description>Whether to display information about all file systems (including types like “autofs” and “procfs”). Useful for getting a list of all currently mounted file systems.
+      </description>
+    </key>
+
+    <key name="disks-interval" type="i">
+      <range min="1000" max="100000"/>
+      <default>5000</default>
+      <summary>Time in milliseconds between updates of the devices list</summary>
+    </key>
+
+    <key name="graph-data-points" type="i">
+      <range min="30" max="600"/>
+      <default>60</default>
+      <summary>Time amount of data points in the resource graphs</summary>
+    </key>
+
+    <key name="show-whose-processes" type="s">
+      <default>'user'</default>
+      <choices>
+        <choice value="all"/>
+        <choice value="user"/>
+        <choice value="active"/>
+      </choices>
+      <summary>Determines which processes to show.</summary>
+    </key>
+
+    <key name="current-tab" type="s">
+      <choices>
+        <choice value="processes"/>
+        <choice value="resources"/>
+        <choice value="disks"/>
+      </choices>
+      <default>'processes'</default>
+      <summary>Saves the currently viewed tab
+      </summary>
+    </key>
+
+    <key name="cpu-colors" type="a(us)">
+      <default>[
+                (0, '#e6194B'),
+                (1, '#f58231'),
+                (2, '#ffe119'),
+                (3, '#bfef45'),
+                (4, '#3cb44b'),
+                (5, '#42d4f4'),
+                (6, '#4363d8'),
+                (7, '#911eb4'),
+                (8, '#f032e6'),
+                (9, '#fabebe'),
+                (10,'#ffd8b1'),
+                (11,'#fffac8'),
+                (12,'#aaffc3'),
+                (13,'#469990'),
+                (14,'#000075'),
+                (15,'#e6beff')
+                ]</default>
+      <summary>CPU colors
+      </summary>
+      <description>Each entry is in the format (CPU#, Hexadecimal color value)
+      </description>
+    </key>
+
+    <key name="mem-color" type="s">
+      <default>'#AB1852'
+      </default>
+      <summary>Default graph memory color
+      </summary>
+    </key>
+
+    <key name="swap-color" type="s">
+      <default>'#49A835'
+      </default>
+      <summary>Default graph swap color
+      </summary>
+    </key>
+
+    <key name="net-in-color" type="s">
+      <default>'#2D7DB3'
+      </default>
+      <summary>Default graph incoming network traffic color
+      </summary>
+    </key>
+
+    <key name="net-out-color" type="s">
+      <default>'#EE1D00'
+      </default>
+      <summary>Default graph outgoing network traffic color
+      </summary>
+    </key>
+
+    <key name="network-in-bits" type="b">
+      <default>false
+      </default>
+      <summary>Show network traffic in bits
+      </summary>
+    </key>
+
+    <key name="network-total-unit" type="b">
+      <default>false
+      </default>
+      <summary>Set network totals unit separately
+      </summary>
+    </key>
+
+    <key name="network-total-in-bits" type="b">
+      <default>false
+      </default>
+      <summary>Show network totals in bits
+      </summary>
+    </key>
+
+    <key name="logarithmic-scale" type="b">
+      <default>false
+      </default>
+      <summary>Show memory in logarithmic scale
+      </summary>
+      <description>If TRUE, system-monitor shows the CPU chart as a stacked area chart instead of a line chart.
+      </description>
+    </key>
+
+    <key name="cpu-stacked-area-chart" type="b">
+      <default>false
+      </default>
+      <summary>Show CPU chart as stacked area chart
+      </summary>
+      <description>If TRUE, system-monitor shows the CPU chart as a stacked area chart instead of a line chart.
+      </description>
+    </key>
+
+    <key name="cpu-smooth-graph" type="b">
+      <default>true
+      </default>
+      <summary>Show CPU, Memory, and Network charts as smooth graphs using Bezier curves
+      </summary>
+      <description>If TRUE, system-monitor shows the CPU, Memory, and Network charts as smoothed graphs, otherwise as line charts.
+      </description>
+    </key>
+
+    <key name="resources-memory-in-iec" type="b">
+      <default>false
+      </default>
+      <summary>Show memory and swap in IEC
+      </summary>
+    </key>
+
+    <child name="proctree" schema="org.gnome.gnome-system-monitor.proctree" />
+    <child name="disktreenew" schema="org.gnome.gnome-system-monitor.disktreenew" />
+    <child name="memmapstree" schema="org.gnome.gnome-system-monitor.memmapstree" />
+    <child name="openfilestree" schema="org.gnome.gnome-system-monitor.openfilestree" />
+  </schema>
+
+  <schema id="org.gnome.gnome-system-monitor.proctree" path="/org/gnome/gnome-system-monitor/proctree/">
+    <key name="sort-col" type="i">
+      <default>0
+      </default>
+      <summary>Process view sort column
+      </summary>
+    </key>
+
+    <key name="columns-order" type="ai">
+      <default>[ 0 ]
+      </default>
+      <summary>Process view columns order
+      </summary>
+    </key>
+
+    <key name="sort-order" type="i">
+      <default>0
+      </default>
+      <summary>Process view sort order
+      </summary>
+    </key>
+
+    <key name="col-0-width" type="i">
+      <default>225
+      </default>
+      <summary>Width of process “Name” column
+      </summary>
+    </key>
+
+    <key name="col-0-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Name” column on startup
+      </summary>
+    </key>
+
+    <key name="col-1-width" type="i">
+      <default>98
+      </default>
+      <summary>Width of process “User” column
+      </summary>
+    </key>
+
+    <key name="col-1-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “User” column on startup
+      </summary>
+    </key>
+
+    <key name="col-2-width" type="i">
+      <default>37
+      </default>
+      <summary>Width of process “Status” column
+      </summary>
+    </key>
+
+    <key name="col-2-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Status” column on startup
+      </summary>
+    </key>
+
+    <key name="col-3-width" type="i">
+      <default>90
+      </default>
+      <summary>Width of process “Virtual Memory” column
+      </summary>
+    </key>
+
+    <key name="col-3-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Virtual Memory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-4-width" type="i">
+      <default>90
+      </default>
+      <summary>Width of process “Resident Memory” column
+      </summary>
+    </key>
+
+    <key name="col-4-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Resident Memory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-5-width" type="i">
+      <default>90
+      </default>
+      <summary>Width of process “Writable Memory” column
+      </summary>
+    </key>
+
+    <key name="col-5-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Writable Memory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-6-width" type="i">
+      <default>90
+      </default>
+      <summary>Width of process “Shared Memory” column
+      </summary>
+    </key>
+
+    <key name="col-6-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Shared Memory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-7-width" type="i">
+      <default>90
+      </default>
+      <summary>Width of process “X Server Memory” column
+      </summary>
+    </key>
+
+    <key name="col-7-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “X Server Memory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-8-width" type="i">
+      <default>71
+      </default>
+      <summary>Width of process “CPU %” column
+      </summary>
+    </key>
+
+    <key name="col-8-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “CPU %” column on startup
+      </summary>
+    </key>
+
+    <key name="col-9-width" type="i">
+      <default>80
+      </default>
+      <summary>Width of process “CPU Time” column
+      </summary>
+    </key>
+
+    <key name="col-9-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “CPU Time” column on startup
+      </summary>
+    </key>
+
+    <key name="col-10-width" type="i">
+      <default>70
+      </default>
+      <summary>Width of process “Started” column
+      </summary>
+    </key>
+
+    <key name="col-10-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Started” column on startup
+      </summary>
+    </key>
+
+    <key name="col-11-width" type="i">
+      <default>48
+      </default>
+      <summary>Width of process “Nice” column
+      </summary>
+    </key>
+
+    <key name="col-11-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Nice” column on startup
+      </summary>
+    </key>
+
+    <key name="col-12-width" type="i">
+      <default>60
+      </default>
+      <summary>Width of process “ID” column
+      </summary>
+    </key>
+
+    <key name="col-12-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “ID” column on startup
+      </summary>
+    </key>
+
+    <key name="col-13-width" type="i">
+      <default>80
+      </default>
+      <summary>Width of process “SELinux Security Context” column
+      </summary>
+    </key>
+    <key name="col-13-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “SELinux Security Context” column on startup
+      </summary>
+    </key>
+
+    <key name="col-14-width" type="i">
+      <default>120
+      </default>
+      <summary>Width of process “Command Line” column
+      </summary>
+    </key>
+
+    <key name="col-14-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Command Line” column on startup
+      </summary>
+    </key>
+
+    <key name="col-15-width" type="i">
+      <default>80
+      </default>
+      <summary>Width of process “Memory” column
+      </summary>
+    </key>
+
+    <key name="col-15-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Memory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-16-width" type="i">
+      <default>48
+      </default>
+      <summary>Width of process “Waiting Channel” column
+      </summary>
+    </key>
+
+    <key name="col-16-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Waiting Channel” column on startup
+      </summary>
+    </key>
+
+    <key name="col-17-width" type="i">
+      <default>48
+      </default>
+      <summary>Width of process “Control Group” column
+      </summary>
+    </key>
+
+    <key name="col-17-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Control Group” column on startup
+      </summary>
+    </key>
+
+    <key name="col-18-width" type="i">
+      <default>70
+      </default>
+      <summary>Width of process “Unit” column
+      </summary>
+    </key>
+
+    <key name="col-18-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Unit” column on startup
+      </summary>
+    </key>
+
+    <key name="col-19-width" type="i">
+      <default>41
+      </default>
+      <summary>Width of process “Session” column
+      </summary>
+    </key>
+
+    <key name="col-19-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Session” column on startup
+      </summary>
+    </key>
+
+    <key name="col-20-width" type="i">
+      <default>59
+      </default>
+      <summary>Width of process “Seat” column
+      </summary>
+    </key>
+
+    <key name="col-20-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Seat” column on startup
+      </summary>
+    </key>
+
+    <key name="col-21-width" type="i">
+      <default>59
+      </default>
+      <summary>Width of process “Owner” column
+      </summary>
+    </key>
+
+    <key name="col-21-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show process “Owner” column on startup
+      </summary>
+    </key>
+
+    <key name="col-22-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of process “Total disk read” column
+      </summary>
+    </key>
+
+    <key name="col-22-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Total disk read” column on startup
+      </summary>
+    </key>
+
+    <key name="col-23-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of process “Total disk write” column
+      </summary>
+    </key>
+
+    <key name="col-23-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Total disk write” column on startup
+      </summary>
+    </key>
+
+    <key name="col-24-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of process “Disk read” column
+      </summary>
+    </key>
+
+    <key name="col-24-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Disk read” column on startup
+      </summary>
+    </key>
+
+    <key name="col-25-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of process “Disk write” column
+      </summary>
+    </key>
+
+    <key name="col-25-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Disk write” column on startup
+      </summary>
+    </key>
+
+    <key name="col-26-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of process “Priority” column
+      </summary>
+    </key>
+
+    <key name="col-26-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show process “Priority” column on startup
+      </summary>
+    </key>
+
+
+  </schema>
+
+  <schema id="org.gnome.gnome-system-monitor.disktreenew" path="/org/gnome/gnome-system-monitor/disktreenew/">
+    <key name="sort-col" type="i">
+      <default>1
+      </default>
+      <summary>Disk view sort column
+      </summary>
+    </key>
+
+    <key name="sort-order" type="i">
+      <default>0
+      </default>
+      <summary>Disk view sort order
+      </summary>
+    </key>
+
+    <key name="columns-order" type="ai">
+      <default>[ 0 ]
+      </default>
+      <summary>Disk view columns order
+      </summary>
+    </key>
+
+    <key name="col-0-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of disk view “Device” column
+      </summary>
+    </key>
+
+    <key name="col-0-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show disk view “Device” column on startup
+      </summary>
+    </key>
+
+    <key name="col-1-width" type="i">
+      <default>100
+      </default>
+      <summary>Width of disk view “Directory” column
+      </summary>
+    </key>
+
+    <key name="col-1-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show disk view “Directory” column on startup
+      </summary>
+    </key>
+
+    <key name="col-2-width" type="i">
+      <default>50
+      </default>
+      <summary>Width of disk view “Type” column
+      </summary>
+    </key>
+
+    <key name="col-2-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show disk view “Type” column on startup
+      </summary>
+    </key>
+
+    <key name="col-3-width" type="i">
+      <default>80
+      </default>
+      <summary>Width of disk view “Total” column
+      </summary>
+    </key>
+
+    <key name="col-3-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show disk view “Total” column on startup
+      </summary>
+    </key>
+
+    <key name="col-4-width" type="i">
+      <default>80
+      </default>
+      <summary>Width of disk view “Free” column
+      </summary>
+    </key>
+
+    <key name="col-4-visible" type="b">
+      <default>false
+      </default>
+      <summary>Show disk view “Free” column on startup
+      </summary>
+    </key>
+
+    <key name="col-5-width" type="i">
+      <default>80
+      </default>
+      <summary>Width of disk view “Available” column
+      </summary>
+    </key>
+
+    <key name="col-5-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show disk view “Available” column on startup
+      </summary>
+    </key>
+
+    <key name="col-6-width" type="i">
+      <default>300
+      </default>
+      <summary>Width of disk view “Used” column
+      </summary>
+    </key>
+
+    <key name="col-6-visible" type="b">
+      <default>true
+      </default>
+      <summary>Show disk view “Used” column on startup
+      </summary>
+    </key>
+
+  </schema>
+
+  <schema id="org.gnome.gnome-system-monitor.memmapstree" path="/org/gnome/gnome-system-monitor/memmapstree/">
+    <key name="sort-col" type="i">
+      <default>0
+      </default>
+      <summary>Memory map sort column
+      </summary>
+    </key>
+
+    <key name="sort-order" type="i">
+      <default>0
+      </default>
+      <summary>Memory map sort order
+      </summary>
+    </key>
+  </schema>
+
+  <schema id="org.gnome.gnome-system-monitor.openfilestree" path="/org/gnome/gnome-system-monitor/openfilestree/">
+    <key name="sort-col" type="i">
+      <default>0
+      </default>
+      <summary>Open files sort column
+      </summary>
+    </key>
+
+    <key name="sort-order" type="i">
+      <default>0
+      </default>
+      <summary>Open files sort order
+      </summary>
+    </key>
+  </schema>
+</schemalist>
+
diff --git a/src/prefsdialog.cpp b/src/prefsdialog.cpp
new file mode 100644
index 0000000..39ca384
--- /dev/null
+++ b/src/prefsdialog.cpp
@@ -0,0 +1,361 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "prefsdialog.h"
+
+#include "cgroups.h"
+#include "proctable.h"
+#include "selinux.h"
+#include "settings-keys.h"
+#include "systemd.h"
+#include "util.h"
+
+static HdyPreferencesWindow *prefs_dialog = NULL;
+
+static gboolean
+prefs_dialog_delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+    prefs_dialog = NULL;
+    return FALSE;
+}
+
+class SpinButtonUpdater
+{
+public:
+    SpinButtonUpdater(const string& key)
+        : key(key)
+    { }
+
+    static gboolean callback(GtkWidget *widget, GdkEventFocus *event, gpointer data)
+    {
+        SpinButtonUpdater* updater = static_cast<SpinButtonUpdater*>(data);
+        gtk_spin_button_update(GTK_SPIN_BUTTON(widget));
+        updater->update(GTK_SPIN_BUTTON(widget));
+        return FALSE;
+    }
+
+private:
+
+    void update(GtkSpinButton* spin)
+    {
+        int new_value = 1000 * gtk_spin_button_get_value(spin);
+
+        GsmApplication::get()->settings->set_int(this->key, new_value);
+
+        procman_debug("set %s to %d", this->key.c_str(), new_value);
+    }
+
+    const string key;
+};
+
+class ScaleUpdater
+{
+public:
+	ScaleUpdater(const string& key)
+	    : key(key)
+	{ }
+
+	static gboolean callback(GtkRange *range, gpointer data)
+	{
+		ScaleUpdater* updater = static_cast<ScaleUpdater*>(data);
+		updater->update(range);
+		return FALSE;
+	}
+
+private:
+
+	void update(GtkRange* range)
+	{
+		int new_value = gtk_range_get_value(range);
+
+		GsmApplication::get()->settings->set_int(this->key, new_value);
+
+		procman_debug("set %s to %d", this->key.c_str(), new_value);
+	}
+
+	const string key;
+};
+
+static void
+field_toggled (const gchar *gsettings_parent, gchar *path_str, gpointer data)
+{
+    GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
+    GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
+    GtkTreeIter iter;
+    GtkTreeViewColumn *column;
+    gboolean toggled;
+    auto settings = GsmApplication::get()->settings->get_child (gsettings_parent);
+    int id;
+
+    if (!path)
+        return;
+
+    gtk_tree_model_get_iter (model, &iter, path);
+
+    gtk_tree_model_get (model, &iter, 2, &column, -1);
+
+    gtk_tree_model_get (model, &iter, 0, &toggled, -1);
+    gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
+    gtk_tree_view_column_set_visible (column, !toggled);
+
+    id = gtk_tree_view_column_get_sort_column_id (column);
+
+    auto key = Glib::ustring::compose ("col-%1-visible", id);
+    settings->set_boolean (key, !toggled);
+
+    gtk_tree_path_free (path);
+
+}
+
+static void
+field_row_activated ( GtkTreeView *tree, GtkTreePath *path,
+                      GtkTreeViewColumn *column, gpointer data)
+{
+    GtkTreeModel * model = gtk_tree_view_get_model (tree);
+    gchar * path_str = gtk_tree_path_to_string (path);
+    field_toggled((gchar*)data, path_str, model );
+    g_free (path_str);
+}
+
+static void
+proc_field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
+{
+    field_toggled("proctree", path_str, data);
+}
+
+static void
+disk_field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
+{
+    field_toggled("disktreenew", path_str, data);
+}
+
+static void
+create_field_page(GtkBuilder* builder, GtkTreeView *tree, const gchar *widgetname)
+{
+    GtkTreeView *treeview;
+    GList *it, *columns;
+    GtkListStore *model;
+    GtkTreeViewColumn *column;
+    GtkCellRenderer *cell;
+    gchar *full_widgetname;
+
+    full_widgetname = g_strdup_printf ("%s_columns", widgetname);
+    treeview = GTK_TREE_VIEW (gtk_builder_get_object (builder, full_widgetname));
+    g_free (full_widgetname);
+
+    model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
+
+    gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL(model));
+    g_object_unref (G_OBJECT (model));
+
+    column = gtk_tree_view_column_new ();
+
+    cell = gtk_cell_renderer_toggle_new ();
+    gtk_tree_view_column_pack_start (column, cell, FALSE);
+    gtk_tree_view_column_set_attributes (column, cell,
+                                         "active", 0,
+                                         NULL);
+    if(!g_strcmp0(widgetname, "proctree"))
+        g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (proc_field_toggled), model);
+    else if(!g_strcmp0(widgetname, "disktreenew"))
+        g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (disk_field_toggled), model);
+
+    g_signal_connect (G_OBJECT (GTK_TREE_VIEW (treeview)), "row-activated", G_CALLBACK (field_row_activated), (gpointer)widgetname);
+
+    gtk_tree_view_column_set_clickable (column, TRUE);
+    gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+
+    column = gtk_tree_view_column_new ();
+
+    cell = gtk_cell_renderer_text_new ();
+    gtk_tree_view_column_pack_start (column, cell, FALSE);
+    gtk_tree_view_column_set_attributes (column, cell,
+                                         "text", 1,
+                                         NULL);
+
+    gtk_tree_view_column_set_title (column, "Not Shown");
+    gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+
+    columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
+
+    for(it = columns; it; it = it->next)
+    {
+        GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
+        GtkTreeIter iter;
+        const gchar *title;
+        gboolean visible;
+        gint column_id;
+
+        title = gtk_tree_view_column_get_title (column);
+        if (!title)
+            title = _("Icon");
+
+        column_id = gtk_tree_view_column_get_sort_column_id(column);
+        if ((column_id == COL_CGROUP) && (!cgroups_enabled()))
+            continue;
+        if ((column_id == COL_SECURITYCONTEXT) && (!can_show_security_context_column ()))
+            continue;
+
+        if ((column_id == COL_UNIT ||
+             column_id == COL_SESSION ||
+             column_id == COL_SEAT ||
+             column_id == COL_OWNER)
+            && !procman::systemd_logind_running()
+            )
+            continue;
+
+        visible = gtk_tree_view_column_get_visible (column);
+
+        gtk_list_store_append (model, &iter);
+        gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
+    }
+
+    g_list_free(columns);
+
+}
+
+void
+create_preferences_dialog (GsmApplication *app)
+{
+    typedef SpinButtonUpdater SBU;
+
+    static SBU interval_updater("update-interval");
+    static SBU graph_interval_updater("graph-update-interval");
+    static SBU disks_interval_updater("disks-interval");
+    static ScaleUpdater graph_points_updater("graph-data-points");
+
+    GtkAdjustment *adjustment;
+    GtkSpinButton *spin_button;
+    GtkSwitch *check_switch;
+    GtkSwitch *smooth_switch;
+    GtkBuilder *builder;
+    gfloat update;
+
+    if (prefs_dialog)
+        return;
+
+    builder = gtk_builder_new();
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/preferences.ui", NULL);
+
+    prefs_dialog = HDY_PREFERENCES_WINDOW (gtk_builder_get_object (builder, "preferences_dialog"));
+
+    spin_button = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "processes_interval_spinner"));
+
+    update = (gfloat) app->config.update_interval;
+    adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON(spin_button));
+    gtk_adjustment_configure (adjustment,
+                              update / 1000.0,
+                              MIN_UPDATE_INTERVAL / 1000,
+                              MAX_UPDATE_INTERVAL / 1000,
+                              0.25,
+                              1.0,
+                              0);
+    g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
+                      G_CALLBACK (SBU::callback), &interval_updater);
+
+    smooth_switch = GTK_SWITCH (gtk_builder_get_object (builder, "smooth_switch"));
+    g_settings_bind(app->settings->gobj (), SmoothRefresh::KEY.c_str(), smooth_switch, "active", G_SETTINGS_BIND_DEFAULT);
+
+    check_switch = GTK_SWITCH (gtk_builder_get_object (builder, "check_switch"));
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_SHOW_KILL_DIALOG,
+                     check_switch, "active",
+                     G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *solaris_switch = GTK_SWITCH (gtk_builder_get_object (builder, "solaris_switch"));
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_SOLARIS_MODE,
+                     solaris_switch, "active",
+                     G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *proc_mem_in_iec_switch = GTK_SWITCH (gtk_builder_get_object (builder, "proc_mem_in_iec_switch"));
+    g_settings_bind(app->settings->gobj (), GSM_SETTING_PROCESS_MEMORY_IN_IEC,
+                    proc_mem_in_iec_switch, "active",
+                    G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *logarithmic_scale_switch = GTK_SWITCH (gtk_builder_get_object (builder, "logarithmic_scale_switch"));
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_LOGARITHMIC_SCALE,
+                     logarithmic_scale_switch, "active",
+                     G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *draw_stacked_switch = GTK_SWITCH (gtk_builder_get_object (builder, "draw_stacked_switch"));
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_DRAW_STACKED,
+                     draw_stacked_switch, "active",
+                     G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *draw_smooth_switch = GTK_SWITCH (gtk_builder_get_object (builder, "draw_smooth_switch"));
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_DRAW_SMOOTH,
+                     draw_smooth_switch, "active",
+                     G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *res_mem_in_iec_switch = GTK_SWITCH (gtk_builder_get_object (builder, "res_mem_in_iec_switch"));
+    g_settings_bind(app->settings->gobj (), GSM_SETTING_RESOURCES_MEMORY_IN_IEC,
+                    res_mem_in_iec_switch, "active",
+                    G_SETTINGS_BIND_DEFAULT);
+
+    create_field_page (builder, GTK_TREE_VIEW (app->tree), "proctree");
+
+    update = (gfloat) app->config.graph_update_interval;
+    spin_button = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "resources_interval_spinner"));
+    adjustment = gtk_spin_button_get_adjustment (spin_button);
+    gtk_adjustment_configure (adjustment, update / 1000.0, 0.05,
+                              10.0, 0.05, 0.5, 0);
+    g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
+                      G_CALLBACK(SBU::callback),
+                      &graph_interval_updater);
+
+    update = (gfloat) app->config.graph_data_points;
+    GtkRange* range = GTK_RANGE (gtk_builder_get_object (builder, "graph_data_points_scale"));
+    adjustment = gtk_range_get_adjustment (range);
+    gtk_adjustment_configure (adjustment, update, 30,
+                              600, 10, 60, 0);
+    g_signal_connect (G_OBJECT (range), "value-changed",
+                      G_CALLBACK(ScaleUpdater::callback),
+                      &graph_points_updater);
+
+    GtkSwitch *bits_switch = GTK_SWITCH (gtk_builder_get_object (builder, "bits_switch"));
+    g_settings_bind(app->settings->gobj (), GSM_SETTING_NETWORK_IN_BITS,
+                    bits_switch, "active",
+                    G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *bits_unit_switch = GTK_SWITCH (gtk_builder_get_object (builder, "bits_unit_switch"));
+    g_settings_bind(app->settings->gobj (), GSM_SETTING_NETWORK_TOTAL_UNIT,
+                    bits_unit_switch, "active",
+                    G_SETTINGS_BIND_DEFAULT);
+
+    GtkSwitch *bits_total_switch = GTK_SWITCH (gtk_builder_get_object (builder, "bits_total_switch"));
+    g_settings_bind(app->settings->gobj (), GSM_SETTING_NETWORK_TOTAL_IN_BITS,
+                    bits_total_switch, "active",
+                    G_SETTINGS_BIND_DEFAULT);
+
+    update = (gfloat) app->config.disks_update_interval;
+    spin_button = GTK_SPIN_BUTTON (gtk_builder_get_object (builder, "devices_interval_spinner"));
+    adjustment = gtk_spin_button_get_adjustment (spin_button);
+    gtk_adjustment_configure (adjustment, update / 1000.0, 1.0,
+                              100.0, 1.0, 1.0, 0);
+    g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
+                      G_CALLBACK(SBU::callback),
+                      &disks_interval_updater);
+
+
+    check_switch = GTK_SWITCH (gtk_builder_get_object (builder, "all_devices_check"));
+    g_settings_bind (app->settings->gobj (), GSM_SETTING_SHOW_ALL_FS,
+                     check_switch, "active",
+                     G_SETTINGS_BIND_DEFAULT);
+
+    create_field_page (builder, GTK_TREE_VIEW (app->disk_list), "disktreenew");
+
+    gtk_window_set_transient_for (GTK_WINDOW (prefs_dialog), GTK_WINDOW (GsmApplication::get()->main_window));
+    gtk_window_set_modal (GTK_WINDOW (prefs_dialog), TRUE);
+
+    gtk_widget_show_all (GTK_WIDGET (prefs_dialog));
+    g_signal_connect (G_OBJECT (prefs_dialog), "delete-event",
+                      G_CALLBACK (prefs_dialog_delete_event), NULL);
+
+    gtk_window_present (GTK_WINDOW (prefs_dialog));
+
+    gtk_builder_connect_signals (builder, NULL);
+    g_object_unref (G_OBJECT (builder));
+}
diff --git a/src/prefsdialog.h b/src/prefsdialog.h
new file mode 100644
index 0000000..63c966c
--- /dev/null
+++ b/src/prefsdialog.h
@@ -0,0 +1,10 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_PREFS_DIALOG_H_
+#define _GSM_PREFS_DIALOG_H_
+
+#include "application.h"
+
+void create_preferences_dialog (GsmApplication *app);
+void on_bits_unit_button_toggled (GtkToggleButton *togglebutton, gpointer bits_total_button);
+
+#endif /* _GSM_PREFS_DIALOG_H_ */
diff --git a/src/prettytable.cpp b/src/prettytable.cpp
new file mode 100644
index 0000000..3a04c63
--- /dev/null
+++ b/src/prettytable.cpp
@@ -0,0 +1,337 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#ifdef HAVE_WNCK
+#define WNCK_I_KNOW_THIS_IS_UNSTABLE
+#include <libwnck/libwnck.h>
+#endif
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <string.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <glibtop/procstate.h>
+#include <giomm/error.h>
+#include <giomm/file.h>
+#include <glibmm/miscutils.h>
+#include <iostream>
+
+#include <vector>
+
+#include "prettytable.h"
+#include "defaulttable.h"
+#include "proctable.h"
+#include "util.h"
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+
+namespace
+{
+  const unsigned APP_ICON_SIZE = 16;
+}
+
+
+PrettyTable::PrettyTable()
+{
+#ifdef HAVE_WNCK
+#ifdef GDK_WINDOWING_X11
+  if (GDK_IS_X11_DISPLAY (gdk_display_get_default ())) {
+      WnckScreen* screen = wnck_screen_get_default();
+      g_signal_connect(G_OBJECT(screen), "application_opened",
+		       G_CALLBACK(PrettyTable::on_application_opened), this);
+      g_signal_connect(G_OBJECT(screen), "application_closed",
+	               G_CALLBACK(PrettyTable::on_application_closed), this);
+  }
+#endif
+#endif
+
+  // init GIO apps cache
+  std::vector<std::string> dirs = Glib::get_system_data_dirs();
+  for (std::vector<std::string>::iterator it = dirs.begin(); it != dirs.end(); ++it) {
+    std::string path = (*it).append("/applications");
+    Glib::RefPtr<Gio::File> file = Gio::File::create_for_path(path);
+    Glib::RefPtr<Gio::FileMonitor> monitor = file->monitor_directory();
+    monitor->set_rate_limit(1000); // 1 second
+
+    monitor->signal_changed().connect(sigc::mem_fun(this, &PrettyTable::file_monitor_event));
+    monitors[path] = monitor;
+  }
+
+  this->init_gio_app_cache();
+}
+
+
+PrettyTable::~PrettyTable()
+{
+}
+
+#ifdef HAVE_WNCK
+void
+PrettyTable::on_application_opened(WnckScreen* screen, WnckApplication* app, gpointer data)
+{
+  PrettyTable * const that = static_cast<PrettyTable*>(data);
+
+  pid_t pid = wnck_application_get_pid(app);
+
+  if (pid == 0)
+    return;
+
+  const char* icon_name = wnck_application_get_icon_name(app);
+
+
+  Glib::RefPtr<Gdk::Pixbuf> icon;
+
+  icon = Glib::wrap(gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), icon_name, APP_ICON_SIZE, GTK_ICON_LOOKUP_USE_BUILTIN, NULL));
+
+  if (not icon) {
+    icon = Glib::wrap(wnck_application_get_icon(app), /* take_copy */ true);
+    icon = icon->scale_simple(APP_ICON_SIZE, APP_ICON_SIZE, Gdk::INTERP_HYPER);
+  }
+
+  if (not icon)
+    return;
+
+  that->register_application(pid, icon);
+}
+
+
+
+void
+PrettyTable::register_application(pid_t pid, Glib::RefPtr<Gdk::Pixbuf> icon)
+{
+  /* If process already exists then set the icon. Otherwise put into hash
+  ** table to be added later */
+    if (ProcInfo* info = GsmApplication::get()->processes.find(pid))
+    {
+      info->set_icon(icon);
+      // move the ref to the map
+      this->apps[pid] = icon;
+      procman_debug("WNCK OK for %u", unsigned(pid));
+    }
+}
+
+
+
+void
+PrettyTable::on_application_closed(WnckScreen* screen, WnckApplication* app, gpointer data)
+{
+  pid_t pid = wnck_application_get_pid(app);
+
+  if (pid == 0)
+    return;
+
+  static_cast<PrettyTable*>(data)->unregister_application(pid);
+}
+
+
+
+void
+PrettyTable::unregister_application(pid_t pid)
+{
+  IconsForPID::iterator it(this->apps.find(pid));
+
+  if (it != this->apps.end())
+    this->apps.erase(it);
+}
+#endif // HAVE_WNCK
+
+void PrettyTable::init_gio_app_cache ()
+{
+  this->gio_apps.clear();
+
+  Glib::ListHandle<Glib::RefPtr<Gio::AppInfo> > apps = Gio::AppInfo::get_all();
+  for (Glib::ListHandle<Glib::RefPtr<Gio::AppInfo> >::const_iterator it = apps.begin();
+       it != apps.end(); ++it) {
+    Glib::RefPtr<Gio::AppInfo> app = *it;
+    std::string executable = app->get_executable();
+    if (executable != "sh" &&
+        executable != "env")
+        this->gio_apps[executable] = app;
+  }
+}
+
+void PrettyTable::file_monitor_event(Glib::RefPtr<Gio::File>,
+                                     Glib::RefPtr<Gio::File>,
+                                     Gio::FileMonitorEvent)
+{
+  this->init_gio_app_cache();
+}
+
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_from_theme(const ProcInfo &info)
+{
+  return Glib::wrap(gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), info.name.c_str(), APP_ICON_SIZE, (GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_FORCE_SIZE), NULL));
+}
+
+
+bool PrettyTable::get_default_icon_name(const string &cmd, string &name)
+{
+  for (size_t i = 0; i != G_N_ELEMENTS(default_table); ++i) {
+    if (default_table[i].command->match(cmd)) {
+      name = default_table[i].icon;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/*
+  Try to get an icon from the default_table
+  If it's not in defaults, try to load it.
+  If there is no default for a command, store NULL in defaults
+  so we don't have to lookup again.
+*/
+
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_from_default(const ProcInfo &info)
+{
+  Glib::RefPtr<Gdk::Pixbuf> pix;
+  string name;
+
+  if (this->get_default_icon_name(info.name, name)) {
+    IconCache::iterator it(this->defaults.find(name));
+
+    if (it == this->defaults.end()) {
+      pix = Glib::wrap(gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), name.c_str(), APP_ICON_SIZE, (GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_FORCE_SIZE), NULL));
+      if (pix)
+	this->defaults[name] = pix;
+    } else
+      pix = it->second;
+  }
+
+  return pix;
+}
+
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_from_gio(const ProcInfo &info)
+{
+  gchar **cmdline = g_strsplit(info.name.c_str(), " ", 2);
+  const gchar *executable = cmdline[0];
+  Glib::RefPtr<Gdk::Pixbuf> icon;
+
+  if (executable) {
+    Glib::RefPtr<Gio::AppInfo> app = this->gio_apps[executable];
+    Glib::RefPtr<Gio::Icon> gicon;
+    Gtk::IconInfo info;
+
+    if (app)
+      gicon = app->get_icon();
+
+    if (gicon)
+      info = Glib::wrap(gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (), gicon->gobj(), APP_ICON_SIZE, (GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_FORCE_SIZE)));
+
+    if (info)
+      icon = Glib::wrap(gtk_icon_info_load_icon (info.gobj(), NULL));
+  }
+
+  g_strfreev(cmdline);
+  return icon;
+}
+
+#ifdef HAVE_WNCK
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_from_wnck(const ProcInfo &info)
+{
+  Glib::RefPtr<Gdk::Pixbuf> icon;
+
+  IconsForPID::iterator it(this->apps.find(info.pid));
+
+  if (it != this->apps.end())
+    icon = it->second;
+
+  return icon;
+}
+#endif
+
+
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_from_name(const ProcInfo &info)
+{
+return Glib::wrap(gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), info.name.c_str(), APP_ICON_SIZE, (GtkIconLookupFlags)(GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_FORCE_SIZE), NULL));
+}
+
+
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_dummy(const ProcInfo &)
+{
+    return Glib::wrap(gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "application-x-executable", APP_ICON_SIZE, GTK_ICON_LOOKUP_USE_BUILTIN, NULL));
+}
+
+
+namespace
+{
+  bool has_kthreadd()
+  {
+    glibtop_proc_state buf;
+    glibtop_get_proc_state(&buf, 2);
+
+    return buf.cmd == string("kthreadd");
+  }
+
+  // @pre: has_kthreadd
+  bool is_kthread(const ProcInfo &info)
+  {
+    return info.pid == 2 or info.ppid == 2;
+  }
+}
+
+
+Glib::RefPtr<Gdk::Pixbuf>
+PrettyTable::get_icon_for_kernel(const ProcInfo &info)
+{
+  if (is_kthread(info))
+    return Glib::wrap(gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "applications-system", APP_ICON_SIZE, GTK_ICON_LOOKUP_USE_BUILTIN, NULL));
+
+  return Glib::RefPtr<Gdk::Pixbuf>();
+}
+
+
+
+void
+PrettyTable::set_icon(ProcInfo &info)
+{
+  typedef Glib::RefPtr<Gdk::Pixbuf>
+    (PrettyTable::*Getter)(const ProcInfo &);
+
+  static std::vector<Getter> getters;
+
+  if (getters.empty())
+    {
+      getters.push_back(&PrettyTable::get_icon_from_gio);
+#ifdef HAVE_WNCK
+      getters.push_back(&PrettyTable::get_icon_from_wnck);
+#endif
+      getters.push_back(&PrettyTable::get_icon_from_theme);
+      getters.push_back(&PrettyTable::get_icon_from_default);
+      getters.push_back(&PrettyTable::get_icon_from_name);
+      if (has_kthreadd())
+	{
+	  procman_debug("kthreadd is running with PID 2");
+	  getters.push_back(&PrettyTable::get_icon_for_kernel);
+	}
+      getters.push_back(&PrettyTable::get_icon_dummy);
+    }
+
+  Glib::RefPtr<Gdk::Pixbuf> icon;
+
+  for (size_t i = 0; not icon and i < getters.size(); ++i) {
+    try {
+      icon = (this->*getters[i])(info);
+    }
+    catch (std::exception& e) {
+      g_warning("Failed to load icon for %s(%u) : %s", info.name.c_str(), info.pid, e.what());
+      continue;
+    }
+    catch (Glib::Exception& e) {
+      g_warning("Failed to load icon for %s(%u) : %s", info.name.c_str(), info.pid, e.what().c_str());
+      continue;
+    }
+  }
+
+  info.set_icon(icon);
+}
+
diff --git a/src/prettytable.h b/src/prettytable.h
new file mode 100644
index 0000000..627ac6f
--- /dev/null
+++ b/src/prettytable.h
@@ -0,0 +1,74 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_PRETTY_TABLE_H_
+#define _GSM_PRETTY_TABLE_H_
+
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <glibmm/refptr.h>
+#include <giomm/filemonitor.h>
+
+#include <gdkmm/pixbuf.h>
+
+#include <map>
+#include <string>
+
+#ifdef HAVE_WNCK
+extern "C" {
+#define WNCK_I_KNOW_THIS_IS_UNSTABLE
+#include <libwnck/libwnck.h>
+}
+#endif
+
+class ProcInfo;
+
+using std::string;
+
+
+
+class PrettyTable
+{
+public:
+    PrettyTable();
+    ~PrettyTable();
+
+    void set_icon(ProcInfo &);
+
+private:
+
+#ifdef HAVE_WNCK
+    static void on_application_opened(WnckScreen* screen, WnckApplication* app, gpointer data);
+    static void on_application_closed(WnckScreen* screen, WnckApplication* app, gpointer data);
+
+    void register_application(pid_t pid, Glib::RefPtr<Gdk::Pixbuf> icon);
+    void unregister_application(pid_t pid);
+#endif
+
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_from_theme(const ProcInfo &);
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_from_default(const ProcInfo &);
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_from_gio(const ProcInfo &);
+#ifdef HAVE_WNCK
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_from_wnck(const ProcInfo &);
+#endif
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_from_name(const ProcInfo &);
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_for_kernel(const ProcInfo &);
+    Glib::RefPtr<Gdk::Pixbuf> get_icon_dummy(const ProcInfo &);
+
+    bool get_default_icon_name(const string &cmd, string &name);
+    void file_monitor_event (Glib::RefPtr<Gio::File>,
+                             Glib::RefPtr<Gio::File>,
+                             Gio::FileMonitorEvent);
+    void init_gio_app_cache ();
+
+    typedef std::map<string, Glib::RefPtr<Gdk::Pixbuf> > IconCache;
+    typedef std::map<pid_t, Glib::RefPtr<Gdk::Pixbuf> > IconsForPID;
+    typedef std::map<string, Glib::RefPtr<Gio::AppInfo> > AppCache;
+    typedef std::map<string, Glib::RefPtr<Gio::FileMonitor> > DesktopDirMonitors;
+
+    IconsForPID apps;
+    IconCache defaults;
+    DesktopDirMonitors monitors;
+    AppCache gio_apps;
+};
+
+
+#endif /* _GSM_PRETTY_TABLE_H_ */
diff --git a/src/procactions.cpp b/src/procactions.cpp
new file mode 100644
index 0000000..6868d25
--- /dev/null
+++ b/src/procactions.cpp
@@ -0,0 +1,187 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman process actions
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include <config.h>
+#include <errno.h>
+
+#include <glib/gi18n.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include "procactions.h"
+#include "application.h"
+#include "proctable.h"
+#include "procdialogs.h"
+
+
+static void
+renice_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
+{
+    const struct ProcActionArgs * const args = static_cast<ProcActionArgs*>(data);
+
+    ProcInfo *info = NULL;
+    gint error;
+    int saved_errno;
+    gchar *error_msg;
+    GtkMessageDialog *dialog;
+
+    gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+
+    if (!info)
+        return;
+    if (info->nice == args->arg_value)
+        return;
+    error = setpriority (PRIO_PROCESS, info->pid, args->arg_value);
+
+    /* success */
+    if(error != -1) return;
+
+    saved_errno = errno;
+
+    /* need to be root */
+    if(errno == EPERM || errno == EACCES) {
+        gboolean success;
+
+        success = procdialog_create_root_password_dialog (
+            PROCMAN_ACTION_RENICE, args->app, info->pid,
+            args->arg_value);
+
+        if(success) return;
+
+        if(errno) {
+            saved_errno = errno;
+        }
+    }
+
+    /* failed */
+    error_msg = g_strdup_printf (
+        _("Cannot change the priority of process with PID %d to %d.\n"
+          "%s"),
+        info->pid, args->arg_value, g_strerror(saved_errno));
+
+    dialog = GTK_MESSAGE_DIALOG (gtk_message_dialog_new (
+        NULL,
+        GTK_DIALOG_DESTROY_WITH_PARENT,
+        GTK_MESSAGE_ERROR,
+        GTK_BUTTONS_OK,
+        "%s", error_msg));
+
+    gtk_dialog_run (GTK_DIALOG (dialog));
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+    g_free (error_msg);
+}
+
+
+void
+renice (GsmApplication *app, int nice)
+{
+    struct ProcActionArgs args = { app, nice };
+
+    /* EEEK - ugly hack - make sure the table is not updated as a crash
+    ** occurs if you first kill a process and the tree node is removed while
+    ** still in the foreach function
+    */
+    proctable_freeze (app);
+
+    gtk_tree_selection_selected_foreach(app->selection, renice_single_process,
+                                        &args);
+
+    proctable_thaw (app);
+
+    proctable_update (app);
+}
+
+
+
+
+static void
+kill_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
+{
+    const struct ProcActionArgs * const args = static_cast<ProcActionArgs*>(data);
+    char *error_msg;
+    ProcInfo *info;
+    int error;
+    int saved_errno;
+    GtkMessageDialog *dialog;
+
+    gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+
+    if (!info)
+        return;
+
+    error = kill (info->pid, args->arg_value);
+
+    /* success */
+    if(error != -1) return;
+
+    saved_errno = errno;
+
+    /* need to be root */
+    if(errno == EPERM) {
+        gboolean success;
+
+        success = procdialog_create_root_password_dialog (
+            PROCMAN_ACTION_KILL, args->app, info->pid,
+            args->arg_value);
+
+        if(success) return;
+
+        if(errno) {
+            saved_errno = errno;
+        }
+    }
+
+    /* failed */
+    error_msg = g_strdup_printf (
+        _("Cannot kill process with PID %d with signal %d.\n"
+          "%s"),
+        info->pid, args->arg_value, g_strerror(saved_errno));
+
+    dialog = GTK_MESSAGE_DIALOG (gtk_message_dialog_new (
+        NULL,
+        GTK_DIALOG_DESTROY_WITH_PARENT,
+        GTK_MESSAGE_ERROR,
+        GTK_BUTTONS_OK,
+        "%s", error_msg));
+
+    gtk_dialog_run (GTK_DIALOG (dialog));
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+    g_free (error_msg);
+}
+
+
+void
+kill_process (GsmApplication *app, int sig)
+{
+    struct ProcActionArgs args = { app, sig };
+
+    /* EEEK - ugly hack - make sure the table is not updated as a crash
+    ** occurs if you first kill a process and the tree node is removed while
+    ** still in the foreach function
+    */
+    proctable_freeze (app);
+
+    gtk_tree_selection_selected_foreach (app->selection, kill_single_process,
+                                         &args);
+
+    proctable_thaw (app);
+
+    proctable_update (app);
+}
diff --git a/src/procactions.h b/src/procactions.h
new file mode 100644
index 0000000..f1f20db
--- /dev/null
+++ b/src/procactions.h
@@ -0,0 +1,33 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman process actions
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef _GSM_PROCACTIONS_H_
+#define _GSM_PROCACTIONS_H_
+
+#include "application.h"
+
+void            renice (GsmApplication *app, int nice);
+void            kill_process (GsmApplication *app, int sig);
+
+struct ProcActionArgs
+{
+    GsmApplication *app;
+    int arg_value;
+};
+
+#endif /* _GSM_PROCACTIONS_H_ */
diff --git a/src/procdialogs.cpp b/src/procdialogs.cpp
new file mode 100644
index 0000000..b0d2a54
--- /dev/null
+++ b/src/procdialogs.cpp
@@ -0,0 +1,336 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman - dialogs
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include <config.h>
+
+#include <glib/gi18n.h>
+
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "procdialogs.h"
+#include "proctable.h"
+#include "prettytable.h"
+#include "procactions.h"
+#include "util.h"
+#include "gsm_gnomesu.h"
+#include "gsm_gksu.h"
+#include "gsm_pkexec.h"
+#include "cgroups.h"
+
+static GtkDialog *renice_dialog = NULL;
+static gint new_nice_value = 0;
+
+
+static void
+kill_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
+{
+    struct ProcActionArgs *kargs = static_cast<ProcActionArgs*>(data);
+
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+
+    if (id == GTK_RESPONSE_OK)
+        kill_process (kargs->app, kargs->arg_value);
+
+    proctable_thaw (kargs->app);
+    proctable_update (kargs->app);
+    g_free (kargs);
+}
+
+void
+procdialog_create_kill_dialog (GsmApplication *app, int signal)
+{
+    GtkMessageDialog *kill_alert_dialog;
+    GtkWidget *confirm_button;
+
+    gchar *primary, *secondary, *button_text;
+    struct ProcActionArgs *kargs;
+
+    proctable_freeze (app);
+    kargs = g_new(ProcActionArgs, 1);
+    kargs->app = app;
+    kargs->arg_value = signal;
+    gint selected_count = gtk_tree_selection_count_selected_rows (app->selection);
+
+    if ( selected_count == 1 ) {
+        ProcInfo *selected_process = NULL;
+        // get the last selected row
+        gtk_tree_selection_selected_foreach (app->selection, get_last_selected,
+                                         &selected_process);
+
+	std::string *process_name = &selected_process->name;
+	std::string short_process_name = process_name->substr(0, process_name->find(" -"));
+
+        switch (signal) {
+            case SIGKILL:
+                /*xgettext: primary alert message for killing single process*/
+                primary = g_strdup_printf (_("Are you sure you want to kill the selected process “%s” (PID: %u)?"),
+                                           short_process_name.c_str(),
+                                           selected_process->pid);
+                break;
+            case SIGTERM:
+                /*xgettext: primary alert message for ending single process*/
+                primary = g_strdup_printf (_("Are you sure you want to end the selected process “%s” (PID: %u)?"),
+                                           short_process_name.c_str(),
+                                           selected_process->pid);
+                break;
+            default: // SIGSTOP
+                /*xgettext: primary alert message for stopping single process*/
+                primary = g_strdup_printf (_("Are you sure you want to stop the selected process “%s” (PID: %u)?"),
+                                           short_process_name.c_str(),
+                                           selected_process->pid);
+                break;
+        }
+    } else {
+        switch (signal) {
+            case SIGKILL:
+                /*xgettext: primary alert message for killing multiple processes*/
+                primary = g_strdup_printf (ngettext("Are you sure you want to kill the selected process?", 
+                                                    "Are you sure you want to kill the %d selected processes?", selected_count),
+                                           selected_count);
+            break;
+            case SIGTERM:
+                /*xgettext: primary alert message for ending multiple processes*/
+                primary = g_strdup_printf (ngettext("Are you sure you want to end the selected process?", 
+                                                    "Are you sure you want to end the %d selected processes?", selected_count),
+                                           selected_count);
+            break;
+            default: // SIGSTOP
+                /*xgettext: primary alert message for stopping multiple processes*/
+                primary = g_strdup_printf (ngettext("Are you sure you want to stop the selected process?", 
+                                                    "Are you sure you want to stop the %d selected processes?", selected_count),
+                                           selected_count);
+            break;
+        }
+    }
+    
+    switch (signal) {
+        case SIGKILL:
+            /*xgettext: secondary alert message*/
+            secondary = _("Killing a process may destroy data, break the "
+                          "session or introduce a security risk. "
+                          "Only unresponsive processes should be killed.");
+            button_text = ngettext("_Kill Process", "_Kill Processes", selected_count);
+            break;
+        case SIGTERM:
+            /*xgettext: secondary alert message*/
+            secondary = _("Ending a process may destroy data, break the "
+                          "session or introduce a security risk. "
+                          "Only unresponsive processes should be ended.");
+            button_text = ngettext("_End Process", "_End Processes", selected_count);
+            break;
+        default: // SIGSTOP
+            /*xgettext: secondary alert message*/
+            secondary = _("Stopping a process may destroy data, break the "
+                          "session or introduce a security risk. "
+                          "Only unresponsive processes should be stopped.");
+            button_text = ngettext("_Stop Process", "_Stop Processes", selected_count);
+            break;
+    }
+
+    kill_alert_dialog = GTK_MESSAGE_DIALOG (gtk_message_dialog_new (GTK_WINDOW (app->main_window),
+                                                static_cast<GtkDialogFlags>(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+                                                GTK_MESSAGE_WARNING,
+                                                GTK_BUTTONS_NONE,
+                                                "%s",
+                                                primary));
+    g_free (primary);
+
+    gtk_message_dialog_format_secondary_text (kill_alert_dialog,
+                                              "%s",
+                                              secondary);
+
+    gtk_dialog_add_button (GTK_DIALOG (kill_alert_dialog),
+                           _("_Cancel"), GTK_RESPONSE_CANCEL);
+
+    confirm_button = gtk_dialog_add_button (GTK_DIALOG (kill_alert_dialog),
+                                            button_text, GTK_RESPONSE_OK);
+    gtk_style_context_add_class (gtk_widget_get_style_context (confirm_button),
+                                 GTK_STYLE_CLASS_DESTRUCTIVE_ACTION);
+
+    gtk_dialog_set_default_response (GTK_DIALOG (kill_alert_dialog),
+                                     GTK_RESPONSE_CANCEL);
+
+    g_signal_connect (G_OBJECT (kill_alert_dialog), "response",
+                      G_CALLBACK (kill_dialog_button_pressed), kargs);
+
+    gtk_widget_show_all (GTK_WIDGET (kill_alert_dialog));
+}
+
+static void
+renice_scale_changed (GtkAdjustment *adj, gpointer data)
+{
+    GtkLabel *label = GTK_LABEL (data);
+
+    new_nice_value = int(gtk_adjustment_get_value (adj));
+    gchar* text = g_strdup(procman::get_nice_level_with_priority (new_nice_value));
+    gtk_label_set_text (label, text);
+    g_free(text);
+
+}
+
+static void
+renice_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
+{
+    GsmApplication *app = static_cast<GsmApplication *>(data);
+    if (id == 100) {
+        if (new_nice_value == -100)
+            return;
+        renice(app, new_nice_value);
+    }
+
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+    renice_dialog = NULL;
+}
+
+void
+procdialog_create_renice_dialog (GsmApplication *app)
+{
+    ProcInfo *info;
+    
+    GtkLabel *label;
+    GtkLabel *priority_label;
+    GtkAdjustment *renice_adj;
+    GtkBuilder *builder;
+    gchar     *text;
+    gchar     *dialog_title;
+
+    if (renice_dialog)
+        return;
+
+    gtk_tree_selection_selected_foreach (app->selection, get_last_selected,
+                                         &info);
+    gint selected_count = gtk_tree_selection_count_selected_rows (app->selection);
+    if (!info)
+        return;
+
+    builder = gtk_builder_new();
+    gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/renice.ui", NULL);
+
+    renice_dialog = GTK_DIALOG (gtk_builder_get_object (builder, "renice_dialog"));
+    if ( selected_count == 1 ) {
+        dialog_title = g_strdup_printf (_("Change Priority of Process “%s” (PID: %u)"),
+                                        info->name.c_str(), info->pid);
+    } else {
+        dialog_title = g_strdup_printf (ngettext("Change Priority of the selected process", "Change Priority of %d selected processes", selected_count),
+                                        selected_count);
+    }
+
+    gtk_window_set_title (GTK_WINDOW(renice_dialog), dialog_title);
+    
+    g_free (dialog_title);
+
+    gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
+    new_nice_value = -100;
+
+    renice_adj = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "renice_adj"));
+    gtk_adjustment_configure( GTK_ADJUSTMENT(renice_adj), info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
+
+    new_nice_value = 0;
+    
+    priority_label =  GTK_LABEL (gtk_builder_get_object (builder, "priority_label"));
+    gtk_label_set_label (priority_label, procman::get_nice_level_with_priority (info->nice));
+
+    text = g_strconcat("<small><i><b>", _("Note:"), "</b> ",
+                       _("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
+                       "</i></small>", NULL);
+    label = GTK_LABEL (gtk_builder_get_object (builder, "note_label"));
+    gtk_label_set_label (label, _(text));
+    gtk_label_set_line_wrap (label, TRUE);
+    g_free (text);
+
+    g_signal_connect (G_OBJECT (renice_dialog), "response",
+                      G_CALLBACK (renice_dialog_button_pressed), app);
+    g_signal_connect (G_OBJECT (renice_adj), "value_changed",
+                      G_CALLBACK (renice_scale_changed), priority_label);
+
+    gtk_window_set_transient_for (GTK_WINDOW (renice_dialog), GTK_WINDOW (GsmApplication::get()->main_window));
+    gtk_widget_show_all (GTK_WIDGET (renice_dialog));
+
+    gtk_builder_connect_signals (builder, NULL);
+
+    g_object_unref (G_OBJECT (builder));
+}
+
+
+
+static char *
+procman_action_to_command(ProcmanActionType type,
+                          gint pid,
+                          gint extra_value)
+{
+    switch (type) {
+        case PROCMAN_ACTION_KILL:
+            return g_strdup_printf("kill -s %d %d", extra_value, pid);
+        case PROCMAN_ACTION_RENICE:
+            return g_strdup_printf("renice %d %d", extra_value, pid);
+        default:
+            g_assert_not_reached();
+    }
+}
+
+
+gboolean
+multi_root_check (char *command)
+{
+    if (procman_has_pkexec ()) {
+        return gsm_pkexec_create_root_password_dialog (command);
+    }
+
+    if (procman_has_gksu ()) {
+        return gsm_gksu_create_root_password_dialog (command);
+    }
+
+    if (procman_has_gnomesu ()) {
+        return gsm_gnomesu_create_root_password_dialog (command);
+    }
+
+    return FALSE;
+}
+
+/*
+ * type determines whether if dialog is for killing process or renice.
+ * type == PROCMAN_ACTION_KILL,   extra_value -> signal to send
+ * type == PROCMAN_ACTION_RENICE, extra_value -> new priority.
+ */
+gboolean
+procdialog_create_root_password_dialog(ProcmanActionType type,
+                                       GsmApplication *app,
+                                       gint pid,
+                                       gint extra_value)
+{
+    char * command;
+    gboolean ret = FALSE;
+
+    command = procman_action_to_command(type, pid, extra_value);
+
+    procman_debug("Trying to run '%s' as root", command);
+
+    if (procman_has_pkexec())
+        ret = gsm_pkexec_create_root_password_dialog(command);
+    else if (procman_has_gksu())
+        ret = gsm_gksu_create_root_password_dialog(command);
+    else if (procman_has_gnomesu())
+        ret = gsm_gnomesu_create_root_password_dialog(command);
+
+    g_free(command);
+    return ret;
+}
diff --git a/src/procdialogs.h b/src/procdialogs.h
new file mode 100644
index 0000000..93fad17
--- /dev/null
+++ b/src/procdialogs.h
@@ -0,0 +1,53 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman - dialogs
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#ifndef _GSM_PROCDIALOGS_H_
+#define _GSM_PROCDIALOGS_H_
+
+
+#include <glib.h>
+#include "application.h"
+
+/* These are the actual range of settable values. Values outside this range
+   are scaled back to these limits. So show these limits in the slider
+*/
+#ifdef __linux__
+const int RENICE_VAL_MIN = -20;
+const int RENICE_VAL_MAX = 19;
+#else /* ! linux */
+const int RENICE_VAL_MIN = -20;
+const int RENICE_VAL_MAX = 20;
+#endif
+
+
+typedef enum
+{
+    PROCMAN_ACTION_RENICE,
+    PROCMAN_ACTION_KILL
+} ProcmanActionType;
+
+
+void                    procdialog_create_kill_dialog (GsmApplication *app, int signal);
+void                    procdialog_create_renice_dialog (GsmApplication *app);
+gboolean                multi_root_check (char *command);
+gboolean                procdialog_create_root_password_dialog (ProcmanActionType type,
+                                                                GsmApplication *app,
+                                                                gint pid, gint extra_value);
+void                    procdialog_create_memmaps_dialog (GsmApplication *app);
+
+#endif /* _GSM_PROCDIALOGS_H_ */
diff --git a/src/procproperties.cpp b/src/procproperties.cpp
new file mode 100644
index 0000000..7476448
--- /dev/null
+++ b/src/procproperties.cpp
@@ -0,0 +1,251 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Process properties dialog
+ * Copyright (C) 2010 Krishnan Parthasarathi <krishnan.parthasarathi@gmail.com>
+ *                    Robert Ancell <robert.ancell@canonical.com>
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <config.h>
+
+#include <glib/gi18n.h>
+#include <glibtop/procmem.h>
+#include <glibtop/procmap.h>
+#include <glibtop/procstate.h>
+
+#include "application.h"
+#include "procproperties.h"
+#include "proctable.h"
+#include "util.h"
+#include "legacy/e_date.h"
+
+enum
+{
+    COL_PROP = 0,
+    COL_VAL,
+    NUM_COLS,
+};
+
+typedef struct _proc_arg {
+    const gchar *prop;
+    gchar *val;
+} proc_arg;
+
+static gchar*
+format_memsize(guint64 size)
+{
+    if (size == 0)
+        return g_strdup(_("N/A"));
+    else
+        return g_format_size_full(size, G_FORMAT_SIZE_IEC_UNITS);
+}
+
+static void
+fill_proc_properties (GtkTreeView *tree, ProcInfo *info)
+{
+    guint i;
+    GtkListStore *store;
+    
+    if (!info)
+        return;
+
+    get_process_memory_writable (info);
+
+    proc_arg proc_props[] = {
+        { N_("Process Name"), g_strdup_printf("%s", info->name.c_str())},
+        { N_("User"), g_strdup_printf("%s (%d)", info->user.c_str(), info->uid)},
+        { N_("Status"), g_strdup(format_process_state(info->status))},
+        { N_("Memory"), format_memsize(info->mem)},
+        { N_("Virtual Memory"), format_memsize(info->vmsize)},
+        { N_("Resident Memory"), format_memsize(info->memres)},
+        { N_("Writable Memory"), format_memsize(info->memwritable)},
+        { N_("Shared Memory"), format_memsize(info->memshared)},
+#ifdef HAVE_WNCK
+        { N_("X Server Memory"), format_memsize(info->memxserver)},
+#endif
+        { N_("CPU"), g_strdup_printf("%.2f%%", info->pcpu)},
+        { N_("CPU Time"), procman::format_duration_for_display(100 * info->cpu_time / GsmApplication::get()->frequency) },
+        { N_("Started"), procman_format_date_for_display(info->start_time) },
+        { N_("Nice"), g_strdup_printf("%d", info->nice)},
+        { N_("Priority"), g_strdup_printf("%s", procman::get_nice_level(info->nice)) },
+        { N_("ID"), g_strdup_printf("%d", info->pid)},
+        { N_("Security Context"), not info->security_context.empty()?g_strdup_printf("%s", info->security_context.c_str()):g_strdup(_("N/A"))},
+        { N_("Command Line"), g_strdup_printf("%s", info->arguments.c_str())},
+        { N_("Waiting Channel"), g_strdup_printf("%s", info->wchan.c_str())},
+        { N_("Control Group"), not info->cgroup_name.empty()?g_strdup_printf("%s", info->cgroup_name.c_str()):g_strdup(_("N/A"))},
+        { NULL, NULL}
+    };
+
+    store = GTK_LIST_STORE(gtk_tree_view_get_model(tree));
+    for (i = 0; proc_props[i].prop; i++) {
+        GtkTreeIter iter;
+
+        if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL(store), &iter, NULL, i)) {
+            gtk_list_store_append(store, &iter);
+            gtk_list_store_set(store, &iter, COL_PROP, gettext(proc_props[i].prop), -1);
+        }
+
+        gtk_list_store_set(store, &iter, COL_VAL, g_strstrip(proc_props[i].val), -1);
+        g_free(proc_props[i].val);
+    }
+}
+
+static void
+update_procproperties_dialog (GtkTreeView *tree)
+{
+    ProcInfo *info;
+
+    pid_t pid = GPOINTER_TO_UINT(static_cast<pid_t*>(g_object_get_data (G_OBJECT (tree), "selected_info")));
+    info = GsmApplication::get()->processes.find(pid);
+
+    fill_proc_properties(tree, info);
+}
+
+static void
+close_procprop_dialog (GtkDialog *dialog, gint id, gpointer data)
+{
+    GtkTreeView *tree = static_cast<GtkTreeView*>(data);
+    guint timer;
+
+    timer = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tree), "timer"));
+    g_source_remove (timer);
+
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
+static GtkTreeView *
+create_procproperties_tree (GsmApplication *app, ProcInfo *info)
+{
+    GtkTreeView *tree;
+    GtkListStore *model;
+    GtkTreeViewColumn *column;
+    GtkCellRenderer *cell;
+    gint i;
+
+    model = gtk_list_store_new (NUM_COLS,
+                                G_TYPE_STRING,	/* Property */
+                                G_TYPE_STRING	/* Value */
+        );
+
+    tree = GTK_TREE_VIEW (gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)));
+    g_object_unref (G_OBJECT (model));
+
+    for (i = 0; i < NUM_COLS; i++) {
+        cell = gtk_cell_renderer_text_new ();
+
+        column = gtk_tree_view_column_new_with_attributes (NULL,
+                                                           cell,
+                                                           "text", i,
+                                                           NULL);
+        gtk_tree_view_column_set_resizable (column, TRUE);
+        gtk_tree_view_append_column (tree, column);
+    }
+
+    gtk_tree_view_set_headers_visible (tree, FALSE);
+    fill_proc_properties(tree, info);
+
+    return tree;
+}
+
+static gboolean
+procprop_timer (gpointer data)
+{
+    GtkTreeView *tree = static_cast<GtkTreeView*>(data);
+    GtkTreeModel *model;
+
+    model = gtk_tree_view_get_model (tree);
+    g_assert(model);
+
+    update_procproperties_dialog (tree);
+
+    return TRUE;
+}
+
+static void
+create_single_procproperties_dialog (GtkTreeModel *model, GtkTreePath *path,
+                                     GtkTreeIter *iter, gpointer data)
+{
+    GsmApplication *app = static_cast<GsmApplication *>(data);
+
+    GtkDialog *procpropdialog;
+    GtkBox *dialog_vbox, *vbox;
+    GtkBox *cmd_hbox;
+    gchar *label;
+    GtkScrolledWindow *scrolled;
+    GtkTreeView *tree;
+    ProcInfo *info;
+    guint timer;
+
+    gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+
+    if (!info)
+        return;
+
+    procpropdialog = GTK_DIALOG (g_object_new (GTK_TYPE_DIALOG, 
+                                               "use-header-bar", TRUE, NULL));
+
+    label = g_strdup_printf( _("%s (PID %u)"), info->name.c_str(), info->pid);
+    gtk_window_set_title (GTK_WINDOW (procpropdialog), label);
+    g_free (label);
+
+    gtk_window_set_destroy_with_parent (GTK_WINDOW (procpropdialog), TRUE);
+
+    gtk_window_set_resizable (GTK_WINDOW (procpropdialog), TRUE);
+    gtk_window_set_default_size (GTK_WINDOW (procpropdialog), 575, 400);
+    gtk_container_set_border_width (GTK_CONTAINER (procpropdialog), 5);
+
+    vbox = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (procpropdialog)));
+    gtk_box_set_spacing (vbox, 2);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+    dialog_vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6));
+    gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
+    gtk_box_pack_start (vbox, GTK_WIDGET (dialog_vbox), TRUE, TRUE, 0);
+
+    cmd_hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12));
+    gtk_box_pack_start (dialog_vbox, GTK_WIDGET (cmd_hbox), FALSE, FALSE, 0);
+
+    scrolled = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
+    gtk_scrolled_window_set_policy (scrolled,
+                                    GTK_POLICY_AUTOMATIC,
+                                    GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_set_shadow_type (scrolled,
+                                         GTK_SHADOW_IN);
+
+    tree = create_procproperties_tree (app, info);
+    gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (tree));
+    g_object_set_data (G_OBJECT (tree), "selected_info", GUINT_TO_POINTER (info->pid));
+
+    gtk_box_pack_start (dialog_vbox, GTK_WIDGET (scrolled), TRUE, TRUE, 0);
+    gtk_widget_show_all (GTK_WIDGET (scrolled));
+
+    g_signal_connect (G_OBJECT (procpropdialog), "response",
+                      G_CALLBACK (close_procprop_dialog), tree);
+
+    gtk_window_set_transient_for (GTK_WINDOW (procpropdialog), GTK_WINDOW (GsmApplication::get()->main_window));
+    gtk_widget_show_all (GTK_WIDGET (procpropdialog));
+
+    timer = g_timeout_add_seconds (5, procprop_timer, tree);
+    g_object_set_data (G_OBJECT (tree), "timer", GUINT_TO_POINTER (timer));
+
+    update_procproperties_dialog (tree);
+}
+
+void
+create_procproperties_dialog (GsmApplication *app)
+{
+    gtk_tree_selection_selected_foreach (app->selection, create_single_procproperties_dialog,
+                                         app);
+}
diff --git a/src/procproperties.h b/src/procproperties.h
new file mode 100644
index 0000000..da04ae9
--- /dev/null
+++ b/src/procproperties.h
@@ -0,0 +1,30 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Process properties dialog
+ * Copyright (C) 2010 Krishnan Parthasarathi <krishnan.parthasarathi@gmail.com>
+ *                    Robert Ancell <robert.ancell@canonical.com>
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _GSM_PROCPROPERTIES_H_
+#define _GSM_PROCPROPERTIES_H_
+
+#include <glib.h>
+
+#include "application.h"
+
+void create_procproperties_dialog (GsmApplication *app);
+
+#endif /* _GSM_PROCPROPERTIES_H_ */
diff --git a/src/proctable.cpp b/src/proctable.cpp
new file mode 100644
index 0000000..078750c
--- /dev/null
+++ b/src/proctable.cpp
@@ -0,0 +1,1280 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman tree view and process updating
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#include <config.h>
+
+
+#include <string.h>
+#include <math.h>
+#include <glib/gi18n.h>
+#include <glib/gprintf.h>
+#include <glibtop.h>
+#include <glibtop/proclist.h>
+#include <glibtop/procstate.h>
+#include <glibtop/procio.h>
+#include <glibtop/procmem.h>
+#include <glibtop/procmap.h>
+#include <glibtop/proctime.h>
+#include <glibtop/procuid.h>
+#include <glibtop/procargs.h>
+#include <glibtop/prockernel.h>
+#include <glibtop/mem.h>
+#include <glibtop/swap.h>
+#include <sys/stat.h>
+#include <pwd.h>
+#include <time.h>
+
+#include <set>
+#include <list>
+
+#ifdef HAVE_WNCK
+#define WNCK_I_KNOW_THIS_IS_UNSTABLE
+#include <libwnck/libwnck.h>
+#endif
+
+#include "application.h"
+#include "proctable.h"
+#include "prettytable.h"
+#include "util.h"
+#include "interface.h"
+#include "selinux.h"
+#include "settings-keys.h"
+#include "cgroups.h"
+#include "legacy/treeview.h"
+#include "systemd.h"
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+
+ProcInfo* ProcList::find(pid_t pid)
+{
+    auto it = data.find(pid);
+    return (it == data.end() ? nullptr : &it->second);
+}
+
+static void
+cb_save_tree_state(gpointer, gpointer data)
+{
+    GsmApplication * const app = static_cast<GsmApplication *>(data);
+
+    gsm_tree_view_save_state (app->tree);
+}
+
+static void
+cb_proctree_destroying (GtkTreeView *self, gpointer data)
+{
+    g_signal_handlers_disconnect_by_func (self,
+                                          (gpointer) cb_save_tree_state,
+                                          data);
+
+    g_signal_handlers_disconnect_by_func (gtk_tree_view_get_model (self),
+                                          (gpointer) cb_save_tree_state,
+                                          data);
+}
+
+static gboolean
+cb_tree_button_pressed (GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    GtkTreePath *path;
+    GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
+
+    if (!gdk_event_triggers_context_menu ((GdkEvent *) event))
+        return FALSE;
+
+    if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (app->tree), event->x, event->y, &path, NULL, NULL, NULL))
+        return FALSE;
+
+    if (!gtk_tree_selection_path_is_selected (selection, path)) {
+        if (!(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
+            gtk_tree_selection_unselect_all (selection);
+        gtk_tree_selection_select_path (selection, path);
+    }
+
+    gtk_tree_path_free (path);
+
+    gtk_menu_popup_at_pointer (GTK_MENU (app->popup_menu), NULL);
+    return TRUE;
+}
+
+static gboolean
+cb_tree_popup_menu (GtkWidget *widget, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    gtk_menu_popup_at_pointer (GTK_MENU (app->popup_menu), NULL);
+
+    return TRUE;
+}
+
+void
+get_last_selected (GtkTreeModel *model, GtkTreePath *path,
+                   GtkTreeIter *iter, gpointer data)
+{
+    ProcInfo **info = (ProcInfo**) data;
+
+    gtk_tree_model_get (model, iter, COL_POINTER, info, -1);
+}
+
+static void
+cb_row_selected (GtkTreeSelection *selection, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    ProcInfo *selected_process = NULL;
+    gint selected_count = gtk_tree_selection_count_selected_rows (selection);
+
+    app->selection = selection;
+
+    gchar *button_text = ngettext("_End Process", "_End Processes", selected_count);
+    gtk_button_set_label (GTK_BUTTON(app->end_process_button), button_text);
+
+    /* get the most recent selected process and determine if there are
+    ** no selected processes
+    */
+    gtk_tree_selection_selected_foreach (selection, get_last_selected,
+                                         &selected_process);
+    if (selected_process) {
+        GVariant *priority;
+        gint nice = selected_process->nice;
+        if (nice < -7)
+            priority = g_variant_new_int32 (-20);
+        else if (nice < -2)
+            priority = g_variant_new_int32 (-5);
+        else if (nice < 3)
+            priority = g_variant_new_int32 (0);
+        else if (nice < 7)
+            priority = g_variant_new_int32 (5);
+        else
+            priority = g_variant_new_int32 (19);
+
+        GAction *action = g_action_map_lookup_action (G_ACTION_MAP (app->main_window),
+                                                      "priority");
+
+        g_action_change_state (action, priority);
+    }
+    update_sensitivity(app);
+}
+
+static gint
+cb_timeout (gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+    guint new_interval;
+
+    proctable_update (app);
+
+    if (app->smooth_refresh->get(new_interval)) {
+        app->timeout = g_timeout_add(new_interval,
+                                     cb_timeout,
+                                     app);
+        return G_SOURCE_REMOVE;
+    }
+
+    return G_SOURCE_CONTINUE;
+}
+
+static void
+cb_refresh_icons (GtkIconTheme *theme, gpointer data)
+{
+    GsmApplication *app = (GsmApplication *) data;
+
+    for (auto& v : app->processes) {
+        app->pretty_table->set_icon(v.second);
+    }
+
+    proctable_update (app);
+}
+
+static gboolean
+iter_matches_search_key (GtkTreeModel *model, GtkTreeIter *iter, const gchar *search_text)
+{
+    char *name;
+    char *user;
+    pid_t pid;
+    char *pids;
+    char *args;
+    gboolean found;
+    char *search_pattern;
+    char **keys;
+    Glib::RefPtr<Glib::Regex> regex;
+
+    gtk_tree_model_get (model, iter,
+                        COL_NAME, &name,
+                        COL_USER, &user,
+                        COL_PID, &pid,
+                        COL_ARGS, &args,
+                        -1);
+
+    pids = g_strdup_printf ("%d", pid);
+
+    keys = g_strsplit_set(search_text, " |", -1);
+    search_pattern = g_strjoinv ("|", keys);
+    try {
+        regex = Glib::Regex::create(search_pattern, Glib::REGEX_CASELESS);
+    } catch (const Glib::Error& ex) {
+        regex = Glib::Regex::create(Glib::Regex::escape_string(search_pattern), Glib::REGEX_CASELESS);
+    }
+
+    found = (name && regex->match(name)) || (user && regex->match(user))
+            || (pids && regex->match(pids)) || (args && regex->match(args));
+
+    g_strfreev (keys);
+    g_free (search_pattern);
+    g_free (name);
+    g_free (user);
+    g_free (args);
+    g_free (pids);
+
+    return found;
+}
+
+static gboolean
+process_visibility_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+    GsmApplication * const app = static_cast<GsmApplication *>(data);
+    const gchar * search_text = app->search_entry == NULL ? "" : gtk_entry_get_text (GTK_ENTRY (app->search_entry));
+    GtkTreePath *tree_path = gtk_tree_model_get_path (model, iter);
+
+    if (strcmp (search_text, "") == 0) {
+        gtk_tree_path_free (tree_path);
+        return TRUE;
+    }
+
+	// in case we are in dependencies view, we show (and expand) rows not matching the text, but having a matching child
+    gboolean match = false;
+    if (app->settings->get_boolean (GSM_SETTING_SHOW_DEPENDENCIES)) {
+        GtkTreeIter child;
+        if (gtk_tree_model_iter_children (model, &child, iter)) {
+            gboolean child_match = FALSE;
+            do {
+                child_match = process_visibility_func (model, &child, data);
+            } while (gtk_tree_model_iter_next (model, &child) && !child_match);
+            match = child_match;
+        }
+
+        match |= iter_matches_search_key (model, iter, search_text);
+        if (match && (strlen (search_text) > 0)) {
+            gtk_tree_view_expand_to_path (GTK_TREE_VIEW (app->tree), tree_path);
+        }
+
+    } else {
+        match = iter_matches_search_key (model, iter, search_text);
+    }
+
+    gtk_tree_path_free (tree_path);
+
+    return match;
+}
+
+static void
+proctable_clear_tree (GsmApplication * const app)
+{
+    GtkTreeModel *model;
+
+    model =  gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (
+             gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT (
+             gtk_tree_view_get_model (GTK_TREE_VIEW(app->tree))))));
+
+    gtk_tree_store_clear (GTK_TREE_STORE (model));
+
+    proctable_free_table (app);
+
+    update_sensitivity(app);
+}
+
+static void
+cb_show_dependencies_changed(Gio::Settings& settings, Glib::ustring key, GsmApplication* app) {
+    if (app->timeout) {
+        gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (app->tree),
+                                          settings.get_boolean (GSM_SETTING_SHOW_DEPENDENCIES));
+
+        proctable_clear_tree (app);
+        proctable_update (app);
+    }
+}
+
+static void
+cb_show_whose_processes_changed(Gio::Settings& settings, Glib::ustring key, GsmApplication* app) {
+    if (app->timeout) {
+        proctable_clear_tree (app);
+        proctable_update (app);
+    }
+}
+
+GsmTreeView *
+proctable_new (GsmApplication * const app)
+{
+    GsmTreeView *proctree;
+    GtkTreeStore *model;
+    GtkTreeModelFilter *model_filter;
+    GtkTreeModelSort *model_sort;
+    GtkTreeSelection *selection;
+
+    GtkTreeViewColumn *column;
+    GtkCellRenderer *cell_renderer;
+    const gchar *titles[] = {
+        N_("Process Name"),
+        N_("User"),
+        N_("Status"),
+        N_("Virtual Memory"),
+        N_("Resident Memory"),
+        N_("Writable Memory"),
+        N_("Shared Memory"),
+        N_("X Server Memory"),
+        /* xgettext:no-c-format */ N_("% CPU"),
+        N_("CPU Time"),
+        N_("Started"),
+        N_("Nice"),
+        N_("ID"),
+        N_("Security Context"),
+        N_("Command Line"),
+        N_("Memory"),
+        /* xgettext: combined noun, the function the process is waiting in, see wchan ps(1) */
+        N_("Waiting Channel"),
+        N_("Control Group"),
+        N_("Unit"),
+        N_("Session"),
+        /* TRANSLATORS: Seat = i.e. the physical seat the session of the process belongs to, only
+	for multi-seat environments. See http://en.wikipedia.org/wiki/Multiseat_configuration */
+        N_("Seat"),
+        N_("Owner"),
+        N_("Disk read total"),
+        N_("Disk write total"),
+        N_("Disk read"),
+        N_("Disk write"),
+        N_("Priority"),
+        NULL,
+        "POINTER"
+    };
+
+    gint i;
+    auto settings = g_settings_get_child (app->settings->gobj (), GSM_SETTINGS_CHILD_PROCESSES);
+    model = gtk_tree_store_new (NUM_COLUMNS,
+                                G_TYPE_STRING,      /* Process Name */
+                                G_TYPE_STRING,      /* User         */
+                                G_TYPE_UINT,        /* Status       */
+                                G_TYPE_ULONG,       /* VM Size      */
+                                G_TYPE_ULONG,       /* Resident Memory */
+                                G_TYPE_ULONG,       /* Writable Memory */
+                                G_TYPE_ULONG,       /* Shared Memory */
+                                G_TYPE_ULONG,       /* X Server Memory */
+                                G_TYPE_DOUBLE,      /* % CPU        */
+                                G_TYPE_UINT64,      /* CPU time     */
+                                G_TYPE_ULONG,       /* Started      */
+                                G_TYPE_INT,         /* Nice         */
+                                G_TYPE_UINT,        /* ID           */
+                                G_TYPE_STRING,      /* Security Context */
+                                G_TYPE_STRING,      /* Arguments    */
+                                G_TYPE_ULONG,       /* Memory       */
+                                G_TYPE_STRING,      /* wchan        */
+                                G_TYPE_STRING,      /* Cgroup       */
+                                G_TYPE_STRING,      /* Unit         */
+                                G_TYPE_STRING,      /* Session      */
+                                G_TYPE_STRING,      /* Seat         */
+                                G_TYPE_STRING,      /* Owner        */
+                                G_TYPE_UINT64,      /* Disk read total */
+                                G_TYPE_UINT64,      /* Disk write total*/
+                                G_TYPE_UINT64,      /* Disk read    */
+                                G_TYPE_UINT64,      /* Disk write   */
+                                G_TYPE_STRING,      /* Priority     */
+                                GDK_TYPE_PIXBUF,    /* Icon         */
+                                G_TYPE_POINTER,     /* ProcInfo     */
+                                G_TYPE_STRING       /* Sexy tooltip */
+        );
+
+    model_filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (model), NULL));
+
+    gtk_tree_model_filter_set_visible_func(model_filter, process_visibility_func, app, NULL);
+
+    model_sort = GTK_TREE_MODEL_SORT (gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (model_filter)));
+
+    proctree = gsm_tree_view_new (settings, TRUE);
+    gtk_tree_view_set_model (GTK_TREE_VIEW (proctree), GTK_TREE_MODEL (model_sort));
+
+    gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (proctree), COL_TOOLTIP);
+    gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (proctree), app->settings->get_boolean (GSM_SETTING_SHOW_DEPENDENCIES));
+    gtk_tree_view_set_enable_search (GTK_TREE_VIEW (proctree), FALSE);
+    g_object_unref (G_OBJECT (model));
+
+    column = gtk_tree_view_column_new ();
+
+    cell_renderer = gtk_cell_renderer_pixbuf_new ();
+    gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);
+    gtk_tree_view_column_set_attributes (column, cell_renderer,
+                                         "pixbuf", COL_PIXBUF,
+                                         NULL);
+
+    cell_renderer = gtk_cell_renderer_text_new ();
+    gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);
+    gtk_tree_view_column_set_attributes (column, cell_renderer,
+                                         "text", COL_NAME,
+                                         NULL);
+    gtk_tree_view_column_set_title (column, _(titles[0]));
+
+    gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
+    gtk_tree_view_column_set_resizable (column, TRUE);
+    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_min_width (column, 1);
+    gtk_tree_view_column_set_reorderable(column, TRUE);
+
+    gsm_tree_view_append_and_bind_column (proctree, column);
+    gtk_tree_view_set_expander_column (GTK_TREE_VIEW (proctree), column);
+
+    gtk_tree_view_column_set_expand (column, TRUE);
+
+    for (i = COL_USER; i <= COL_PRIORITY; i++) {
+        GtkTreeViewColumn *col;
+        GtkCellRenderer *cell;
+        PangoAttrList *attrs = NULL;
+
+#ifndef HAVE_WNCK
+        if (i == COL_MEMXSERVER)
+          continue;
+#endif
+
+        if (i == COL_MEMWRITABLE)
+            continue;
+
+        cell = gtk_cell_renderer_text_new();
+        col = gtk_tree_view_column_new();
+        gtk_tree_view_column_pack_start(col, cell, TRUE);
+        gtk_tree_view_column_set_title(col, _(titles[i]));
+        gtk_tree_view_column_set_resizable(col, TRUE);
+        gtk_tree_view_column_set_sort_column_id(col, i);
+        gtk_tree_view_column_set_reorderable(col, TRUE);
+        gsm_tree_view_append_and_bind_column (proctree, col);
+
+        // type
+        switch (i) {
+#ifdef HAVE_WNCK
+            case COL_MEMXSERVER:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::size_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+#endif
+            case COL_VMSIZE:
+            case COL_MEMRES:
+            case COL_MEMSHARED:
+            case COL_MEM:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::size_na_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+            case COL_CPU:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::percentage_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+            case COL_CPU_TIME:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::duration_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+
+            case COL_START_TIME:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::time_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+
+            case COL_STATUS:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::status_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+            case COL_DISK_READ_TOTAL:
+            case COL_DISK_WRITE_TOTAL:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::size_na_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+                break;
+            case COL_DISK_READ_CURRENT:
+            case COL_DISK_WRITE_CURRENT:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::io_rate_cell_data_func,
+                                                        GUINT_TO_POINTER(i),
+                                                        NULL);
+
+                break;
+            case COL_PRIORITY:
+                gtk_tree_view_column_set_cell_data_func(col, cell,
+                                                        &procman::priority_cell_data_func,
+                                                        GUINT_TO_POINTER(COL_NICE),
+                                                        NULL);
+                break;
+            default:
+                gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);
+                break;
+        }
+
+        // Tabular Numbers
+        switch (i) {
+#ifdef HAVE_WNCK
+            case COL_MEMXSERVER:
+#endif
+            case COL_PID:
+            case COL_VMSIZE:
+            case COL_MEMRES:
+            case COL_MEMSHARED:
+            case COL_MEM:
+            case COL_CPU:
+            case COL_CPU_TIME:
+            case COL_DISK_READ_TOTAL:
+            case COL_DISK_WRITE_TOTAL:
+            case COL_DISK_READ_CURRENT:
+            case COL_DISK_WRITE_CURRENT:
+            case COL_START_TIME:
+            case COL_NICE:
+            case COL_WCHAN:
+                attrs = make_tnum_attr_list ();
+                g_object_set (cell, "attributes", attrs, NULL);
+                g_clear_pointer (&attrs, pango_attr_list_unref);
+                break;
+            default:
+                break;
+        }
+
+        // sorting
+        switch (i) {
+#ifdef HAVE_WNCK
+            case COL_MEMXSERVER:
+#endif
+            case COL_VMSIZE:
+            case COL_MEMRES:
+            case COL_MEMSHARED:
+            case COL_MEM:
+            case COL_CPU:
+            case COL_CPU_TIME:
+            case COL_DISK_READ_TOTAL:
+            case COL_DISK_WRITE_TOTAL:
+            case COL_DISK_READ_CURRENT:
+            case COL_DISK_WRITE_CURRENT:
+            case COL_START_TIME:
+                gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model_sort), i,
+                                                 procman::number_compare_func,
+                                                 GUINT_TO_POINTER (i),
+                                                 NULL);
+                break;
+            case COL_PRIORITY:
+                gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model_sort), i,
+                                                 procman::priority_compare_func,
+                                                 GUINT_TO_POINTER (COL_NICE), NULL);
+                break;
+            default:
+                break;
+        }
+
+        // xalign
+        switch(i)
+        {
+            case COL_VMSIZE:
+            case COL_MEMRES:
+            case COL_MEMSHARED:
+#ifdef HAVE_WNCK
+            case COL_MEMXSERVER:
+#endif
+            case COL_CPU:
+            case COL_NICE:
+            case COL_PID:
+            case COL_DISK_READ_TOTAL:
+            case COL_DISK_WRITE_TOTAL:
+            case COL_DISK_READ_CURRENT:
+            case COL_DISK_WRITE_CURRENT:
+            case COL_CPU_TIME:
+            case COL_MEM:
+                g_object_set(G_OBJECT(cell), "xalign", 1.0f, NULL);
+                break;
+        }
+
+        gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
+        // sizing
+        switch (i) {
+            case COL_ARGS:
+                gtk_tree_view_column_set_min_width(col, 150);
+                break;
+            default:
+                gtk_tree_view_column_set_min_width(column, 20);
+                break;
+        }
+
+        if (i == COL_ARGS) {
+            gtk_tree_view_column_set_expand(col, TRUE);
+        } else {
+            gtk_tree_view_column_set_expand(col, FALSE);
+        }
+    }
+    app->tree = proctree;
+    app->top_of_tree = NULL;
+    app->last_vscroll_max = 0;
+    app->last_vscroll_value = 0;
+
+    if (!cgroups_enabled ())
+        gsm_tree_view_add_excluded_column (proctree, COL_CGROUP);
+
+    if (!procman::systemd_logind_running())
+    {
+        gsm_tree_view_add_excluded_column (proctree, COL_UNIT);
+        gsm_tree_view_add_excluded_column (proctree, COL_SESSION);
+        gsm_tree_view_add_excluded_column (proctree, COL_SEAT);
+        gsm_tree_view_add_excluded_column (proctree, COL_OWNER);
+    }
+
+    if (!can_show_security_context_column ())
+        gsm_tree_view_add_excluded_column (proctree, COL_SECURITYCONTEXT);
+
+    gsm_tree_view_load_state (proctree);
+
+    GtkIconTheme* theme = gtk_icon_theme_get_default();
+    g_signal_connect(G_OBJECT (theme), "changed", G_CALLBACK (cb_refresh_icons), app);
+
+    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree));
+    app->selection = selection;
+
+    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
+
+    g_signal_connect (G_OBJECT (selection),
+                      "changed",
+                      G_CALLBACK (cb_row_selected), app);
+    g_signal_connect (G_OBJECT (proctree), "popup_menu",
+                      G_CALLBACK (cb_tree_popup_menu), app);
+    g_signal_connect (G_OBJECT (proctree), "button_press_event",
+                      G_CALLBACK (cb_tree_button_pressed), app);
+
+    g_signal_connect (G_OBJECT (proctree), "destroy",
+                      G_CALLBACK (cb_proctree_destroying),
+                      app);
+
+    g_signal_connect (G_OBJECT (proctree), "columns-changed",
+                      G_CALLBACK (cb_save_tree_state), app);
+
+    g_signal_connect (G_OBJECT (model_sort), "sort-column-changed",
+                      G_CALLBACK (cb_save_tree_state), app);
+
+    app->settings->signal_changed(GSM_SETTING_SHOW_DEPENDENCIES).connect([app](const Glib::ustring& key) {
+        cb_show_dependencies_changed(*app->settings.operator->(), key, app);
+    });
+
+    app->settings->signal_changed(GSM_SETTING_SHOW_WHOSE_PROCESSES).connect([app](const Glib::ustring& key) {
+        cb_show_whose_processes_changed(*app->settings.operator->(), key, app);
+    });
+
+    gtk_widget_show (GTK_WIDGET (proctree));
+
+    return proctree;
+}
+
+static void
+get_process_name (ProcInfo *info,
+                  const gchar *cmd, const GStrv args)
+{
+    if (args) {
+        // look for /usr/bin/very_long_name
+        // and also /usr/bin/interpreter /usr/.../very_long_name
+        // which may have use prctl to alter 'cmd' name
+        for (int i = 0; i != 2 && args[i]; ++i) {
+            char* basename;
+            basename = g_path_get_basename(args[i]);
+
+            if (g_str_has_prefix(basename, cmd)) {
+                info->name = make_string(basename);
+                return;
+            }
+
+            g_free(basename);
+        }
+    }
+    info->name = cmd;
+}
+
+std::string
+ProcInfo::lookup_user(guint uid)
+{
+    static std::map<guint, std::string> users;
+    auto p = users.insert({uid, ""});
+
+    // procman_debug("User lookup for uid %u: %s", uid, (p.second ? "MISS" : "HIT"));
+
+    if (p.second) {
+        struct passwd* pwd;
+        pwd = getpwuid(uid);
+
+        if (pwd && pwd->pw_name)
+            p.first->second = pwd->pw_name;
+        else {
+            char username[16];
+            g_sprintf(username, "%u", uid);
+            p.first->second = username;
+        }
+    }
+
+    return p.first->second;
+}
+
+void
+ProcInfo::set_user(guint uid)
+{
+    if (G_LIKELY(this->uid == uid))
+        return;
+
+    this->uid = uid;
+    this->user = lookup_user(uid);
+}
+
+void
+get_process_memory_writable (ProcInfo *info)
+{
+    glibtop_proc_map buf;
+    glibtop_map_entry *maps;
+
+    maps = glibtop_get_proc_map(&buf, info->pid);
+
+    const bool use_private_dirty = buf.flags & (1 << GLIBTOP_MAP_ENTRY_PRIVATE_DIRTY);
+
+    gulong memwritable = 0;
+    const unsigned number = buf.number;
+
+    for (unsigned i = 0; i < number; ++i) {
+        if (use_private_dirty) {
+            // clang++ 3.4 is not smart enough to move this invariant out of the loop
+            // but who cares ?
+            memwritable += maps[i].private_dirty;
+        }
+        else if (maps[i].perm & GLIBTOP_MAP_PERM_WRITE) {
+            memwritable += maps[i].size;
+        }
+    }
+
+    info->memwritable = memwritable;
+
+    g_free(maps);
+}
+
+static void
+get_process_memory_info(ProcInfo *info)
+{
+    glibtop_proc_mem procmem;
+
+#ifdef HAVE_WNCK
+    info->memxserver = 0;
+#ifdef GDK_WINDOWING_X11
+    if (GDK_IS_X11_DISPLAY (gdk_display_get_default ())) {
+        WnckResourceUsage xresources;
+
+        wnck_pid_read_resource_usage (gdk_display_get_default (),
+                                      info->pid,
+                                      &xresources);
+
+        info->memxserver = xresources.total_bytes_estimate;
+    }
+#endif
+#endif
+
+    glibtop_get_proc_mem(&procmem, info->pid);
+
+    info->vmsize    = procmem.vsize;
+    info->memres    = procmem.resident;
+    info->memshared = procmem.share;
+
+    info->mem = info->memres - info->memshared;
+#ifdef HAVE_WNCK
+    info->mem += info->memxserver;
+#endif
+}
+
+static void
+update_info_mutable_cols(ProcInfo *info)
+{
+    GtkTreeModel *model;
+    model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (
+            gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(
+            gtk_tree_view_get_model (GTK_TREE_VIEW(GsmApplication::get()->tree))))));
+
+    using procman::tree_store_update;
+
+    tree_store_update(model, &info->node, COL_STATUS, info->status);
+    tree_store_update(model, &info->node, COL_USER, info->user.c_str());
+    tree_store_update(model, &info->node, COL_VMSIZE, info->vmsize);
+    tree_store_update(model, &info->node, COL_MEMRES, info->memres);
+    tree_store_update(model, &info->node, COL_MEMSHARED, info->memshared);
+#ifdef HAVE_WNCK
+    tree_store_update(model, &info->node, COL_MEMXSERVER, info->memxserver);
+#endif
+    tree_store_update(model, &info->node, COL_CPU, info->pcpu);
+    tree_store_update(model, &info->node, COL_CPU_TIME, info->cpu_time);
+    tree_store_update(model, &info->node, COL_DISK_READ_TOTAL, info->disk_read_bytes_total);
+    tree_store_update(model, &info->node, COL_DISK_WRITE_TOTAL, info->disk_write_bytes_total);
+    tree_store_update(model, &info->node, COL_DISK_READ_CURRENT, info->disk_read_bytes_current);
+    tree_store_update(model, &info->node, COL_DISK_WRITE_CURRENT, info->disk_write_bytes_current);
+    tree_store_update(model, &info->node, COL_START_TIME, info->start_time);
+    tree_store_update(model, &info->node, COL_NICE, info->nice);
+    tree_store_update(model, &info->node, COL_MEM, info->mem);
+    tree_store_update(model, &info->node, COL_WCHAN, info->wchan.c_str());
+    tree_store_update(model, &info->node, COL_CGROUP, info->cgroup_name.c_str());
+    tree_store_update(model, &info->node, COL_UNIT, info->unit.c_str());
+    tree_store_update(model, &info->node, COL_SESSION, info->session.c_str());
+    tree_store_update(model, &info->node, COL_SEAT, info->seat.c_str());
+    tree_store_update(model, &info->node, COL_OWNER, info->owner.c_str());
+}
+
+static void
+insert_info_to_tree (ProcInfo *info, GsmApplication *app, bool forced = false)
+{
+    GtkTreeModel *model;
+    GtkTreeModel *filtered;
+    GtkTreeModel *sorted;
+    sorted = gtk_tree_view_get_model (GTK_TREE_VIEW(app->tree));
+    filtered = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(sorted));
+    model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filtered));
+
+    if (app->settings->get_boolean (GSM_SETTING_SHOW_DEPENDENCIES)) {
+
+        ProcInfo *parent = 0;
+
+        if (not forced)
+            parent = app->processes.find(info->ppid);
+
+        if (parent) {
+            GtkTreePath *parent_node = gtk_tree_model_get_path(model, &parent->node);
+            gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, &parent->node, 0);
+
+            GtkTreePath *filtered_parent = gtk_tree_model_filter_convert_child_path_to_path (GTK_TREE_MODEL_FILTER (filtered), parent_node);
+            if (filtered_parent != NULL) {
+                GtkTreePath *sorted_parent = gtk_tree_model_sort_convert_child_path_to_path (GTK_TREE_MODEL_SORT (sorted), filtered_parent);
+
+                if (sorted_parent != NULL) {
+                    if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(app->tree), sorted_parent)
+#ifdef __linux__
+                        // on linuxes we don't want to expand kthreadd by default (always has pid 2)
+                        && (parent->pid != 2)
+#endif
+                    )
+                        gtk_tree_view_expand_row(GTK_TREE_VIEW(app->tree), sorted_parent, FALSE);
+                    gtk_tree_path_free (sorted_parent);
+                }
+                gtk_tree_path_free (filtered_parent);
+            }
+            gtk_tree_path_free (parent_node);
+        } else
+            gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, NULL, 0);
+    }
+    else
+        gtk_tree_store_insert (GTK_TREE_STORE (model), &info->node, NULL, 0);
+
+    gtk_tree_store_set (GTK_TREE_STORE (model), &info->node,
+                        COL_POINTER, info,
+                        COL_NAME, info->name.c_str(),
+                        COL_ARGS, info->arguments.c_str(),
+                        COL_TOOLTIP, info->tooltip.c_str(),
+                        COL_PID, info->pid,
+                        COL_SECURITYCONTEXT, info->security_context.c_str(),
+                        -1);
+
+    app->pretty_table->set_icon(*info);
+
+    procman_debug("inserted %d%s", info->pid, (forced ? " (forced)" : ""));
+}
+
+/* Removing a node with children - make sure the children are queued
+** to be readded.
+*/
+template<typename List>
+static void
+remove_info_from_tree (GsmApplication *app, GtkTreeModel *model,
+                       ProcInfo& current, List &orphans, unsigned lvl = 0)
+{
+    GtkTreeIter child_node;
+
+    if (std::find(orphans.begin(), orphans.end(), &current) != orphans.end()) {
+        procman_debug("[%u] %d already removed from tree", lvl, int(current.pid));
+        return;
+    }
+
+    procman_debug("[%u] pid %d, %d children", lvl, int(current.pid),
+                  gtk_tree_model_iter_n_children(model, &current.node));
+
+    // it is not possible to iterate&erase over a treeview so instead we
+    // just pop one child after another and recursively remove it and
+    // its children
+
+    while (gtk_tree_model_iter_children(model, &child_node, &current.node)) {
+        ProcInfo *child = 0;
+        gtk_tree_model_get(model, &child_node, COL_POINTER, &child, -1);
+        remove_info_from_tree(app, model, *child, orphans, lvl + 1);
+    }
+
+    g_assert(not gtk_tree_model_iter_has_child(model, &current.node));
+
+    orphans.push_back(&current);
+    gtk_tree_store_remove(GTK_TREE_STORE(model), &current.node);
+    procman::poison(current.node, 0x69);
+}
+
+
+static std::string
+get_proc_kernel_wchan(glibtop_proc_kernel& obj) {
+    char buf[40] = {0};
+    g_strlcpy(buf, obj.wchan, sizeof(buf));
+    buf[sizeof(buf)-1] = '\0';
+    return buf;
+}
+
+static void
+update_info (GsmApplication *app, ProcInfo *info)
+{
+    glibtop_proc_state procstate;
+    glibtop_proc_uid procuid;
+    glibtop_proc_time proctime;
+    glibtop_proc_kernel prockernel;
+    glibtop_proc_io procio;
+    gdouble update_interval_seconds = app->config.update_interval / 1000;
+    glibtop_get_proc_kernel(&prockernel, info->pid);
+    info->wchan = get_proc_kernel_wchan(prockernel);
+
+    glibtop_get_proc_state (&procstate, info->pid);
+    info->status = procstate.state;
+
+    glibtop_get_proc_uid (&procuid, info->pid);
+    glibtop_get_proc_time (&proctime, info->pid);
+    glibtop_get_proc_io (&procio, info->pid);
+
+    get_process_memory_info(info);
+
+    info->set_user(procstate.uid);
+
+    // if the cpu time has increased reset the status to running
+    // regardless of kernel state (#606579)
+    guint64 difference = proctime.rtime - info->cpu_time;
+    if (difference > 0)
+        info->status = GLIBTOP_PROCESS_RUNNING;
+
+    guint cpu_scale = 100;
+    if (not app->config.solaris_mode)
+        cpu_scale *= app->config.num_cpus;
+
+    info->pcpu = (gdouble)difference * cpu_scale / app->cpu_total_time;
+    info->pcpu = MIN(info->pcpu, cpu_scale);
+
+    app->processes.cpu_times[info->pid] = info->cpu_time = proctime.rtime;
+    info->nice = procuid.nice;
+
+    info->disk_write_bytes_current = (procio.disk_wbytes - info->disk_write_bytes_total)/update_interval_seconds;
+    info->disk_read_bytes_current = (procio.disk_rbytes - info->disk_read_bytes_total)/update_interval_seconds;
+
+    info->disk_write_bytes_total = procio.disk_wbytes;
+    info->disk_read_bytes_total = procio.disk_rbytes;
+
+    // set the ppid only if one can exist
+    // i.e. pid=0 can never have a parent
+    if (info->pid > 0) {
+        info->ppid = procuid.ppid;
+    }
+
+    g_assert(info->pid != info->ppid);
+    g_assert(info->ppid != -1 || info->pid == 0);
+
+    /* get cgroup data */
+    get_process_cgroup_info(*info);
+
+    procman::get_process_systemd_info(info);
+}
+
+ProcInfo::ProcInfo(pid_t pid)
+    : node(),
+      pixbuf(),
+      pid(pid),
+      ppid(-1),
+      uid(-1)
+{
+    ProcInfo * const info = this;
+    glibtop_proc_state procstate;
+    glibtop_proc_time proctime;
+    glibtop_proc_args procargs;
+    gchar** arguments;
+
+    glibtop_get_proc_state (&procstate, pid);
+    glibtop_get_proc_time (&proctime, pid);
+    arguments = glibtop_get_proc_argv (&procargs, pid, 0);
+
+    /* FIXME : wrong. name and arguments may change with exec* */
+    get_process_name (info, procstate.cmd, static_cast<const GStrv>(arguments));
+
+    std::string tooltip = make_string(g_strjoinv(" ", arguments));
+    if (tooltip.empty())
+        tooltip = procstate.cmd;
+
+    info->tooltip = make_string(g_markup_escape_text(tooltip.c_str(), -1));
+
+    info->arguments = make_string(g_strescape(tooltip.c_str(), "\\\""));
+    g_strfreev(arguments);
+
+    guint64 cpu_time = proctime.rtime;
+    auto app = GsmApplication::get();
+    auto it = app->processes.cpu_times.find(pid);
+    if (it != app->processes.cpu_times.end())
+    {
+        if (proctime.rtime >= it->second)
+            cpu_time = it->second;
+    }
+    info->cpu_time = cpu_time;
+    info->start_time = proctime.start_time;
+
+    get_process_selinux_context (info);
+    get_process_cgroup_info(*info);
+
+    get_process_systemd_info(info);
+}
+
+static void
+refresh_list (GsmApplication *app, const pid_t* pid_list, const guint n)
+{
+    typedef std::list<ProcInfo*> ProcList;
+    ProcList addition;
+
+    GtkTreeModel    *model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (
+                             gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT (
+                             gtk_tree_view_get_model (GTK_TREE_VIEW(app->tree))))));
+    guint i;
+
+    // Add or update processes in the process list
+    for(i = 0; i < n; ++i) {
+        ProcInfo *info = app->processes.find(pid_list[i]);
+
+        if (!info) {
+            info = app->processes.add(pid_list[i]);
+            addition.push_back(info);
+        }
+
+        update_info (app, info);
+    }
+
+
+    // Remove dead processes from the process list and from the
+    // tree. children are queued to be readded at the right place
+    // in the tree.
+
+    const std::set<pid_t> pids(pid_list, pid_list + n);
+
+    auto it = std::begin(app->processes);
+    while (it != std::end(app->processes)) {
+        auto& info = it->second;
+        if (pids.find(info.pid) == pids.end()) {
+            procman_debug("ripping %d", info.pid);
+            remove_info_from_tree(app, model, info, addition);
+            addition.remove(&info);
+            it = app->processes.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    // INVARIANT
+    // pid_list == ProcInfo::all + addition
+
+
+    if (app->settings->get_boolean (GSM_SETTING_SHOW_DEPENDENCIES)) {
+
+        // insert process in the tree. walk through the addition list
+        // (new process + process that have a new parent). This loop
+        // handles the dependencies because we cannot insert a process
+        // until its parent is in the tree.
+
+        std::set<pid_t> in_tree(pids);
+
+        for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)
+            in_tree.erase((*it)->pid);
+
+
+        while (not addition.empty()) {
+            procman_debug("looking for %d parents", int(addition.size()));
+            ProcList::iterator it(addition.begin());
+
+            while (it != addition.end()) {
+                procman_debug("looking for %d's parent with ppid %d",
+                              int((*it)->pid), int((*it)->ppid));
+
+
+                // inserts the process in the treeview if :
+                // - it has no parent (ppid = -1),
+                //   ie it is for example the [kernel] on FreeBSD
+                // - it is init
+                // - its parent is already in tree
+                // - its parent is unreachable
+                //
+                // rounds == 2 means that addition contains processes with
+                // unreachable parents
+                //
+                // FIXME: this is broken if the unreachable parent becomes active
+                // i.e. it gets active or changes ower
+                // so we just clear the tree on __each__ update
+                // see proctable_update (ProcData * const procdata)
+
+
+                if ((*it)->ppid <= 0 or in_tree.find((*it)->ppid) != in_tree.end()) {
+                    insert_info_to_tree(*it, app);
+                    in_tree.insert((*it)->pid);
+                    it = addition.erase(it);
+                    continue;
+                }
+
+                ProcInfo *parent = app->processes.find((*it)->ppid);
+                // if the parent is unreachable
+                if (not parent) {
+                    // or std::find(addition.begin(), addition.end(), parent) == addition.end()) {
+                    insert_info_to_tree(*it, app, true);
+                    in_tree.insert((*it)->pid);
+                    it = addition.erase(it);
+                    continue;
+                }
+
+                ++it;
+            }
+        }
+    }
+    else {
+        // don't care of the tree
+        for (auto& v : addition) insert_info_to_tree(v, app);
+    }
+
+
+    for (auto& v : app->processes) update_info_mutable_cols(&v.second);
+}
+
+void
+proctable_update (GsmApplication *app)
+{
+    pid_t* pid_list;
+    glibtop_proclist proclist;
+    glibtop_cpu cpu;
+    int which = 0;
+    int arg = 0;
+    auto whose_processes = app->settings->get_string(GSM_SETTING_SHOW_WHOSE_PROCESSES);
+    if (whose_processes == "all") {
+        which = GLIBTOP_KERN_PROC_ALL;
+        arg = 0;
+    } else if (whose_processes == "active") {
+        which = GLIBTOP_KERN_PROC_ALL | GLIBTOP_EXCLUDE_IDLE;
+        arg = 0;
+    } else if (whose_processes == "user") {
+      which = GLIBTOP_KERN_PROC_UID;
+      arg = getuid ();
+    }
+
+    pid_list = glibtop_get_proclist (&proclist, which, arg);
+
+    /* FIXME: total cpu time elapsed should be calculated on an individual basis here
+    ** should probably have a total_time_last gint in the ProcInfo structure */
+    glibtop_get_cpu (&cpu);
+    app->cpu_total_time = MAX(cpu.total - app->cpu_total_time_last, 1);
+    app->cpu_total_time_last = cpu.total;
+
+    // FIXME: not sure if glibtop always returns a sorted list of pid
+    // but it is important otherwise refresh_list won't find the parent
+    std::sort(pid_list, pid_list + proclist.number);
+    refresh_list (app, pid_list, proclist.number);
+
+    // juggling with tree scroll position to fix https://bugzilla.gnome.org/show_bug.cgi?id=92724
+    GtkTreePath* current_top;
+    if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(app->tree), 0,0, &current_top, NULL, NULL, NULL)) {
+        GtkAdjustment *vadjustment = GTK_ADJUSTMENT (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (app->tree)));
+        gdouble current_max = gtk_adjustment_get_upper(vadjustment);
+        gdouble current_value = gtk_adjustment_get_value(vadjustment);
+
+        if (app->top_of_tree) {
+            // if the visible cell from the top of the tree is still the same, as last time
+            if (gtk_tree_path_compare (app->top_of_tree, current_top) == 0) {
+                //but something from the scroll parameters has changed compared to the last values
+                if (app->last_vscroll_value == 0 && current_value != 0) {
+                    // the tree was scrolled to top, and something has been added above the current top row
+                    gtk_tree_view_scroll_to_point(GTK_TREE_VIEW(app->tree), -1, 0);
+                } else if (current_max > app->last_vscroll_max && app->last_vscroll_max == app->last_vscroll_value) {
+                    // the tree was scrolled to bottom, something has been added below the current bottom row
+                    gtk_tree_view_scroll_to_point(GTK_TREE_VIEW(app->tree), -1, current_max);
+                }
+            }
+
+            gtk_tree_path_free(app->top_of_tree);
+        }
+
+        app->top_of_tree = current_top;
+        app->last_vscroll_value = current_value;
+        app->last_vscroll_max = current_max;
+    }
+
+    g_free (pid_list);
+
+    /* proclist.number == g_list_length(procdata->info) == g_hash_table_size(procdata->pids) */
+}
+
+void
+proctable_free_table (GsmApplication * const app)
+{
+    app->processes.clear();
+}
+
+void
+ProcInfo::set_icon(Glib::RefPtr<Gdk::Pixbuf> icon)
+{
+    this->pixbuf = icon;
+
+    GtkTreeModel *model;
+    model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (
+            gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(
+            gtk_tree_view_get_model (GTK_TREE_VIEW(GsmApplication::get()->tree))))));
+    gtk_tree_store_set(GTK_TREE_STORE(model), &this->node,
+                       COL_PIXBUF, (this->pixbuf ? this->pixbuf->gobj() : NULL),
+                       -1);
+}
+
+void
+proctable_freeze (GsmApplication *app)
+{
+    if (app->timeout) {
+      g_source_remove (app->timeout);
+      app->timeout = 0;
+    }
+}
+
+void
+proctable_thaw (GsmApplication *app)
+{
+    if (app->timeout)
+        return;
+
+    app->timeout = g_timeout_add (app->config.update_interval,
+                                  cb_timeout,
+                                  app);
+}
+
+void
+proctable_reset_timeout (GsmApplication *app)
+{
+    proctable_freeze (app);
+    proctable_thaw (app);
+}
diff --git a/src/proctable.h b/src/proctable.h
new file mode 100644
index 0000000..a66ee93
--- /dev/null
+++ b/src/proctable.h
@@ -0,0 +1,75 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* Procman - tree view
+ * Copyright (C) 2001 Kevin Vandersloot
+ *
+ * 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 Library General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef _GSM_PROCTABLE_H_
+#define _GSM_PROCTABLE_H_
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include "application.h"
+#include "legacy/treeview.h"
+
+enum
+{
+    COL_NAME = 0,
+    COL_USER,
+    COL_STATUS,
+    COL_VMSIZE,
+    COL_MEMRES,
+    COL_MEMWRITABLE,
+    COL_MEMSHARED,
+    COL_MEMXSERVER,
+    COL_CPU,
+    COL_CPU_TIME,
+    COL_START_TIME,
+    COL_NICE,
+    COL_PID,
+    COL_SECURITYCONTEXT,
+    COL_ARGS,
+    COL_MEM,
+    COL_WCHAN,
+    COL_CGROUP,
+    COL_UNIT,
+    COL_SESSION,
+    COL_SEAT,
+    COL_OWNER,
+    COL_DISK_READ_TOTAL,
+    COL_DISK_WRITE_TOTAL,
+    COL_DISK_READ_CURRENT,
+    COL_DISK_WRITE_CURRENT,
+    COL_PRIORITY,
+    COL_PIXBUF,
+    COL_POINTER,
+    COL_TOOLTIP,
+    NUM_COLUMNS
+};
+
+
+GsmTreeView*      proctable_new (GsmApplication *app);
+void            proctable_update (GsmApplication *app);
+void            proctable_free_table (GsmApplication *app);
+void            proctable_freeze (GsmApplication *app);
+void            proctable_thaw (GsmApplication *app);
+void            proctable_reset_timeout (GsmApplication *app);
+
+void            get_process_memory_writable (ProcInfo *info);
+void            get_last_selected (GtkTreeModel *model, GtkTreePath *path,
+                                   GtkTreeIter *iter, gpointer data);
+
+#endif /* _GSM_PROCTABLE_H_ */
diff --git a/src/selinux.cpp b/src/selinux.cpp
new file mode 100644
index 0000000..a9596d5
--- /dev/null
+++ b/src/selinux.cpp
@@ -0,0 +1,66 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib.h>
+
+#include "selinux.h"
+#include "application.h"
+#include "util.h"
+
+
+static int (*getpidcon)(pid_t, char**);
+static void (*freecon)(char*);
+static int (*is_selinux_enabled)(void);
+
+static gboolean has_selinux;
+
+static gboolean load_selinux(void)
+{
+    return load_symbols("libselinux.so.1",
+                        "getpidcon", &getpidcon,
+                        "freecon", &freecon,
+                        "is_selinux_enabled", &is_selinux_enabled,
+                        NULL);
+}
+
+
+
+void
+get_process_selinux_context (ProcInfo *info)
+{
+    char *con;
+
+    if (has_selinux && !getpidcon (info->pid, &con)) {
+        info->security_context = g_strdup (con);
+        freecon (con);
+    }
+}
+
+
+
+gboolean
+can_show_security_context_column (void)
+{
+    if (!(has_selinux = load_selinux()))
+        return FALSE;
+
+    switch (is_selinux_enabled()) {
+        case 1:
+            /* We're running on an SELinux kernel */
+            return TRUE;
+
+        case -1:
+            /* Error; hide the security context column */
+
+        case 0:
+            /* We're not running on an SELinux kernel:
+               hide the security context column */
+
+        default:
+            procman_debug("SELinux was found but is not enabled.\n");
+            return FALSE;
+    }
+}
+
+
+
diff --git a/src/selinux.h b/src/selinux.h
new file mode 100644
index 0000000..e30c7c0
--- /dev/null
+++ b/src/selinux.h
@@ -0,0 +1,15 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_SELINUX_H_
+#define _GSM_SELINUX_H_
+
+#include <glib.h>
+
+#include "application.h"
+
+void
+get_process_selinux_context (ProcInfo *info);
+
+gboolean
+can_show_security_context_column (void) G_GNUC_CONST;
+
+#endif /* _GSM_SELINUX_H_ */
diff --git a/src/setaffinity.cpp b/src/setaffinity.cpp
new file mode 100644
index 0000000..e8c1546
--- /dev/null
+++ b/src/setaffinity.cpp
@@ -0,0 +1,473 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/**
+ * Copyright (C) 2020 Jacob Barkdull
+ *
+ * This program is part of GNOME System Monitor.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+**/
+
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <glibtop/procaffinity.h>
+#include <sys/stat.h>
+#include <glib/gi18n.h>
+
+#include "proctable.h"
+#include "procdialogs.h"
+#include "util.h"
+#include "setaffinity.h"
+
+namespace
+{
+    class SetAffinityData
+    {
+        public:
+            GtkWidget  *dialog;
+            pid_t       pid;
+            GtkWidget **buttons;
+            guint32     cpu_count;
+            gboolean    toggle_single_blocked;
+            gboolean    toggle_all_blocked;
+    };
+}
+
+static gboolean
+all_toggled (SetAffinityData *affinity)
+{
+    guint32 i;
+
+    /* Check if any CPU's aren't set for this process */
+    for (i = 1; i <= affinity->cpu_count; i++) {
+        /* If so, return FALSE */
+        if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (affinity->buttons[i]))) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static void
+affinity_toggler_single (GtkToggleButton *button,
+                         gpointer         data)
+{
+    SetAffinityData *affinity = static_cast<SetAffinityData *>(data);
+    gboolean         toggle_all_state = FALSE;
+
+    /* Return void if toggle single is blocked */
+    if (affinity->toggle_single_blocked == TRUE) {
+        return;
+    }
+
+    /* Set toggle all state based on whether all are toggled */
+    if (gtk_toggle_button_get_active (button)) {
+        toggle_all_state = all_toggled (affinity);
+    }
+
+    /* Block toggle all signal */
+    affinity->toggle_all_blocked = TRUE;
+
+    /* Set toggle all check box state */
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (affinity->buttons[0]),
+                                  toggle_all_state);
+
+    /* Unblock toggle all signal */
+    affinity->toggle_all_blocked = FALSE;
+}
+
+static void
+affinity_toggle_all (GtkToggleButton *toggle_all_button,
+                     gpointer         data)
+{
+    SetAffinityData *affinity = static_cast<SetAffinityData *>(data);
+
+    guint32  i;
+    gboolean state;
+
+    /* Return void if toggle all is blocked */
+    if (affinity->toggle_all_blocked == TRUE) {
+        return;
+    }
+
+    /* Set individual CPU toggles based on toggle all state */
+    state = gtk_toggle_button_get_active (toggle_all_button);
+
+    /* Block toggle single signal */
+    affinity->toggle_single_blocked = TRUE;
+
+    /* Set all CPU check boxes to specified state */
+    for (i = 1; i <= affinity->cpu_count; i++) {
+        gtk_toggle_button_set_active (
+            GTK_TOGGLE_BUTTON (affinity->buttons[i]),
+            state
+        );
+    }
+
+    /* Unblock toggle single signal */
+    affinity->toggle_single_blocked = FALSE;
+}
+
+static void
+set_affinity_error (void)
+{
+    GtkWidget *dialog;
+
+    /* Create error message dialog */
+    dialog = gtk_message_dialog_new (GTK_WINDOW (GsmApplication::get()->main_window),
+                                     GTK_DIALOG_DESTROY_WITH_PARENT,
+                                     GTK_MESSAGE_ERROR,
+                                     GTK_BUTTONS_CLOSE,
+                                     "GNU CPU Affinity error: %s",
+                                     g_strerror (errno));
+
+    /* Set dialog as modal */
+    gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+
+    /* Show the dialog */
+    gtk_widget_show (dialog);
+
+    /* Connect response signal to GTK widget destroy function */
+    g_signal_connect_swapped (dialog,
+                              "response",
+                              G_CALLBACK (gtk_widget_destroy),
+                              dialog);
+}
+
+static guint16 *
+gsm_set_proc_affinity (glibtop_proc_affinity *buf, GArray *cpus, pid_t pid)
+{
+#ifdef __linux__
+    guint i;
+    cpu_set_t set;
+    guint16 cpu;
+
+    CPU_ZERO (&set);
+
+    for (i = 0; i < cpus->len; i++) {
+        cpu = g_array_index (cpus, guint16, i);
+        CPU_SET (cpu, &set);
+    }
+
+    if (sched_setaffinity (pid, sizeof (set), &set) != -1) {
+        return glibtop_get_proc_affinity (buf, pid);
+    }
+#endif
+
+    return NULL;
+}
+
+static void
+execute_taskset_command (gchar **cpu_list, pid_t pid)
+{
+#ifdef __linux__
+    gchar *pc;
+    gchar *command;
+
+    /* Join CPU number strings by commas for taskset command CPU list */
+    pc = g_strjoinv (",", cpu_list);
+
+    /* Construct taskset command */
+    command = g_strdup_printf ("taskset -pc %s %d", pc, pid);
+
+    /* Execute taskset command; show error on failure */
+    if (!multi_root_check (command)) {
+        set_affinity_error ();
+    }
+
+    /* Free memory for taskset command */
+    g_free (command);
+    g_free (pc);
+#endif
+}
+
+static void
+set_affinity (GtkToggleButton *button,
+              gpointer         data)
+{
+    SetAffinityData *affinity = static_cast<SetAffinityData *>(data);
+
+    glibtop_proc_affinity get_affinity;
+    glibtop_proc_affinity set_affinity;
+
+    gchar   **cpu_list;
+    GArray   *cpuset;
+    guint32   i;
+    gint      taskset_cpu = 0;
+
+    /* Create string array for taskset command CPU list */
+    cpu_list = g_new0 (gchar *, affinity->cpu_count);
+
+    /* Check whether we can get process's current affinity */
+    if (glibtop_get_proc_affinity (&get_affinity, affinity->pid) != NULL) {
+        /* If so, create array for CPU numbers */
+        cpuset = g_array_new (FALSE, FALSE, sizeof (guint16));
+
+        /* Run through all CPUs set for this process */
+        for (i = 0; i < affinity->cpu_count; i++) {
+            /* Check if CPU check box button is active */
+            if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (affinity->buttons[i + 1]))) {
+                /* If so, get its CPU number as 16bit integer */
+                guint16 n = i;
+
+                /* Add its CPU for process affinity */
+                g_array_append_val (cpuset, n);
+
+                /* Store CPU number as string for taskset command CPU list */
+                cpu_list[taskset_cpu] = g_strdup_printf ("%i", i);
+                taskset_cpu++;
+            }
+        }
+
+        /* Set process affinity; Show message dialog upon error */
+        if (gsm_set_proc_affinity (&set_affinity, cpuset, affinity->pid) == NULL) {
+            /* If so, check whether an access error occurred */
+            if (errno == EPERM or errno == EACCES) {
+                /* If so, attempt to run taskset as root, show error on failure */
+                execute_taskset_command (cpu_list, affinity->pid);
+            } else {
+                /* If not, show error immediately */
+                set_affinity_error ();
+            }
+        }
+
+        /* Free memory for CPU strings */
+        for (i = 0; i < affinity->cpu_count; i++) {
+             g_free (cpu_list[i]);
+        }
+
+        /* Free CPU array memory */
+        g_array_free (cpuset, TRUE);
+    } else {
+        /* If not, show error message dialog */
+        set_affinity_error ();
+    }
+
+    /* Destroy dialog window */
+    gtk_widget_destroy (affinity->dialog);
+}
+
+static void
+create_single_set_affinity_dialog (GtkTreeModel *model,
+                                   GtkTreePath  *path,
+                                   GtkTreeIter  *iter,
+                                   gpointer      data)
+{
+    GsmApplication *app = static_cast<GsmApplication *>(data);
+
+    ProcInfo        *info;
+    SetAffinityData *affinity_data;
+    GtkWidget       *cancel_button;
+    GtkWidget       *apply_button;
+    GtkWidget       *dialog_vbox;
+    GtkWidget       *label;
+    GtkWidget       *scrolled;
+    GtkStyleContext *scrolled_style;
+    GtkGrid         *cpulist_grid;
+
+    guint16               *affinity_cpus;
+    guint16                affinity_cpu;
+    glibtop_proc_affinity  affinity;
+    guint32                affinity_i;
+    gint                   button_n;
+    gchar                 *button_text;
+
+    /* Get selected process information */
+    gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+
+    /* Return void if process information comes back not true */
+    if (!info) {
+        return;
+    }
+
+    /* Create affinity data object */
+    affinity_data = new SetAffinityData ();
+
+    /* Set initial check box array */
+    affinity_data->buttons = g_new (GtkWidget *, app->config.num_cpus);
+
+    /* Create dialog window */
+    affinity_data->dialog = GTK_WIDGET (g_object_new (GTK_TYPE_DIALOG,
+                                                      "title", _("Set Affinity"),
+                                                      "use-header-bar", TRUE,
+                                                      "destroy-with-parent", TRUE,
+                                                      NULL));
+
+    /* Add cancel button to header bar */
+    cancel_button = gtk_dialog_add_button (GTK_DIALOG (affinity_data->dialog),
+                                           _("_Cancel"),
+                                           GTK_RESPONSE_CANCEL);
+
+    /* Add apply button to header bar */
+    apply_button = gtk_dialog_add_button (GTK_DIALOG (affinity_data->dialog),
+                                          _("_Apply"),
+                                          GTK_RESPONSE_APPLY);
+
+    /* Set dialog window "transient for" */
+    gtk_window_set_transient_for (GTK_WINDOW (affinity_data->dialog),
+                                  GTK_WINDOW (GsmApplication::get()->main_window));
+
+    /* Set dialog window to be resizable */
+    gtk_window_set_resizable (GTK_WINDOW (affinity_data->dialog), TRUE);
+
+    /* Set default dialog window size */
+    gtk_widget_set_size_request (affinity_data->dialog, 600, 430);
+
+    /* Set dialog box padding ("border") */
+    gtk_container_set_border_width (GTK_CONTAINER (affinity_data->dialog), 5);
+
+    /* Get dialog content area VBox */
+    dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (affinity_data->dialog));
+
+    /* Set dialog VBox padding ("border") */
+    gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 10);
+
+    /* Set dialog VBox spacing */
+    gtk_box_set_spacing (GTK_BOX (dialog_vbox), 10);
+
+    /* Add selected process pid to affinity data */
+    affinity_data->pid = info->pid;
+
+    /* Add CPU count to affinity data */
+    affinity_data->cpu_count = app->config.num_cpus;
+
+    /* Set default toggle signal block states */
+    affinity_data->toggle_single_blocked = FALSE;
+    affinity_data->toggle_all_blocked = FALSE;
+
+    /* Create a label describing the dialog windows intent */
+    label = GTK_WIDGET (procman_make_label_for_mmaps_or_ofiles (
+        _("Select CPUs \"%s\" (PID %u) is allowed to run on:"),
+        info->name.c_str(),
+        info->pid
+    ));
+
+    /* Add label to dialog VBox */
+    gtk_box_pack_start (GTK_BOX (dialog_vbox), label, FALSE, TRUE, 0);
+
+    /* Create scrolled box ("window") */
+    scrolled = gtk_scrolled_window_new (NULL, NULL);
+
+    /* Add view class to scrolled box style */
+    scrolled_style = gtk_widget_get_style_context (scrolled);
+    gtk_style_context_add_class (scrolled_style, "view");
+
+    /* Set scrolled box vertical and horizontal policies */
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+                                    GTK_POLICY_AUTOMATIC,
+                                    GTK_POLICY_AUTOMATIC);
+
+    /* Set scrolled box shadow */
+    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+                                         GTK_SHADOW_IN);
+
+    /* Create grid for CPU list */
+    cpulist_grid = GTK_GRID (gtk_grid_new ());
+
+    /* Set CPU list grid padding ("border") */
+    gtk_container_set_border_width (GTK_CONTAINER (cpulist_grid), 10);
+
+    /* Set grid row spacing */
+    gtk_grid_set_row_spacing (cpulist_grid, 10);
+
+    /* Create toggle all check box */
+    affinity_data->buttons[0] = gtk_check_button_new_with_label ("Run on all CPUs");
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (affinity_data->buttons[0]), TRUE);
+    gtk_widget_set_hexpand (affinity_data->buttons[0], TRUE);
+
+    /* Get process's current affinity */
+    affinity_cpus = glibtop_get_proc_affinity (&affinity, info->pid);
+
+    /* Set toggle all check box based on whether all CPUs are set for this process */
+    gtk_toggle_button_set_active (
+        GTK_TOGGLE_BUTTON (affinity_data->buttons[0]),
+        affinity.all
+    );
+
+    /* Add toggle all check box to CPU grid */
+    gtk_grid_attach (cpulist_grid, affinity_data->buttons[0], 0, 0, 1, 1);
+
+    /* Run through all CPU buttons */
+    for (button_n = 1; button_n < app->config.num_cpus + 1; button_n++) {
+        /* Set check box label value to CPU [1..2048] */
+        button_text = g_strdup_printf (_("CPU %d"), button_n);
+
+        /* Create check box button for current CPU */
+        affinity_data->buttons[button_n] = gtk_check_button_new_with_label (button_text);
+        gtk_widget_set_hexpand (affinity_data->buttons[button_n], TRUE);
+
+        /* Add check box to CPU grid */
+        gtk_grid_attach (cpulist_grid, affinity_data->buttons[button_n], 0, button_n, 1, 1);
+
+        /* Connect check box to toggler function */
+        g_signal_connect (affinity_data->buttons[button_n],
+                          "toggled",
+                          G_CALLBACK (affinity_toggler_single),
+                          affinity_data);
+
+        /* Free check box label value gchar */
+        g_free (button_text);
+    }
+
+    /* Run through all CPUs set for this process */
+    for (affinity_i = 0; affinity_i < affinity.number; affinity_i++) {
+        /* Get CPU button index */
+        affinity_cpu = affinity_cpus[affinity_i] + 1;
+
+        /* Set CPU check box active */
+        gtk_toggle_button_set_active (
+            GTK_TOGGLE_BUTTON (affinity_data->buttons[affinity_cpu]),
+            TRUE
+        );
+    }
+
+    /* Add CPU grid to scrolled box */
+    gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (cpulist_grid));
+
+    /* Add scrolled box to dialog VBox */
+    gtk_box_pack_start (GTK_BOX (dialog_vbox), scrolled, TRUE, TRUE, 0);
+
+    /* Swap click signal on "Cancel" button */
+    g_signal_connect_swapped (cancel_button,
+                              "clicked",
+                              G_CALLBACK (gtk_widget_destroy),
+                              affinity_data->dialog);
+
+    /* Connect click signal on "Apply" button */
+    g_signal_connect (apply_button,
+                      "clicked",
+                      G_CALLBACK (set_affinity),
+                      affinity_data);
+
+    /* Connect toggle all check box to (de)select all function */
+    g_signal_connect (affinity_data->buttons[0],
+                      "toggled",
+                      G_CALLBACK (affinity_toggle_all),
+                      affinity_data);
+
+    /* Show dialog window */
+    gtk_widget_show_all (affinity_data->dialog);
+}
+
+void
+create_set_affinity_dialog (GsmApplication *app)
+{
+    /* Create a dialog window for each selected process */
+    gtk_tree_selection_selected_foreach (app->selection,
+                                         create_single_set_affinity_dialog,
+                                         app);
+}
diff --git a/src/setaffinity.h b/src/setaffinity.h
new file mode 100644
index 0000000..6e1c7c9
--- /dev/null
+++ b/src/setaffinity.h
@@ -0,0 +1,21 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/**
+ * Copyright (C) 2020 Jacob Barkdull
+ *
+ * I, Jacob Barkdull, hereby release this work into the public domain.
+ * This applies worldwide. If this is not legally possible, I grant any
+ * entity the right to use this work for any purpose, without any
+ * conditions, unless such conditions are required by law.
+**/
+
+
+#ifndef _GSM_SETAFFINITY_H_
+#define _GSM_SETAFFINITY_H_
+
+#include <glib.h>
+#include "application.h"
+
+void            create_set_affinity_dialog (GsmApplication *app);
+
+#endif /* _GSM_SETAFFINITY_H_ */
diff --git a/src/settings-keys.h b/src/settings-keys.h
new file mode 100644
index 0000000..d1c964e
--- /dev/null
+++ b/src/settings-keys.h
@@ -0,0 +1,45 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_SETTINGS_KEYS_H_
+#define _GSM_SETTINGS_KEYS_H_
+
+#define GSM_GSETTINGS_SCHEMA                "org.gnome.gnome-system-monitor"
+#define FONT_SETTINGS_SCHEMA                "org.gnome.desktop.interface"
+
+#define FONT_SETTING_SCALING                "text-scaling-factor"
+
+#define GSM_SETTINGS_CHILD_OPEN_FILES       "openfilestree"
+#define GSM_SETTINGS_CHILD_DISKS            "disktreenew"
+#define GSM_SETTINGS_CHILD_PROCESSES        "proctree"
+#define GSM_SETTINGS_CHILD_MEMMAP           "memmapstree"
+
+#define GSM_SETTING_WINDOW_STATE            "window-state"
+#define GSM_SETTING_MAXIMIZED               "maximized"
+#define GSM_SETTING_CURRENT_TAB             "current-tab"
+#define GSM_SETTING_PROCESS_UPDATE_INTERVAL "update-interval"
+#define GSM_SETTING_SHOW_WHOSE_PROCESSES    "show-whose-processes"
+#define GSM_SETTING_SHOW_DEPENDENCIES       "show-dependencies"
+#define GSM_SETTING_SHOW_KILL_DIALOG        "kill-dialog"
+#define GSM_SETTING_SOLARIS_MODE            "solaris-mode"
+#define GSM_SETTING_PROCESS_MEMORY_IN_IEC   "process-memory-in-iec"
+#define GSM_SETTING_GRAPH_UPDATE_INTERVAL   "graph-update-interval"
+#define GSM_SETTING_CPU_COLORS              "cpu-colors"
+#define GSM_SETTING_MEM_COLOR               "mem-color"
+#define GSM_SETTING_SWAP_COLOR              "swap-color"
+#define GSM_SETTING_NET_IN_COLOR            "net-in-color"
+#define GSM_SETTING_NET_OUT_COLOR           "net-out-color"
+#define GSM_SETTING_LOGARITHMIC_SCALE       "logarithmic-scale"
+#define GSM_SETTING_DRAW_STACKED            "cpu-stacked-area-chart"
+#define GSM_SETTING_DRAW_SMOOTH             "cpu-smooth-graph"
+#define GSM_SETTING_RESOURCES_MEMORY_IN_IEC "resources-memory-in-iec"
+#define GSM_SETTING_NETWORK_IN_BITS         "network-in-bits"
+#define GSM_SETTING_GRAPH_DATA_POINTS       "graph-data-points"
+#define GSM_SETTING_NETWORK_TOTAL_UNIT      "network-total-unit"
+#define GSM_SETTING_NETWORK_TOTAL_IN_BITS   "network-total-in-bits"
+#define GSM_SETTING_SHOW_CPU                "show-cpu"
+#define GSM_SETTING_SHOW_MEM                "show-mem"
+#define GSM_SETTING_SHOW_NETWORK            "show-network"
+#define GSM_SETTING_DISKS_UPDATE_INTERVAL   "disks-interval"
+#define GSM_SETTING_SHOW_ALL_FS             "show-all-fs"
+#define GSM_SETTING_SMOOTH_REFRESH          "smooth-refresh"
+
+#endif /* _GSM_SETTINGS_KEYS_H_ */
diff --git a/src/smooth_refresh.cpp b/src/smooth_refresh.cpp
new file mode 100644
index 0000000..45f28c1
--- /dev/null
+++ b/src/smooth_refresh.cpp
@@ -0,0 +1,151 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <glib.h>
+
+#include <glibtop.h>
+#include <glibtop/proctime.h>
+#include <glibtop/cpu.h>
+
+#include "smooth_refresh.h"
+#include "application.h"
+#include "settings-keys.h"
+#include "util.h"
+
+
+const string SmoothRefresh::KEY(GSM_SETTING_SMOOTH_REFRESH);
+
+
+
+unsigned SmoothRefresh::get_own_cpu_usage()
+{
+    glibtop_cpu cpu;
+    glibtop_proc_time proctime;
+    guint64 elapsed;
+    unsigned usage = PCPU_LO;
+
+    glibtop_get_cpu (&cpu);
+    elapsed = cpu.total - this->last_total_time;
+
+    if (elapsed) { // avoid division by 0
+        glibtop_get_proc_time(&proctime, getpid());
+        usage = (proctime.rtime - this->last_cpu_time) * 100 / elapsed;
+        this->last_cpu_time = proctime.rtime;
+    }
+
+    usage = CLAMP(usage, 0, 100);
+
+    this->last_total_time = cpu.total;
+
+    return usage;
+}
+
+void SmoothRefresh::load_settings_value(Glib::ustring key)
+{
+    this->active = this->settings->get_boolean(key);
+
+    if (this->active)
+        procman_debug("smooth_refresh is enabled");
+}
+
+
+SmoothRefresh::SmoothRefresh(Glib::RefPtr<Gio::Settings> a_settings)
+    :
+    settings(a_settings),
+    active(false),
+    interval(0),
+    last_pcpu(0),
+    last_total_time(0ULL),
+    last_cpu_time(0ULL)
+{
+    this->connection = a_settings->signal_changed("smooth_refresh").connect([this](const Glib::ustring& key) { this->load_settings_value(key); });
+
+    this->reset();
+    this->load_settings_value(KEY);
+}
+
+
+
+void SmoothRefresh::reset()
+{
+    glibtop_cpu cpu;
+    glibtop_proc_time proctime;
+
+    glibtop_get_cpu(&cpu);
+    glibtop_get_proc_time(&proctime, getpid());
+
+    this->interval = GsmApplication::get()->config.update_interval;
+    this->last_pcpu = PCPU_LO;
+    this->last_total_time = cpu.total;
+    this->last_cpu_time = proctime.rtime;
+}
+
+
+
+SmoothRefresh::~SmoothRefresh()
+{
+    if (this->connection)
+        this->connection.disconnect();
+}
+
+
+
+bool
+SmoothRefresh::get(guint &new_interval)
+{
+    const unsigned config_interval = GsmApplication::get()->config.update_interval;
+
+    g_assert(this->interval >= config_interval);
+
+    if (not this->active)
+        return false;
+
+
+    const unsigned pcpu = this->get_own_cpu_usage();
+    /*
+      invariant: MAX_UPDATE_INTERVAL >= interval >= config_interval >= MIN_UPDATE_INTERVAL
+
+      i see 3 cases:
+
+      a) interval is too big (CPU usage < 10%)
+      -> increase interval
+
+      b) interval is too small (CPU usage > 10%) AND interval != config_interval
+      >
+      -> decrease interval
+
+      c) interval is config_interval (start or interval is perfect)
+
+    */
+
+    if (pcpu > PCPU_HI && this->last_pcpu > PCPU_HI)
+        new_interval = this->interval * 11 / 10;
+    else if (this->interval != config_interval && pcpu < PCPU_LO && this->last_pcpu < PCPU_LO)
+        new_interval = this->interval * 9 / 10;
+    else
+        new_interval = this->interval;
+
+    new_interval = CLAMP(new_interval, config_interval, config_interval * 2);
+    new_interval = CLAMP(new_interval, MIN_UPDATE_INTERVAL, MAX_UPDATE_INTERVAL);
+
+    bool changed = this->interval != new_interval;
+
+    if (changed)
+        this->interval = new_interval;
+
+    this->last_pcpu = pcpu;
+
+
+    if (changed) {
+        procman_debug("CPU usage is %3u%%, changed refresh_interval to %u (config %u)",
+                      this->last_pcpu,
+                      this->interval,
+                      config_interval);
+    }
+
+    g_assert(this->interval == new_interval);
+    g_assert(this->interval >= config_interval);
+
+    return changed;
+}
+
diff --git a/src/smooth_refresh.h b/src/smooth_refresh.h
new file mode 100644
index 0000000..8dc1f97
--- /dev/null
+++ b/src/smooth_refresh.h
@@ -0,0 +1,103 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_SMOOTH_REFRESH_H
+#define _GSM_SMOOTH_REFRESH_H
+
+#include <giomm.h>
+#include <glibmm.h>
+#include <string>
+
+#include "util.h"
+
+using std::string;
+
+
+
+class SmoothRefresh
+  : private procman::NonCopyable
+{
+  public:
+
+    /*
+      smooth_refresh_new
+
+      @config_interval : pointer to config_interval so we can observe
+      config_interval changes.
+
+      @return : initialized SmoothRefresh
+    */
+    SmoothRefresh(Glib::RefPtr<Gio::Settings> a_settings);
+
+    ~SmoothRefresh();
+
+    /*
+      smooth_refresh_reset
+
+      Resets state and re-read config_interval
+    */
+    void reset();
+
+    /*
+      smooth_refresh_get
+
+      Computes the new refresh_interval so that CPU usage is lower than
+      SMOOTH_REFRESH_PCPU.
+
+      @new_interval : where the new refresh_interval is stored.
+
+      @return : TRUE is refresh_interval has changed. The new refresh_interval
+      is stored in @new_interval. Else FALSE;
+    */
+    bool get(guint &new_interval);
+
+
+    static const string KEY;
+    static const bool KEY_DEFAULT_VALUE;
+
+  private:
+
+    unsigned get_own_cpu_usage();
+
+    void load_settings_value(Glib::ustring key);
+
+    /*
+      fuzzy logic:
+      - decrease refresh interval only if current CPU% and last CPU%
+      are higher than PCPU_LO
+      - increase refresh interval only if current CPU% and last CPU%
+      are higher than PCPU_HI
+
+    */
+
+    enum
+    {
+        PCPU_HI = 22,
+        PCPU_LO = 18
+    };
+
+    /*
+      -self : procman's PID (so we call getpid() only once)
+
+      -interval : current refresh interval
+
+      -config_interval : pointer to the configuration refresh interval.
+      Used to watch configuration changes
+
+      -interval >= -config_interval
+
+      -last_pcpu : to avoid spikes, the last CPU%. See PCPU_{LO,HI}
+
+      -last_total_time:
+      -last_cpu_time: Save last cpu and process times to compute CPU%
+    */
+
+    Glib::RefPtr<Gio::Settings> settings;
+    bool active;
+    sigc::connection connection;
+    guint interval;
+    unsigned  last_pcpu;
+    guint64 last_total_time;
+    guint64 last_cpu_time;
+};
+
+
+#endif /* _GSM_SMOOTH_REFRESH_H */
diff --git a/src/systemd.cpp b/src/systemd.cpp
new file mode 100644
index 0000000..880fc4c
--- /dev/null
+++ b/src/systemd.cpp
@@ -0,0 +1,61 @@
+#include <config.h>
+#include <stdlib.h>
+
+#ifdef HAVE_SYSTEMD
+#include <systemd/sd-login.h>
+#endif
+
+#include "application.h"
+#include "systemd.h"
+
+
+bool
+procman::systemd_logind_running()
+{
+#ifdef HAVE_SYSTEMD
+  static bool init;
+  static bool is_running;
+
+  if (!init) {
+    /* check if logind is running */
+    if (access("/run/systemd/seats/", F_OK) >= 0) {
+      is_running = true;
+    }
+    init = true;
+  }
+
+  return is_running;
+
+#else
+  return false;
+#endif
+}
+
+void
+procman::get_process_systemd_info(ProcInfo *info)
+{
+#ifdef HAVE_SYSTEMD
+    uid_t uid;
+
+    if (!systemd_logind_running())
+        return;
+
+    char* unit = NULL;
+    sd_pid_get_unit(info->pid, &unit);
+    info->unit = make_string(unit);
+
+    char* session = NULL;
+    sd_pid_get_session(info->pid, &session);
+    info->session = make_string(session);
+
+    if (!info->session.empty()) {
+      char* seat = NULL;
+      sd_session_get_seat(info->session.c_str(), &seat);
+      info->seat = make_string(seat);
+    }
+    if (sd_pid_get_owner_uid(info->pid, &uid) >= 0)
+        info->owner = info->lookup_user(uid);
+    else
+        info->owner = "";
+#endif
+}
diff --git a/src/systemd.h b/src/systemd.h
new file mode 100644
index 0000000..6604877
--- /dev/null
+++ b/src/systemd.h
@@ -0,0 +1,12 @@
+#ifndef PROCMAN_SYSTEMD_H_144CA8D6_BF03_11E4_B291_000C298F6617
+#define PROCMAN_SYSTEMD_H_144CA8D6_BF03_11E4_B291_000C298F6617
+
+#include "application.h"
+
+namespace procman
+{
+  bool systemd_logind_running();
+  void get_process_systemd_info(ProcInfo *info);
+}
+
+#endif
diff --git a/src/util.cpp b/src/util.cpp
new file mode 100644
index 0000000..59cb7b3
--- /dev/null
+++ b/src/util.cpp
@@ -0,0 +1,766 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#include <config.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <random>
+#include <tuple>
+#include <vector>
+
+#include <glib/gi18n.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include <glibtop/proctime.h>
+#include <glibtop/procstate.h>
+
+#include "util.h"
+#include "application.h"
+
+extern "C" {
+#include "legacy/e_date.h"
+}
+
+
+const char*
+format_process_state(guint state)
+{
+    const char *status;
+
+    switch (state)
+    {
+        case GLIBTOP_PROCESS_RUNNING:
+            status = _("Running");
+            break;
+
+        case GLIBTOP_PROCESS_STOPPED:
+            status = _("Stopped");
+            break;
+
+        case GLIBTOP_PROCESS_ZOMBIE:
+            status = _("Zombie");
+            break;
+
+        case GLIBTOP_PROCESS_UNINTERRUPTIBLE:
+            status = _("Uninterruptible");
+            break;
+
+        default:
+            status = _("Sleeping");
+            break;
+    }
+
+    return status;
+}
+
+
+
+static char *
+mnemonic_safe_process_name(const char *process_name)
+{
+    const char *p;
+    GString *name;
+
+    name = g_string_new ("");
+
+    for(p = process_name; *p; ++p)
+    {
+        g_string_append_c (name, *p);
+
+        if(*p == '_')
+            g_string_append_c (name, '_');
+    }
+
+    return g_string_free (name, FALSE);
+}
+
+
+
+static inline unsigned divide(unsigned *q, unsigned *r, unsigned d)
+{
+    *q = *r / d;
+    *r = *r % d;
+    return *q != 0;
+}
+
+
+/*
+ * @param d: duration in centiseconds
+ * @type d: unsigned
+ */
+char *
+procman::format_duration_for_display(unsigned centiseconds)
+{
+    unsigned weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0;
+
+    (void)(divide(&seconds, &centiseconds, 100)
+           && divide(&minutes, &seconds, 60)
+           && divide(&hours, &minutes, 60)
+           && divide(&days, &hours, 24)
+           && divide(&weeks, &days, 7));
+
+    if (weeks)
+        /* xgettext: weeks, days */
+        return g_strdup_printf(_("%uw%ud"), weeks, days);
+
+    if (days)
+        /* xgettext: days, hours (0 -> 23) */
+        return g_strdup_printf(_("%ud%02uh"), days, hours);
+
+    if (hours)
+        /* xgettext: hours (0 -> 23), minutes, seconds */
+        return g_strdup_printf(_("%u:%02u:%02u"), hours, minutes, seconds);
+
+    /* xgettext: minutes, seconds, centiseconds */
+    return g_strdup_printf(_("%u:%02u.%02u"), minutes, seconds, centiseconds);
+}
+
+
+
+GtkLabel*
+procman_make_label_for_mmaps_or_ofiles(const char *format,
+                                       const char *process_name,
+                                       unsigned pid)
+{
+    GtkLabel* label;
+    char *name, *title;
+
+    name = mnemonic_safe_process_name (process_name);
+    title = g_strdup_printf(format, name, pid);
+    label = GTK_LABEL (gtk_label_new_with_mnemonic (title));
+    gtk_widget_set_valign (GTK_WIDGET (label), GTK_ALIGN_CENTER);
+    gtk_widget_set_halign (GTK_WIDGET (label), GTK_ALIGN_START);
+
+    g_free (title);
+    g_free (name);
+
+    return label;
+}
+
+
+
+/**
+ * procman::format_size:
+ * @size:
+ *
+ * Formats the file size passed in @bytes in a way that is easy for
+ * the user to read. Gives the size in bytes, kibibytes, mebibytes or
+ * gibibytes, choosing whatever is appropriate.
+ *
+ * Returns: a newly allocated string with the size ready to be shown.
+ **/
+
+gchar*
+procman::format_size(guint64 size, bool want_bits)
+{
+    if (want_bits)
+        size *= 8;
+
+    const GFormatSizeFlags flags = (want_bits ? G_FORMAT_SIZE_BITS : G_FORMAT_SIZE_IEC_UNITS);
+    return g_format_size_full(size, flags);
+}
+
+gchar *
+procman::get_nice_level (gint nice)
+{
+    if (nice < -7)
+        return _("Very High");
+    else if (nice < -2)
+        return _("High");
+    else if (nice < 3)
+        return _("Normal");
+    else if (nice < 7)
+        return _("Low");
+    else
+        return _("Very Low");
+}
+
+gchar *
+procman::get_nice_level_with_priority (gint nice)
+{
+    if (nice < -7)
+        return _("Very High Priority");
+    else if (nice < -2)
+        return _("High Priority");
+    else if (nice < 3)
+        return _("Normal Priority");
+    else if (nice < 7)
+        return _("Low Priority");
+    else
+        return _("Very Low Priority");
+}
+
+gchar*
+format_byte_size(guint64 size, bool want_iec_format)
+{
+    const GFormatSizeFlags flags = (want_iec_format ? G_FORMAT_SIZE_IEC_UNITS : G_FORMAT_SIZE_DEFAULT);
+    return g_format_size_full(size, flags);
+}
+
+gboolean
+load_symbols(const char *module, ...)
+{
+    GModule *mod;
+    gboolean found_all = TRUE;
+    va_list args;
+
+    mod = g_module_open(module, static_cast<GModuleFlags>(G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL));
+
+    if (!mod)
+        return FALSE;
+
+    procman_debug("Found %s", module);
+
+    va_start(args, module);
+
+    while (1) {
+        const char *name;
+        void **symbol;
+
+        name = va_arg(args, char*);
+
+        if (!name)
+            break;
+
+        symbol = va_arg(args, void**);
+
+        if (g_module_symbol(mod, name, symbol)) {
+            procman_debug("Loaded %s from %s", name, module);
+        }
+        else {
+            procman_debug("Could not load %s from %s", name, module);
+            found_all = FALSE;
+            break;
+        }
+    }
+
+    va_end(args);
+
+
+    if (found_all)
+        g_module_make_resident(mod);
+    else
+        g_module_close(mod);
+
+    return found_all;
+}
+
+
+static gboolean
+is_debug_enabled(void)
+{
+    static gboolean init;
+    static gboolean enabled;
+
+    if (!init) {
+        enabled = g_getenv("GNOME_SYSTEM_MONITOR_DEBUG") != NULL;
+        init = TRUE;
+    }
+
+    return enabled;
+}
+
+
+static double
+get_relative_time(void)
+{
+    static unsigned long start_time;
+
+    if (G_UNLIKELY(!start_time)) {
+        glibtop_proc_time buf;
+        glibtop_get_proc_time(&buf, getpid());
+        start_time = buf.start_time;
+    }
+
+    return 1e-6 * g_get_monotonic_time () - start_time;
+}
+
+static gdouble
+get_size_from_column(GtkTreeModel* model, GtkTreeIter* first,
+                             const guint index)
+{
+    GValue value = { 0 };
+    gtk_tree_model_get_value(model, first, index, &value);
+
+    gdouble size;
+    switch (G_VALUE_TYPE(&value)) {
+        case G_TYPE_UINT:
+            size = g_value_get_uint(&value);
+            break;
+        case G_TYPE_ULONG:
+            size = g_value_get_ulong(&value);
+            break;
+        case G_TYPE_UINT64:
+            size = g_value_get_uint64(&value);
+            break;
+        case G_TYPE_DOUBLE:
+            size = g_value_get_double(&value);
+            break;
+        default:
+            g_assert_not_reached();
+    }
+
+    g_value_unset(&value);
+    return size;
+}
+
+void
+procman_debug_real(const char *file, int line, const char *func,
+                   const char *format, ...)
+{
+    va_list args;
+    char *msg;
+
+    if (G_LIKELY(!is_debug_enabled()))
+        return;
+
+    va_start(args, format);
+    msg = g_strdup_vprintf(format, args);
+    va_end(args);
+
+    g_print ("[%.3f %s:%d %s] %s\n", get_relative_time(), file, line, func, msg);
+
+    g_free(msg);
+}
+
+
+// h is in [0.0; 1.0] (and not [0°; 360°] )
+// s is in [0.0; 1.0]
+// v is in [0.0; 1.0]
+// https://en.wikipedia.org/wiki/HSL_and_HSV#From_HSV
+std::tuple<double, double, double> hsv_to_rgb(double h, double s, double v)
+{
+    const double c = v * s;
+    const double hp = h * 6; // 360° / 60°
+    const double x = c * (1 - std::abs(std::fmod(hp, 2.0) - 1));
+
+    double r1 = 0 , g1 = 0, b1 = 0;
+
+    switch (int(hp)) {
+    case 0: r1 = c; g1 = x; b1 = 0; break;
+    case 1: r1 = x; g1 = c; b1 = 0; break;
+    case 2: r1 = 0; g1 = c; b1 = x; break;
+    case 3: r1 = 0; g1 = x; b1 = c; break;
+    case 4: r1 = x; g1 = 0; b1 = c; break;
+    case 5: r1 = c; g1 = 0; b1 = x; break;
+    }
+
+    const double m = v - c;
+
+    return {r1 + m, g1 + m, b1 + m};
+}
+
+
+std::string rgb_to_color_string(const std::tuple<double, double, double> &t)
+{
+    char b[14];
+    auto c = [](double d) { return (unsigned short)(0xffff * d); };
+    std::snprintf(b, sizeof b, "#%04x%04x%04x", c(std::get<0>(t)), c(std::get<1>(t)), c(std::get<2>(t)));
+    return {b, 13};
+}
+
+
+namespace procman
+{
+
+    // http://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/
+    std::vector<std::string> generate_colors(unsigned n)
+    {
+        constexpr double golden_ration_conjugate = 0.618033988749894848204586834;
+
+        std::vector<std::string> values;
+
+        std::random_device re;
+        std::uniform_real_distribution<> dist(0.0, 1.0);
+
+        double h = dist(re);
+
+        for (unsigned i = 0; i < n; i++) {
+            h = CLAMP(h, 0.0, 1.0);
+            auto rgb = hsv_to_rgb(h, 0.5, 0.95);
+            values.push_back(rgb_to_color_string(rgb));
+            h = std::fmod(h + golden_ration_conjugate, 1.0);
+        }
+
+        return values;
+    }
+
+    void size_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        guint64 size;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_ULONG:
+                size = g_value_get_ulong(&value);
+                break;
+
+            case G_TYPE_UINT64:
+                size = g_value_get_uint64(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        char *str = g_format_size_full(size, G_FORMAT_SIZE_IEC_UNITS);
+        g_object_set(renderer, "text", str, NULL);
+        g_free(str);
+    }
+
+    void percentage_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        gdouble size;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+        size = g_value_get_double(&value);
+        g_value_unset(&value);
+
+        char *str = g_strdup_printf("%.2f", size);
+        g_object_set(renderer, "text", str, NULL);
+        g_free(str);
+    }
+
+
+    /*
+      Same as above but handles size == 0 as not available
+    */
+    void size_na_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                                GtkTreeModel *model, GtkTreeIter *iter,
+                                gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        guint64 size;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_ULONG:
+                size = g_value_get_ulong(&value);
+                break;
+
+            case G_TYPE_UINT64:
+                size = g_value_get_uint64(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        if (size == 0) {
+            g_object_set (renderer,
+                          "text", _("N/A"),
+                          "style", PANGO_STYLE_ITALIC,
+                          NULL);
+        }
+        else {
+            char *str = format_byte_size(size, GsmApplication::get()->config.process_memory_in_iec);
+            g_object_set (renderer,
+                          "text", str,
+                          "style", PANGO_STYLE_NORMAL,
+                          NULL);
+            g_free(str);
+        }
+
+    }
+
+    void io_rate_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                                GtkTreeModel *model, GtkTreeIter *iter,
+                                gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        guint64 size;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_ULONG:
+                size = g_value_get_ulong(&value);
+                break;
+
+            case G_TYPE_UINT64:
+                size = g_value_get_uint64(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        if (size == 0) {
+            g_object_set (renderer,
+                          "text", _("N/A"),
+                          "style", PANGO_STYLE_ITALIC,
+                          NULL);
+        }
+        else {
+            g_object_set (renderer,
+                          "text", procman::format_rate(size, FALSE).c_str(),
+                          "style", PANGO_STYLE_NORMAL,
+                          NULL);
+        }
+
+    }
+    
+    /*
+        Cell data function to format a size value with SI units (to be used only for disk size, see bugzilla 693630)
+    */
+    void size_si_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        guint64 size;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_ULONG:
+                size = g_value_get_ulong(&value);
+                break;
+
+            case G_TYPE_UINT64:
+                size = g_value_get_uint64(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        char *str = g_format_size(size);
+        g_object_set(renderer, "text", str, NULL);
+        g_free(str);
+    }
+
+    void duration_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                                 GtkTreeModel *model, GtkTreeIter *iter,
+                                 gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        unsigned time;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_ULONG:
+                time = g_value_get_ulong(&value);
+                break;
+
+            case G_TYPE_UINT64:
+                time = g_value_get_uint64(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        time = 100 * time / GsmApplication::get()->frequency;
+        char *str = format_duration_for_display(time);
+        g_object_set(renderer, "text", str, NULL);
+        g_free(str);
+    }
+
+
+    void time_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        time_t time;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_ULONG:
+                time = g_value_get_ulong(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        char *str = procman_format_date_for_display(time);
+        g_object_set(renderer, "text", str, NULL);
+        g_free(str);
+    }
+
+    void status_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                               GtkTreeModel *model, GtkTreeIter *iter,
+                               gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        guint state;
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        switch (G_VALUE_TYPE(&value)) {
+            case G_TYPE_UINT:
+                state = g_value_get_uint(&value);
+                break;
+
+            default:
+                g_assert_not_reached();
+        }
+
+        g_value_unset(&value);
+
+        const char *str = format_process_state(state);
+        g_object_set(renderer, "text", str, NULL);
+    }
+
+    void priority_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        GValue value = { 0 };
+
+        gtk_tree_model_get_value(model, iter, index, &value);
+
+        gint priority = g_value_get_int(&value);
+
+        g_value_unset(&value);
+
+        g_object_set(renderer, "text", procman::get_nice_level(priority), NULL);
+
+    }
+
+    gint priority_compare_func(GtkTreeModel* model, GtkTreeIter* first,
+                            GtkTreeIter* second, gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+        GValue value1 = { 0 };
+        GValue value2 = { 0 };
+        gtk_tree_model_get_value(model, first, index, &value1);
+        gtk_tree_model_get_value(model, second, index, &value2);
+        gint result = g_value_get_int(&value1) - g_value_get_int(&value2);
+        g_value_unset(&value1);
+        g_value_unset(&value2);
+        return result;
+    }
+
+    gint number_compare_func(GtkTreeModel* model, GtkTreeIter* first,
+                            GtkTreeIter* second, gpointer user_data)
+    {
+        const guint index = GPOINTER_TO_UINT(user_data);
+
+        gdouble size1, size2;
+        size1 = get_size_from_column(model, first, index);
+        size2 = get_size_from_column(model, second, index);
+
+        if ( size2 > size1 )
+            return 1;
+        else if ( size2 < size1 )
+            return -1;
+        return 0;
+    }
+
+    template<>
+    void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value)
+    {
+        char* current_value;
+
+        gtk_tree_model_get(model, iter, column, &current_value, -1);
+
+        if (g_strcmp0(current_value, new_value) != 0)
+            gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
+
+        g_free(current_value);
+    }
+
+
+    std::string format_rate(guint64 rate, bool want_bits)
+    {
+        char* bytes = procman::format_size(rate, want_bits);
+        // xgettext: rate, 10MiB/s or 10Mbit/s
+        std::string formatted_rate(make_string(g_strdup_printf(_("%s/s"), bytes)));
+        g_free(bytes);
+        return formatted_rate;
+    }
+
+
+    std::string format_network(guint64 rate)
+    {
+        char* bytes = procman::format_size(rate, GsmApplication::get()->config.network_total_in_bits);
+        std::string formatted(bytes);
+        g_free(bytes);
+        return formatted;
+    }
+
+
+    std::string format_network_rate(guint64 rate)
+    {
+        return procman::format_rate(rate, GsmApplication::get()->config.network_in_bits);
+    }
+
+}
+
+Glib::ustring
+get_monospace_system_font_name ()
+{
+    return Gio::Settings::create ("org.gnome.desktop.interface")->get_string ("monospace-font-name");
+}
+
+
+GtkLabel *
+make_tnum_label (void)
+{
+    PangoAttrList *attrs = make_tnum_attr_list ();
+    GtkWidget *label = gtk_label_new (NULL);
+
+    gtk_label_set_attributes (GTK_LABEL (label), attrs);
+
+    g_clear_pointer (&attrs, pango_attr_list_unref);
+
+    return GTK_LABEL (label);
+}
+
+
+PangoAttrList *
+make_tnum_attr_list (void)
+{
+    PangoAttrList *attrs = NULL;
+
+    attrs = pango_attr_list_new ();
+    pango_attr_list_insert (attrs, pango_attr_font_features_new ("tnum=1"));
+
+    return attrs;
+}
+
diff --git a/src/util.h b/src/util.h
new file mode 100644
index 0000000..750fa38
--- /dev/null
+++ b/src/util.h
@@ -0,0 +1,177 @@
+/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+#ifndef _GSM_UTIL_H_
+#define _GSM_UTIL_H_
+
+#include <gtkmm.h>
+#include <string>
+#include <vector>
+
+using std::string;
+
+GtkLabel*
+procman_make_label_for_mmaps_or_ofiles(const char *format,
+                                       const char *process_name,
+                                       unsigned pid);
+
+gboolean
+load_symbols(const char *module, ...) G_GNUC_NULL_TERMINATED;
+
+const char*
+format_process_state(guint state);
+
+gchar*
+format_byte_size(guint64 size, bool want_iec_format);
+
+void
+procman_debug_real(const char *file, int line, const char *func,
+                   const char *format, ...) G_GNUC_PRINTF(4, 5);
+                   
+#define procman_debug(FMT, ...) procman_debug_real(__FILE__, __LINE__, __func__, FMT, ##__VA_ARGS__)
+
+Glib::ustring get_monospace_system_font_name (void);
+GtkLabel *make_tnum_label (void);
+PangoAttrList *make_tnum_attr_list (void);
+std::tuple<double, double, double> hsv_to_rgb(double h, double s, double v);
+std::string rgb_to_color_string(const std::tuple<double, double, double> &t);
+
+inline string make_string(char *c_str)
+{
+    if (!c_str) {
+        procman_debug("NULL string");
+        return string();
+    }
+
+    string s(c_str);
+    g_free(c_str);
+    return s;
+}
+
+
+namespace procman
+{
+    // create a list of n color strings
+    std::vector<std::string> generate_colors(unsigned n);
+
+    char* format_duration_for_display(unsigned centiseconds);
+
+    void size_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data);
+
+    void io_rate_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data);
+
+    void size_na_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                                GtkTreeModel *model, GtkTreeIter *iter,
+                                gpointer user_data);
+
+    void size_si_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                                GtkTreeModel *model, GtkTreeIter *iter,
+                                gpointer user_data);
+
+
+    void duration_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                                 GtkTreeModel *model, GtkTreeIter *iter,
+                                 gpointer user_data);
+
+    void time_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data);
+    void percentage_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                             GtkTreeModel *model, GtkTreeIter *iter,
+                             gpointer user_data);
+
+    void status_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                               GtkTreeModel *model, GtkTreeIter *iter,
+                               gpointer user_data);
+    void priority_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+                               GtkTreeModel *model, GtkTreeIter *iter,
+                               gpointer user_data);
+    gint priority_compare_func(GtkTreeModel* model, GtkTreeIter* first,
+                            GtkTreeIter* second, gpointer user_data);
+    gint number_compare_func(GtkTreeModel* model, GtkTreeIter* first,
+                            GtkTreeIter* second, gpointer user_data);
+
+
+    template<typename T>
+    void poison(T &t, char c)
+    {
+        memset(&t, c, sizeof t);
+    }
+
+
+
+    //
+    // Stuff to update a tree_store in a smart way
+    //
+
+    template<typename T>
+    void tree_store_update(GtkTreeModel* model, GtkTreeIter* iter, int column, const T& new_value)
+    {
+        T current_value;
+
+        gtk_tree_model_get(model, iter, column, &current_value, -1);
+
+        if (current_value != new_value)
+            gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
+    }
+
+    // undefined
+    // catch every thing about pointers
+    // just to make sure i'm not doing anything wrong
+    template<typename T>
+    void tree_store_update(GtkTreeModel* model, GtkTreeIter* iter, int column, T* new_value);
+
+    // specialized versions for strings
+    template<>
+    void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value);
+
+    template<>
+    inline void tree_store_update<char>(GtkTreeModel* model, GtkTreeIter* iter, int column, char* new_value)
+    {
+        tree_store_update<const char>(model, iter, column, new_value);
+    }
+
+    gchar* format_size(guint64 size, bool want_bits = false);
+
+    gchar* get_nice_level (gint nice);
+
+    gchar* get_nice_level_with_priority (gint nice);
+
+    std::string format_rate(guint64 rate, bool want_bits = false);
+
+    std::string format_network(guint64 rate);
+    std::string format_network_rate(guint64 rate);
+
+    class NonCopyable
+    {
+    protected:
+        NonCopyable() {}  // = default
+        ~NonCopyable() {} // = default
+    private:
+        NonCopyable(const NonCopyable&)            /* = delete */;
+        NonCopyable& operator=(const NonCopyable&) /* = delete */;
+    };
+
+
+    // join the elements of c with sep
+    template<typename C, typename S>
+        auto join(const C& c, const S& sep) -> decltype(c[0] + sep)
+    {
+        decltype(c[0] + sep) r;
+        bool first = true;
+
+        for(const auto& e : c) {
+            if (!first) {
+                r += sep;
+            }
+            first = false;
+            r += e;
+        }
+
+        return r;
+    }
+}
+
+#endif /* _GSM_UTIL_H_ */