/* -*- 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;

    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 (app->selection, path)) {

        if (!(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))

            gtk_tree_selection_unselect_all (app->selection);

        gtk_tree_selection_select_path (app->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);

}

void

cb_row_selected (GtkTreeSelection *selection, gpointer data)

{

    GsmApplication *app = (GsmApplication *) data;

    app->selection = selection;

    ProcInfo *selected_process = NULL;

    /* get the most recent selected process and determine if there are

    ** no selected processes

    */

    gtk_tree_selection_selected_foreach (app->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;

    if(app->timeout) {

        g_source_remove (app->timeout);

    }

    for (auto& v : app->processes) {

        app->pretty_table->set_icon(v.second);

    }

    cb_timeout(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;

    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);

    auto regex = Glib::Regex::create(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);

        // TODO auto-expand items not matching the search string but having matching children

        // complicated because of treestore nested in treemodelfilter nested in treemodelsort

        // expand to path requires the path string in the treemodelsort, but tree_path is the path in the double nested treestore

        //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;

    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_UINT,        /* % 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);

    for (i = COL_USER; i <= COL_PRIORITY; i++) {

        GtkTreeViewColumn *col;

        GtkCellRenderer *cell;

#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_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;

        }

        // 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;

        }

    }

    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);

    app->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree));

    gtk_tree_selection_set_mode (app->selection, GTK_SELECTION_MULTIPLE);

    g_signal_connect (G_OBJECT (app->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)) {