[gnome-system-monitor] Get rid of ProcData structure
- From: Robert Roth <robertroth src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-system-monitor] Get rid of ProcData structure
- Date: Wed, 3 Oct 2012 15:38:06 +0000 (UTC)
commit 97674c7940e819bef14c8a98bd181cbb5a604226
Author: Stefano Facchini <stefano facchini gmail com>
Date: Wed Oct 3 18:21:42 2012 +0300
Get rid of ProcData structure
It's redundant now that we have a true Application object
https://bugzilla.gnome.org/show_bug.cgi?id=684536
src/callbacks.cpp | 214 ++++++++++-----------
src/callbacks.h | 4 +-
src/cgroups.cpp | 2 +-
src/cgroups.h | 2 +-
src/disks.cpp | 35 ++--
src/disks.h | 4 +-
src/interface.cpp | 185 +++++++++---------
src/interface.h | 10 +-
src/load-graph.cpp | 20 +-
src/lsof.cpp | 10 +-
src/lsof.h | 4 +-
src/memmaps.cpp | 18 +-
src/memmaps.h | 4 +-
src/openfiles.cpp | 18 +-
src/openfiles.h | 4 +-
src/procactions.cpp | 38 ++--
src/procactions.h | 6 +-
src/procdialogs.cpp | 89 +++++-----
src/procdialogs.h | 12 +-
src/procman-app.cpp | 491 +++++++++++++++++++++++++++++++----------------
src/procman-app.h | 222 +++++++++++++++++++++-
src/procman.cpp | 188 +------------------
src/procman.h | 262 -------------------------
src/procman_gksu.cpp | 2 +-
src/procman_gnomesu.cpp | 2 +-
src/procman_pkexec.cpp | 2 +-
src/procproperties.cpp | 17 +-
src/procproperties.h | 4 +-
src/proctable.cpp | 127 +++++++------
src/proctable.h | 14 +-
src/selinux.cpp | 2 +-
src/selinux.h | 2 +-
src/smooth_refresh.cpp | 6 +-
src/sysinfo.cpp | 5 +-
src/util.cpp | 8 +-
35 files changed, 976 insertions(+), 1057 deletions(-)
---
diff --git a/src/callbacks.cpp b/src/callbacks.cpp
index f4f1bb4..81f0bf5 100644
--- a/src/callbacks.cpp
+++ b/src/callbacks.cpp
@@ -30,7 +30,7 @@
#include "proctable.h"
#include "util.h"
#include "procactions.h"
-#include "procman.h"
+#include "procman-app.h"
#include "procdialogs.h"
#include "memmaps.h"
#include "openfiles.h"
@@ -43,10 +43,10 @@
void
cb_kill_sigstop(GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
/* no confirmation */
- kill_process (procdata, SIGSTOP);
+ kill_process (app, SIGSTOP);
}
@@ -55,44 +55,43 @@ cb_kill_sigstop(GtkAction *action, gpointer data)
void
cb_kill_sigcont(GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
/* no confirmation */
- kill_process (procdata, SIGCONT);
+ kill_process (app, SIGCONT);
}
-
static void
-kill_process_helper(ProcData *procdata, int sig)
+kill_process_helper(ProcmanApp *app, int sig)
{
- if (procdata->config.show_kill_warning)
- procdialog_create_kill_dialog (procdata, sig);
+ if (app->config.show_kill_warning)
+ procdialog_create_kill_dialog (app, sig);
else
- kill_process (procdata, sig);
+ kill_process (app, sig);
}
void
cb_edit_preferences (GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procdialog_create_preferences_dialog (procdata);
+ procdialog_create_preferences_dialog (app);
}
void
cb_renice (GtkAction *action, GtkRadioAction *current, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
gint selected = gtk_radio_action_get_current_value(current);
if (selected == CUSTOM_PRIORITY)
{
- procdialog_create_renice_dialog (procdata);
+ procdialog_create_renice_dialog (app);
} else {
gint new_nice_value = 0;
switch (selected) {
@@ -102,7 +101,7 @@ cb_renice (GtkAction *action, GtkRadioAction *current, gpointer data)
case LOW_PRIORITY: new_nice_value = 5; break;
case VERY_LOW_PRIORITY: new_nice_value = 19; break;
}
- renice(procdata, new_nice_value);
+ renice(app, new_nice_value);
}
}
@@ -110,52 +109,53 @@ cb_renice (GtkAction *action, GtkRadioAction *current, gpointer data)
void
cb_end_process (GtkAction *action, gpointer data)
{
- kill_process_helper(static_cast<ProcData*>(data), SIGTERM);
+ kill_process_helper(static_cast<ProcmanApp *>(data), SIGTERM);
}
void
cb_kill_process (GtkAction *action, gpointer data)
{
- kill_process_helper(static_cast<ProcData*>(data), SIGKILL);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
+ kill_process_helper(app, SIGKILL);
}
void
cb_show_memory_maps (GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- create_memmaps_dialog (procdata);
+ create_memmaps_dialog (app);
}
void
cb_show_open_files (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- create_openfiles_dialog (procdata);
+ create_openfiles_dialog (app);
}
void
cb_show_process_properties (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- create_procproperties_dialog (procdata);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ create_procproperties_dialog (app);
}
void
cb_show_lsof(GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- procman_lsof(procdata);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ procman_lsof(app);
}
void
cb_about (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
const gchar * const authors[] = {
"Kevin Vandersloot",
@@ -180,7 +180,7 @@ cb_about (GtkAction *action, gpointer data)
};
gtk_show_about_dialog (
- GTK_WINDOW (procdata->app),
+ GTK_WINDOW (app->main_window),
"name", _("System Monitor"),
"comments", _("View current processes and monitor "
"system state"),
@@ -211,38 +211,22 @@ cb_help_contents (GtkAction *action, gpointer data)
}
-void
-cb_app_exit (GtkAction *action, gpointer data)
-{
- ProcData * const procdata = static_cast<ProcData*>(data);
-
- cb_app_delete (NULL, NULL, procdata);
- gtk_widget_destroy (procdata->app);
-}
-
-
gboolean
-cb_app_delete (GtkWidget *window, GdkEventAny *event, gpointer data)
+cb_main_window_delete (GtkWidget *window, GdkEvent *event, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
-
- procman_save_config (procdata);
- if (procdata->timeout)
- g_source_remove (procdata->timeout);
- if (procdata->disk_timeout)
- g_source_remove (procdata->disk_timeout);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- procdata->terminating = TRUE;
+ app->shutdown ();
- return FALSE;
+ return TRUE;
}
-
void
cb_end_process_button_pressed (GtkButton *button, gpointer data)
{
- kill_process_helper(static_cast<ProcData*>(data), SIGTERM);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ kill_process_helper(app, SIGTERM);
}
void
@@ -291,30 +275,30 @@ static void change_settings_color(GSettings *settings, const char *key,
void
cb_mem_color_changed (GSMColorButton *cp, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- change_settings_color(procdata->settings, "mem-color", cp);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
+ change_settings_color(app->settings, "mem-color", cp);
}
void
cb_swap_color_changed (GSMColorButton *cp, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- change_settings_color(procdata->settings, "swap-color", cp);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
+ change_settings_color(app->settings, "swap-color", cp);
}
void
cb_net_in_color_changed (GSMColorButton *cp, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- change_settings_color(procdata->settings, "net-in-color", cp);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
+ change_settings_color(app->settings, "net-in-color", cp);
}
void
cb_net_out_color_changed (GSMColorButton *cp, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- change_settings_color(procdata->settings, "net-out-color", cp);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
+ change_settings_color(app->settings, "net-out-color", cp);
}
static void
@@ -330,20 +314,20 @@ get_last_selected (GtkTreeModel *model, GtkTreePath *path,
void
cb_row_selected (GtkTreeSelection *selection, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- procdata->selection = selection;
+ app->selection = selection;
- procdata->selected_process = NULL;
+ app->selected_process = NULL;
/* get the most recent selected process and determine if there are
** no selected processes
*/
- gtk_tree_selection_selected_foreach (procdata->selection, get_last_selected,
- &procdata->selected_process);
- if (procdata->selected_process) {
+ gtk_tree_selection_selected_foreach (app->selection, get_last_selected,
+ &app->selected_process);
+ if (app->selected_process) {
gint value;
- gint nice = procdata->selected_process->nice;
+ gint nice = app->selected_process->nice;
if (nice < -7)
value = VERY_HIGH_PRIORITY;
else if (nice < -2)
@@ -355,13 +339,13 @@ cb_row_selected (GtkTreeSelection *selection, gpointer data)
else
value = VERY_LOW_PRIORITY;
- GtkRadioAction* normal = GTK_RADIO_ACTION(gtk_action_group_get_action(procdata->action_group, "Normal"));
- block_priority_changed_handlers(procdata, TRUE);
+ GtkRadioAction* normal = GTK_RADIO_ACTION(gtk_action_group_get_action(app->action_group, "Normal"));
+ block_priority_changed_handlers(app, TRUE);
gtk_radio_action_set_current_value(normal, value);
- block_priority_changed_handlers(procdata, FALSE);
+ block_priority_changed_handlers(app, FALSE);
}
- update_sensitivity(procdata);
+ update_sensitivity(app);
}
@@ -370,10 +354,10 @@ cb_tree_button_pressed (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
- do_popup_menu (procdata, event);
+ do_popup_menu (app, event);
return FALSE;
}
@@ -382,9 +366,9 @@ cb_tree_button_pressed (GtkWidget *widget,
gboolean
cb_tree_popup_menu (GtkWidget *widget, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- do_popup_menu (procdata, NULL);
+ do_popup_menu (app, NULL);
return TRUE;
}
@@ -400,59 +384,59 @@ cb_switch_page (GtkNotebook *nb, GtkWidget *page,
void
cb_change_current_page (GtkNotebook *nb, gint num, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- procdata->config.current_tab = num;
+ app->config.current_tab = num;
if (num == PROCMAN_TAB_PROCESSES) {
- cb_timeout (procdata);
+ cb_timeout (app);
- if (!procdata->timeout)
- procdata->timeout = g_timeout_add (
- procdata->config.update_interval,
- cb_timeout, procdata);
+ if (!app->timeout)
+ app->timeout = g_timeout_add (
+ app->config.update_interval,
+ cb_timeout, app);
- update_sensitivity(procdata);
+ update_sensitivity(app);
}
else {
- if (procdata->timeout) {
- g_source_remove (procdata->timeout);
- procdata->timeout = 0;
+ if (app->timeout) {
+ g_source_remove (app->timeout);
+ app->timeout = 0;
}
- update_sensitivity(procdata);
+ update_sensitivity(app);
}
if (num == PROCMAN_TAB_RESOURCES) {
- load_graph_start (procdata->cpu_graph);
- load_graph_start (procdata->mem_graph);
- load_graph_start (procdata->net_graph);
+ load_graph_start (app->cpu_graph);
+ load_graph_start (app->mem_graph);
+ load_graph_start (app->net_graph);
}
else {
- load_graph_stop (procdata->cpu_graph);
- load_graph_stop (procdata->mem_graph);
- load_graph_stop (procdata->net_graph);
+ load_graph_stop (app->cpu_graph);
+ load_graph_stop (app->mem_graph);
+ load_graph_stop (app->net_graph);
}
if (num == PROCMAN_TAB_DISKS) {
- cb_update_disks (procdata);
+ cb_update_disks (app);
- if(!procdata->disk_timeout) {
- procdata->disk_timeout =
- g_timeout_add (procdata->config.disks_update_interval,
+ if(!app->disk_timeout) {
+ app->disk_timeout =
+ g_timeout_add (app->config.disks_update_interval,
cb_update_disks,
- procdata);
+ app);
}
}
else {
- if(procdata->disk_timeout) {
- g_source_remove (procdata->disk_timeout);
- procdata->disk_timeout = 0;
+ if(app->disk_timeout) {
+ g_source_remove (app->disk_timeout);
+ app->disk_timeout = 0;
}
}
@@ -466,8 +450,8 @@ cb_change_current_page (GtkNotebook *nb, gint num, gpointer data)
gint
cb_user_refresh (GtkAction*, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- proctable_update_all(procdata);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
+ proctable_update_all(app);
return FALSE;
}
@@ -475,18 +459,18 @@ cb_user_refresh (GtkAction*, gpointer data)
gint
cb_timeout (gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
guint new_interval;
- if (!procdata->terminating) {
- proctable_update_all (procdata);
-
- if (procdata->smooth_refresh->get(new_interval))
- {
- procdata->timeout = g_timeout_add(new_interval,
- cb_timeout,
- procdata);
- return FALSE;
- }
+
+
+ proctable_update_all (app);
+
+ if (app->smooth_refresh->get(new_interval))
+ {
+ app->timeout = g_timeout_add(new_interval,
+ cb_timeout,
+ app);
+ return FALSE;
}
return TRUE;
@@ -496,10 +480,10 @@ cb_timeout (gpointer data)
void
cb_radio_processes(GtkAction *action, GtkRadioAction *current, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- procdata->config.whose_process = gtk_radio_action_get_current_value(current);
+ app->config.whose_process = gtk_radio_action_get_current_value(current);
- g_settings_set_int (procdata->settings, "view-as",
- procdata->config.whose_process);
+ g_settings_set_int (app->settings, "view-as",
+ app->config.whose_process);
}
diff --git a/src/callbacks.h b/src/callbacks.h
index 573d66a..4f88117 100644
--- a/src/callbacks.h
+++ b/src/callbacks.h
@@ -22,7 +22,6 @@
#define _PROCMAN_CALLBACKS_H_
#include <gtk/gtk.h>
-#include "procman.h"
#include "gsm_color_button.h"
@@ -38,8 +37,7 @@ void cb_edit_preferences (GtkAction *action, gpointer data);
void cb_help_contents (GtkAction *action, gpointer data);
void cb_about (GtkAction *action, gpointer data);
-void cb_app_exit (GtkAction *action, gpointer data);
-gboolean cb_app_delete (GtkWidget *window, GdkEventAny *event, gpointer data);
+gboolean cb_main_window_delete (GtkWidget *window, GdkEvent *event, gpointer data);
void cb_end_process_button_pressed (GtkButton *button, gpointer data);
void cb_logout (GtkButton *button, gpointer data);
diff --git a/src/cgroups.cpp b/src/cgroups.cpp
index eafa1e3..d77b9aa 100644
--- a/src/cgroups.cpp
+++ b/src/cgroups.cpp
@@ -3,7 +3,7 @@
#include <glib.h>
#include <glib/gi18n.h>
-#include "procman.h"
+#include "procman-app.h"
#include "util.h"
gboolean
diff --git a/src/cgroups.h b/src/cgroups.h
index 8c42f6f..0bf3947 100644
--- a/src/cgroups.h
+++ b/src/cgroups.h
@@ -3,7 +3,7 @@
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
void
get_process_cgroup_info (ProcInfo *info);
diff --git a/src/disks.cpp b/src/disks.cpp
index 0638558..5047cb7 100644
--- a/src/disks.cpp
+++ b/src/disks.cpp
@@ -7,7 +7,7 @@
#include <glibtop/fsusage.h>
#include <glib/gi18n.h>
-#include "procman.h"
+#include "procman-app.h"
#include "disks.h"
#include "util.h"
#include "interface.h"
@@ -218,21 +218,20 @@ add_disk(GtkListStore *list, const glibtop_mountentry *entry, bool show_all_fs)
int
cb_update_disks(gpointer data)
{
- ProcData *const procdata = static_cast<ProcData*>(data);
-
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
GtkListStore *list;
glibtop_mountentry * entries;
glibtop_mountlist mountlist;
guint i;
- list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(procdata->disk_list)));
+ list = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(app->disk_list)));
- entries = glibtop_get_mountlist(&mountlist, procdata->config.show_all_fs);
+ entries = glibtop_get_mountlist(&mountlist, app->config.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], procdata->config.show_all_fs);
+ add_disk(list, &entries[i], app->config.show_all_fs);
g_free(entries);
@@ -241,11 +240,11 @@ cb_update_disks(gpointer data)
static void
-cb_disk_columns_changed(GtkTreeView *treeview, gpointer user_data)
+cb_disk_columns_changed(GtkTreeView *treeview, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(user_data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procman_save_tree_state(procdata->settings,
+ procman_save_tree_state(app->settings,
GTK_WIDGET(treeview),
"disktreenew");
}
@@ -284,8 +283,14 @@ static void open_dir(GtkTreeView *tree_view,
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);
+}
+
void
-create_disk_view(ProcData *procdata, GtkBuilder *builder)
+create_disk_view(ProcmanApp *app, GtkBuilder *builder)
{
GtkWidget *scrolled;
GtkWidget *disk_tree;
@@ -320,7 +325,7 @@ create_disk_view(ProcData *procdata, GtkBuilder *builder)
disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
- procdata->disk_list = disk_tree;
+ app->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), disk_tree);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(disk_tree), TRUE);
g_object_unref(G_OBJECT(model));
@@ -397,10 +402,14 @@ create_disk_view(ProcData *procdata, GtkBuilder *builder)
/* numeric sort */
- procman_get_tree_state(procdata->settings, disk_tree,
+ procman_get_tree_state(app->settings, disk_tree,
"disktreenew");
+ 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), procdata);
+ G_CALLBACK(cb_disk_columns_changed), app);
}
diff --git a/src/disks.h b/src/disks.h
index 311cd9e..d3acf47 100644
--- a/src/disks.h
+++ b/src/disks.h
@@ -1,10 +1,10 @@
#ifndef H_GNOME_SYSTEM_MONITOR_DISKS_1123719137
#define H_GNOME_SYSTEM_MONITOR_DISKS_1123719137
-#include "procman.h"
+#include "procman-app.h"
void
-create_disk_view(ProcData *procdata, GtkBuilder *builder);
+create_disk_view(ProcmanApp *app, GtkBuilder *builder);
int
cb_update_disks(gpointer procdata);
diff --git a/src/interface.cpp b/src/interface.cpp
index 379faaa..5d45c53 100644
--- a/src/interface.cpp
+++ b/src/interface.cpp
@@ -30,7 +30,6 @@
#include <gdk/gdkkeysyms.h>
#include <math.h>
-#include "procman.h"
#include "callbacks.h"
#include "interface.h"
#include "proctable.h"
@@ -124,7 +123,7 @@ make_title_label (const char *text)
}
static void
-create_proc_view(ProcData *procdata, GtkBuilder * builder)
+create_proc_view(ProcmanApp *app, GtkBuilder * builder)
{
GtkWidget *proctree;
GtkWidget *scrolled;
@@ -135,34 +134,34 @@ create_proc_view(ProcData *procdata, GtkBuilder * builder)
/* create the processes tab */
string = make_loadavg_string ();
- procdata->loadavg = GTK_WIDGET (gtk_builder_get_object (builder, "load_avg_label"));
- gtk_label_set_text (GTK_LABEL (procdata->loadavg), string);
+ app->loadavg = GTK_WIDGET (gtk_builder_get_object (builder, "load_avg_label"));
+ gtk_label_set_text (GTK_LABEL (app->loadavg), string);
g_free (string);
- proctree = proctable_new (procdata);
+ proctree = proctable_new (app);
scrolled = GTK_WIDGET (gtk_builder_get_object (builder, "processes_scrolled"));
gtk_container_add (GTK_CONTAINER (scrolled), proctree);
- procdata->endprocessbutton = GTK_WIDGET (gtk_builder_get_object (builder, "endprocessbutton"));
- g_signal_connect (G_OBJECT (procdata->endprocessbutton), "clicked",
- G_CALLBACK (cb_end_process_button_pressed), procdata);
+ app->endprocessbutton = GTK_WIDGET (gtk_builder_get_object (builder, "endprocessbutton"));
+ g_signal_connect (G_OBJECT (app->endprocessbutton), "clicked",
+ G_CALLBACK (cb_end_process_button_pressed), app);
button = GTK_WIDGET (gtk_builder_get_object (builder, "viewmenubutton"));
- viewmenu = gtk_ui_manager_get_widget (procdata->uimanager, "/ViewMenu");
+ viewmenu = gtk_ui_manager_get_widget (app->uimanager, "/ViewMenu");
gtk_widget_set_halign (viewmenu, GTK_ALIGN_END);
gtk_menu_button_set_popup (GTK_MENU_BUTTON (button), viewmenu);
button = GTK_WIDGET (gtk_builder_get_object (builder, "refreshbutton"));
- action = gtk_action_group_get_action (procdata->action_group, "Refresh");
+ action = gtk_action_group_get_action (app->action_group, "Refresh");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (button), action);
/* create popup_menu for the processes tab */
- procdata->popup_menu = gtk_ui_manager_get_widget (procdata->uimanager, "/PopupMenu");
+ app->popup_menu = gtk_ui_manager_get_widget (app->uimanager, "/PopupMenu");
}
static void
-create_sys_view (ProcData *procdata, GtkBuilder * builder)
+create_sys_view (ProcmanApp *app, GtkBuilder * builder)
{
GtkWidget *cpu_graph_box, *mem_graph_box, *net_graph_box;
GtkWidget *label,*cpu_label;
@@ -192,7 +191,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
GtkWidget* cpu_table = GTK_WIDGET (gtk_builder_get_object (builder, "cpu_table"));
gint cols = 4;
- for (i=0;i<procdata->config.num_cpus; i++) {
+ for (i=0;i<app->config.num_cpus; i++) {
GtkWidget *temp_hbox;
temp_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
@@ -212,7 +211,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
G_CALLBACK (cb_cpu_color_changed), GINT_TO_POINTER (i));
gtk_box_pack_start (GTK_BOX (temp_hbox), color_picker, FALSE, TRUE, 0);
gtk_widget_set_size_request(GTK_WIDGET(color_picker), 32, -1);
- if(procdata->config.num_cpus == 1) {
+ if(app->config.num_cpus == 1) {
label_text = g_strdup (_("CPU"));
} else {
label_text = g_strdup_printf (_("CPU%d"), i+1);
@@ -231,7 +230,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
}
- procdata->cpu_graph = cpu_graph;
+ app->cpu_graph = cpu_graph;
/** The memory box */
mem_graph_box = GTK_WIDGET (gtk_builder_get_object (builder, "mem_graph_box"));
@@ -247,7 +246,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
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), procdata);
+ G_CALLBACK (cb_mem_color_changed), app);
title_text = g_strdup_printf(title_template, _("Memory"));
gsm_color_button_set_title(GSM_COLOR_BUTTON(color_picker), title_text);
g_free(title_text);
@@ -258,7 +257,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
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), procdata);
+ 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);
@@ -266,7 +265,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
gtk_grid_attach (GTK_GRID (table), load_graph_get_labels(mem_graph)->swap, 3, 1, 1, 1);
- procdata->mem_graph = mem_graph;
+ app->mem_graph = mem_graph;
/* The net box */
net_graph_box = GTK_WIDGET (gtk_builder_get_object (builder, "net_graph_box"));
@@ -283,7 +282,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
color_picker = gsm_color_button_new (
&net_graph->colors.at(0), GSMCP_TYPE_NETWORK_IN);
g_signal_connect (G_OBJECT (color_picker), "color_set",
- G_CALLBACK (cb_net_in_color_changed), procdata);
+ G_CALLBACK (cb_net_in_color_changed), app);
title_text = g_strdup_printf(title_template, _("Receiving"));
gsm_color_button_set_title(GSM_COLOR_BUTTON(color_picker), title_text);
g_free(title_text);
@@ -298,7 +297,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
color_picker = gsm_color_button_new (
&net_graph->colors.at(1), GSMCP_TYPE_NETWORK_OUT);
g_signal_connect (G_OBJECT (color_picker), "color_set",
- G_CALLBACK (cb_net_out_color_changed), procdata);
+ G_CALLBACK (cb_net_out_color_changed), app);
title_text = g_strdup_printf(title_template, _("Sending"));
gsm_color_button_set_title(GSM_COLOR_BUTTON(color_picker), title_text);
g_free(title_text);
@@ -312,7 +311,7 @@ create_sys_view (ProcData *procdata, GtkBuilder * builder)
gtk_grid_attach (GTK_GRID (table), load_graph_get_labels(net_graph)->net_out_total, 6, 1, 1, 1);
- procdata->net_graph = net_graph;
+ app->net_graph = net_graph;
g_free(title_template);
}
@@ -324,11 +323,11 @@ on_activate_about (GSimpleAction *, GVariant *, gpointer data)
}
void
-create_main_window (ProcData *procdata, GtkApplication *application)
+create_main_window (ProcmanApp *app)
{
gint i;
gint width, height, xpos, ypos;
- GtkWidget *app;
+ GtkWidget *main_window;
GtkAction *action;
GtkWidget *notebook;
@@ -338,102 +337,105 @@ create_main_window (ProcData *procdata, GtkApplication *application)
gtk_builder_add_from_file (builder, filename, NULL);
g_free (filename);
- app = GTK_WIDGET (gtk_builder_get_object (builder, "main_window"));
- gtk_window_set_application (GTK_WINDOW (app), application);
+ main_window = GTK_WIDGET (gtk_builder_get_object (builder, "main_window"));
+ gtk_window_set_application (GTK_WINDOW (main_window), app->gobj());
+ gtk_widget_set_name (main_window, "gnome-system-monitor");
GActionEntry win_action_entries[] = {
{ "about", on_activate_about, NULL, NULL, NULL }
};
- g_action_map_add_action_entries (G_ACTION_MAP (app),
+ g_action_map_add_action_entries (G_ACTION_MAP (main_window),
win_action_entries,
G_N_ELEMENTS (win_action_entries),
- procdata);
+ app);
- GdkScreen* screen = gtk_widget_get_screen(app);
+ GdkScreen* screen = gtk_widget_get_screen(main_window);
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
/* use visual, if available */
if (visual)
- gtk_widget_set_visual(app, visual);
-
- width = procdata->config.width;
- height = procdata->config.height;
- xpos = procdata->config.xpos;
- ypos = procdata->config.ypos;
- gtk_window_set_default_size (GTK_WINDOW (app), width, height);
- gtk_window_move(GTK_WINDOW (app), xpos, ypos);
- if (procdata->config.maximized) {
- gtk_window_maximize(GTK_WINDOW(app));
+ gtk_widget_set_visual(main_window, visual);
+
+ width = app->config.width;
+ height = app->config.height;
+ xpos = app->config.xpos;
+ ypos = app->config.ypos;
+ gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
+ gtk_window_move(GTK_WINDOW (main_window), xpos, ypos);
+ if (app->config.maximized) {
+ gtk_window_maximize(GTK_WINDOW(main_window));
}
- procdata->uimanager = gtk_ui_manager_new ();
+ app->uimanager = gtk_ui_manager_new ();
- gtk_window_add_accel_group (GTK_WINDOW (app),
- gtk_ui_manager_get_accel_group (procdata->uimanager));
+ gtk_window_add_accel_group (GTK_WINDOW (main_window),
+ gtk_ui_manager_get_accel_group (app->uimanager));
filename = g_build_filename (GSM_DATA_DIR, "popups.ui", NULL);
- if (!gtk_ui_manager_add_ui_from_file (procdata->uimanager,
+ if (!gtk_ui_manager_add_ui_from_file (app->uimanager,
filename,
NULL)) {
g_error("building menus failed");
}
g_free (filename);
- procdata->action_group = gtk_action_group_new ("ProcmanActions");
- gtk_action_group_set_translation_domain (procdata->action_group, NULL);
- gtk_action_group_add_actions (procdata->action_group,
+ app->action_group = gtk_action_group_new ("ProcmanActions");
+ gtk_action_group_set_translation_domain (app->action_group, NULL);
+ gtk_action_group_add_actions (app->action_group,
menu_entries,
G_N_ELEMENTS (menu_entries),
- procdata);
- gtk_action_group_add_toggle_actions (procdata->action_group,
+ app);
+ gtk_action_group_add_toggle_actions (app->action_group,
toggle_menu_entries,
G_N_ELEMENTS (toggle_menu_entries),
- procdata);
+ app);
- gtk_action_group_add_radio_actions (procdata->action_group,
+ gtk_action_group_add_radio_actions (app->action_group,
radio_menu_entries,
G_N_ELEMENTS (radio_menu_entries),
- procdata->config.whose_process,
+ app->config.whose_process,
G_CALLBACK(cb_radio_processes),
- procdata);
+ app);
- gtk_action_group_add_radio_actions (procdata->action_group,
+ gtk_action_group_add_radio_actions (app->action_group,
priority_menu_entries,
G_N_ELEMENTS (priority_menu_entries),
NORMAL_PRIORITY,
G_CALLBACK(cb_renice),
- procdata);
+ app);
- gtk_ui_manager_insert_action_group (procdata->uimanager,
- procdata->action_group,
+ gtk_ui_manager_insert_action_group (app->uimanager,
+ app->action_group,
0);
/* create the main notebook */
- procdata->notebook = notebook = GTK_WIDGET (gtk_builder_get_object (builder, "notebook"));
+ app->notebook = notebook = GTK_WIDGET (gtk_builder_get_object (builder, "notebook"));
- create_proc_view(procdata, builder);
- create_sys_view (procdata, builder);
-
- create_disk_view (procdata, builder);
+ create_proc_view(app, builder);
+
+ create_sys_view (app, builder);
+ create_disk_view (app, builder);
+
+
g_signal_connect (G_OBJECT (notebook), "switch-page",
- G_CALLBACK (cb_switch_page), procdata);
+ G_CALLBACK (cb_switch_page), app);
g_signal_connect (G_OBJECT (notebook), "change-current-page",
- G_CALLBACK (cb_change_current_page), procdata);
+ G_CALLBACK (cb_change_current_page), app);
gtk_widget_show_all(notebook); // need to make page switch work
- gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab);
- cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata);
- g_signal_connect (G_OBJECT (app), "delete_event",
- G_CALLBACK (cb_app_delete),
- procdata);
+ gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), app->config.current_tab);
+ cb_change_current_page (GTK_NOTEBOOK (notebook), app->config.current_tab, app);
+ g_signal_connect (G_OBJECT (main_window), "delete_event",
+ G_CALLBACK (cb_main_window_delete),
+ app);
GtkAccelGroup *accel_group;
GClosure *goto_tab_closure[4];
accel_group = gtk_accel_group_new ();
- gtk_window_add_accel_group (GTK_WINDOW(app), accel_group);
+ gtk_window_add_accel_group (GTK_WINDOW(main_window), accel_group);
for (i = 0; i < 4; ++i) {
goto_tab_closure[i] = g_cclosure_new_swap (G_CALLBACK (cb_proc_goto_tab),
GINT_TO_POINTER (i), NULL);
@@ -441,21 +443,21 @@ create_main_window (ProcData *procdata, GtkApplication *application)
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE,
goto_tab_closure[i]);
}
- action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies");
+ action = gtk_action_group_get_action (app->action_group, "ShowDependencies");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
- procdata->config.show_tree);
+ app->config.show_tree);
gtk_builder_connect_signals (builder, NULL);
- gtk_widget_show_all(app);
- procdata->app = app;
+ gtk_widget_show_all(main_window);
+ app->main_window = main_window;
g_object_unref (G_OBJECT (builder));
}
void
-do_popup_menu (ProcData *procdata, GdkEventButton *event)
+do_popup_menu (ProcmanApp *app, GdkEventButton *event)
{
guint button;
guint32 event_time;
@@ -469,12 +471,12 @@ do_popup_menu (ProcData *procdata, GdkEventButton *event)
event_time = gtk_get_current_event_time ();
}
- gtk_menu_popup (GTK_MENU (procdata->popup_menu), NULL, NULL,
+ gtk_menu_popup (GTK_MENU (app->popup_menu), NULL, NULL,
NULL, NULL, button, event_time);
}
void
-update_sensitivity(ProcData *data)
+update_sensitivity(ProcmanApp *app)
{
const char * const selected_actions[] = { "StopProcess",
"ContProcess",
@@ -496,43 +498,43 @@ update_sensitivity(ProcData *data)
gboolean processes_sensitivity, selected_sensitivity;
GtkAction *action;
- processes_sensitivity = (data->config.current_tab == PROCMAN_TAB_PROCESSES);
- selected_sensitivity = (processes_sensitivity && data->selected_process != NULL);
+ processes_sensitivity = (app->config.current_tab == PROCMAN_TAB_PROCESSES);
+ selected_sensitivity = (processes_sensitivity && app->selected_process != NULL);
- if(data->endprocessbutton) {
+ if(app->endprocessbutton) {
/* avoid error on startup if endprocessbutton
has not been built yet */
- gtk_widget_set_sensitive(data->endprocessbutton, selected_sensitivity);
+ gtk_widget_set_sensitive(app->endprocessbutton, selected_sensitivity);
}
for (i = 0; i != G_N_ELEMENTS(processes_actions); ++i) {
- action = gtk_action_group_get_action(data->action_group,
+ action = gtk_action_group_get_action(app->action_group,
processes_actions[i]);
gtk_action_set_sensitive(action, processes_sensitivity);
}
for (i = 0; i != G_N_ELEMENTS(selected_actions); ++i) {
- action = gtk_action_group_get_action(data->action_group,
+ action = gtk_action_group_get_action(app->action_group,
selected_actions[i]);
gtk_action_set_sensitive(action, selected_sensitivity);
}
}
void
-block_priority_changed_handlers(ProcData *data, bool block)
+block_priority_changed_handlers(ProcmanApp *app, bool block)
{
gint i;
if (block) {
for (i = 0; i != G_N_ELEMENTS(priority_menu_entries); ++i) {
- GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(data->action_group,
+ GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(app->action_group,
priority_menu_entries[i].name));
- g_signal_handlers_block_by_func(action, (gpointer)cb_renice, data);
+ g_signal_handlers_block_by_func(action, (gpointer)cb_renice, app);
}
} else {
for (i = 0; i != G_N_ELEMENTS(priority_menu_entries); ++i) {
- GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(data->action_group,
+ GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(app->action_group,
priority_menu_entries[i].name));
- g_signal_handlers_unblock_by_func(action, (gpointer)cb_renice, data);
+ g_signal_handlers_unblock_by_func(action, (gpointer)cb_renice, app);
}
}
}
@@ -540,11 +542,12 @@ block_priority_changed_handlers(ProcData *data, bool block)
static void
cb_toggle_tree (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings; gboolean show;
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ GSettings *settings = app->settings;
+ gboolean show;
show = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
- if (show == procdata->config.show_tree)
+ if (show == app->config.show_tree)
return;
g_settings_set_boolean (settings, "show-tree", show);
@@ -553,6 +556,6 @@ cb_toggle_tree (GtkAction *action, gpointer data)
static void
cb_proc_goto_tab (gint tab)
{
- ProcData *data = ProcData::get_instance ();
- gtk_notebook_set_current_page (GTK_NOTEBOOK (data->notebook), tab);
+ Glib::RefPtr<ProcmanApp> app = ProcmanApp::get();
+ gtk_notebook_set_current_page (GTK_NOTEBOOK (app->notebook), tab);
}
diff --git a/src/interface.h b/src/interface.h
index d6bb336..48a4a54 100644
--- a/src/interface.h
+++ b/src/interface.h
@@ -22,12 +22,12 @@
#include <glib.h>
#include <gtk/gtk.h>
-#include "procman.h"
+#include "procman-app.h"
-void create_main_window (ProcData *data, GtkApplication *application);
-void update_sensitivity (ProcData *data);
-void block_priority_changed_handlers(ProcData *data, bool block);
-void do_popup_menu(ProcData *data, GdkEventButton *event);
+void create_main_window (ProcmanApp *app);
+void update_sensitivity (ProcmanApp *app);
+void block_priority_changed_handlers(ProcmanApp *app, bool block);
+void do_popup_menu(ProcmanApp *app, GdkEventButton *event);
GtkWidget * make_title_label (const char *text);
#endif /* _PROCMAN_INTERFACE_H_ */
diff --git a/src/load-graph.cpp b/src/load-graph.cpp
index c9e3fcd..6a026ec 100644
--- a/src/load-graph.cpp
+++ b/src/load-graph.cpp
@@ -23,7 +23,7 @@
#include <algorithm>
-#include "procman.h"
+#include "procman-app.h"
#include "load-graph.h"
#include "util.h"
#include "gsm_color_button.h"
@@ -91,7 +91,7 @@ void draw_background(LoadGraph *graph) {
cr = cairo_create (graph->background);
// set the background colour
- GtkStyle *style = gtk_widget_get_style (ProcData::get_instance()->notebook);
+ GtkStyle *style = gtk_widget_get_style (ProcmanApp::get()->notebook);
gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);
cairo_paint (cr);
@@ -443,7 +443,7 @@ net_scale (LoadGraph *graph, guint64 din, guint64 dout)
const guint64 bak_max(new_max);
- if (ProcData::get_instance()->config.network_in_bits) {
+ if (ProcmanApp::get()->config.network_in_bits) {
// nice number is for the ticks
unsigned ticks = graph->num_bars();
@@ -686,7 +686,7 @@ LoadGraph::LoadGraph(guint type)
switch (type) {
case LOAD_GRAPH_CPU:
memset(&cpu, 0, sizeof cpu);
- n = ProcData::get_instance()->config.num_cpus;
+ n = ProcmanApp::get()->config.num_cpus;
for(guint i = 0; i < G_N_ELEMENTS(labels.cpu); ++i)
labels.cpu[i] = gtk_label_new(NULL);
@@ -720,26 +720,26 @@ LoadGraph::LoadGraph(guint type)
break;
}
- speed = ProcData::get_instance()->config.graph_update_interval;
+ speed = ProcmanApp::get()->config.graph_update_interval;
colors.resize(n);
switch (type) {
case LOAD_GRAPH_CPU:
- memcpy(&colors[0], ProcData::get_instance()->config.cpu_color,
+ memcpy(&colors[0], ProcmanApp::get()->config.cpu_color,
n * sizeof colors[0]);
break;
case LOAD_GRAPH_MEM:
- colors[0] = ProcData::get_instance()->config.mem_color;
- colors[1] = ProcData::get_instance()->config.swap_color;
+ colors[0] = ProcmanApp::get()->config.mem_color;
+ colors[1] = ProcmanApp::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:
- colors[0] = ProcData::get_instance()->config.net_in_color;
- colors[1] = ProcData::get_instance()->config.net_out_color;
+ colors[0] = ProcmanApp::get()->config.net_in_color;
+ colors[1] = ProcmanApp::get()->config.net_out_color;
break;
}
diff --git a/src/lsof.cpp b/src/lsof.cpp
index 430a080..c9406dc 100644
--- a/src/lsof.cpp
+++ b/src/lsof.cpp
@@ -16,7 +16,7 @@
#include <glibmm/regex.h>
-#include "procman.h"
+#include "procman-app.h"
#include "lsof.h"
#include "util.h"
@@ -89,7 +89,7 @@ namespace
GtkEntry *entry;
GtkWindow *window;
GtkLabel *count;
- ProcData *procdata;
+ ProcmanApp *app;
bool case_insensitive;
@@ -235,7 +235,7 @@ namespace
-void procman_lsof(ProcData *procdata)
+void procman_lsof(ProcmanApp *app)
{
GtkListStore *model = \
gtk_list_store_new(PROCMAN_LSOF_NCOLS,
@@ -312,7 +312,7 @@ void procman_lsof(ProcData *procdata)
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "lsof_dialog"));
- gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(procdata->app));
+ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app->main_window));
// entry = sexy_icon_entry_new();
// sexy_icon_entry_add_clear_button(SEXY_ICON_ENTRY(entry));
@@ -333,7 +333,7 @@ void procman_lsof(ProcData *procdata)
gtk_container_add(GTK_CONTAINER(scrolled), tree);
GUI *gui = new GUI; // wil be deleted by the close button or delete-event
- gui->procdata = procdata;
+ gui->app = app;
gui->model = model;
gui->window = GTK_WINDOW(dialog);
gui->entry = GTK_ENTRY(entry);
diff --git a/src/lsof.h b/src/lsof.h
index da420e2..60c4766 100644
--- a/src/lsof.h
+++ b/src/lsof.h
@@ -2,8 +2,8 @@
#define H_PROCMAN_LSOF_1161179202
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
-void procman_lsof(ProcData *data);
+void procman_lsof(ProcmanApp *app);
#endif /* H_PROCMAN_LSOF_1161179202 */
diff --git a/src/memmaps.cpp b/src/memmaps.cpp
index 9b5bbb0..49df912 100644
--- a/src/memmaps.cpp
+++ b/src/memmaps.cpp
@@ -14,7 +14,7 @@
using std::string;
-#include "procman.h"
+#include "procman-app.h"
#include "memmaps.h"
#include "proctable.h"
#include "util.h"
@@ -329,7 +329,7 @@ dialog_response (GtkDialog * dialog, gint response_id, gpointer data)
static MemMapsData*
-create_memmapsdata (ProcData *procdata)
+create_memmapsdata (ProcmanApp *app)
{
GtkWidget *tree;
GtkListStore *model;
@@ -425,7 +425,7 @@ create_memmapsdata (ProcData *procdata)
}
}
- return new MemMapsData(tree, procdata->settings);
+ return new MemMapsData(tree, app->settings);
}
@@ -448,7 +448,7 @@ static void
create_single_memmaps_dialog (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
MemMapsData *mmdata;
GtkWidget *memmapsdialog;
GtkWidget *dialog_vbox;
@@ -461,10 +461,10 @@ create_single_memmaps_dialog (GtkTreeModel *model, GtkTreePath *path,
if (!info)
return;
- mmdata = create_memmapsdata (procdata);
+ mmdata = create_memmapsdata (app);
mmdata->info = info;
- memmapsdialog = gtk_dialog_new_with_buttons (_("Memory Maps"), GTK_WINDOW (procdata->app),
+ memmapsdialog = gtk_dialog_new_with_buttons (_("Memory Maps"), GTK_WINDOW (app->main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
@@ -506,9 +506,9 @@ create_single_memmaps_dialog (GtkTreeModel *model, GtkTreePath *path,
void
-create_memmaps_dialog (ProcData *procdata)
+create_memmaps_dialog (ProcmanApp *app)
{
/* TODO: do we really want to open multiple dialogs ? */
- gtk_tree_selection_selected_foreach (procdata->selection, create_single_memmaps_dialog,
- procdata);
+ gtk_tree_selection_selected_foreach (app->selection, create_single_memmaps_dialog,
+ app);
}
diff --git a/src/memmaps.h b/src/memmaps.h
index b79476e..014591b 100644
--- a/src/memmaps.h
+++ b/src/memmaps.h
@@ -2,8 +2,8 @@
#define _PROCMAN_MEMMAPS_H_
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
-void create_memmaps_dialog (ProcData *procdata);
+void create_memmaps_dialog (ProcmanApp *app);
#endif /* _PROCMAN_MEMMAPS_H_ */
diff --git a/src/openfiles.cpp b/src/openfiles.cpp
index 9c4b36f..f9a6877 100644
--- a/src/openfiles.cpp
+++ b/src/openfiles.cpp
@@ -9,7 +9,7 @@
#include <netinet/in.h>
#include <arpa/inet.h>
-#include "procman.h"
+#include "procman-app.h"
#include "openfiles.h"
#include "proctable.h"
#include "util.h"
@@ -235,7 +235,7 @@ close_openfiles_dialog (GtkDialog *dialog, gint id, gpointer data)
static GtkWidget *
-create_openfiles_tree (ProcData *procdata)
+create_openfiles_tree (ProcmanApp *app)
{
GtkWidget *tree;
GtkListStore *model;
@@ -292,7 +292,7 @@ create_openfiles_tree (ProcData *procdata)
GTK_SORT_ASCENDING);*/
#endif
- procman_get_tree_state (procdata->settings, tree, procman::settings::open_files_tree_prefix.c_str());
+ procman_get_tree_state (app->settings, tree, procman::settings::open_files_tree_prefix.c_str());
return tree;
@@ -318,7 +318,7 @@ static void
create_single_openfiles_dialog (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
GtkWidget *openfilesdialog;
GtkWidget *cmd_grid;
GtkWidget *label;
@@ -351,10 +351,10 @@ create_single_openfiles_dialog (GtkTreeModel *model, GtkTreePath *path,
scrolled = GTK_WIDGET (gtk_builder_get_object (builder, "scrolled"));
- tree = create_openfiles_tree (procdata);
+ tree = create_openfiles_tree (app);
gtk_container_add (GTK_CONTAINER (scrolled), tree);
g_object_set_data (G_OBJECT (tree), "selected_info", info);
- g_object_set_data (G_OBJECT (tree), "settings", procdata->settings);
+ g_object_set_data (G_OBJECT (tree), "settings", app->settings);
g_signal_connect (G_OBJECT (openfilesdialog), "response",
G_CALLBACK (close_openfiles_dialog), tree);
@@ -374,8 +374,8 @@ create_single_openfiles_dialog (GtkTreeModel *model, GtkTreePath *path,
void
-create_openfiles_dialog (ProcData *procdata)
+create_openfiles_dialog (ProcmanApp *app)
{
- gtk_tree_selection_selected_foreach (procdata->selection, create_single_openfiles_dialog,
- procdata);
+ gtk_tree_selection_selected_foreach (app->selection, create_single_openfiles_dialog,
+ app);
}
diff --git a/src/openfiles.h b/src/openfiles.h
index d135942..f5a7e1c 100644
--- a/src/openfiles.h
+++ b/src/openfiles.h
@@ -3,8 +3,8 @@
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
-void create_openfiles_dialog (ProcData *procdata);
+void create_openfiles_dialog (ProcmanApp *app);
#endif
diff --git a/src/procactions.cpp b/src/procactions.cpp
index a359d43..db91b2f 100644
--- a/src/procactions.cpp
+++ b/src/procactions.cpp
@@ -26,7 +26,7 @@
#include <sys/time.h>
#include <sys/resource.h>
#include "procactions.h"
-#include "procman.h"
+#include "procman-app.h"
#include "proctable.h"
#include "procdialogs.h"
#include "callbacks.h"
@@ -61,7 +61,7 @@ renice_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter
gboolean success;
success = procdialog_create_root_password_dialog (
- PROCMAN_ACTION_RENICE, args->procdata, info->pid,
+ PROCMAN_ACTION_RENICE, args->app, info->pid,
args->nice_value);
if(success) return;
@@ -91,24 +91,24 @@ renice_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter
void
-renice (ProcData *procdata, int nice)
+renice (ProcmanApp *app, int nice)
{
- struct ReniceArgs args = { procdata, nice };
+ struct ReniceArgs 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
*/
- g_source_remove(procdata->timeout);
+ g_source_remove(app->timeout);
- gtk_tree_selection_selected_foreach(procdata->selection, renice_single_process,
+ gtk_tree_selection_selected_foreach(app->selection, renice_single_process,
&args);
- procdata->timeout = g_timeout_add(procdata->config.update_interval,
- cb_timeout,
- procdata);
+ app->timeout = g_timeout_add(app->config.update_interval,
+ cb_timeout,
+ app);
- proctable_update_all (procdata);
+ proctable_update_all (app);
}
@@ -141,7 +141,7 @@ kill_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,
gboolean success;
success = procdialog_create_root_password_dialog (
- PROCMAN_ACTION_KILL, args->procdata, info->pid,
+ PROCMAN_ACTION_KILL, args->app, info->pid,
args->signal);
if(success) return;
@@ -171,21 +171,21 @@ kill_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,
void
-kill_process (ProcData *procdata, int sig)
+kill_process (ProcmanApp *app, int sig)
{
- struct KillArgs args = { procdata, sig };
+ struct KillArgs 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
*/
- g_source_remove (procdata->timeout);
+ g_source_remove (app->timeout);
- gtk_tree_selection_selected_foreach (procdata->selection, kill_single_process,
+ gtk_tree_selection_selected_foreach (app->selection, kill_single_process,
&args);
- procdata->timeout = g_timeout_add (procdata->config.update_interval,
- cb_timeout,
- procdata);
- proctable_update_all (procdata);
+ app->timeout = g_timeout_add (app->config.update_interval,
+ cb_timeout,
+ app);
+ proctable_update_all (app);
}
diff --git a/src/procactions.h b/src/procactions.h
index 95e5ccb..35a9599 100644
--- a/src/procactions.h
+++ b/src/procactions.h
@@ -19,10 +19,10 @@
#ifndef _PROCACTIONS_H_
#define _PROCACTIONS_H_
-#include "procman.h"
+#include "procman-app.h"
-void renice (ProcData *procdata, int nice);
-void kill_process (ProcData *procdata, int sig);
+void renice (ProcmanApp *app, int nice);
+void kill_process (ProcmanApp *app, int sig);
#endif
diff --git a/src/procdialogs.cpp b/src/procdialogs.cpp
index 7e9b1b7..e690e5b 100644
--- a/src/procdialogs.cpp
+++ b/src/procdialogs.cpp
@@ -56,28 +56,28 @@ kill_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
gtk_widget_destroy (GTK_WIDGET (dialog));
if (id == GTK_RESPONSE_OK)
- kill_process (kargs->procdata, kargs->signal);
+ kill_process (kargs->app, kargs->signal);
g_free (kargs);
}
void
-procdialog_create_kill_dialog (ProcData *procdata, int signal)
+procdialog_create_kill_dialog (ProcmanApp *app, int signal)
{
GtkWidget *kill_alert_dialog;
gchar *primary, *secondary, *button_text;
struct KillArgs *kargs;
kargs = g_new(KillArgs, 1);
- kargs->procdata = procdata;
+ kargs->app = app;
kargs->signal = signal;
if (signal == SIGKILL) {
/*xgettext: primary alert message*/
primary = g_strdup_printf (_("Kill the selected process â%sâ (PID: %u)?"),
- procdata->selected_process->name,
- procdata->selected_process->pid);
+ app->selected_process->name,
+ app->selected_process->pid);
/*xgettext: secondary alert message*/
secondary = _("Killing a process may destroy data, break the "
"session or introduce a security risk. "
@@ -87,8 +87,8 @@ procdialog_create_kill_dialog (ProcData *procdata, int signal)
else {
/*xgettext: primary alert message*/
primary = g_strdup_printf (_("End the selected process â%sâ (PID: %u)?"),
- procdata->selected_process->name,
- procdata->selected_process->pid);
+ app->selected_process->name,
+ app->selected_process->pid);
/*xgettext: secondary alert message*/
secondary = _("Ending a process may destroy data, break the "
"session or introduce a security risk. "
@@ -96,7 +96,7 @@ procdialog_create_kill_dialog (ProcData *procdata, int signal)
button_text = _("_End Process");
}
- kill_alert_dialog = gtk_message_dialog_new (GTK_WINDOW (procdata->app),
+ kill_alert_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,
@@ -137,12 +137,11 @@ renice_scale_changed (GtkAdjustment *adj, gpointer data)
static void
renice_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
-
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
if (id == 100) {
if (new_nice_value == -100)
return;
- renice(procdata, new_nice_value);
+ renice(app, new_nice_value);
}
gtk_widget_destroy (GTK_WIDGET (dialog));
@@ -150,9 +149,9 @@ renice_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
}
void
-procdialog_create_renice_dialog (ProcData *procdata)
+procdialog_create_renice_dialog (ProcmanApp *app)
{
- ProcInfo *info = procdata->selected_process;
+ ProcInfo *info = app->selected_process;
GtkWidget *label;
GtkWidget *priority_label;
GtkAdjustment *renice_adj;
@@ -200,7 +199,7 @@ procdialog_create_renice_dialog (ProcData *procdata)
g_free (text);
g_signal_connect (G_OBJECT (renice_dialog), "response",
- G_CALLBACK (renice_dialog_button_pressed), procdata);
+ G_CALLBACK (renice_dialog_button_pressed), app);
g_signal_connect (G_OBJECT (renice_adj), "value_changed",
G_CALLBACK (renice_scale_changed), priority_label);
@@ -235,8 +234,8 @@ prefs_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
static void
show_kill_dialog_toggled (GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ GSettings *settings = app->settings;
gboolean toggled;
@@ -250,8 +249,8 @@ show_kill_dialog_toggled (GtkToggleButton *button, gpointer data)
static void
solaris_mode_toggled(GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ GSettings *settings = app->settings;
gboolean toggled;
toggled = gtk_toggle_button_get_active(button);
@@ -262,8 +261,8 @@ solaris_mode_toggled(GtkToggleButton *button, gpointer data)
static void
network_in_bits_toggled(GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ GSettings *settings = app->settings;
gboolean toggled;
toggled = gtk_toggle_button_get_active(button);
@@ -275,8 +274,8 @@ network_in_bits_toggled(GtkToggleButton *button, gpointer data)
static void
smooth_refresh_toggled(GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ GSettings *settings = app->settings;
gboolean toggled;
@@ -290,8 +289,8 @@ smooth_refresh_toggled(GtkToggleButton *button, gpointer data)
static void
show_all_fs_toggled (GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+ GSettings *settings = app->settings;
gboolean toggled;
@@ -322,7 +321,7 @@ private:
{
int new_value = int(1000 * gtk_spin_button_get_value(spin));
- g_settings_set_int(ProcData::get_instance()->settings,
+ g_settings_set_int(ProcmanApp::get()->settings,
this->key.c_str(), new_value);
procman_debug("set %s to %d", this->key.c_str(), new_value);
@@ -342,7 +341,7 @@ field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
GtkTreeIter iter;
GtkTreeViewColumn *column;
gboolean toggled;
- GSettings *settings = g_settings_get_child (ProcData::get_instance()->settings, "proctree");
+ GSettings *settings = g_settings_get_child (ProcmanApp::get()->settings, "proctree");
gchar *key;
int id;
@@ -443,7 +442,7 @@ create_field_page(GtkBuilder* builder, GtkWidget *tree, const gchar *widgetname)
}
void
-procdialog_create_preferences_dialog (ProcData *procdata)
+procdialog_create_preferences_dialog (ProcmanApp *app)
{
typedef SpinButtonUpdater SBU;
@@ -473,7 +472,7 @@ procdialog_create_preferences_dialog (ProcData *procdata)
spin_button = GTK_WIDGET (gtk_builder_get_object (builder, "processes_interval_spinner"));
- update = (gfloat) procdata->config.update_interval;
+ update = (gfloat) app->config.update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0,
MIN_UPDATE_INTERVAL / 1000,
MAX_UPDATE_INTERVAL / 1000,
@@ -487,27 +486,27 @@ procdialog_create_preferences_dialog (ProcData *procdata)
smooth_button = GTK_WIDGET (gtk_builder_get_object (builder, "smooth_button"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button),
- g_settings_get_boolean(procdata->settings,
+ g_settings_get_boolean(app->settings,
SmoothRefresh::KEY.c_str()));
g_signal_connect(G_OBJECT(smooth_button), "toggled",
- G_CALLBACK(smooth_refresh_toggled), procdata);
+ G_CALLBACK(smooth_refresh_toggled), app);
check_button = GTK_WIDGET (gtk_builder_get_object (builder, "check_button"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
- procdata->config.show_kill_warning);
+ app->config.show_kill_warning);
g_signal_connect (G_OBJECT (check_button), "toggled",
- G_CALLBACK (show_kill_dialog_toggled), procdata);
+ G_CALLBACK (show_kill_dialog_toggled), app);
GtkWidget *solaris_button = GTK_WIDGET (gtk_builder_get_object (builder, "solaris_button"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button),
- g_settings_get_boolean(procdata->settings,
+ g_settings_get_boolean(app->settings,
procman::settings::solaris_mode.c_str()));
g_signal_connect(G_OBJECT(solaris_button), "toggled",
- G_CALLBACK(solaris_mode_toggled), procdata);
+ G_CALLBACK(solaris_mode_toggled), app);
- create_field_page (builder, procdata->tree, "processes_columns_treeview");
+ create_field_page (builder, app->tree, "processes_columns_treeview");
- update = (gfloat) procdata->config.graph_update_interval;
+ update = (gfloat) app->config.graph_update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25,
100.0, 0.25, 1.0, 0);
spin_button = GTK_WIDGET (gtk_builder_get_object (builder, "resources_interval_spinner"));
@@ -519,12 +518,12 @@ procdialog_create_preferences_dialog (ProcData *procdata)
GtkWidget *bits_button = GTK_WIDGET (gtk_builder_get_object (builder, "bits_button"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button),
- g_settings_get_boolean(procdata->settings,
+ g_settings_get_boolean(app->settings,
procman::settings::network_in_bits.c_str()));
g_signal_connect(G_OBJECT(bits_button), "toggled",
- G_CALLBACK(network_in_bits_toggled), procdata);
+ G_CALLBACK(network_in_bits_toggled), app);
- update = (gfloat) procdata->config.disks_update_interval;
+ update = (gfloat) app->config.disks_update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0,
100.0, 1.0, 1.0, 0);
spin_button = GTK_WIDGET (gtk_builder_get_object (builder, "devices_interval_spinner"));
@@ -536,17 +535,17 @@ procdialog_create_preferences_dialog (ProcData *procdata)
check_button = GTK_WIDGET (gtk_builder_get_object (builder, "all_devices_check"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
- procdata->config.show_all_fs);
+ app->config.show_all_fs);
g_signal_connect (G_OBJECT (check_button), "toggled",
- G_CALLBACK (show_all_fs_toggled), procdata);
+ G_CALLBACK (show_all_fs_toggled), app);
- create_field_page (builder, procdata->disk_list, "devices_columns_treeview");
+ create_field_page (builder, app->disk_list, "devices_columns_treeview");
gtk_widget_show_all (prefs_dialog);
g_signal_connect (G_OBJECT (prefs_dialog), "response",
- G_CALLBACK (prefs_dialog_button_pressed), procdata);
+ G_CALLBACK (prefs_dialog_button_pressed), app);
- switch (procdata->config.current_tab) {
+ switch (app->config.current_tab) {
case PROCMAN_TAB_SYSINFO:
case PROCMAN_TAB_PROCESSES:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
@@ -589,7 +588,7 @@ procman_action_to_command(ProcmanActionType type,
*/
gboolean
procdialog_create_root_password_dialog(ProcmanActionType type,
- ProcData *procdata,
+ ProcmanApp *app,
gint pid,
gint extra_value)
{
diff --git a/src/procdialogs.h b/src/procdialogs.h
index 752fa35..1b8c130 100644
--- a/src/procdialogs.h
+++ b/src/procdialogs.h
@@ -21,7 +21,7 @@
#include <glib.h>
-#include "procman.h"
+#include "procman-app.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
@@ -42,13 +42,13 @@ typedef enum
} ProcmanActionType;
-void procdialog_create_kill_dialog (ProcData *data, int signal);
-void procdialog_create_renice_dialog (ProcData *data);
+void procdialog_create_kill_dialog (ProcmanApp *app, int signal);
+void procdialog_create_renice_dialog (ProcmanApp *app);
gboolean procdialog_create_root_password_dialog (ProcmanActionType type,
- ProcData *procdata,
+ ProcmanApp *app,
gint pid, gint extra_value);
-void procdialog_create_memmaps_dialog (ProcData *data);
-void procdialog_create_preferences_dialog (ProcData *data);
+void procdialog_create_memmaps_dialog (ProcmanApp *app);
+void procdialog_create_preferences_dialog (ProcmanApp *app);
#endif
diff --git a/src/procman-app.cpp b/src/procman-app.cpp
index 9215cc6..1a6ef38 100644
--- a/src/procman-app.cpp
+++ b/src/procman-app.cpp
@@ -5,7 +5,6 @@
#include <glibtop/close.h>
#include "procman-app.h"
-#include "procman.h"
#include "interface.h"
#include "proctable.h"
#include "callbacks.h"
@@ -15,124 +14,124 @@
#include "util.h"
static void
-mount_changed(const Glib::RefPtr<Gio::Mount>&)
+mount_changed(const Glib::RefPtr<Gio::Mount>&, ProcmanApp *app)
{
- cb_update_disks(ProcData::get_instance());
+ cb_update_disks(app);
}
static void
-init_volume_monitor(ProcData *procdata)
+init_volume_monitor(ProcmanApp *app)
{
using namespace Gio;
using namespace Glib;
RefPtr<VolumeMonitor> monitor = VolumeMonitor::get();
- monitor->signal_mount_added().connect(sigc::ptr_fun(&mount_changed));
- monitor->signal_mount_changed().connect(sigc::ptr_fun(&mount_changed));
- monitor->signal_mount_removed().connect(sigc::ptr_fun(&mount_changed));
+ monitor->signal_mount_added().connect(sigc::bind<ProcmanApp *>(sigc::ptr_fun(&mount_changed), app));
+ monitor->signal_mount_changed().connect(sigc::bind<ProcmanApp *>(sigc::ptr_fun(&mount_changed), app));
+ monitor->signal_mount_removed().connect(sigc::bind<ProcmanApp *>(sigc::ptr_fun(&mount_changed), app));
}
static void
tree_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procdata->config.show_tree = g_settings_get_boolean(settings, key);
+ app->config.show_tree = g_settings_get_boolean(settings, key);
- g_object_set(G_OBJECT(procdata->tree),
- "show-expanders", procdata->config.show_tree,
+ g_object_set(G_OBJECT(app->tree),
+ "show-expanders", app->config.show_tree,
NULL);
- proctable_clear_tree (procdata);
- proctable_update_all (procdata);
+ proctable_clear_tree (app);
+ proctable_update_all (app);
}
static void
solaris_mode_changed_cb(GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procdata->config.solaris_mode = g_settings_get_boolean(settings, key);
- proctable_update_all (procdata);
+ app->config.solaris_mode = g_settings_get_boolean(settings, key);
+ proctable_update_all (app);
}
static void
network_in_bits_changed_cb(GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procdata->config.network_in_bits = g_settings_get_boolean(settings, key);
+ app->config.network_in_bits = g_settings_get_boolean(settings, key);
// force scale to be redrawn
- procdata->net_graph->clear_background();
+ app->net_graph->clear_background();
}
static void
view_as_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procdata->config.whose_process = g_settings_get_int (settings, key);
- procdata->config.whose_process = CLAMP (procdata->config.whose_process, 0, 2);
- proctable_clear_tree (procdata);
- proctable_update_all (procdata);
+ app->config.whose_process = g_settings_get_int (settings, key);
+ app->config.whose_process = CLAMP (app->config.whose_process, 0, 2);
+ proctable_clear_tree (app);
+ proctable_update_all (app);
}
static void
warning_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
if (g_str_equal (key, "kill-dialog")) {
- procdata->config.show_kill_warning = g_settings_get_boolean (settings, key);
+ app->config.show_kill_warning = g_settings_get_boolean (settings, key);
}
}
static void
timeouts_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
if (g_str_equal (key, "update-interval")) {
- procdata->config.update_interval = g_settings_get_int (settings, key);
- procdata->config.update_interval =
- MAX (procdata->config.update_interval, 1000);
+ app->config.update_interval = g_settings_get_int (settings, key);
+ app->config.update_interval =
+ MAX (app->config.update_interval, 1000);
- procdata->smooth_refresh->reset();
+ app->smooth_refresh->reset();
- if(procdata->timeout) {
- g_source_remove (procdata->timeout);
- procdata->timeout = g_timeout_add (procdata->config.update_interval,
- cb_timeout,
- procdata);
+ if(app->timeout) {
+ g_source_remove (app->timeout);
+ app->timeout = g_timeout_add (app->config.update_interval,
+ cb_timeout,
+ app);
}
}
else if (g_str_equal (key, "graph-update-interval")){
- procdata->config.graph_update_interval = g_settings_get_int (settings, key);
- procdata->config.graph_update_interval =
- MAX (procdata->config.graph_update_interval,
+ app->config.graph_update_interval = g_settings_get_int (settings, key);
+ app->config.graph_update_interval =
+ MAX (app->config.graph_update_interval,
250);
- load_graph_change_speed(procdata->cpu_graph,
- procdata->config.graph_update_interval);
- load_graph_change_speed(procdata->mem_graph,
- procdata->config.graph_update_interval);
- load_graph_change_speed(procdata->net_graph,
- procdata->config.graph_update_interval);
+ 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 (g_str_equal(key, "disks-interval")) {
- procdata->config.disks_update_interval = g_settings_get_int (settings, key);
- procdata->config.disks_update_interval =
- MAX (procdata->config.disks_update_interval, 1000);
+ app->config.disks_update_interval = g_settings_get_int (settings, key);
+ app->config.disks_update_interval =
+ MAX (app->config.disks_update_interval, 1000);
- if(procdata->disk_timeout) {
- g_source_remove (procdata->disk_timeout);
- procdata->disk_timeout = \
- g_timeout_add (procdata->config.disks_update_interval,
+ if(app->disk_timeout) {
+ g_source_remove (app->disk_timeout);
+ app->disk_timeout = \
+ g_timeout_add (app->config.disks_update_interval,
cb_update_disks,
- procdata);
+ app);
}
}
else {
@@ -141,8 +140,10 @@ timeouts_changed_cb (GSettings *settings, const gchar *key, gpointer data)
}
static void
-apply_cpu_color_settings(GSettings *settings, ProcData * const procdata)
+apply_cpu_color_settings(GSettings *settings, gpointer data)
{
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+
GVariant *cpu_colors_var = g_settings_get_value(settings, "cpu-colors");
gsize n = g_variant_n_children(cpu_colors_var);
@@ -155,7 +156,7 @@ apply_cpu_color_settings(GSettings *settings, ProcData * const procdata)
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
- for (guint i = 0; i < static_cast<guint>(procdata->config.num_cpus); i++) {
+ 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);
@@ -164,12 +165,12 @@ apply_cpu_color_settings(GSettings *settings, ProcData * const procdata)
color = g_strdup ("#f25915e815e8");
g_variant_builder_add(&builder, "(us)", i, color);
}
- gdk_color_parse(color, &procdata->config.cpu_color[i]);
+ gdk_color_parse(color, &app->config.cpu_color[i]);
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>(procdata->config.num_cpus)) {
+ if (n < static_cast<guint>(app->config.num_cpus)) {
g_settings_set_value(settings, "cpu-colors", full);
}
}
@@ -177,13 +178,13 @@ apply_cpu_color_settings(GSettings *settings, ProcData * const procdata)
static void
color_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
if (g_str_equal (key, "cpu-colors")) {
- apply_cpu_color_settings(settings, procdata);
- for (int i = 0; i < procdata->config.num_cpus; i++) {
- if(!gdk_color_equal(&procdata->cpu_graph->colors[i], &procdata->config.cpu_color[i])) {
- procdata->cpu_graph->colors[i] = procdata->config.cpu_color[i];
+ apply_cpu_color_settings(settings, app);
+ for (int i = 0; i < app->config.num_cpus; i++) {
+ if(!gdk_color_equal(&app->cpu_graph->colors[i], &app->config.cpu_color[i])) {
+ app->cpu_graph->colors[i] = app->config.cpu_color[i];
break;
}
}
@@ -192,20 +193,20 @@ color_changed_cb (GSettings *settings, const gchar *key, gpointer data)
const gchar *color = g_settings_get_string (settings, key);
if (g_str_equal (key, "mem-color")) {
- gdk_color_parse (color, &procdata->config.mem_color);
- procdata->mem_graph->colors.at(0) = procdata->config.mem_color;
+ gdk_color_parse (color, &app->config.mem_color);
+ app->mem_graph->colors.at(0) = app->config.mem_color;
}
else if (g_str_equal (key, "swap-color")) {
- gdk_color_parse (color, &procdata->config.swap_color);
- procdata->mem_graph->colors.at(1) = procdata->config.swap_color;
+ gdk_color_parse (color, &app->config.swap_color);
+ app->mem_graph->colors.at(1) = app->config.swap_color;
}
else if (g_str_equal (key, "net-in-color")) {
- gdk_color_parse (color, &procdata->config.net_in_color);
- procdata->net_graph->colors.at(0) = procdata->config.net_in_color;
+ gdk_color_parse (color, &app->config.net_in_color);
+ app->net_graph->colors.at(0) = app->config.net_in_color;
}
else if (g_str_equal (key, "net-out-color")) {
- gdk_color_parse (color, &procdata->config.net_out_color);
- procdata->net_graph->colors.at(1) = procdata->config.net_out_color;
+ gdk_color_parse (color, &app->config.net_out_color);
+ app->net_graph->colors.at(1) = app->config.net_out_color;
}
else {
g_assert_not_reached();
@@ -215,84 +216,83 @@ color_changed_cb (GSettings *settings, const gchar *key, gpointer data)
static void
show_all_fs_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
- procdata->config.show_all_fs = g_settings_get_boolean (settings, key);
+ app->config.show_all_fs = g_settings_get_boolean (settings, key);
- cb_update_disks (data);
+ cb_update_disks (app);
}
-static ProcData *
-procman_data_new (GSettings *settings)
+void
+ProcmanApp::load_settings()
{
- ProcData *pd;
gchar *color;
gint swidth, sheight;
gint i;
glibtop_cpu cpu;
- pd = ProcData::get_instance();
+ settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
- pd->config.width = g_settings_get_int (settings, "width");
- pd->config.height = g_settings_get_int (settings, "height");
- pd->config.xpos = g_settings_get_int (settings, "x-position");
- pd->config.ypos = g_settings_get_int (settings, "y-position");
- pd->config.maximized = g_settings_get_boolean (settings, "maximized");
+ config.width = g_settings_get_int (settings, "width");
+ config.height = g_settings_get_int (settings, "height");
+ config.xpos = g_settings_get_int (settings, "x-position");
+ config.ypos = g_settings_get_int (settings, "y-position");
+ config.maximized = g_settings_get_boolean (settings, "maximized");
- pd->config.show_tree = g_settings_get_boolean (settings, "show-tree");
- g_signal_connect (G_OBJECT(settings), "changed::show-tree", G_CALLBACK(tree_changed_cb), pd);
+ config.show_tree = g_settings_get_boolean (settings, "show-tree");
+ g_signal_connect (G_OBJECT(settings), "changed::show-tree", G_CALLBACK(tree_changed_cb), this);
- pd->config.solaris_mode = g_settings_get_boolean(settings, procman::settings::solaris_mode.c_str());
+ config.solaris_mode = g_settings_get_boolean(settings, procman::settings::solaris_mode.c_str());
std::string detail_string("changed::" + procman::settings::solaris_mode);
- g_signal_connect(G_OBJECT(settings), detail_string.c_str(), G_CALLBACK(solaris_mode_changed_cb), pd);
+ g_signal_connect(G_OBJECT(settings), detail_string.c_str(), G_CALLBACK(solaris_mode_changed_cb), this);
- pd->config.network_in_bits = g_settings_get_boolean(settings, procman::settings::network_in_bits.c_str());
+ config.network_in_bits = g_settings_get_boolean(settings, procman::settings::network_in_bits.c_str());
detail_string = "changed::" + procman::settings::network_in_bits;
- g_signal_connect(G_OBJECT(settings), detail_string.c_str(), G_CALLBACK(network_in_bits_changed_cb), pd);
+ g_signal_connect(G_OBJECT(settings), detail_string.c_str(), G_CALLBACK(network_in_bits_changed_cb), this);
- pd->config.show_kill_warning = g_settings_get_boolean (settings, "kill-dialog");
- g_signal_connect (G_OBJECT(settings), "changed::kill-dialog", G_CALLBACK(warning_changed_cb), pd);
- pd->config.update_interval = g_settings_get_int (settings, "update-interval");
- g_signal_connect (G_OBJECT(settings), "changed::update-interval", G_CALLBACK(timeouts_changed_cb), pd);
- pd->config.graph_update_interval = g_settings_get_int (settings,
+ config.show_kill_warning = g_settings_get_boolean (settings, "kill-dialog");
+ g_signal_connect (G_OBJECT(settings), "changed::kill-dialog", G_CALLBACK(warning_changed_cb), this);
+ config.update_interval = g_settings_get_int (settings, "update-interval");
+ g_signal_connect (G_OBJECT(settings), "changed::update-interval", G_CALLBACK(timeouts_changed_cb), this);
+ config.graph_update_interval = g_settings_get_int (settings,
"graph-update-interval");
g_signal_connect (G_OBJECT(settings), "changed::graph-update-interval",
- G_CALLBACK(timeouts_changed_cb), pd);
- pd->config.disks_update_interval = g_settings_get_int (settings, "disks-interval");
- g_signal_connect (G_OBJECT(settings), "changed::disks-interval", G_CALLBACK(timeouts_changed_cb), pd);
+ G_CALLBACK(timeouts_changed_cb), this);
+ config.disks_update_interval = g_settings_get_int (settings, "disks-interval");
+ g_signal_connect (G_OBJECT(settings), "changed::disks-interval", G_CALLBACK(timeouts_changed_cb), this);
/* show_all_fs */
- pd->config.show_all_fs = g_settings_get_boolean (settings, "show-all-fs");
- g_signal_connect (settings, "changed::show-all-fs", G_CALLBACK(show_all_fs_changed_cb), pd);
+ config.show_all_fs = g_settings_get_boolean (settings, "show-all-fs");
+ g_signal_connect (settings, "changed::show-all-fs", G_CALLBACK(show_all_fs_changed_cb), this);
- pd->config.whose_process = g_settings_get_int (settings, "view-as");
- g_signal_connect (G_OBJECT(settings), "changed::view-as", G_CALLBACK(view_as_changed_cb),pd);
- pd->config.current_tab = g_settings_get_int (settings, "current-tab");
+ config.whose_process = g_settings_get_int (settings, "view-as");
+ g_signal_connect (G_OBJECT(settings), "changed::view-as", G_CALLBACK(view_as_changed_cb), this);
+ config.current_tab = g_settings_get_int (settings, "current-tab");
/* Determine number of cpus since libgtop doesn't really tell you*/
- pd->config.num_cpus = 0;
+ config.num_cpus = 0;
glibtop_get_cpu (&cpu);
- pd->frequency = cpu.frequency;
+ frequency = cpu.frequency;
i=0;
while (i < GLIBTOP_NCPU && cpu.xcpu_total[i] != 0) {
- pd->config.num_cpus ++;
+ config.num_cpus ++;
i++;
}
- if (pd->config.num_cpus == 0)
- pd->config.num_cpus = 1;
+ if (config.num_cpus == 0)
+ config.num_cpus = 1;
- apply_cpu_color_settings(settings, pd);
+ apply_cpu_color_settings(settings, this);
g_signal_connect (G_OBJECT(settings), "changed::cpu-colors",
- G_CALLBACK(color_changed_cb), pd);
+ G_CALLBACK(color_changed_cb), this);
color = g_settings_get_string (settings, "mem-color");
if (!color)
color = g_strdup ("#000000ff0082");
g_signal_connect (G_OBJECT(settings), "changed::mem-color",
- G_CALLBACK(color_changed_cb), pd);
- gdk_color_parse(color, &pd->config.mem_color);
+ G_CALLBACK(color_changed_cb), this);
+ gdk_color_parse(color, &config.mem_color);
g_free (color);
@@ -300,77 +300,219 @@ procman_data_new (GSettings *settings)
if (!color)
color = g_strdup ("#00b6000000ff");
g_signal_connect (G_OBJECT(settings), "changed::swap-color",
- G_CALLBACK(color_changed_cb), pd);
- gdk_color_parse(color, &pd->config.swap_color);
+ G_CALLBACK(color_changed_cb), this);
+ gdk_color_parse(color, &config.swap_color);
g_free (color);
color = g_settings_get_string (settings, "net-in-color");
if (!color)
color = g_strdup ("#000000f200f2");
g_signal_connect (G_OBJECT(settings), "changed::net-in-color",
- G_CALLBACK(color_changed_cb), pd);
- gdk_color_parse(color, &pd->config.net_in_color);
+ G_CALLBACK(color_changed_cb), this);
+ gdk_color_parse(color, &config.net_in_color);
g_free (color);
color = g_settings_get_string (settings, "net-out-color");
if (!color)
color = g_strdup ("#00f2000000c1");
g_signal_connect (G_OBJECT(settings), "changed::net-out-color",
- G_CALLBACK(color_changed_cb), pd);
- gdk_color_parse(color, &pd->config.net_out_color);
+ G_CALLBACK(color_changed_cb), this);
+ gdk_color_parse(color, &config.net_out_color);
g_free (color);
/* Sanity checks */
swidth = gdk_screen_width ();
sheight = gdk_screen_height ();
- pd->config.width = CLAMP (pd->config.width, 50, swidth);
- pd->config.height = CLAMP (pd->config.height, 50, sheight);
- pd->config.update_interval = MAX (pd->config.update_interval, 1000);
- pd->config.graph_update_interval = MAX (pd->config.graph_update_interval, 250);
- pd->config.disks_update_interval = MAX (pd->config.disks_update_interval, 1000);
- pd->config.whose_process = CLAMP (pd->config.whose_process, 0, 2);
- pd->config.current_tab = CLAMP(pd->config.current_tab,
- PROCMAN_TAB_SYSINFO,
- PROCMAN_TAB_DISKS);
-
- // delayed initialization as SmoothRefresh() needs ProcData
- // i.e. we can't call ProcData::get_instance
- pd->smooth_refresh = new SmoothRefresh(settings);
+ config.width = CLAMP (config.width, 50, swidth);
+ config.height = CLAMP (config.height, 50, sheight);
+ config.update_interval = MAX (config.update_interval, 1000);
+ config.graph_update_interval = MAX (config.graph_update_interval, 250);
+ config.disks_update_interval = MAX (config.disks_update_interval, 1000);
+ config.whose_process = CLAMP (config.whose_process, 0, 2);
+ config.current_tab = CLAMP(config.current_tab,
+ PROCMAN_TAB_SYSINFO,
+ PROCMAN_TAB_DISKS);
+}
- pd->terminating = FALSE;
+ProcmanApp::ProcmanApp() : Gtk::Application("org.gnome.SystemMonitor", Gio::APPLICATION_HANDLES_COMMAND_LINE)
+{
+ Glib::set_application_name(_("System Monitor"));
+}
- return pd;
+Glib::RefPtr<ProcmanApp> ProcmanApp::get ()
+{
+ static Glib::RefPtr<ProcmanApp> singleton;
+ if (!singleton) {
+ singleton = Glib::RefPtr<ProcmanApp>(new ProcmanApp());
+ }
+ return singleton;
}
-static void
-procman_free_data (ProcData *procdata)
+void ProcmanApp::on_activate()
{
-
- proctable_free_table (procdata);
- delete procdata->smooth_refresh;
+ gtk_window_present (GTK_WINDOW (main_window));
}
-ProcmanApp::ProcmanApp() : Gtk::Application("org.gnome.SystemMonitor", Gio::APPLICATION_HANDLES_COMMAND_LINE)
+static void
+set_tab(GtkNotebook* notebook, gint tab, ProcmanApp *app)
{
- Glib::set_application_name(_("System Monitor"));
+ gtk_notebook_set_current_page(notebook, tab);
+ cb_change_current_page(notebook, tab, app);
}
-Glib::RefPtr<ProcmanApp> ProcmanApp::create ()
+gboolean
+procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
{
- return Glib::RefPtr<ProcmanApp>(new ProcmanApp());
+ GtkTreeModel *model;
+ GList *columns, *it;
+ gint sort_col;
+ GtkSortType order;
+
+ g_assert(tree);
+ g_assert(child_schema);
+
+ GSettings *pt_settings = g_settings_get_child (settings, child_schema);
+
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
+
+ sort_col = g_settings_get_int (pt_settings, "sort-col");
+
+ order = static_cast<GtkSortType>(g_settings_get_int (pt_settings, "sort-order"));
+
+ if (sort_col != -1)
+ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
+ sort_col,
+ order);
+
+ columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
+
+ if(!g_strcmp0(child_schema, "proctree"))
+ {
+ for(it = columns; it; it = it->next)
+ {
+ GtkTreeViewColumn *column;
+ gint width;
+ gboolean visible;
+ int id;
+ gchar *key;
+
+ column = static_cast<GtkTreeViewColumn*>(it->data);
+ id = gtk_tree_view_column_get_sort_column_id (column);
+
+ key = g_strdup_printf ("col-%d-width", id);
+ g_settings_get (pt_settings, key, "i", &width);
+ g_free (key);
+
+ key = g_strdup_printf ("col-%d-visible", id);
+ visible = g_settings_get_boolean (pt_settings, key);
+ g_free (key);
+
+ column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree), id);
+ if(!column) continue;
+ gtk_tree_view_column_set_visible (column, visible);
+ if (visible) {
+ /* ensure column is really visible */
+ width = MAX(width, 10);
+ gtk_tree_view_column_set_fixed_width(column, width);
+ }
+ }
+ }
+
+ if(!g_strcmp0(child_schema, "proctree") ||
+ !g_strcmp0(child_schema, "disktreenew"))
+ {
+ GVariant *value;
+ GVariantIter iter;
+ int sortIndex;
+
+ GSList *order = NULL;
+
+ value = g_settings_get_value(pt_settings, "columns-order");
+ g_variant_iter_init(&iter, value);
+
+ while (g_variant_iter_loop (&iter, "i", &sortIndex))
+ order = g_slist_append(order, GINT_TO_POINTER(sortIndex));
+
+ proctable_set_columns_order(GTK_TREE_VIEW(tree), order);
+
+ g_slist_free(order);
+ }
+
+ g_object_unref(pt_settings);
+ pt_settings = NULL;
+
+ g_list_free(columns);
+
+ return TRUE;
}
-void ProcmanApp::on_activate()
+void
+procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
{
- gtk_window_present (GTK_WINDOW (procdata->app));
+ GtkTreeModel *model;
+ GList *columns;
+ gint sort_col;
+ GtkSortType order;
+
+ g_assert(tree);
+ g_assert(child_schema);
+
+ GSettings *pt_settings = g_settings_get_child (settings, child_schema);
+
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
+ if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), &sort_col,
+ &order)) {
+ g_settings_set_int (pt_settings, "sort-col", sort_col);
+ g_settings_set_int (pt_settings, "sort-order", order);
+ }
+
+ columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
+
+ if(!g_strcmp0(child_schema, "proctree") || !g_strcmp0(child_schema, "disktreenew"))
+ {
+ GSList *order;
+ GSList *order_node;
+ GVariantBuilder *builder;
+ GVariant *order_variant;
+
+ order = proctable_get_columns_order(GTK_TREE_VIEW(tree));
+
+ builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
+
+ for(order_node = order; order_node; order_node = order_node->next)
+ g_variant_builder_add(builder, "i", GPOINTER_TO_INT(order_node->data));
+
+ order_variant = g_variant_new("ai", builder);
+ g_settings_set_value(pt_settings, "columns-order", order_variant);
+
+ g_slist_free(order);
+ }
+
+ g_list_free(columns);
}
-static void
-set_tab(GtkNotebook* notebook, gint tab, ProcData* procdata)
+void
+ProcmanApp::save_config ()
{
- gtk_notebook_set_current_page(notebook, tab);
- cb_change_current_page(notebook, tab, procdata);
+ procman_save_tree_state (settings, tree, "proctree");
+ procman_save_tree_state (settings, disk_list, "disktreenew");
+
+ config.width = gdk_window_get_width (gtk_widget_get_window (main_window));
+ config.height = gdk_window_get_height(gtk_widget_get_window (main_window));
+ gtk_window_get_position(GTK_WINDOW(main_window), &config.xpos, &config.ypos);
+
+ config.maximized = gdk_window_get_state(gtk_widget_get_window (main_window)) & GDK_WINDOW_STATE_MAXIMIZED;
+
+ g_settings_set_int (settings, "width", config.width);
+ g_settings_set_int (settings, "height", config.height);
+ g_settings_set_int (settings, "x-position", config.xpos);
+ g_settings_set_int (settings, "y-position", config.ypos);
+ g_settings_set_boolean (settings, "maximized", config.maximized);
+
+ g_settings_set_int (settings, "current-tab", config.current_tab);
+
+ g_settings_sync ();
}
int ProcmanApp::on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>& command_line)
@@ -392,16 +534,16 @@ int ProcmanApp::on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>&
if (option_group.show_system_tab) {
procman_debug("Starting with PROCMAN_TAB_SYSINFO by commandline request");
- set_tab(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO, procdata);
+ set_tab(GTK_NOTEBOOK(notebook), PROCMAN_TAB_SYSINFO, this);
} else if (option_group.show_processes_tab) {
procman_debug("Starting with PROCMAN_TAB_PROCESSES by commandline request");
- set_tab(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_PROCESSES, procdata);
+ set_tab(GTK_NOTEBOOK(notebook), PROCMAN_TAB_PROCESSES, this);
} else if (option_group.show_resources_tab) {
procman_debug("Starting with PROCMAN_TAB_RESOURCES by commandline request");
- set_tab(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_RESOURCES, procdata);
+ set_tab(GTK_NOTEBOOK(notebook), PROCMAN_TAB_RESOURCES, this);
} else if (option_group.show_file_systems_tab) {
procman_debug("Starting with PROCMAN_TAB_DISKS by commandline request");
- set_tab(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_DISKS, procdata);
+ set_tab(GTK_NOTEBOOK(notebook), PROCMAN_TAB_DISKS, this);
}
on_activate ();
@@ -412,27 +554,45 @@ int ProcmanApp::on_command_line(const Glib::RefPtr<Gio::ApplicationCommandLine>&
void
ProcmanApp::on_help_activate(const Glib::VariantBase&)
{
- cb_help_contents (NULL, NULL);
+ cb_help_contents (NULL, this);
}
void
ProcmanApp::on_lsof_activate(const Glib::VariantBase&)
{
- cb_show_lsof (NULL, procdata);
+ cb_show_lsof (NULL, this);
}
void
ProcmanApp::on_preferences_activate(const Glib::VariantBase&)
{
- cb_edit_preferences (NULL, procdata);
+ cb_edit_preferences (NULL, this);
}
void
ProcmanApp::on_quit_activate(const Glib::VariantBase&)
{
- this->quit();
+ shutdown ();
}
+void
+ProcmanApp::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 ProcmanApp::on_startup()
{
@@ -463,26 +623,19 @@ void ProcmanApp::on_startup()
Glib::RefPtr<Gio::Menu> menu = Glib::RefPtr<Gio::Menu>::cast_static(builder->get_object ("app-menu"));
set_app_menu (menu);
- GSettings *settings;
-
Gtk::Window::set_default_icon_name ("utilities-system-monitor");
- settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
-
glibtop_init ();
- procdata = procman_data_new (settings);
- procdata->settings = g_settings_new(GSM_GSETTINGS_SCHEMA);
+ load_settings ();
- create_main_window (procdata, this->gobj());
- init_volume_monitor (procdata);
+ pretty_table = new PrettyTable();
+ smooth_refresh = new SmoothRefresh(settings);
- gtk_widget_show (procdata->app);
- gtk_widget_set_name (procdata->app, "gnome-system-monitor");
-}
+ create_main_window (this);
-void ProcmanApp::on_shutdown()
-{
- procman_free_data(procdata);
- glibtop_close();
+ init_volume_monitor (this);
+
+ gtk_widget_show (main_window);
}
+
diff --git a/src/procman-app.h b/src/procman-app.h
index b1e24e7..280bca4 100644
--- a/src/procman-app.h
+++ b/src/procman-app.h
@@ -2,13 +2,173 @@
#define _PROCMAN_PROCMAN_APP_H_
#include <gtkmm.h>
+#include <glibtop/cpu.h>
+
+struct ProcInfo;
+struct LoadGraph;
+
+#include "smooth_refresh.h"
+#include "prettytable.h"
+
+#define GSM_GSETTINGS_SCHEMA "org.gnome.gnome-system-monitor"
+
+enum
+{
+ ALL_PROCESSES,
+ MY_PROCESSES,
+ ACTIVE_PROCESSES
+};
+
+enum
+{
+ VERY_HIGH_PRIORITY,
+ HIGH_PRIORITY,
+ NORMAL_PRIORITY,
+ LOW_PRIORITY,
+ VERY_LOW_PRIORITY,
+ CUSTOM_PRIORITY
+};
+
+static const unsigned MIN_UPDATE_INTERVAL = 1 * 1000;
+static const unsigned MAX_UPDATE_INTERVAL = 100 * 1000;
+
+
+enum ProcmanTab
+{
+ PROCMAN_TAB_SYSINFO,
+ PROCMAN_TAB_PROCESSES,
+ PROCMAN_TAB_RESOURCES,
+ PROCMAN_TAB_DISKS
+};
+
+
+struct ProcConfig
+{
+ gint width;
+ gint height;
+ gint xpos;
+ gint ypos;
+ gboolean maximized;
+ gboolean show_kill_warning;
+ gboolean show_tree;
+ gboolean show_all_fs;
+ int update_interval;
+ int graph_update_interval;
+ int disks_update_interval;
+ gint whose_process;
+ gint current_tab;
+ GdkColor cpu_color[GLIBTOP_NCPU];
+ GdkColor mem_color;
+ GdkColor swap_color;
+ GdkColor net_in_color;
+ GdkColor net_out_color;
+ GdkColor bg_color;
+ GdkColor frame_color;
+ gint num_cpus;
+ bool solaris_mode;
+ bool network_in_bits;
+};
+
+
+
+struct MutableProcInfo
+{
+MutableProcInfo()
+: status(0)
+ { }
+
+ std::string user;
+
+ gchar wchan[40];
+
+ // 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;
+
+ // wnck gives an unsigned long
+ gulong memxserver;
+
+ gulong start_time;
+ guint64 cpu_time;
+ guint status;
+ guint pcpu;
+ gint nice;
+ gchar *cgroup_name;
+
+ gchar *unit;
+ gchar *session;
+ gchar *seat;
+
+ std::string owner;
+};
+
+
+class ProcInfo
+: public MutableProcInfo
+{
+ /* undefined */ ProcInfo& operator=(const ProcInfo&);
+ /* undefined */ ProcInfo(const ProcInfo&);
+
+ typedef std::map<guint, std::string> UserMap;
+ /* cached username */
+ static UserMap users;
+
+ public:
+
+ // 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;
+ typedef List::iterator Iterator;
+
+ static List all;
+
+ static ProcInfo* find(pid_t pid);
+ static Iterator begin() { return ProcInfo::all.begin(); }
+ static Iterator end() { return ProcInfo::all.end(); }
+
+
+ ProcInfo(pid_t pid);
+ ~ProcInfo();
+ // 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;
+ gchar *tooltip;
+ gchar *name;
+ gchar *arguments;
+
+ gchar *security_context;
+
+ const guint pid;
+ guint ppid;
+ guint uid;
+
+// private:
+ // tracks cpu time per process keeps growing because if a
+ // ProcInfo is deleted this does not mean that the process is
+ // not going to be recreated on the next update. For example,
+ // if dependencies + (My or Active), the proclist is cleared
+ // on each update. This is a workaround
+ static std::map<pid_t, guint64> cpu_times;
+};
+
-#include "procman.h"
class ProcmanApp : public Gtk::Application
{
private:
- ProcData *procdata;
+ void load_settings();
void on_preferences_activate(const Glib::VariantBase&);
void on_lsof_activate(const Glib::VariantBase&);
@@ -17,12 +177,66 @@ private:
protected:
ProcmanApp();
public:
- static Glib::RefPtr<ProcmanApp> create ();
+ static Glib::RefPtr<ProcmanApp> get ();
+
+ void save_config();
+ void shutdown();
+
+ GtkUIManager *uimanager;
+ GtkActionGroup *action_group;
+ GtkWidget *tree;
+ GtkWidget *loadavg;
+ GtkWidget *endprocessbutton;
+ GtkWidget *popup_menu;
+ GtkWidget *disk_list;
+ GtkWidget *notebook;
+ ProcConfig config;
+ LoadGraph *cpu_graph;
+ LoadGraph *mem_graph;
+ LoadGraph *net_graph;
+ gint cpu_label_fixed_width;
+ gint net_label_fixed_width;
+ ProcInfo *selected_process;
+ GtkTreeSelection *selection;
+ guint timeout;
+ guint disk_timeout;
+
+ PrettyTable *pretty_table;
+
+ GSettings *settings;
+ GtkWidget *main_window;
+ GtkUIManager *menu;
+
+ 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();
- virtual void on_shutdown();
};
+struct ReniceArgs
+{
+ ProcmanApp *app;
+ int nice_value;
+};
+
+
+struct KillArgs
+{
+ ProcmanApp *app;
+ int signal;
+};
+
+
+void procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *prefix);
+gboolean procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gchar *prefix);
+
+
+
#endif /* _PROCMAN_PROCMAN_APP_H_ */
diff --git a/src/procman.cpp b/src/procman.cpp
index 33f4093..a4dee1e 100644
--- a/src/procman.cpp
+++ b/src/procman.cpp
@@ -27,192 +27,6 @@
#include <glib/gi18n.h>
#include "procman-app.h"
-#include "procman.h"
-#include "proctable.h"
-
-ProcData::ProcData()
- : tree(NULL),
- cpu_graph(NULL),
- mem_graph(NULL),
- net_graph(NULL),
- selected_process(NULL),
- timeout(0),
- disk_timeout(0),
- cpu_total_time(1),
- cpu_total_time_last(1)
-{ }
-
-
-ProcData* ProcData::get_instance()
-{
- static ProcData instance;
- return &instance;
-}
-
-gboolean
-procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
-{
- GtkTreeModel *model;
- GList *columns, *it;
- gint sort_col;
- GtkSortType order;
-
- g_assert(tree);
- g_assert(child_schema);
-
- GSettings *pt_settings = g_settings_get_child (settings, child_schema);
-
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
-
- sort_col = g_settings_get_int (pt_settings, "sort-col");
-
- order = static_cast<GtkSortType>(g_settings_get_int (pt_settings, "sort-order"));
-
- if (sort_col != -1)
- gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
- sort_col,
- order);
-
- columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
-
- if(!g_strcmp0(child_schema, "proctree"))
- {
- for(it = columns; it; it = it->next)
- {
- GtkTreeViewColumn *column;
- gint width;
- gboolean visible;
- int id;
- gchar *key;
-
- column = static_cast<GtkTreeViewColumn*>(it->data);
- id = gtk_tree_view_column_get_sort_column_id (column);
-
- key = g_strdup_printf ("col-%d-width", id);
- g_settings_get (pt_settings, key, "i", &width);
- g_free (key);
-
- key = g_strdup_printf ("col-%d-visible", id);
- visible = g_settings_get_boolean (pt_settings, key);
- g_free (key);
-
- column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree), id);
- if(!column) continue;
- gtk_tree_view_column_set_visible (column, visible);
- if (visible) {
- /* ensure column is really visible */
- width = MAX(width, 10);
- gtk_tree_view_column_set_fixed_width(column, width);
- }
- }
- }
-
- if(!g_strcmp0(child_schema, "proctree") ||
- !g_strcmp0(child_schema, "disktreenew"))
- {
- GVariant *value;
- GVariantIter iter;
- int sortIndex;
-
- GSList *order = NULL;
-
- value = g_settings_get_value(pt_settings, "columns-order");
- g_variant_iter_init(&iter, value);
-
- while (g_variant_iter_loop (&iter, "i", &sortIndex))
- order = g_slist_append(order, GINT_TO_POINTER(sortIndex));
-
- proctable_set_columns_order(GTK_TREE_VIEW(tree), order);
-
- g_slist_free(order);
- }
-
- g_object_unref(pt_settings);
- pt_settings = NULL;
-
- g_list_free(columns);
-
- return TRUE;
-}
-
-void
-procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
-{
- GtkTreeModel *model;
- GList *columns;
- gint sort_col;
- GtkSortType order;
-
- if (ProcData::get_instance()->terminating)
- return;
-
- g_assert(tree);
- g_assert(child_schema);
-
- GSettings *pt_settings = g_settings_get_child (settings, child_schema);
-
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
- if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), &sort_col,
- &order)) {
- g_settings_set_int (pt_settings, "sort-col", sort_col);
- g_settings_set_int (pt_settings, "sort-order", order);
- }
-
- columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
-
- if(!g_strcmp0(child_schema, "proctree") || !g_strcmp0(child_schema, "disktreenew"))
- {
- GSList *order;
- GSList *order_node;
- GVariantBuilder *builder;
- GVariant *order_variant;
-
- order = proctable_get_columns_order(GTK_TREE_VIEW(tree));
-
- builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
-
- for(order_node = order; order_node; order_node = order_node->next)
- g_variant_builder_add(builder, "i", GPOINTER_TO_INT(order_node->data));
-
- order_variant = g_variant_new("ai", builder);
- g_settings_set_value(pt_settings, "columns-order", order_variant);
-
- g_slist_free(order);
- }
-
- g_list_free(columns);
-}
-
-void
-procman_save_config (ProcData *data)
-{
- GSettings *settings = data->settings;
-
- g_assert(data);
-
- procman_save_tree_state (data->settings, data->tree, "proctree");
- procman_save_tree_state (data->settings, data->disk_list, "disktreenew");
-
- data->config.maximized = gdk_window_get_state(gtk_widget_get_window (data->app)) & GDK_WINDOW_STATE_MAXIMIZED;
-
- if (!data->config.maximized) {
- // we only want to store/overwrite size and position info with non-maximized state info
- data->config.width = gdk_window_get_width (gtk_widget_get_window (data->app));
- data->config.height = gdk_window_get_height(gtk_widget_get_window (data->app));
-
- gtk_window_get_position(GTK_WINDOW(data->app), &data->config.xpos, &data->config.ypos);
-
- g_settings_set_int (settings, "width", data->config.width);
- g_settings_set_int (settings, "height", data->config.height);
- g_settings_set_int (settings, "x-position", data->config.xpos);
- g_settings_set_int (settings, "y-position", data->config.ypos);
- }
- g_settings_set_boolean (settings, "maximized", data->config.maximized);
-
- g_settings_set_int (settings, "current-tab", data->config.current_tab);
-
- g_settings_sync ();
-}
int
@@ -223,7 +37,7 @@ main (int argc, char *argv[])
textdomain (GETTEXT_PACKAGE);
setlocale (LC_ALL, "");
- Glib::RefPtr<ProcmanApp> application = ProcmanApp::create();
+ Glib::RefPtr<ProcmanApp> application = ProcmanApp::get();
return application->run (argc, argv);
}
diff --git a/src/procman_gksu.cpp b/src/procman_gksu.cpp
index 58faa0c..6ee6693 100644
--- a/src/procman_gksu.cpp
+++ b/src/procman_gksu.cpp
@@ -1,6 +1,6 @@
#include <config.h>
-#include "procman.h"
+#include "procman-app.h"
#include "procman_gksu.h"
#include "util.h"
diff --git a/src/procman_gnomesu.cpp b/src/procman_gnomesu.cpp
index 42f891c..c096dac 100644
--- a/src/procman_gnomesu.cpp
+++ b/src/procman_gnomesu.cpp
@@ -2,7 +2,7 @@
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
#include "procman_gnomesu.h"
#include "util.h"
diff --git a/src/procman_pkexec.cpp b/src/procman_pkexec.cpp
index 70c3090..4dc4e67 100644
--- a/src/procman_pkexec.cpp
+++ b/src/procman_pkexec.cpp
@@ -1,6 +1,6 @@
#include <config.h>
-#include "procman.h"
+#include "procman-app.h"
#include "procman_pkexec.h"
#include "util.h"
diff --git a/src/procproperties.cpp b/src/procproperties.cpp
index c61f1b9..ea64148 100644
--- a/src/procproperties.cpp
+++ b/src/procproperties.cpp
@@ -31,7 +31,7 @@
#include <sys/sysctl.h>
#endif
-#include "procman.h"
+#include "procman-app.h"
#include "procproperties.h"
#include "proctable.h"
#include "util.h"
@@ -188,7 +188,7 @@ close_procprop_dialog (GtkDialog *dialog, gint id, gpointer data)
}
static GtkWidget *
-create_procproperties_tree (ProcData *procdata)
+create_procproperties_tree (ProcmanApp *app)
{
GtkWidget *tree;
GtkListStore *model;
@@ -217,7 +217,7 @@ create_procproperties_tree (ProcData *procdata)
}
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), FALSE);
- fill_proc_properties(tree, procdata->selected_process);
+ fill_proc_properties(tree, app->selected_process);
return tree;
}
@@ -240,7 +240,8 @@ static void
create_single_procproperties_dialog (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcmanApp *app = static_cast<ProcmanApp *>(data);
+
GtkWidget *procpropdialog;
GtkWidget *dialog_vbox, *vbox;
GtkWidget *cmd_hbox;
@@ -288,7 +289,7 @@ create_single_procproperties_dialog (GtkTreeModel *model, GtkTreePath *path,
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
- tree = create_procproperties_tree (procdata);
+ tree = create_procproperties_tree (app);
gtk_container_add (GTK_CONTAINER (scrolled), tree);
g_object_set_data (G_OBJECT (tree), "selected_info", info);
@@ -307,8 +308,8 @@ create_single_procproperties_dialog (GtkTreeModel *model, GtkTreePath *path,
}
void
-create_procproperties_dialog (ProcData *procdata)
+create_procproperties_dialog (ProcmanApp *app)
{
- gtk_tree_selection_selected_foreach (procdata->selection, create_single_procproperties_dialog,
- procdata);
+ gtk_tree_selection_selected_foreach (app->selection, create_single_procproperties_dialog,
+ app);
}
diff --git a/src/procproperties.h b/src/procproperties.h
index ca1103c..28b3958 100644
--- a/src/procproperties.h
+++ b/src/procproperties.h
@@ -23,9 +23,9 @@
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
-void create_procproperties_dialog (ProcData *procdata);
+void create_procproperties_dialog (ProcmanApp *app);
#endif
diff --git a/src/proctable.cpp b/src/proctable.cpp
index 96f6bee..97da46f 100644
--- a/src/proctable.cpp
+++ b/src/proctable.cpp
@@ -49,7 +49,7 @@
#include <systemd/sd-login.h>
#endif
-#include "procman.h"
+#include "procman-app.h"
#include "selection.h"
#include "proctable.h"
#include "callbacks.h"
@@ -73,12 +73,12 @@ ProcInfo* ProcInfo::find(pid_t pid)
static void
-set_proctree_reorderable(ProcData *procdata)
+set_proctree_reorderable(ProcmanApp *app)
{
GList *columns, *col;
GtkTreeView *proctree;
- proctree = GTK_TREE_VIEW(procdata->tree);
+ proctree = GTK_TREE_VIEW(app->tree);
columns = gtk_tree_view_get_columns (proctree);
@@ -90,11 +90,11 @@ set_proctree_reorderable(ProcData *procdata)
static void
-cb_columns_changed(GtkTreeView *treeview, gpointer user_data)
+cb_columns_changed(GtkTreeView *treeview, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(user_data);
+ ProcmanApp * const app = static_cast<ProcmanApp *>(data);
- procman_save_tree_state(procdata->settings,
+ procman_save_tree_state(app->settings,
GTK_WIDGET(treeview),
"proctree");
}
@@ -183,7 +183,7 @@ cb_proctable_column_resized(GtkWidget *widget)
GSettings *settings;
gint saved_width;
- settings = g_settings_get_child (ProcData::get_instance()->settings, "proctree");
+ settings = g_settings_get_child (ProcmanApp::get()->settings, "proctree");
id = gtk_tree_view_column_get_sort_column_id (column);
width = gtk_tree_view_column_get_width (column);
key = g_strdup_printf ("col-%d-width", id);
@@ -221,10 +221,14 @@ search_equal_func(GtkTreeModel *model,
return found;
}
-
+static void
+cb_proctree_destroying (GtkTreeView *self, gpointer data)
+{
+ g_signal_handlers_disconnect_by_func(self, (gpointer) cb_columns_changed, data);
+}
GtkWidget *
-proctable_new (ProcData * const procdata)
+proctable_new (ProcmanApp * const app)
{
GtkWidget *proctree;
GtkTreeStore *model;
@@ -297,7 +301,7 @@ proctable_new (ProcData * const procdata)
proctree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (proctree), COL_TOOLTIP);
g_object_set(G_OBJECT(proctree),
- "show-expanders", procdata->config.show_tree,
+ "show-expanders", app->config.show_tree,
NULL);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (proctree),
search_equal_func,
@@ -450,11 +454,11 @@ proctable_new (ProcData * const procdata)
}
}
- procdata->tree = proctree;
+ app->tree = proctree;
- set_proctree_reorderable(procdata);
+ set_proctree_reorderable(app);
- procman_get_tree_state (procdata->settings, proctree, "proctree");
+ procman_get_tree_state (app->settings, proctree, "proctree");
/* Override column settings by hiding this column if it's meaningless: */
if (!can_show_security_context_column ()) {
@@ -484,14 +488,18 @@ proctable_new (ProcData * const procdata)
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree))),
"changed",
- G_CALLBACK (cb_row_selected), procdata);
+ G_CALLBACK (cb_row_selected), app);
g_signal_connect (G_OBJECT (proctree), "popup_menu",
- G_CALLBACK (cb_tree_popup_menu), procdata);
+ G_CALLBACK (cb_tree_popup_menu), app);
g_signal_connect (G_OBJECT (proctree), "button_press_event",
- G_CALLBACK (cb_tree_button_pressed), procdata);
+ 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_columns_changed), procdata);
+ G_CALLBACK(cb_columns_changed), app);
return proctree;
}
@@ -625,9 +633,8 @@ get_process_memory_info(ProcInfo *info)
static void
update_info_mutable_cols(ProcInfo *info)
{
- ProcData * const procdata = ProcData::get_instance();
GtkTreeModel *model;
- model = gtk_tree_view_get_model(GTK_TREE_VIEW(procdata->tree));
+ model = gtk_tree_view_get_model(GTK_TREE_VIEW(ProcmanApp::get()->tree));
using procman::tree_store_update;
@@ -654,13 +661,13 @@ update_info_mutable_cols(ProcInfo *info)
static void
-insert_info_to_tree (ProcInfo *info, ProcData *procdata, bool forced = false)
+insert_info_to_tree (ProcInfo *info, ProcmanApp *app, bool forced = false)
{
GtkTreeModel *model;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (app->tree));
- if (procdata->config.show_tree) {
+ if (app->config.show_tree) {
ProcInfo *parent = 0;
@@ -671,13 +678,13 @@ insert_info_to_tree (ProcInfo *info, ProcData *procdata, bool forced = false)
GtkTreePath *parent_node = gtk_tree_model_get_path(model, &parent->node);
gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, &parent->node, 0);
- if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(procdata->tree), parent_node)
+ if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(app->tree), parent_node)
#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(procdata->tree), parent_node, FALSE);
+ gtk_tree_view_expand_row(GTK_TREE_VIEW(app->tree), parent_node, FALSE);
gtk_tree_path_free(parent_node);
} else
gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, NULL, 0);
@@ -694,7 +701,7 @@ insert_info_to_tree (ProcInfo *info, ProcData *procdata, bool forced = false)
COL_SECURITYCONTEXT, info->security_context,
-1);
- procdata->pretty_table.set_icon(*info);
+ app->pretty_table->set_icon(*info);
procman_debug("inserted %d%s", info->pid, (forced ? " (forced)" : ""));
}
@@ -705,7 +712,7 @@ insert_info_to_tree (ProcInfo *info, ProcData *procdata, bool forced = false)
*/
template<typename List>
static void
-remove_info_from_tree (ProcData *procdata, GtkTreeModel *model,
+remove_info_from_tree (ProcmanApp *app, GtkTreeModel *model,
ProcInfo *current, List &orphans, unsigned lvl = 0)
{
GtkTreeIter child_node;
@@ -725,13 +732,13 @@ remove_info_from_tree (ProcData *procdata, GtkTreeModel *model,
while (gtk_tree_model_iter_children(model, &child_node, ¤t->node)) {
ProcInfo *child = 0;
gtk_tree_model_get(model, &child_node, COL_POINTER, &child, -1);
- remove_info_from_tree(procdata, model, child, orphans, lvl + 1);
+ remove_info_from_tree(app, model, child, orphans, lvl + 1);
}
g_assert(not gtk_tree_model_iter_has_child(model, ¤t->node));
- if (procdata->selected_process == current)
- procdata->selected_process = NULL;
+ if (app->selected_process == current)
+ app->selected_process = NULL;
orphans.push_back(current);
gtk_tree_store_remove(GTK_TREE_STORE(model), ¤t->node);
@@ -769,7 +776,7 @@ get_process_systemd_info(ProcInfo *info)
}
static void
-update_info (ProcData *procdata, ProcInfo *info)
+update_info (ProcmanApp *app, ProcInfo *info)
{
glibtop_proc_state procstate;
glibtop_proc_uid procuid;
@@ -789,11 +796,11 @@ update_info (ProcData *procdata, ProcInfo *info)
info->set_user(procstate.uid);
- info->pcpu = (proctime.rtime - info->cpu_time) * 100 / procdata->cpu_total_time;
+ info->pcpu = (proctime.rtime - info->cpu_time) * 100 / app->cpu_total_time;
info->pcpu = MIN(info->pcpu, 100);
- if (not procdata->config.solaris_mode)
- info->pcpu *= procdata->config.num_cpus;
+ if (not app->config.solaris_mode)
+ info->pcpu *= app->config.num_cpus;
ProcInfo::cpu_times[info->pid] = info->cpu_time = proctime.rtime;
info->nice = procuid.nice;
@@ -855,12 +862,12 @@ ProcInfo::ProcInfo(pid_t pid)
}
static void
-refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
+refresh_list (ProcmanApp *app, const pid_t* pid_list, const guint n)
{
typedef std::list<ProcInfo*> ProcList;
ProcList addition;
- GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
+ GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (app->tree));
guint i;
// Add or update processes in the process list
@@ -873,7 +880,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
addition.push_back(info);
}
- update_info (procdata, info);
+ update_info (app, info);
}
@@ -892,7 +899,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
if (pids.find(info->pid) == pids.end()) {
procman_debug("ripping %d", info->pid);
- remove_info_from_tree(procdata, model, info, addition);
+ remove_info_from_tree(app, model, info, addition);
addition.remove(info);
ProcInfo::all.erase(it);
delete info;
@@ -905,7 +912,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
// pid_list == ProcInfo::all + addition
- if (procdata->config.show_tree) {
+ if (app->config.show_tree) {
// insert process in the tree. walk through the addition list
// (new process + process that have a new parent). This loop
@@ -942,7 +949,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
if ((*it)->ppid == 0 or in_tree.find((*it)->ppid) != in_tree.end()) {
- insert_info_to_tree(*it, procdata);
+ insert_info_to_tree(*it, app);
in_tree.insert((*it)->pid);
it = addition.erase(it);
continue;
@@ -952,7 +959,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
// if the parent is unreachable
if (not parent) {
// or std::find(addition.begin(), addition.end(), parent) == addition.end()) {
- insert_info_to_tree(*it, procdata, true);
+ insert_info_to_tree(*it, app, true);
in_tree.insert((*it)->pid);
it = addition.erase(it);
continue;
@@ -965,7 +972,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
else {
// don't care of the tree
for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)
- insert_info_to_tree(*it, procdata);
+ insert_info_to_tree(*it, app);
}
@@ -975,7 +982,7 @@ refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
void
-proctable_update_list (ProcData * const procdata)
+proctable_update_list (ProcmanApp *app)
{
pid_t* pid_list;
glibtop_proclist proclist;
@@ -983,7 +990,7 @@ proctable_update_list (ProcData * const procdata)
gint which, arg;
procman::SelectionMemento selection;
- switch (procdata->config.whose_process) {
+ switch (app->config.whose_process) {
case ALL_PROCESSES:
which = GLIBTOP_KERN_PROC_ALL;
arg = 0;
@@ -992,18 +999,18 @@ proctable_update_list (ProcData * const procdata)
case ACTIVE_PROCESSES:
which = GLIBTOP_KERN_PROC_ALL | GLIBTOP_EXCLUDE_IDLE;
arg = 0;
- if (procdata->config.show_tree)
+ if (app->config.show_tree)
{
- selection.save(procdata->tree);
+ selection.save(app->tree);
}
break;
default:
which = GLIBTOP_KERN_PROC_UID;
arg = getuid ();
- if (procdata->config.show_tree)
+ if (app->config.show_tree)
{
- selection.save(procdata->tree);
+ selection.save(app->tree);
}
break;
}
@@ -1013,12 +1020,12 @@ proctable_update_list (ProcData * const procdata)
/* 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);
- procdata->cpu_total_time = MAX(cpu.total - procdata->cpu_total_time_last, 1);
- procdata->cpu_total_time_last = cpu.total;
+ app->cpu_total_time = MAX(cpu.total - app->cpu_total_time_last, 1);
+ app->cpu_total_time_last = cpu.total;
- refresh_list (procdata, pid_list, proclist.number);
+ refresh_list (app, pid_list, proclist.number);
- selection.restore(procdata->tree);
+ selection.restore(app->tree);
g_free (pid_list);
@@ -1027,35 +1034,35 @@ proctable_update_list (ProcData * const procdata)
void
-proctable_update_all (ProcData * const procdata)
+proctable_update_all (ProcmanApp * const app)
{
char* string;
string = make_loadavg_string();
- gtk_label_set_text (GTK_LABEL(procdata->loadavg), string);
+ gtk_label_set_text (GTK_LABEL(app->loadavg), string);
g_free (string);
- proctable_update_list (procdata);
+ proctable_update_list (app);
}
void
-proctable_clear_tree (ProcData * const procdata)
+proctable_clear_tree (ProcmanApp * const app)
{
GtkTreeModel *model;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (app->tree));
gtk_tree_store_clear (GTK_TREE_STORE (model));
- proctable_free_table (procdata);
+ proctable_free_table (app);
- update_sensitivity(procdata);
+ update_sensitivity(app);
}
void
-proctable_free_table (ProcData * const procdata)
+proctable_free_table (ProcmanApp * const app)
{
for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)
delete it->second;
@@ -1088,7 +1095,7 @@ ProcInfo::set_icon(Glib::RefPtr<Gdk::Pixbuf> icon)
this->pixbuf = icon;
GtkTreeModel *model;
- model = gtk_tree_view_get_model(GTK_TREE_VIEW(ProcData::get_instance()->tree));
+ model = gtk_tree_view_get_model(GTK_TREE_VIEW(ProcmanApp::get()->tree));
gtk_tree_store_set(GTK_TREE_STORE(model), &this->node,
COL_PIXBUF, (this->pixbuf ? this->pixbuf->gobj() : NULL),
-1);
diff --git a/src/proctable.h b/src/proctable.h
index dbfeada..e6b01ab 100644
--- a/src/proctable.h
+++ b/src/proctable.h
@@ -22,7 +22,7 @@
#include <glib.h>
#include <gtk/gtk.h>
-#include "procman.h"
+#include "procman-app.h"
enum
{
@@ -56,12 +56,12 @@ enum
};
-GtkWidget* proctable_new (ProcData *data);
-void proctable_update_table (ProcData *data);
-void proctable_update_list (ProcData *data);
-void proctable_update_all (ProcData *data);
-void proctable_clear_tree (ProcData *data);
-void proctable_free_table (ProcData *data);
+GtkWidget* proctable_new (ProcmanApp *app);
+void proctable_update_table (ProcmanApp *app);
+void proctable_update_list (ProcmanApp *app);
+void proctable_update_all (ProcmanApp *app);
+void proctable_clear_tree (ProcmanApp *app);
+void proctable_free_table (ProcmanApp *app);
GSList* proctable_get_columns_order(GtkTreeView *treeview);
void proctable_set_columns_order(GtkTreeView *treeview, GSList *order);
diff --git a/src/selinux.cpp b/src/selinux.cpp
index f9eaddf..2115453 100644
--- a/src/selinux.cpp
+++ b/src/selinux.cpp
@@ -3,7 +3,7 @@
#include <glib.h>
#include "selinux.h"
-#include "procman.h"
+#include "procman-app.h"
#include "util.h"
diff --git a/src/selinux.h b/src/selinux.h
index be79ce9..6e099f2 100644
--- a/src/selinux.h
+++ b/src/selinux.h
@@ -3,7 +3,7 @@
#include <glib.h>
-#include "procman.h"
+#include "procman-app.h"
void
get_process_selinux_context (ProcInfo *info);
diff --git a/src/smooth_refresh.cpp b/src/smooth_refresh.cpp
index f3ef70e..32d719d 100644
--- a/src/smooth_refresh.cpp
+++ b/src/smooth_refresh.cpp
@@ -11,7 +11,7 @@
#include <algorithm>
#include "smooth_refresh.h"
-#include "procman.h"
+#include "procman-app.h"
#include "util.h"
@@ -83,7 +83,7 @@ void SmoothRefresh::reset()
glibtop_get_cpu(&cpu);
glibtop_get_proc_time(&proctime, getpid());
- this->interval = ProcData::get_instance()->config.update_interval;
+ this->interval = ProcmanApp::get()->config.update_interval;
this->last_pcpu = PCPU_LO;
this->last_total_time = cpu.total;
this->last_cpu_time = proctime.rtime;
@@ -102,7 +102,7 @@ SmoothRefresh::~SmoothRefresh()
bool
SmoothRefresh::get(guint &new_interval)
{
- const unsigned config_interval = ProcData::get_instance()->config.update_interval;
+ const unsigned config_interval = ProcmanApp::get()->config.update_interval;
g_assert(this->interval >= config_interval);
diff --git a/src/sysinfo.cpp b/src/sysinfo.cpp
index 5a0169a..041569d 100644
--- a/src/sysinfo.cpp
+++ b/src/sysinfo.cpp
@@ -28,7 +28,7 @@
#include <sys/utsname.h>
#include "sysinfo.h"
-#include "procman.h"
+#include "procman-app.h"
#include "util.h"
@@ -797,9 +797,8 @@ namespace procman
static GtkWidget* ui;
if (!ui) {
- ProcData* procdata = ProcData::get_instance();
ui = procman_create_sysinfo_view();
- GtkBox* box = GTK_BOX(gtk_notebook_get_nth_page(GTK_NOTEBOOK(procdata->notebook),
+ GtkBox* box = GTK_BOX(gtk_notebook_get_nth_page(GTK_NOTEBOOK(ProcmanApp::get()->notebook),
PROCMAN_TAB_SYSINFO));
gtk_box_pack_start(box, ui, TRUE, TRUE, 0);
gtk_widget_show_all(ui);
diff --git a/src/util.cpp b/src/util.cpp
index 660664d..8532e13 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -12,7 +12,7 @@
#include <cstring>
#include "util.h"
-#include "procman.h"
+#include "procman-app.h"
extern "C" {
#include "e_date.h"
@@ -470,7 +470,7 @@ namespace procman
g_value_unset(&value);
- time = 100 * time / ProcData::get_instance()->frequency;
+ time = 100 * time / ProcmanApp::get()->frequency;
char *str = format_duration_for_display(time);
g_object_set(renderer, "text", str, NULL);
g_free(str);
@@ -604,13 +604,13 @@ namespace procman
std::string format_network(guint64 rate, guint64 max_rate)
{
- return procman::format_size(rate, max_rate, ProcData::get_instance()->config.network_in_bits);
+ return procman::format_size(rate, max_rate, ProcmanApp::get()->config.network_in_bits);
}
std::string format_network_rate(guint64 rate, guint64 max_rate)
{
- return procman::format_rate(rate, max_rate, ProcData::get_instance()->config.network_in_bits);
+ return procman::format_rate(rate, max_rate, ProcmanApp::get()->config.network_in_bits);
}
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
